import * as VScript from "http://172.16.0.12/bladerunner_sdk/vscript@2.5.2/deno/release/mod.ts";
import * as VAPI from "./mod.ts";
export const lift = {
  VANCAfdInserterBlank: (
    _raw: [],
    _socket: VScript.VSocket,
  ): VANCAfdInserterBlank => {
    return {};
  },
  BypassReplaceFlags: (
    _raw: [
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
      boolean,
    ],
    _socket: VScript.VSocket,
  ): BypassReplaceFlags => {
    return {
      c_unknown: _raw[0],
      y_334_cea_708_cdp: _raw[1],
      y_334_cea_608: _raw[2],
      y_334_program: _raw[3],
      y_334_data: _raw[4],
      y_334_vbi: _raw[5],
      y_2010_ansi_scte_104: _raw[6],
      y_2031_dvb_scte_vbi: _raw[7],
      y_rdd_8_op_47: _raw[8],
      y_2020_amd: _raw[9],
      y_obs: _raw[10],
      y_unknown: _raw[11],
    };
  },
  LatchControl: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new LatchControl(_raw),
  NAME: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) => new NAME(_raw),
  VANCAfdInserterPassthrough: (
    _raw: [],
    _socket: VScript.VSocket,
  ): VANCAfdInserterPassthrough => {
    return {};
  },
  VANCAfdInserterReplace: (
    _raw: [null | VAPI.Definitions.VANCAfdCode],
    _socket: VScript.VSocket,
  ): VANCAfdInserterReplace => {
    return {
      afd: _raw[0],
    };
  },
  VANCAfdInserter: (
    _raw: [0, []] | [1, []] | [2, [null | VAPI.Definitions.VANCAfdCode]],
    _socket: VScript.VSocket,
  ): VANCAfdInserter => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "Passthrough",
          value: VAPI.Definitions.lift.VANCAfdInserterPassthrough(
            _raw[1],
            _socket,
          ),
        };
      case 1:
        return {
          variant: "Blank",
          value: VAPI.Definitions.lift.VANCAfdInserterBlank(_raw[1], _socket),
        };
      case 2:
        return {
          variant: "Replace",
          value: VAPI.Definitions.lift.VANCAfdInserterReplace(_raw[1], _socket),
        };
    }
  },
  LatchControlBoundaries: (
    _raw: [number, number, number],
    _socket: VScript.VSocket,
  ): LatchControlBoundaries => {
    return {
      attack_time: VScript.VAPIHelpers.liftNanoseconds(_raw[0], _socket),
      mediaclock_late: VScript.VAPIHelpers.liftNanoseconds(_raw[1], _socket),
      mediaclock_early: VScript.VAPIHelpers.liftNanoseconds(_raw[2], _socket),
    };
  },
} as const;
export const lower = {
  VANCAfdInserterBlank: (_x: {}, _socket: VScript.VSocket): [] => [],
  BypassReplaceFlags: (
    _x: {
      /**
      Bypass unknown meta data
    */
      c_unknown: boolean;

      /**
      Bypass DID 61 SDID 01 (SMPTE 334-1 CEA-708 / CDP)
    */
      y_334_cea_708_cdp: boolean;

      /**
      Bypass DID 61 SDID 02 (SMPTE 334-1 CEA-608)
    */
      y_334_cea_608: boolean;

      /**
      Bypass DID 62 SDID 01 (SMPTE 334-1 Program description)
    */
      y_334_program: boolean;

      /**
      Bypass DID 62 SDID 02 (SMPTE 334-1 Data broadcast)
    */
      y_334_data: boolean;

      /**
      Bypass DID 62 SDID 03 (SMPTE 334-1 VBI data)
    */
      y_334_vbi: boolean;

      /**
      Bypass DID 41 SDID 07 (SMPTE 2010 - ANSI/SCTE 104)
    */
      y_2010_ansi_scte_104: boolean;

      /**
      Bypass DID 41 SDID 08 (SMPTE 2031 - DVB/SCTE VBI)
    */
      y_2031_dvb_scte_vbi: boolean;

      /**
      Bypass DID 43 SDID 02 (RDD 8 / OP-47)
    */
      y_rdd_8_op_47: boolean;

      /**
      Bypass DID 45 (SMPTE 2020 - Audio Meta Data)
    */
      y_2020_amd: boolean;

      /**
      Bypass DID 53 (OBS Source ID)
    */
      y_obs: boolean;

      /**
      Bypass unknown meta data
    */
      y_unknown: boolean;
    },
    _socket: VScript.VSocket,
  ): [
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
  ] => [
    _x.c_unknown,
    _x.y_334_cea_708_cdp,
    _x.y_334_cea_608,
    _x.y_334_program,
    _x.y_334_data,
    _x.y_334_vbi,
    _x.y_2010_ansi_scte_104,
    _x.y_2031_dvb_scte_vbi,
    _x.y_rdd_8_op_47,
    _x.y_2020_amd,
    _x.y_obs,
    _x.y_unknown,
  ],
  LatchControl: (_x: LatchControl) => _x.raw.kwl,
  NAME: (_x: NAME) => _x.raw.kwl,
  VANCAfdInserterPassthrough: (_x: {}, _socket: VScript.VSocket): [] => [],
  VANCAfdInserterReplace: (
    _x: { afd: null | VAPI.Definitions.VANCAfdCode },
    _socket: VScript.VSocket,
  ): [null | VAPI.Definitions.VANCAfdCode] => [_x.afd],
  VANCAfdInserter: (
    _x:
      | {
          variant: "Passthrough";
          value: VAPI.Definitions.VANCAfdInserterPassthrough;
        }
      | { variant: "Blank"; value: VAPI.Definitions.VANCAfdInserterBlank }
      | { variant: "Replace"; value: VAPI.Definitions.VANCAfdInserterReplace },
    _socket: VScript.VSocket,
  ): [0, []] | [1, []] | [2, [null | VAPI.Definitions.VANCAfdCode]] => {
    switch (_x.variant) {
      case "Passthrough":
        return [
          0,
          VAPI.Definitions.lower.VANCAfdInserterPassthrough(_x.value, _socket),
        ];
      case "Blank":
        return [
          1,
          VAPI.Definitions.lower.VANCAfdInserterBlank(_x.value, _socket),
        ];
      case "Replace":
        return [
          2,
          VAPI.Definitions.lower.VANCAfdInserterReplace(_x.value, _socket),
        ];
    }
  },
  LatchControlBoundaries: (
    _x: {
      attack_time: VScript.Duration;
      mediaclock_late: VScript.Duration;
      mediaclock_early: VScript.Duration;
    },
    _socket: VScript.VSocket,
  ): [number, number, number] => [
    VScript.VAPIHelpers.lowerNanoseconds(_x.attack_time, _socket),
    VScript.VAPIHelpers.lowerNanoseconds(_x.mediaclock_late, _socket),
    VScript.VAPIHelpers.lowerNanoseconds(_x.mediaclock_early, _socket),
  ],
} as const;
export type AudioFormat = "AM824" | "L24" | "L16";
export type Bandwidth = "b1_5Gb" | "b3_0Gb" | "b12_0Gb";
export interface VANCAfdInserterBlank {}
export interface BypassReplaceFlags {
  /**
    Bypass unknown meta data
  */
  c_unknown: boolean;

