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 = {
  AudioConfigurationContainer: (
    _raw: VScript.DataViews.Subtree<VScript.VSocket>,
  ) => new AudioConfigurationContainer(_raw),
  AudioConfigurationFormat: (
    _raw: [number, VAPI.Audio.Format, VAPI.Definitions.PacketTime],
    _socket: VScript.VSocket,
  ): AudioConfigurationFormat => {
    return {
      num_channels: _raw[0],
      format: _raw[1],
      packet_time: _raw[2],
    };
  },
  AudioGroupControl: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new AudioGroupControl(_raw),
  AudioGroupControlStatus: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new AudioGroupControlStatus(_raw),
  CompressionBandwidth: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): CompressionBandwidth => {
    return {
      max_data_rate: _raw[0],
    };
  },
  Compression: (
    _raw: [0, [number]] | [1, [number]],
    _socket: VScript.VSocket,
  ): Compression => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "Bandwidth",
          value: VAPI.RTPTransmitter.lift.CompressionBandwidth(
            _raw[1],
            _socket,
          ),
        };
      case 1:
        return {
          variant: "Ratio",
          value: VAPI.RTPTransmitter.lift.CompressionRatio(_raw[1], _socket),
        };
    }
  },
  Constraints: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new Constraints(_raw),
  HeaderSettings: (
    _raw: [
      null | number,
      null | VAPI.RTPTransmitter.ClassOfService,
      null | VAPI.RTPTransmitter.TrafficClassOrQos,
      null | number,
      number,
    ],
    _socket: VScript.VSocket,
  ): HeaderSettings => {
    return {
      payload_type: _raw[0],
      class_of_service: _raw[1],
      traffic_class: _raw[2],
      ssrc: _raw[3],
      ttl: _raw[4],
    };
  },
  IpConfig: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new IpConfig(_raw),
  IpConfigInterfaces: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new IpConfigInterfaces(_raw),
  IpConfigMipMap: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new IpConfigMipMap(_raw),
  IpSDPConfigInterfaces: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new IpSDPConfigInterfaces(_raw),
  JpegXsSettings: (
    _raw: [
      [0, [number]] | [1, [number]],
      VAPI.RTPTransmitter.LVLMODE,
      boolean,
      boolean,
    ],
    _socket: VScript.VSocket,
  ): JpegXsSettings => {
    return {
      compression: VAPI.RTPTransmitter.lift.Compression(_raw[0], _socket),
      lvl_weight_mode: _raw[1],
      add_st2110_40: _raw[2],
      omit_mandatory_pre_header: _raw[3],
    };
  },
  MipMapEncoder: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new MipMapEncoder(_raw),
  MuxStatistics: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new MuxStatistics(_raw),
  CompressionRatio: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): CompressionRatio => {
    return {
      ratio: _raw[0],
    };
  },
  RouterError: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new RouterError(_raw),
  SSRCStatus: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): SSRCStatus => {
    return {
      ssrc: _raw[0],
      ssrc_counter: _raw[1],
    };
  },
  ST20226Settings: (_raw: [], _socket: VScript.VSocket): ST20226Settings => {
    return {};
  },
  ST2042Settings: (
    _raw: [VAPI.Video.DiracCompression, boolean],
    _socket: VScript.VSocket,
  ): ST2042Settings => {
    return {
      compression: _raw[0],
      add_st2110_40: _raw[1],
    };
  },
  SourceAddressVlan: (
    _raw: [null | number, null | string],
    _socket: VScript.VSocket,
  ): SourceAddressVlan => {
    return {
      vlan_id: _raw[0],
      src_address: _raw[1],
    };
  },
  Tagging: (
    _raw: [number, [number, VAPI.RTPTransmitter.ClassOfService]],
    _socket: VScript.VSocket,
  ): Tagging => {
    return {
      tagging_hw_value: _raw[0],
      tagging_decipher: VAPI.RTPTransmitter.lift.TaggingDecipher(
        _raw[1],
        _socket,
      ),
    };
  },
  TaggingDecipher: (
    _raw: [number, VAPI.RTPTransmitter.ClassOfService],
    _socket: VScript.VSocket,
  ): TaggingDecipher => {
    return {
      vlan_id: _raw[0],
      class_of_service: _raw[1],
    };
  },
  IpConfigMipMapActiveStreamParameter: (
    _raw: [null | string, null | string, number, number, null | number],
    _socket: VScript.VSocket,
  ): IpConfigMipMapActiveStreamParameter => {
    return {
      src_address: _raw[0],
      dst_address: _raw[1],
      lane_id: _raw[2],
      stream_id: _raw[3],
      vlan_id: _raw[4],
    };
  },
  RouterErrorErrorInput: (
    _raw: [Array<number>, Array<number>, Array<number>, number],
    _socket: VScript.VSocket,
  ): RouterErrorErrorInput => {
    return {
      max_fifo_level: _raw[0],
      max_fifo_level_last_read: _raw[1],
      overflow: _raw[2],
      error_irq_counter: _raw[3],
    };
  },
  RouterErrorErrorOutput: (
    _raw: [Array<number>, Array<number>, Array<number>],
    _socket: VScript.VSocket,
  ): RouterErrorErrorOutput => {
    return {
      max_fifo_level: _raw[0],
      max_fifo_level_last_read: _raw[1],
      overflow: _raw[2],
    };
  },
  IpConfigHeaderInfo: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new IpConfigHeaderInfo(_raw),
  SessionInterfaces: (
    _raw: [null | string, null | string],
    _socket: VScript.VSocket,
  ): SessionInterfaces => {
    return {
      primary:
        _raw[0] === null
          ? null
          : new VAPI.NetworkInterfaces.VirtualInterface(
              VScript.VAPIHelpers.get_subtree(
                _socket,
                _raw[0] as VScript.KWLName<"full">,
              ),
            ),
      secondary:
        _raw[1] === null
          ? null
          : new VAPI.NetworkInterfaces.VirtualInterface(
              VScript.VAPIHelpers.get_subtree(
                _socket,
                _raw[1] as VScript.KWLName<"full">,
              ),
            ),
    };
  },
  MediaStreamerIpConfiguration: (
    _raw: VScript.DataViews.Subtree<VScript.VSocket>,
  ) => new MediaStreamerIpConfiguration(_raw),
  MediaStreamerVideoIpConfiguration: (
    _raw: VScript.DataViews.Subtree<VScript.VSocket>,
  ) => new MediaStreamerVideoIpConfiguration(_raw),
  MipMapStreamerIpConfiguration: (
    _raw: VScript.DataViews.Subtree<VScript.VSocket>,
  ) => new MipMapStreamerIpConfiguration(_raw),
  JpegXsHardware: (
    _raw: [
      number,
      number,
      VAPI.RTPTransmitter.ColorSampleMode,
      number,
      VAPI.RTPTransmitter.ValidateMode,
      number,
      VAPI.RTPTransmitter.VideoDepth,
      boolean,
      Array<number>,
      number,
    ],
    _socket: VScript.VSocket,
  ): JpegXsHardware => {
    return {
      width: _raw[0],
      height: _raw[1],
      mode: _raw[2],
      budget_per_frame: _raw[3],
      vld: _raw[4],
      number_of_images: _raw[5],
      video_depth: _raw[6],
      play_mode: _raw[7],
      level_weights: _raw[8],
      profile: _raw[9],
    };
  },
  AllLicenseInformation: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new AllLicenseInformation(_raw),
  MipMapStreamerIpConfigurationMedia: (
    _raw: VScript.DataViews.Subtree<VScript.VSocket>,
  ) => new MipMapStreamerIpConfigurationMedia(_raw),
  AllSettingsOnIncompleteConfiguration: (
    _raw: [boolean, boolean],
    _socket: VScript.VSocket,
  ): AllSettingsOnIncompleteConfiguration => {
    return {
      refuse_activation: _raw[0],
      reserve_resources: _raw[1],
    };
  },
  MuxStatisticsPort0: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): MuxStatisticsPort0 => {
    return {
      words: _raw[0],
      packets: _raw[1],
    };
  },
  MuxStatisticsPort1: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): MuxStatisticsPort1 => {
    return {
      words: _raw[0],
      packets: _raw[1],
    };
  },
  MuxStatisticsScheduler: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): MuxStatisticsScheduler => {
    return {
      packets: _raw[0],
    };
  },
  AllSettings: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new AllSettings(_raw),
} as const;
export const lower = {
  AudioConfigurationContainer: (_x: AudioConfigurationContainer) => _x.raw.kwl,
  AudioConfigurationFormat: (
    _x: {
      num_channels: VAPI.Audio.Channelcount;
      format: VAPI.Audio.Format;
      packet_time: VAPI.Definitions.PacketTime;
    },
    _socket: VScript.VSocket,
  ): [number, VAPI.Audio.Format, VAPI.Definitions.PacketTime] => [
    _x.num_channels,
    _x.format,
    _x.packet_time,
  ],
  AudioGroupControl: (_x: AudioGroupControl) => _x.raw.kwl,
  AudioGroupControlStatus: (_x: AudioGroupControlStatus) => _x.raw.kwl,
  CompressionBandwidth: (
    _x: { max_data_rate: VAPI.Primitives.Unsigned32 },
    _socket: VScript.VSocket,
  ): [number] => [_x.max_data_rate],
  Compression: (
    _x:
      | {
          variant: "Bandwidth";
          value: VAPI.RTPTransmitter.CompressionBandwidth;
        }
      | { variant: "Ratio"; value: VAPI.RTPTransmitter.CompressionRatio },
    _socket: VScript.VSocket,
  ): [0, [number]] | [1, [number]] => {
    switch (_x.variant) {
      case "Bandwidth":
        return [
          0,
          VAPI.RTPTransmitter.lower.CompressionBandwidth(_x.value, _socket),
        ];
      case "Ratio":
        return [
          1,
          VAPI.RTPTransmitter.lower.CompressionRatio(_x.value, _socket),
        ];
    }
  },
  Constraints: (_x: Constraints) => _x.raw.kwl,
  HeaderSettings: (
    _x: {
      payload_type: null | VAPI.Definitions.RtpPayloadType;

      /**
                refers to 802.1p Class of Service (CoS). The CoS is only
                available when VLAN tagging is used.
              */
      class_of_service: null | VAPI.RTPTransmitter.ClassOfService;

      /**
                The Class Name (assured forwarding) offers an easy way to
                identify the DSCP value. DSCP uses the first six bits of the
                Type of Service(Tos) to identify the packet priority. The
                first three bits represent the Class Selector. The last three
                bits the Drop Precedence. For example, if a packet is marked
                `assured_forwarding_23`, then its Class Selector is 2 (the 2
                in 23) and its Drop Precedence is High (the 3 in 23).
              */
      traffic_class: null | VAPI.RTPTransmitter.TrafficClassOrQos;

      /**
                This field is used to identify the synchronization source.
                The value is determined randomly so that with high
                probability no two sources have the same identification
                number
              */
      ssrc: null | VAPI.Primitives.Unsigned32;
      ttl: number;
    },
    _socket: VScript.VSocket,
  ): [
    null | number,
    null | VAPI.RTPTransmitter.ClassOfService,
    null | VAPI.RTPTransmitter.TrafficClassOrQos,
    null | number,
    number,
  ] => [
    _x.payload_type,
    _x.class_of_service,
    _x.traffic_class,
    _x.ssrc,
    _x.ttl,
  ],
  IpConfig: (_x: IpConfig) => _x.raw.kwl,
  IpConfigInterfaces: (_x: IpConfigInterfaces) => _x.raw.kwl,
  IpConfigMipMap: (_x: IpConfigMipMap) => _x.raw.kwl,
  IpSDPConfigInterfaces: (_x: IpSDPConfigInterfaces) => _x.raw.kwl,
  JpegXsSettings: (
    _x: {
      compression: VAPI.RTPTransmitter.Compression;

      /**
                        PSNR optimization: by default, the rate allocation of
                        the encoder is configured to optimize the image
                        quality based on the Peak Signal to Noise Ratio
                        (PSNR) calculation. This configuration, called 'PSNR
                        Weights', is providing the best results of TICO
                        compression for PSNR measurements. visual
                        optimization: the 'Visual Weights' configuration is
                        the optimal configuration for real-life subjective
                        quality assessment. Compared to the “PSNR
                        Weights” configuration, it provides a better
                        viewing experience but it sometimes produces lower
                        PSNR results.
                      */
      lvl_weight_mode: VAPI.RTPTransmitter.LVLMODE;
      add_st2110_40: boolean;
      omit_mandatory_pre_header: boolean;
    },
    _socket: VScript.VSocket,
  ): [
    [0, [number]] | [1, [number]],
    VAPI.RTPTransmitter.LVLMODE,
    boolean,
    boolean,
  ] => [
    VAPI.RTPTransmitter.lower.Compression(_x.compression, _socket),
    _x.lvl_weight_mode,
    _x.add_st2110_40,
    _x.omit_mandatory_pre_header,
  ],
  MipMapEncoder: (_x: MipMapEncoder) => _x.raw.kwl,
  MuxStatistics: (_x: MuxStatistics) => _x.raw.kwl,
  CompressionRatio: (
    _x: { ratio: number },
    _socket: VScript.VSocket,
  ): [number] => [_x.ratio],
  RouterError: (_x: RouterError) => _x.raw.kwl,
  SSRCStatus: (
    _x: {
      /**
                              This field is used to identify the
                              synchronization source. The value is determined
                              randomly so that no two sources within the RTP
                              session have the same identification number
                            */
      ssrc: VAPI.Primitives.Unsigned32;
      ssrc_counter: VAPI.Primitives.Unsigned32;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.ssrc, _x.ssrc_counter],
  ST20226Settings: (_x: {}, _socket: VScript.VSocket): [] => [],
  ST2042Settings: (
    _x: { compression: VAPI.Video.DiracCompression; add_st2110_40: boolean },
    _socket: VScript.VSocket,
  ): [VAPI.Video.DiracCompression, boolean] => [
    _x.compression,
    _x.add_st2110_40,
  ],
  SourceAddressVlan: (
    _x: {
      vlan_id: null | VAPI.Primitives.VlanID;

      /**
                              IP (unicast) address of the RTP stream sender
                            */
      src_address: null | string;
    },
    _socket: VScript.VSocket,
  ): [null | number, null | string] => [_x.vlan_id, _x.src_address],
  Tagging: (
    _x: {
      tagging_hw_value: VAPI.Primitives.Unsigned32;
      tagging_decipher: VAPI.RTPTransmitter.TaggingDecipher;
    },
    _socket: VScript.VSocket,
  ): [number, [number, VAPI.RTPTransmitter.ClassOfService]] => [
    _x.tagging_hw_value,
    VAPI.RTPTransmitter.lower.TaggingDecipher(_x.tagging_decipher, _socket),
  ],
  TaggingDecipher: (
    _x: {
      vlan_id: VAPI.Primitives.VlanID;
      class_of_service: VAPI.RTPTransmitter.ClassOfService;
    },
    _socket: VScript.VSocket,
  ): [number, VAPI.RTPTransmitter.ClassOfService] => [
    _x.vlan_id,
    _x.class_of_service,
  ],
  IpConfigMipMapActiveStreamParameter: (
    _x: {
      /**
                              IP (unicast) address of the RTP stream sender
                            */
      src_address: null | string;

      /**
                              IP (multicast) destination address of the RTP
                              stream
                            */
      dst_address: null | string;
      lane_id: number;
      stream_id: number;
      vlan_id: null | VAPI.Primitives.VlanID;
    },
    _socket: VScript.VSocket,
  ): [null | string, null | string, number, number, null | number] => [
    _x.src_address,
    _x.dst_address,
    _x.lane_id,
    _x.stream_id,
    _x.vlan_id,
  ],
  RouterErrorErrorInput: (
    _x: {
      max_fifo_level: Array<VAPI.Primitives.Unsigned32>;
      max_fifo_level_last_read: Array<VAPI.Primitives.Unsigned32>;
      overflow: Array<VAPI.Primitives.Unsigned32>;
      error_irq_counter: VAPI.Primitives.Unsigned32;
    },
    _socket: VScript.VSocket,
  ): [Array<number>, Array<number>, Array<number>, number] => [
    _x.max_fifo_level,
    _x.max_fifo_level_last_read,
    _x.overflow,
    _x.error_irq_counter,
  ],
  RouterErrorErrorOutput: (
    _x: {
      max_fifo_level: Array<VAPI.Primitives.Unsigned32>;
      max_fifo_level_last_read: Array<VAPI.Primitives.Unsigned32>;
      overflow: Array<VAPI.Primitives.Unsigned32>;
    },
    _socket: VScript.VSocket,
  ): [Array<number>, Array<number>, Array<number>] => [
    _x.max_fifo_level,
    _x.max_fifo_level_last_read,
    _x.overflow,
  ],
  IpConfigHeaderInfo: (_x: IpConfigHeaderInfo) => _x.raw.kwl,
  SessionInterfaces: (
    _x: {
      primary: null | VAPI.NetworkInterfaces.VirtualInterface;
      secondary: null | VAPI.NetworkInterfaces.VirtualInterface;
    },
    _socket: VScript.VSocket,
  ): [null | string, null | string] => [
    _x.primary === null ? null : _x.primary.raw.kwl,
    _x.secondary === null ? null : _x.secondary.raw.kwl,
  ],
  MediaStreamerIpConfiguration: (_x: MediaStreamerIpConfiguration) =>
    _x.raw.kwl,
  MediaStreamerVideoIpConfiguration: (_x: MediaStreamerVideoIpConfiguration) =>
    _x.raw.kwl,
  MipMapStreamerIpConfiguration: (_x: MipMapStreamerIpConfiguration) =>
    _x.raw.kwl,
  JpegXsHardware: (
    _x: {
      /**
                                      Width of the input encoded image, in
                                      pixels. Must be a multiple of 2. Up to
                                      4096 for UHD IP-core flavor
                                    */
      width: VAPI.Primitives.Unsigned32;

      /**
                                      Height of the input encoded image, in
                                      pixels. Must be a multiple of 2, and
                                      greater than or equal to 4
                                    */
      height: VAPI.Primitives.Unsigned32;

      /**
                                      Contains input mode configuration
                                      fields: bit 3-0: color and sub-sampling
                                      mode
                                    */
      mode: VAPI.RTPTransmitter.ColorSampleMode;

      /**
                                      Budget in bytes per compressed frame,
                                      which is allocated to the picture
                                      header and the compressed data. Note:
                                      To compute this value according to a
                                      bit per pixel rate: budget = bpp x
                                      width x height / 8 Complementary header
                                      (ie. boxes) is not included in the
                                      budget
                                    */
      budget_per_frame: VAPI.Primitives.Unsigned32;

      /**
                                      VALIDATE It validates the given
                                      configuration. Set to '1' to start the
                                      IP-core, after setting mode and images
                                      parameters. This signal must be
                                      activated to validate any change in
                                      configuration (width, height, ...). Set
                                      to '0' to stop the IP-core. bit 1: (R)
                                      CFG_READY ‘1’ indicates that the
                                      TICO-XS is ready to receive a new
                                      configuration, when this bit is ‘0’
                                      configuration registers shouldn't be
                                      modified
                                    */
      vld: VAPI.RTPTransmitter.ValidateMode;

      /**
                                      Number of images to play when the
                                      IP-core is in command mode. (when
                                      PLAY_MODE register = 0)
                                    */
      number_of_images: VAPI.Primitives.Unsigned32;

      /**
                                      Bit depth of the video content, mapped
                                      on the MSBs of the port interface. The
                                      valid bit depths are 8, 10 and 12 bits
                                      per component
                                    */
      video_depth: VAPI.RTPTransmitter.VideoDepth;

      /**
                                      It allows to choose between two running
                                      modes: set to '1' to run in play mode,
                                      in which the IP-core processes frames
                                      continuously. or set to '0' to run in
                                      command mode, in which the IP-core
                                      processes n frames, n defined by NBR
                                    */
      play_mode: boolean;

      /**
                                      This register is used to program the
                                      image quality optimization parameters
                                      (visual or PSNR). Each pre-computed
                                      weights value must be written to this
                                      register sequentially to ensure proper
                                      encoder behavior.
                                    */
      level_weights: Array<VAPI.Primitives.Unsigned32>;
      profile: VAPI.Primitives.Unsigned32;
    },
    _socket: VScript.VSocket,
  ): [
    number,
    number,
    VAPI.RTPTransmitter.ColorSampleMode,
    number,
    VAPI.RTPTransmitter.ValidateMode,
    number,
    VAPI.RTPTransmitter.VideoDepth,
    boolean,
    Array<number>,
    number,
  ] => [
    _x.width,
    _x.height,
    _x.mode,
    _x.budget_per_frame,
    _x.vld,
    _x.number_of_images,
    _x.video_depth,
    _x.play_mode,
    _x.level_weights,
    _x.profile,
  ],
  AllLicenseInformation: (_x: AllLicenseInformation) => _x.raw.kwl,
  MipMapStreamerIpConfigurationMedia: (
    _x: MipMapStreamerIpConfigurationMedia,
  ) => _x.raw.kwl,
  AllSettingsOnIncompleteConfiguration: (
    _x: {
      /**
                                          allow the session to be activated
                                          even though not all ip
                                          configuration has been completed.
                                        */
      refuse_activation: boolean;

      /**
                                          true: reserve the hardware for the
                                          incomplete configured path
                                        */
      reserve_resources: boolean;
    },
    _socket: VScript.VSocket,
  ): [boolean, boolean] => [_x.refuse_activation, _x.reserve_resources],
  MuxStatisticsPort0: (
    _x: {
      words: VAPI.Primitives.Unsigned32;
      packets: VAPI.Primitives.Unsigned32;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.words, _x.packets],
  MuxStatisticsPort1: (
    _x: {
      words: VAPI.Primitives.Unsigned32;
      packets: VAPI.Primitives.Unsigned32;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.words, _x.packets],
  MuxStatisticsScheduler: (
    _x: { packets: VAPI.Primitives.Unsigned32 },
    _socket: VScript.VSocket,
  ): [number] => [_x.packets],
  AllSettings: (_x: AllSettings) => _x.raw.kwl,
} as const;
export type ActivationControl = "Off" | "Off_preserve_resource" | "On";
export class AudioConfigurationContainer
  implements
    VScript.Referenceable<"RTPTransmitter::Data::AudioConfigurationContainer">
{
  readonly type_identifier =
    "RTPTransmitter::Data::AudioConfigurationContainer" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get transport_format(): VScript.dKeyword<
    VScript.VSocket,
    [number, VAPI.Audio.Format, VAPI.Definitions.PacketTime],
    [number, VAPI.Audio.Format, VAPI.Definitions.PacketTime],
    VAPI.RTPTransmitter.AudioConfigurationFormat,
    VAPI.RTPTransmitter.AudioConfigurationFormat,
    VAPI.RTPTransmitter.AudioConfigurationContainer
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      [number, VAPI.Audio.Format, VAPI.Definitions.PacketTime],
      [number, VAPI.Audio.Format, VAPI.Definitions.PacketTime],
      VAPI.RTPTransmitter.AudioConfigurationFormat,
      VAPI.RTPTransmitter.AudioConfigurationFormat,
      VAPI.RTPTransmitter.AudioConfigurationContainer
    >(
      this,
      "transport_format" as VScript.SysName,
      {
        lift: VAPI.RTPTransmitter.lift.AudioConfigurationFormat,
        lower: VAPI.RTPTransmitter.lower.AudioConfigurationFormat,
      },
      {
        lift: VAPI.RTPTransmitter.lift.AudioConfigurationFormat,
        lower: VAPI.RTPTransmitter.lower.AudioConfigurationFormat,
      },
      null,
    );
  }
}
export interface AudioConfigurationFormat {
  num_channels: VAPI.Audio.Channelcount;
  format: VAPI.Audio.Format;
  packet_time: VAPI.Definitions.PacketTime;
}
export class AudioGroupControl
  implements VScript.Referenceable<"RTPTransmitter::Data::AudioGroupControl">
{
  readonly type_identifier = "RTPTransmitter::Data::AudioGroupControl" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get remapping(): VScript.rKeyword<
    VScript.VSocket,
    Array<number>,
    Array<number>,
    VAPI.RTPTransmitter.AudioGroupControl
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      Array<number>,
      Array<number>,
      VAPI.RTPTransmitter.AudioGroupControl
    >(this, "remapping" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get enabled_output_0(): VScript.rKeyword<
    VScript.VSocket,
    number,
    VAPI.Primitives.Unsigned32,
    VAPI.RTPTransmitter.AudioGroupControl
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      number,
      VAPI.Primitives.Unsigned32,
      VAPI.RTPTransmitter.AudioGroupControl
    >(this, "enabled_output_0" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get enabled_output_1(): VScript.rKeyword<
    VScript.VSocket,
    number,
    VAPI.Primitives.Unsigned32,
    VAPI.RTPTransmitter.AudioGroupControl
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      number,
      VAPI.Primitives.Unsigned32,
      VAPI.RTPTransmitter.AudioGroupControl
    >(this, "enabled_output_1" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get used_groups(): VScript.rKeyword<
    VScript.VSocket,
    string,
    string,
    VAPI.RTPTransmitter.AudioGroupControl
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      string,
      string,
      VAPI.RTPTransmitter.AudioGroupControl
    >(this, "used_groups" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
}
export class AudioGroupControlStatus
  implements
    VScript.Referenceable<"RTPTransmitter::Data::AudioGroupControlStatus">
{
  readonly type_identifier =
    "RTPTransmitter::Data::AudioGroupControlStatus" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get primary(): VScript.rKeyword<
    VScript.VSocket,
    Array<number>,
    Array<VAPI.Primitives.Signed32>,
    VAPI.RTPTransmitter.AudioGroupControlStatus
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      Array<number>,
      Array<VAPI.Primitives.Signed32>,
      VAPI.RTPTransmitter.AudioGroupControlStatus
    >(this, "primary" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get secondary(): VScript.rKeyword<
    VScript.VSocket,
    Array<number>,
    Array<VAPI.Primitives.Signed32>,
    VAPI.RTPTransmitter.AudioGroupControlStatus
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      Array<number>,
      Array<VAPI.Primitives.Signed32>,
      VAPI.RTPTransmitter.AudioGroupControlStatus
    >(this, "secondary" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
}
export interface CompressionBandwidth {
  max_data_rate: VAPI.Primitives.Unsigned32;
}
export type ClassOfService =
  | "best_effort"
  | "medium_priority"
  | "high_priority"
  | "voice_call_signaling"
  | "video"
  | "voice";
export type ColorSampleMode =
  | "GB_444"
  | "YCbCr_422"
  | "YCbCr_420"
  | "YCbCr_444";
export type Compression =
  | { variant: "Bandwidth"; value: VAPI.RTPTransmitter.CompressionBandwidth }
  | { variant: "Ratio"; value: VAPI.RTPTransmitter.CompressionRatio };
export class Constraints
  implements VScript.Referenceable<"RTPTransmitter::Data::Constraints">
{
  readonly type_identifier = "RTPTransmitter::Data::Constraints" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get calculation_standard(): VScript.rKeyword<
    VScript.VSocket,
    VAPI.Video.Standard,
    VAPI.Video.Standard,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      VAPI.Video.Standard,
      VAPI.Video.Standard,
      VAPI.RTPTransmitter.Constraints
    >(this, "calculation_standard" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get latched_standard(): VScript.rKeyword<
    VScript.VSocket,
    null | VAPI.Video.Standard,
    null | VAPI.Video.Standard,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | VAPI.Video.Standard,
      null | VAPI.Video.Standard,
      VAPI.RTPTransmitter.Constraints
    >(this, "latched_standard" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get current_send_standard(): VScript.rKeyword<
    VScript.VSocket,
    null | VAPI.Video.Standard,
    null | VAPI.Video.Standard,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | VAPI.Video.Standard,
      null | VAPI.Video.Standard,
      VAPI.RTPTransmitter.Constraints
    >(this, "current_send_standard" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get latched_pixel_format(): VScript.rKeyword<
    VScript.VSocket,
    | null
    | [
        null | VAPI.Video.ColorSpace,
        VAPI.Video.BitDepth,
        null | VAPI.Video.TransferCharacteristics,
        VAPI.Video.LuminanceAndColorDifferenceSignal,
      ],
    null | VAPI.Video.PixelFormat,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      | null
      | [
          null | VAPI.Video.ColorSpace,
          VAPI.Video.BitDepth,
          null | VAPI.Video.TransferCharacteristics,
          VAPI.Video.LuminanceAndColorDifferenceSignal,
        ],
      null | VAPI.Video.PixelFormat,
      VAPI.RTPTransmitter.Constraints
    >(this, "latched_pixel_format" as VScript.SysName, {
      lift: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.Video.lift.PixelFormat,
      ),
      lower: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.Video.lower.PixelFormat,
      ),
    });
  }
  get standard(): VScript.dKeyword<
    VScript.VSocket,
    null | VAPI.Video.Standard,
    null | VAPI.Video.Standard,
    null | VAPI.Video.Standard,
    null | VAPI.Video.Standard,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      null | VAPI.Video.Standard,
      null | VAPI.Video.Standard,
      null | VAPI.Video.Standard,
      null | VAPI.Video.Standard,
      VAPI.RTPTransmitter.Constraints
    >(
      this,
      "standard" 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 sub_stream(): VScript.rKeyword<
    VScript.VSocket,
    null | VAPI.Video.SubStream,
    null | VAPI.Video.SubStream,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | VAPI.Video.SubStream,
      null | VAPI.Video.SubStream,
      VAPI.RTPTransmitter.Constraints
    >(this, "sub_stream" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get max_bandwidth(): VScript.dKeyword<
    VScript.VSocket,
    VAPI.Definitions.Bandwidth,
    VAPI.Definitions.Bandwidth,
    VAPI.Definitions.Bandwidth,
    VAPI.Definitions.Bandwidth,
    VAPI.RTPTransmitter.Constraints
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      VAPI.Definitions.Bandwidth,
      VAPI.Definitions.Bandwidth,
      VAPI.Definitions.Bandwidth,
      VAPI.Definitions.Bandwidth,
      VAPI.RTPTransmitter.Constraints
    >(
      this,
      "max_bandwidth" 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 interface HeaderSettings {
  payload_type: null | VAPI.Definitions.RtpPayloadType;

  /**
    refers to 802.1p Class of Service (CoS). The CoS is only available when
    VLAN tagging is used.
  */
  class_of_service: null | VAPI.RTPTransmitter.ClassOfService;

  /**
    The Class Name (assured forwarding) offers an easy way to identify the
    DSCP value. DSCP uses the first six bits of the Type of Service(Tos) to
    identify the packet priority. The first three bits represent the Class
    Selector. The last three bits the Drop Precedence. For example, if a
    packet is marked `assured_forwarding_23`, then its Class Selector is 2
    (the 2 in 23) and its Drop Precedence is High (the 3 in 23).
  */
  traffic_class: null | VAPI.RTPTransmitter.TrafficClassOrQos;

  /**
    This field is used to identify the synchronization source. The value is
    determined randomly so that with high probability no two sources have the
    same identification number
  */
  ssrc: null | VAPI.Primitives.Unsigned32;
  ttl: number;
}
export class IpConfig
  implements VScript.Referenceable<"RTPTransmitter::Data::IpConfig">
{
  readonly type_identifier = "RTPTransmitter::Data::IpConfig" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get sdp_a(): VScript.rKeyword<
    VScript.VSocket,
    string,
    string,
    VAPI.RTPTransmitter.IpConfig
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      string,
      string,
      VAPI.RTPTransmitter.IpConfig
    >(this, "sdp_a" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get preserve_src_ip_entry(): VScript.rwKeyword<
    VScript.VSocket,
    boolean,
    boolean,
    boolean,
    boolean,
    VAPI.RTPTransmitter.IpConfig
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      boolean,
      boolean,
      boolean,
      boolean,
      VAPI.RTPTransmitter.IpConfig
    >(
      this,
      "preserve_src_ip_entry" 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 src_address_vlan(): VScript.dKeyword<
    VScript.VSocket,
    [null | number, null | string],
    [null | number, null | string],
    VAPI.RTPTransmitter.SourceAddressVlan,
    VAPI.RTPTransmitter.SourceAddressVlan,
    VAPI.RTPTransmitter.IpConfig
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      [null | number, null | string],
      [null | number, null | string],
      VAPI.RTPTransmitter.SourceAddressVlan,
      VAPI.RTPTransmitter.SourceAddressVlan,
      VAPI.RTPTransmitter.IpConfig
    >(
      this,
      "src_address_vlan" as VScript.SysName,
      {
        lift: VAPI.RTPTransmitter.lift.SourceAddressVlan,
        lower: VAPI.RTPTransmitter.lower.SourceAddressVlan,
      },
      {
        lift: VAPI.RTPTransmitter.lift.SourceAddressVlan,
        lower: VAPI.RTPTransmitter.lower.SourceAddressVlan,
      },
      null,
    );
  }

  /**
    IP (multicast) destination address of the RTP stream
  */
  get dst_address(): VScript.dKeyword<
    VScript.VSocket,
    null | string,
    null | string,
    null | string,
    null | string,
    VAPI.RTPTransmitter.IpConfig
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      null | string,
      null | string,
      null | string,
      null | string,
      VAPI.RTPTransmitter.IpConfig
    >(
      this,
      "dst_address" 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,
      },
      (parent: VAPI.RTPTransmitter.IpConfig, command: null | string) => (
        void parent,
        void command,
        {
          criterion: "status",
          validator: (status: null | string) =>
            VScript.addrs_equal_up_to_port({ command, status }),
        }
      ),
    );
  }
  get header_settings(): VScript.dKeyword<
    VScript.VSocket,
    [
      null | number,
      null | VAPI.RTPTransmitter.ClassOfService,
      null | VAPI.RTPTransmitter.TrafficClassOrQos,
      null | number,
      number,
    ],
    [
      null | number,
      null | VAPI.RTPTransmitter.ClassOfService,
      null | VAPI.RTPTransmitter.TrafficClassOrQos,
      null | number,
      number,
    ],
    VAPI.RTPTransmitter.HeaderSettings,
    VAPI.RTPTransmitter.HeaderSettings,
    VAPI.RTPTransmitter.IpConfig
  > {
    return new VScript.dKeyword<
      VScript.VSocket,
      [
        null | number,
        null | VAPI.RTPTransmitter.ClassOfService,
        null | VAPI.RTPTransmitter.TrafficClassOrQos,
        null | number,
        number,
      ],
      [
        null | number,
        null | VAPI.RTPTransmitter.ClassOfService,
        null | VAPI.RTPTransmitter.TrafficClassOrQos,
        null | number,
        number,
      ],
      VAPI.RTPTransmitter.HeaderSettings,
      VAPI.RTPTransmitter.HeaderSettings,
      VAPI.RTPTransmitter.IpConfig
    >(
      this,
      "header_settings" as VScript.SysName,
      {
        lift: VAPI.RTPTransmitter.lift.HeaderSettings,
        lower: VAPI.RTPTransmitter.lower.HeaderSettings,
      },
      {
        lift: VAPI.RTPTransmitter.lift.HeaderSettings,
        lower: VAPI.RTPTransmitter.lower.HeaderSettings,
      },
      null,
    );
  }
  get header_info() {
    return VAPI.RTPTransmitter.lift.IpConfigHeaderInfo(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 5, "header_info"),
    );
  }
}
export class IpConfigInterfaces
  implements VScript.Referenceable<"RTPTransmitter::Data::IpConfigInterfaces">
{
  readonly type_identifier =
    "RTPTransmitter::Data::IpConfigInterfaces" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get primary() {
    return VAPI.RTPTransmitter.lift.IpConfig(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 0, "primary"),
    );
  }
  get secondary() {
    return VAPI.RTPTransmitter.lift.IpConfig(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 1, "secondary"),
    );
  }
}
export class IpConfigMipMap
  implements VScript.Referenceable<"RTPTransmitter::Data::IpConfigMipMap">
{
  readonly type_identifier = "RTPTransmitter::Data::IpConfigMipMap" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get active_stream_parameter(): VScript.rKeyword<
    VScript.VSocket,
    null | [null | string, null | string, number, number, null | number],
    null | VAPI.RTPTransmitter.IpConfigMipMapActiveStreamParameter,
    VAPI.RTPTransmitter.IpConfigMipMap
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | [null | string, null | string, number, number, null | number],
      null | VAPI.RTPTransmitter.IpConfigMipMapActiveStreamParameter,
      VAPI.RTPTransmitter.IpConfigMipMap
    >(this, "active_stream_parameter" as VScript.SysName, {
      lift: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.RTPTransmitter.lift.IpConfigMipMapActiveStreamParameter,
      ),
      lower: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.RTPTransmitter.lower.IpConfigMipMapActiveStreamParameter,
      ),
    });
  }
}
export class IpSDPConfigInterfaces
  implements
    VScript.Referenceable<"RTPTransmitter::Data::IpSDPConfigInterfaces">
{
  readonly type_identifier =
    "RTPTransmitter::Data::IpSDPConfigInterfaces" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get sdp_a(): VScript.rKeyword<
    VScript.VSocket,
    string,
    string,
    VAPI.RTPTransmitter.IpSDPConfigInterfaces
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      string,
      string,
      VAPI.RTPTransmitter.IpSDPConfigInterfaces
    >(this, "sdp_a" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get primary() {
    return VAPI.RTPTransmitter.lift.IpConfig(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 1, "primary"),
    );
  }
  get secondary() {
    return VAPI.RTPTransmitter.lift.IpConfig(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 2, "secondary"),
    );
  }
}
export interface JpegXsSettings {
  compression: VAPI.RTPTransmitter.Compression;

  /**
    PSNR optimization: by default, the rate allocation of the encoder is
    configured to optimize the image quality based on the Peak Signal to
    Noise Ratio (PSNR) calculation. This configuration, called 'PSNR
    Weights', is providing the best results of TICO compression for PSNR
    measurements. visual optimization: the 'Visual Weights' configuration is
    the optimal configuration for real-life subjective quality assessment.
    Compared to the “PSNR Weights” configuration, it provides a better
    viewing experience but it sometimes produces lower PSNR results.
  */
  lvl_weight_mode: VAPI.RTPTransmitter.LVLMODE;
  add_st2110_40: boolean;
  omit_mandatory_pre_header: boolean;
}
export type LVLMODE = "peak_signal_noise_ratio" | "visual_optimization";
export class MipMapEncoder
  implements VScript.Referenceable<"RTPTransmitter::Data::MipMapEncoder">
{
  readonly type_identifier = "RTPTransmitter::Data::MipMapEncoder" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get allocated_blocks(): VScript.rKeyword<
    VScript.VSocket,
    number,
    VAPI.Primitives.Unsigned32,
    VAPI.RTPTransmitter.MipMapEncoder
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      number,
      VAPI.Primitives.Unsigned32,
      VAPI.RTPTransmitter.MipMapEncoder
    >(this, "allocated_blocks" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get block_addr(): VScript.rKeyword<
    VScript.VSocket,
    Array<number>,
    Array<VAPI.Primitives.Unsigned32>,
    VAPI.RTPTransmitter.MipMapEncoder
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      Array<number>,
      Array<VAPI.Primitives.Unsigned32>,
      VAPI.RTPTransmitter.MipMapEncoder
    >(this, "block_addr" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
}
export class MuxStatistics
  implements VScript.Referenceable<"RTPTransmitter::Data::MuxStatistics">
{
  readonly type_identifier = "RTPTransmitter::Data::MuxStatistics" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get port0(): VScript.rKeyword<
    VScript.VSocket,
    [number, number],
    VAPI.RTPTransmitter.MuxStatisticsPort0,
    VAPI.RTPTransmitter.MuxStatistics
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      [number, number],
      VAPI.RTPTransmitter.MuxStatisticsPort0,
      VAPI.RTPTransmitter.MuxStatistics
    >(this, "port0" as VScript.SysName, {
      lift: VAPI.RTPTransmitter.lift.MuxStatisticsPort0,
      lower: VAPI.RTPTransmitter.lower.MuxStatisticsPort0,
    });
  }
  get port1(): VScript.rKeyword<
    VScript.VSocket,
    [number, number],
    VAPI.RTPTransmitter.MuxStatisticsPort1,
    VAPI.RTPTransmitter.MuxStatistics
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      [number, number],
      VAPI.RTPTransmitter.MuxStatisticsPort1,
      VAPI.RTPTransmitter.MuxStatistics
    >(this, "port1" as VScript.SysName, {
      lift: VAPI.RTPTransmitter.lift.MuxStatisticsPort1,
      lower: VAPI.RTPTransmitter.lower.MuxStatisticsPort1,
    });
  }
  get scheduler(): VScript.rKeyword<
    VScript.VSocket,
    [number],
    VAPI.RTPTransmitter.MuxStatisticsScheduler,
    VAPI.RTPTransmitter.MuxStatistics
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      [number],
      VAPI.RTPTransmitter.MuxStatisticsScheduler,
      VAPI.RTPTransmitter.MuxStatistics
    >(this, "scheduler" as VScript.SysName, {
      lift: VAPI.RTPTransmitter.lift.MuxStatisticsScheduler,
      lower: VAPI.RTPTransmitter.lower.MuxStatisticsScheduler,
    });
  }
}
export type OnConfiguration = "RefuseActivation" | "AllowActivation";
export type PackingMode = "GPM" | "BPM";
export interface CompressionRatio {
  ratio: number;
}
export type ReduceMaxThroughput =
  | "doNotReduce"
  | "ReduceBy_1Percent"
  | "ReduceBy_2Percent"
  | "ReduceBy_3Percent"
  | "ReduceBy_4Percent"
  | "ReduceBy_5Percent"
  | "ReduceBy_6Percent"
  | "ReduceBy_7Percent"
  | "ReduceBy_8Percent"
  | "ReduceBy_9Percent"
  | "ReduceBy_10Percent";
export class RouterError
  implements VScript.Referenceable<"RTPTransmitter::Data::RouterError">
{
  readonly type_identifier = "RTPTransmitter::Data::RouterError" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get error_input(): VScript.rKeyword<
    VScript.VSocket,
    [Array<number>, Array<number>, Array<number>, number],
    VAPI.RTPTransmitter.RouterErrorErrorInput,
    VAPI.RTPTransmitter.RouterError
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      [Array<number>, Array<number>, Array<number>, number],
      VAPI.RTPTransmitter.RouterErrorErrorInput,
      VAPI.RTPTransmitter.RouterError
    >(this, "error_input" as VScript.SysName, {
      lift: VAPI.RTPTransmitter.lift.RouterErrorErrorInput,
      lower: VAPI.RTPTransmitter.lower.RouterErrorErrorInput,
    });
  }
  get error_output(): VScript.rKeyword<
    VScript.VSocket,
    [Array<number>, Array<number>, Array<number>],
    VAPI.RTPTransmitter.RouterErrorErrorOutput,
    VAPI.RTPTransmitter.RouterError
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      [Array<number>, Array<number>, Array<number>],
      VAPI.RTPTransmitter.RouterErrorErrorOutput,
      VAPI.RTPTransmitter.RouterError
    >(this, "error_output" as VScript.SysName, {
      lift: VAPI.RTPTransmitter.lift.RouterErrorErrorOutput,
      lower: VAPI.RTPTransmitter.lower.RouterErrorErrorOutput,
    });
  }
}
export type SPSMode = "possible" | "in_use" | "is_optimized";
export interface SSRCStatus {
  /**
    This field is used to identify the synchronization source. The value is
    determined randomly so that no two sources within the RTP session have
    the same identification number
  */
  ssrc: VAPI.Primitives.Unsigned32;
  ssrc_counter: VAPI.Primitives.Unsigned32;
}
export interface ST20226Settings {}
export interface ST2042Settings {
  compression: VAPI.Video.DiracCompression;
  add_st2110_40: boolean;
}
export interface SourceAddressVlan {
  vlan_id: null | VAPI.Primitives.VlanID;

  /**
    IP (unicast) address of the RTP stream sender
  */
  src_address: null | string;
}
export type StripMining = "ReduceToMinimum" | "HoldInBackhand";
export interface Tagging {
  tagging_hw_value: VAPI.Primitives.Unsigned32;
  tagging_decipher: VAPI.RTPTransmitter.TaggingDecipher;
}
export interface TaggingDecipher {
  vlan_id: VAPI.Primitives.VlanID;
  class_of_service: VAPI.RTPTransmitter.ClassOfService;
}
export type TrafficClassOrQos =
  | "assured_forwarding_default"
  | "assured_forwarding_11"
  | "assured_forwarding_12"
  | "assured_forwarding_13"
  | "assured_forwarding_21"
  | "assured_forwarding_22"
  | "assured_forwarding_23"
  | "assured_forwarding_31"
  | "assured_forwarding_32"
  | "assured_forwarding_33"
  | "assured_forwarding_41"
  | "assured_forwarding_42"
  | "assured_forwarding_43"
  | "assured_forwarding_ef";
export type ValidateMode = "validate_start" | "validate_stop";
export type VideoDepth = "depths_8" | "depths_10" | "depths_12";
export interface IpConfigMipMapActiveStreamParameter {
  /**
    IP (unicast) address of the RTP stream sender
  */
  src_address: null | string;

  /**
    IP (multicast) destination address of the RTP stream
  */
  dst_address: null | string;
  lane_id: number;
  stream_id: number;
  vlan_id: null | VAPI.Primitives.VlanID;
}
export interface RouterErrorErrorInput {
  max_fifo_level: Array<VAPI.Primitives.Unsigned32>;
  max_fifo_level_last_read: Array<VAPI.Primitives.Unsigned32>;
  overflow: Array<VAPI.Primitives.Unsigned32>;
  error_irq_counter: VAPI.Primitives.Unsigned32;
}
export interface RouterErrorErrorOutput {
  max_fifo_level: Array<VAPI.Primitives.Unsigned32>;
  max_fifo_level_last_read: Array<VAPI.Primitives.Unsigned32>;
  overflow: Array<VAPI.Primitives.Unsigned32>;
}
export class IpConfigHeaderInfo
  implements VScript.Referenceable<"RTPTransmitter::Data::IpConfig::HeaderInfo">
{
  readonly type_identifier =
    "RTPTransmitter::Data::IpConfig::HeaderInfo" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get tagging(): VScript.rKeyword<
    VScript.VSocket,
    null | [number, [number, VAPI.RTPTransmitter.ClassOfService]],
    null | VAPI.RTPTransmitter.Tagging,
    VAPI.RTPTransmitter.IpConfigHeaderInfo
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | [number, [number, VAPI.RTPTransmitter.ClassOfService]],
      null | VAPI.RTPTransmitter.Tagging,
      VAPI.RTPTransmitter.IpConfigHeaderInfo
    >(this, "tagging" as VScript.SysName, {
      lift: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.RTPTransmitter.lift.Tagging,
      ),
      lower: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.RTPTransmitter.lower.Tagging,
      ),
    });
  }
  get ssrc_info(): VScript.rKeyword<
    VScript.VSocket,
    null | [number, number],
    null | VAPI.RTPTransmitter.SSRCStatus,
    VAPI.RTPTransmitter.IpConfigHeaderInfo
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | [number, number],
      null | VAPI.RTPTransmitter.SSRCStatus,
      VAPI.RTPTransmitter.IpConfigHeaderInfo
    >(this, "ssrc_info" as VScript.SysName, {
      lift: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.RTPTransmitter.lift.SSRCStatus,
      ),
      lower: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.RTPTransmitter.lower.SSRCStatus,
      ),
    });
  }
}
export interface SessionInterfaces {
  primary: null | VAPI.NetworkInterfaces.VirtualInterface;
  secondary: null | VAPI.NetworkInterfaces.VirtualInterface;
}
export class MediaStreamerIpConfiguration
  implements
    VScript.Referenceable<"RTPTransmitter::Data::MediaStreamer::IpConfiguration">
{
  readonly type_identifier =
    "RTPTransmitter::Data::MediaStreamer::IpConfiguration" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get sdp_a(): VScript.rKeyword<
    VScript.VSocket,
    string,
    string,
    VAPI.RTPTransmitter.MediaStreamerIpConfiguration
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      string,
      string,
      VAPI.RTPTransmitter.MediaStreamerIpConfiguration
    >(this, "sdp_a" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get media() {
    return VAPI.RTPTransmitter.lift.IpConfigInterfaces(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 1, "media"),
    );
  }
}
export class MediaStreamerVideoIpConfiguration
  implements
    VScript.Referenceable<"RTPTransmitter::Data::MediaStreamerVideo::IpConfiguration">
{
  readonly type_identifier =
    "RTPTransmitter::Data::MediaStreamerVideo::IpConfiguration" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get sdp_a(): VScript.rKeyword<
    VScript.VSocket,
    string,
    string,
    VAPI.RTPTransmitter.MediaStreamerVideoIpConfiguration
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      string,
      string,
      VAPI.RTPTransmitter.MediaStreamerVideoIpConfiguration
    >(this, "sdp_a" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
  get video() {
    return VAPI.RTPTransmitter.lift.IpSDPConfigInterfaces(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 1, "video"),
    );
  }
  get meta() {
    return VAPI.RTPTransmitter.lift.IpSDPConfigInterfaces(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 2, "meta"),
    );
  }
}
export class MipMapStreamerIpConfiguration
  implements
    VScript.Referenceable<"RTPTransmitter::Data::MipMapStreamer::IpConfiguration">
{
  readonly type_identifier =
    "RTPTransmitter::Data::MipMapStreamer::IpConfiguration" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get media() {
    return VAPI.RTPTransmitter.lift.MipMapStreamerIpConfigurationMedia(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 0, "media"),
    );
  }
}
export type MediaStreamerIssues = {
  missing_dst_ip: boolean;
  missing_src_ip4: boolean;
  missing_src_ip6: boolean;
};
export type MediaStreamerVideoIssues = {
  missing_dst_ip: boolean;
  missing_input_dt_node: boolean;
  missing_src_ip4: boolean;
  missing_src_ip6: boolean;
};
export interface JpegXsHardware {
  /**
    Width of the input encoded image, in pixels. Must be a multiple of 2. Up
    to 4096 for UHD IP-core flavor
  */
  width: VAPI.Primitives.Unsigned32;

  /**
    Height of the input encoded image, in pixels. Must be a multiple of 2,
    and greater than or equal to 4
  */
  height: VAPI.Primitives.Unsigned32;

  /**
    Contains input mode configuration fields: bit 3-0: color and sub-sampling
    mode
  */
  mode: VAPI.RTPTransmitter.ColorSampleMode;

  /**
    Budget in bytes per compressed frame, which is allocated to the picture
    header and the compressed data. Note: To compute this value according to
    a bit per pixel rate: budget = bpp x width x height / 8 Complementary
    header (ie. boxes) is not included in the budget
  */
  budget_per_frame: VAPI.Primitives.Unsigned32;

  /**
    VALIDATE It validates the given configuration. Set to '1' to start the
    IP-core, after setting mode and images parameters. This signal must be
    activated to validate any change in configuration (width, height, ...).
    Set to '0' to stop the IP-core. bit 1: (R) CFG_READY ‘1’ indicates
    that the TICO-XS is ready to receive a new configuration, when this bit
    is ‘0’ configuration registers shouldn't be modified
  */
  vld: VAPI.RTPTransmitter.ValidateMode;

  /**
    Number of images to play when the IP-core is in command mode. (when
    PLAY_MODE register = 0)
  */
  number_of_images: VAPI.Primitives.Unsigned32;