  /**
    Bypass DID 61 SDID 01 (SMPTE 334-1 CEA-708 / CDP)
  */
  y_334_cea_708_cdp: boolean;

  /**
    Bypass DID 61 SDID 02 (SMPTE 334-1 CEA-608)
  */
  y_334_cea_608: boolean;

  /**
    Bypass DID 62 SDID 01 (SMPTE 334-1 Program description)
  */
  y_334_program: boolean;

  /**
    Bypass DID 62 SDID 02 (SMPTE 334-1 Data broadcast)
  */
  y_334_data: boolean;

  /**
    Bypass DID 62 SDID 03 (SMPTE 334-1 VBI data)
  */
  y_334_vbi: boolean;

  /**
    Bypass DID 41 SDID 07 (SMPTE 2010 - ANSI/SCTE 104)
  */
  y_2010_ansi_scte_104: boolean;

  /**
    Bypass DID 41 SDID 08 (SMPTE 2031 - DVB/SCTE VBI)
  */
  y_2031_dvb_scte_vbi: boolean;

  /**
    Bypass DID 43 SDID 02 (RDD 8 / OP-47)
  */
  y_rdd_8_op_47: boolean;

  /**
    Bypass DID 45 (SMPTE 2020 - Audio Meta Data)
  */
  y_2020_amd: boolean;

  /**
    Bypass DID 53 (OBS Source ID)
  */
  y_obs: boolean;

  /**
    Bypass unknown meta data
  */
  y_unknown: boolean;
}
export type InputTypes =
  | "SDI"
  | "VidStream"
  | "AudStream"
  | "SRC"
  | "DELAY"
  | "TestTone"
  | "Volume"
  | "Mixer";
export class LatchControl
  implements VScript.Referenceable<"Definitions::Data::LatchControl">
{
  readonly type_identifier = "Definitions::Data::LatchControl" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get mode(): VScript.dKeyword<
    VScript.VSocket,
    VAPI.Definitions.LatchMode,
    VAPI.Definitions.LatchMode,
    VAPI.Definitions.LatchMode,
    VAPI.Definitions.LatchMode,
    VAPI.Definitions.LatchControl
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      VAPI.Definitions.LatchMode,
      VAPI.Definitions.LatchMode,
      VAPI.Definitions.LatchMode,
      VAPI.Definitions.LatchMode,
      VAPI.Definitions.LatchControl
    >(
      this,
      "mode" as VScript.SysName,
      {
        lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
        lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
      },
      {
        lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
        lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
      },
      null,
    );
  }
  get boundaries(): VScript.rwKeyword<
    VScript.VSocket,
    [number, number, number],
    [number, number, number],
    VAPI.Definitions.LatchControlBoundaries,
    VAPI.Definitions.LatchControlBoundaries,
    VAPI.Definitions.LatchControl
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      [number, number, number],
      [number, number, number],
      VAPI.Definitions.LatchControlBoundaries,
      VAPI.Definitions.LatchControlBoundaries,
      VAPI.Definitions.LatchControl
    >(
      this,
      "boundaries" as VScript.SysName,
      {
        lift: VAPI.Definitions.lift.LatchControlBoundaries,
        lower: VAPI.Definitions.lower.LatchControlBoundaries,
      },
      {
        lift: VAPI.Definitions.lift.LatchControlBoundaries,
        lower: VAPI.Definitions.lower.LatchControlBoundaries,
      },
      null,
    );
  }
}
export type LatchMode = "On_Start" | "Continuous";
export class NAME implements VScript.Referenceable<"Definitions::Data::NAME"> {
  readonly type_identifier = "Definitions::Data::NAME" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}

  /**
    Is the textual brief
  */
  get brief(): VScript.dKeyword<
    VScript.VSocket,
    string,
    string,
    string,
    string,
    VAPI.Definitions.NAME
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      string,
      string,
      string,
      string,
      VAPI.Definitions.NAME
    >(
      this,
      "brief" as VScript.SysName,
      {
        lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
        lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
      },
      {
        lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
        lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
      },
      null,
    );
  }

  /**
    Provides textual information
  */
  get description(): VScript.dKeyword<
    VScript.VSocket,
    string,
    string,
    string,
    string,
    VAPI.Definitions.NAME
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      string,
      string,
      string,
      string,
      VAPI.Definitions.NAME
    >(
      this,
      "description" as VScript.SysName,
      {
        lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
        lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
      },
      {
        lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
        lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
      },
      null,
    );
  }
}
export type PacketTime =
  | "p1"
  | "p0_666"
  | "p0_500"
  | "p0_333"
  | "p0_250"
  | "p0_125";
export interface VANCAfdInserterPassthrough {}
export interface VANCAfdInserterReplace {
  afd: null | VAPI.Definitions.VANCAfdCode;
}
export type TRSEmbedder = "Embed" | "Bypass" | "Off";
export type VANCAfdCode =
  | "Code_0010"
  | "Code_0011"
  | "Code_0100"
  | "Code_0101"
  | "Code_0110"
  | "Code_0111"
  | "Code_1000"
  | "Code_1001"
  | "Code_1010"
  | "Code_1011"
  | "Code_1100"
  | "Code_1101"
  | "Code_1110"
  | "Code_1111";
export type VANCAfdInserter =
  | {
      variant: "Passthrough";
      value: VAPI.Definitions.VANCAfdInserterPassthrough;
    }
  | { variant: "Blank"; value: VAPI.Definitions.VANCAfdInserterBlank }
  | { variant: "Replace"; value: VAPI.Definitions.VANCAfdInserterReplace };
export type AudioInput = number;
export interface LatchControlBoundaries {
  attack_time: VScript.Duration;
  mediaclock_late: VScript.Duration;
  mediaclock_early: VScript.Duration;
}
export type RtpPayloadType = number;
export type VideoInput = number;
export const Enums = {
  VANCAfdCode: [
    "Code_0010",
    "Code_0011",
    "Code_0100",
    "Code_0101",
    "Code_0110",
    "Code_0111",
    "Code_1000",
    "Code_1001",
    "Code_1010",
    "Code_1011",
    "Code_1100",
    "Code_1101",
    "Code_1110",
    "Code_1111",
  ] as VANCAfdCode[],
  TRSEmbedder: ["Embed", "Bypass", "Off"] as TRSEmbedder[],
  PacketTime: [
    "p1",
    "p0_666",
    "p0_500",
    "p0_333",
    "p0_250",
    "p0_125",
  ] as PacketTime[],
  LatchMode: ["On_Start", "Continuous"] as LatchMode[],
  InputTypes: [
    "SDI",
    "VidStream",
    "AudStream",
    "SRC",
    "DELAY",
    "TestTone",
    "Volume",
    "Mixer",
  ] as InputTypes[],
  Bandwidth: ["b1_5Gb", "b3_0Gb", "b12_0Gb"] as Bandwidth[],
  AudioFormat: ["AM824", "L24", "L16"] as AudioFormat[],
} as const;