  /**
    Bit depth of the video content, mapped on the MSBs of the port interface.
    The valid bit depths are 8, 10 and 12 bits per component
  */
  video_depth: VAPI.RTPTransmitter.VideoDepth;

  /**
    It allows to choose between two running modes: set to '1' to run in play
    mode, in which the IP-core processes frames continuously. or set to '0'
    to run in command mode, in which the IP-core processes n frames, n
    defined by NBR
  */
  play_mode: boolean;

  /**
    This register is used to program the image quality optimization
    parameters (visual or PSNR). Each pre-computed weights value must be
    written to this register sequentially to ensure proper encoder behavior.
  */
  level_weights: Array<VAPI.Primitives.Unsigned32>;
  profile: VAPI.Primitives.Unsigned32;
}
export class AllLicenseInformation
  implements
    VScript.Referenceable<"RTPTransmitter::Data::All::LicenseInformation">
{
  readonly type_identifier =
    "RTPTransmitter::Data::All::LicenseInformation" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get num_jpeg_xs_transmitters(): VScript.rKeyword<
    VScript.VSocket,
    number,
    VAPI.Primitives.Unsigned16,
    VAPI.RTPTransmitter.AllLicenseInformation
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      number,
      VAPI.Primitives.Unsigned16,
      VAPI.RTPTransmitter.AllLicenseInformation
    >(this, "num_jpeg_xs_transmitters" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
}
export class MipMapStreamerIpConfigurationMedia
  implements
    VScript.Referenceable<"RTPTransmitter::Data::MipMapStreamer::IpConfiguration::Media">
{
  readonly type_identifier =
    "RTPTransmitter::Data::MipMapStreamer::IpConfiguration::Media" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get primary() {
    return VAPI.RTPTransmitter.lift.IpConfigMipMap(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 0, "primary"),
    );
  }
  get secondary() {
    return VAPI.RTPTransmitter.lift.IpConfigMipMap(
      VScript.VAPIHelpers.subtree_child_checked(this.raw, 1, "secondary"),
    );
  }
}
export interface AllSettingsOnIncompleteConfiguration {
  /**
    allow the session to be activated even though not all ip configuration
    has been completed.
  */
  refuse_activation: boolean;

  /**
    true: reserve the hardware for the incomplete configured path
  */
  reserve_resources: boolean;
}
export interface MuxStatisticsPort0 {
  words: VAPI.Primitives.Unsigned32;
  packets: VAPI.Primitives.Unsigned32;
}
export interface MuxStatisticsPort1 {
  words: VAPI.Primitives.Unsigned32;
  packets: VAPI.Primitives.Unsigned32;
}
export interface MuxStatisticsScheduler {
  packets: VAPI.Primitives.Unsigned32;
}
export class AllSettings
  implements VScript.Referenceable<"RTPTransmitter::Data::All::Settings">
{
  readonly type_identifier = "RTPTransmitter::Data::All::Settings" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get on_incomplete_configuration(): VScript.rwKeyword<
    VScript.VSocket,
    [boolean, boolean],
    [boolean, boolean],
    VAPI.RTPTransmitter.AllSettingsOnIncompleteConfiguration,
    VAPI.RTPTransmitter.AllSettingsOnIncompleteConfiguration,
    VAPI.RTPTransmitter.AllSettings
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      [boolean, boolean],
      [boolean, boolean],
      VAPI.RTPTransmitter.AllSettingsOnIncompleteConfiguration,
      VAPI.RTPTransmitter.AllSettingsOnIncompleteConfiguration,
      VAPI.RTPTransmitter.AllSettings
    >(
      this,
      "on_incomplete_configuration" as VScript.SysName,
      {
        lift: VAPI.RTPTransmitter.lift.AllSettingsOnIncompleteConfiguration,
        lower: VAPI.RTPTransmitter.lower.AllSettingsOnIncompleteConfiguration,
      },
      {
        lift: VAPI.RTPTransmitter.lift.AllSettingsOnIncompleteConfiguration,
        lower: VAPI.RTPTransmitter.lower.AllSettingsOnIncompleteConfiguration,
      },
      null,
    );
  }

  /**
    reserves a desired bandwidth from the maximum possible throughput of the
    port to be used for inband control
  */
  get reserved_bandwidth(): VScript.rwKeyword<
    VScript.VSocket,
    number,
    number,
    number,
    number,
    VAPI.RTPTransmitter.AllSettings
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      number,
      number,
      number,
      number,
      VAPI.RTPTransmitter.AllSettings
    >(
      this,
      "reserved_bandwidth" 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 check_ip_address_timeout(): VScript.rwKeyword<
    VScript.VSocket,
    number,
    number,
    VScript.Duration,
    VScript.Duration,
    VAPI.RTPTransmitter.AllSettings
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      number,
      number,
      VScript.Duration,
      VScript.Duration,
      VAPI.RTPTransmitter.AllSettings
    >(
      this,
      "check_ip_address_timeout" as VScript.SysName,
      {
        lift: VScript.VAPIHelpers.liftNanoseconds,
        lower: VScript.VAPIHelpers.lowerNanoseconds,
      },
      {
        lift: VScript.VAPIHelpers.liftNanoseconds,
        lower: VScript.VAPIHelpers.lowerNanoseconds,
      },
      null,
    );
  }
}
export const Enums = {
  VideoDepth: ["depths_8", "depths_10", "depths_12"] as VideoDepth[],
  ValidateMode: ["validate_start", "validate_stop"] as ValidateMode[],
  TrafficClassOrQos: [
    "assured_forwarding_default",
    "assured_forwarding_11",
    "assured_forwarding_12",
    "assured_forwarding_13",
    "assured_forwarding_21",
    "assured_forwarding_22",
    "assured_forwarding_23",
    "assured_forwarding_31",
    "assured_forwarding_32",
    "assured_forwarding_33",
    "assured_forwarding_41",
    "assured_forwarding_42",
    "assured_forwarding_43",
    "assured_forwarding_ef",
  ] as TrafficClassOrQos[],
  StripMining: ["ReduceToMinimum", "HoldInBackhand"] as StripMining[],
  SPSMode: ["possible", "in_use", "is_optimized"] as SPSMode[],
  ReduceMaxThroughput: [
    "doNotReduce",
    "ReduceBy_1Percent",
    "ReduceBy_2Percent",
    "ReduceBy_3Percent",
    "ReduceBy_4Percent",
    "ReduceBy_5Percent",
    "ReduceBy_6Percent",
    "ReduceBy_7Percent",
    "ReduceBy_8Percent",
    "ReduceBy_9Percent",
    "ReduceBy_10Percent",
  ] as ReduceMaxThroughput[],
  PackingMode: ["GPM", "BPM"] as PackingMode[],
  OnConfiguration: ["RefuseActivation", "AllowActivation"] as OnConfiguration[],
  LVLMODE: ["peak_signal_noise_ratio", "visual_optimization"] as LVLMODE[],
  ColorSampleMode: [
    "GB_444",
    "YCbCr_422",
    "YCbCr_420",
    "YCbCr_444",
  ] as ColorSampleMode[],
  ClassOfService: [
    "best_effort",
    "medium_priority",
    "high_priority",
    "voice_call_signaling",
    "video",
    "voice",
  ] as ClassOfService[],
  ActivationControl: [
    "Off",
    "Off_preserve_resource",
    "On",
  ] as ActivationControl[],
} as const;
