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 = {
  CompressorCurveAutoGain: (
    _raw: [number, number, number, number],
    _socket: VScript.VSocket,
  ): CompressorCurveAutoGain => {
    return {
      cutoff: _raw[0],
      target: _raw[1],
      width: _raw[2],
      ratio: _raw[3],
    };
  },
  StereoPanBalanceBalanceCenterLinear: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): StereoPanBalanceBalanceCenterLinear => {
    return { balance: _raw[0] };
  },
  CompressorARTime: (
    _raw: [0, [number]] | [1, [number]],
    _socket: VScript.VSocket,
  ): CompressorARTime => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "Samples",
          value: VAPI.AudioEngine.lift.CompressorARTimeSamples(
            _raw[1],
            _socket,
          ),
        };
      case 1:
        return {
          variant: "Time",
          value: VAPI.AudioEngine.lift.CompressorARTimeTime(_raw[1], _socket),
        };
    }
  },
  CompressorCapabilities: (
    _raw: [number, [0, [boolean]] | [1, []], boolean],
    _socket: VScript.VSocket,
  ): CompressorCapabilities => {
    return {
      channels: _raw[0],
      control: VAPI.AudioEngine.lift.CompressorCapabilitiesControl(
        _raw[1],
        _socket,
      ),
      lookahead: _raw[2],
    };
  },
  CompressorCurve: (
    _raw:
      | [0, [number, number, number]]
      | [1, [number, number]]
      | [2, [number, number, number]]
      | [3, [number, number]]
      | [4, [number, number, number, number]],
    _socket: VScript.VSocket,
  ): CompressorCurve => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "SoftKnee",
          value: VAPI.AudioEngine.lift.CompressorCurveSoftKnee(
            _raw[1],
            _socket,
          ),
        };
      case 1:
        return {
          variant: "HardKnee",
          value: VAPI.AudioEngine.lift.CompressorCurveHardKnee(
            _raw[1],
            _socket,
          ),
        };
      case 2:
        return {
          variant: "Ducking",
          value: VAPI.AudioEngine.lift.CompressorCurveDucking(_raw[1], _socket),
        };
      case 3:
        return {
          variant: "Gate",
          value: VAPI.AudioEngine.lift.CompressorCurveGate(_raw[1], _socket),
        };
      case 4:
        return {
          variant: "AutoGain",
          value: VAPI.AudioEngine.lift.CompressorCurveAutoGain(
            _raw[1],
            _socket,
          ),
        };
    }
  },
  CompressorCurvePoint: (
    _raw: [number, number, null | number],
    _socket: VScript.VSocket,
  ): CompressorCurvePoint => {
    return {
      i: _raw[0],
      o: _raw[1],
      c: _raw[2],
    };
  },
  CompressorParameter: (
    _raw: [
      [0, [number]] | [1, [number]],
      [0, [number]] | [1, [number]],
      [0, [number]] | [1, [number]],
      number,
    ],
    _socket: VScript.VSocket,
  ): CompressorParameter => {
    return {
      attack: VAPI.AudioEngine.lift.CompressorARTime(_raw[0], _socket),
      release: VAPI.AudioEngine.lift.CompressorARTime(_raw[1], _socket),
      hold: VAPI.AudioEngine.lift.CompressorARTime(_raw[2], _socket),
      gain: _raw[3],
    };
  },
  CompressorSource: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new CompressorSource(_raw),
  DelayCapabilities: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): DelayCapabilities => {
    return {
      channels: _raw[0],
      taps: _raw[1],
    };
  },
  DelayParameter: (
    _raw: [0, [number]] | [1, [number]],
    _socket: VScript.VSocket,
  ): DelayParameter => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "Samples",
          value: VAPI.AudioEngine.lift.DelayParameterSamples(_raw[1], _socket),
        };
      case 1:
        return {
          variant: "Time",
          value: VAPI.AudioEngine.lift.DelayParameterTime(_raw[1], _socket),
        };
    }
  },
  DownMixCapabilities: (
    _raw: [VAPI.AudioEngine.DownMixCapabilitiesChannels],
    _socket: VScript.VSocket,
  ): DownMixCapabilities => {
    return {
      channels: _raw[0],
    };
  },
  CompressorCurveDucking: (
    _raw: [number, number, number],
    _socket: VScript.VSocket,
  ): CompressorCurveDucking => {
    return {
      threshold: _raw[0],
      width: _raw[1],
      gain: _raw[2],
    };
  },
  Fader: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) => new Fader(_raw),
  FilterCapabilities: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): FilterCapabilities => {
    return {
      channels: _raw[0],
      bands: _raw[1],
    };
  },
  FilterCoeffs: (
    _raw: [number, number, number, number, number],
    _socket: VScript.VSocket,
  ): FilterCoeffs => {
    return {
      a0: _raw[0],
      a1: _raw[1],
      a2: _raw[2],
      b1: _raw[3],
      b2: _raw[4],
    };
  },
  FilterHighPass: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): FilterHighPass => {
    return {
      fc: _raw[0],
      q: _raw[1],
    };
  },
  FilterHighShelf: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): FilterHighShelf => {
    return {
      fc: _raw[0],
      gain: _raw[1],
    };
  },
  FilterLowPass: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): FilterLowPass => {
    return {
      fc: _raw[0],
      q: _raw[1],
    };
  },
  FilterLowShelf: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): FilterLowShelf => {
    return {
      fc: _raw[0],
      gain: _raw[1],
    };
  },
  FilterParameter: (
    _raw:
      | [0, [number, number]]
      | [1, [number, number]]
      | [2, [number, number, number]]
      | [3, [number, number]]
      | [4, [number, number]],
    _socket: VScript.VSocket,
  ): FilterParameter => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "LowPass",
          value: VAPI.AudioEngine.lift.FilterLowPass(_raw[1], _socket),
        };
      case 1:
        return {
          variant: "HighPass",
          value: VAPI.AudioEngine.lift.FilterHighPass(_raw[1], _socket),
        };
      case 2:
        return {
          variant: "Peak",
          value: VAPI.AudioEngine.lift.FilterPeak(_raw[1], _socket),
        };
      case 3:
        return {
          variant: "LowShelf",
          value: VAPI.AudioEngine.lift.FilterLowShelf(_raw[1], _socket),
        };
      case 4:
        return {
          variant: "HighShelf",
          value: VAPI.AudioEngine.lift.FilterHighShelf(_raw[1], _socket),
        };
    }
  },
  FilterPeak: (
    _raw: [number, number, number],
    _socket: VScript.VSocket,
  ): FilterPeak => {
    return {
      fc: _raw[0],
      q: _raw[1],
      gain: _raw[2],
    };
  },
  CompressorCurveGate: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): CompressorCurveGate => {
    return {
      threshold: _raw[0],
      width: _raw[1],
    };
  },
  Group: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) => new Group(_raw),
  HWInputAssignment: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): HWInputAssignment => {
    return {
      value: _raw[0],
    };
  },
  CompressorCurveHardKnee: (
    _raw: [number, number],
    _socket: VScript.VSocket,
  ): CompressorCurveHardKnee => {
    return {
      threshold: _raw[0],
      ratio: _raw[1],
    };
  },
  Info: (
    _raw: [
      number,
      number,
      [number, number],
      [number, number],
      [number, number],
      [number, number],
      null | [[number, number], [number, number]],
      [
        null | [number, number],
        null | [number, number],
        null | [number, number],
      ],
      null | [[number, number], [number, number], [number, number]],
    ],
    _socket: VScript.VSocket,
  ): Info => {
    return {
      engine_load: _raw[0],
      planning_time: VScript.VAPIHelpers.liftNanoseconds(_raw[1], _socket),
      inputs: VAPI.AudioEngine.lift.Resource(_raw[2], _socket),
      outputs: VAPI.AudioEngine.lift.Resource(_raw[3], _socket),
      faders: VAPI.AudioEngine.lift.Resource(_raw[4], _socket),
      biquads: VAPI.AudioEngine.lift.Resource(_raw[5], _socket),
      delays:
        _raw[6] === null
          ? null
          : VAPI.AudioEngine.lift.InfoDelays(_raw[6], _socket),
      measurement: VAPI.AudioEngine.lift.InfoMeasurement(_raw[7], _socket),
      compressor:
        _raw[8] === null
          ? null
          : VAPI.AudioEngine.lift.InfoCompressor(_raw[8], _socket),
    };
  },
  CompressorCapabilitiesControlInput: (
    _raw: [boolean],
    _socket: VScript.VSocket,
  ): CompressorCapabilitiesControlInput => {
    return {
      bandpass: _raw[0],
    };
  },
  LoudnessCapabilities: (
    _raw: [number, number, boolean],
    _socket: VScript.VSocket,
  ): LoudnessCapabilities => {
    return {
      front_channels: _raw[0],
      surround_channels: _raw[1],
      k_weighting: _raw[2],
    };
  },
  LoudnessMeasurement: (
    _raw: [null | number, null | number, null | number, number],
    _socket: VScript.VSocket,
  ): LoudnessMeasurement => {
    return {
      momentary: _raw[0],
      short_term: _raw[1],
      gated: _raw[2],
      gated_recorded: VScript.VAPIHelpers.liftNanoseconds(_raw[3], _socket),
    };
  },
  MSFader: (_raw: [number, boolean], _socket: VScript.VSocket): MSFader => {
    return {
      gain: _raw[0],
      mute: _raw[1],
    };
  },
  MidSideCapabilities: (
    _raw: [VAPI.AudioEngine.MidSideCapabilitiesInputMode],
    _socket: VScript.VSocket,
  ): MidSideCapabilities => {
    return {
      input_mode: _raw[0],
    };
  },
  MonoMixCapabilities: (
    _raw: [number, boolean],
    _socket: VScript.VSocket,
  ): MonoMixCapabilities => {
    return {
      channels: _raw[0],
      master_fader: _raw[1],
    };
  },
  NMinus1Capabilities: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): NMinus1Capabilities => {
    return {
      channels: _raw[0],
    };
  },
  StereoPanBalancePanCenterLinear: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): StereoPanBalancePanCenterLinear => {
    return {
      pan: _raw[0],
    };
  },
  StereoPanBalancePanConstantPower: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): StereoPanBalancePanConstantPower => {
    return {
      pan: _raw[0],
    };
  },
  StereoPanBalancePanFullLinear: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): StereoPanBalancePanFullLinear => {
    return {
      pan: _raw[0],
    };
  },
  Resource: (_raw: [number, number], _socket: VScript.VSocket): Resource => {
    return {
      used: _raw[0],
      available: _raw[1],
    };
  },
  CompressorARTimeSamples: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): CompressorARTimeSamples => {
    return {
      samples: _raw[0],
    };
  },
  DelayParameterSamples: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): DelayParameterSamples => {
    return {
      samples: _raw[0],
    };
  },
  CompressorCapabilitiesControlSidechainOnly: (
    _raw: [],
    _socket: VScript.VSocket,
  ): CompressorCapabilitiesControlSidechainOnly => {
    return {};
  },
  CompressorCurveSoftKnee: (
    _raw: [number, number, number],
    _socket: VScript.VSocket,
  ): CompressorCurveSoftKnee => {
    return {
      threshold: _raw[0],
      width: _raw[1],
      ratio: _raw[2],
    };
  },
  StereoMixCapabilities: (
    _raw: [number, boolean],
    _socket: VScript.VSocket,
  ): StereoMixCapabilities => {
    return {
      channels: _raw[0],
      master_fader: _raw[1],
    };
  },
  StereoPanBalance: (
    _raw: [0, [number]] | [1, [number]] | [2, [number]] | [3, [number]],
    _socket: VScript.VSocket,
  ): StereoPanBalance => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "PanCenterLinear",
          value: VAPI.AudioEngine.lift.StereoPanBalancePanCenterLinear(
            _raw[1],
            _socket,
          ),
        };
      case 1:
        return {
          variant: "PanFullLinear",
          value: VAPI.AudioEngine.lift.StereoPanBalancePanFullLinear(
            _raw[1],
            _socket,
          ),
        };
      case 2:
        return {
          variant: "PanConstantPower",
          value: VAPI.AudioEngine.lift.StereoPanBalancePanConstantPower(
            _raw[1],
            _socket,
          ),
        };
      case 3:
        return {
          variant: "BalanceCenterLinear",
          value: VAPI.AudioEngine.lift.StereoPanBalanceBalanceCenterLinear(
            _raw[1],
            _socket,
          ),
        };
    }
  },
  CompressorARTimeTime: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): CompressorARTimeTime => {
    return {
      time: VScript.VAPIHelpers.liftNanoseconds(_raw[0], _socket),
    };
  },
  DelayParameterTime: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): DelayParameterTime => {
    return {
      time: VScript.VAPIHelpers.liftNanoseconds(_raw[0], _socket),
    };
  },
  TruePeakCapabilities: (
    _raw: [number],
    _socket: VScript.VSocket,
  ): TruePeakCapabilities => {
    return {
      channels: _raw[0],
    };
  },
  CompressorBandpass: (
    _raw: [boolean, [number, number], [number, number]],
    _socket: VScript.VSocket,
  ): CompressorBandpass => {
    return {
      enabled: _raw[0],
      lowcut: VAPI.AudioEngine.lift.FilterHighPass(_raw[1], _socket),
      highcut: VAPI.AudioEngine.lift.FilterLowPass(_raw[2], _socket),
    };
  },
  FilterBands: (_raw: VScript.DataViews.Subtree<VScript.VSocket>) =>
    new FilterBands(_raw),
  InfoCompressor: (
    _raw: [[number, number], [number, number], [number, number]],
    _socket: VScript.VSocket,
  ): InfoCompressor => {
    return {
      curve_ram: VAPI.AudioEngine.lift.Resource(_raw[0], _socket),
      engines: VAPI.AudioEngine.lift.Resource(_raw[1], _socket),
      channels: VAPI.AudioEngine.lift.Resource(_raw[2], _socket),
    };
  },
  CompressorCapabilitiesControl: (
    _raw: [0, [boolean]] | [1, []],
    _socket: VScript.VSocket,
  ): CompressorCapabilitiesControl => {
    switch (_raw[0]) {
      case 0:
        return {
          variant: "Input",
          value: VAPI.AudioEngine.lift.CompressorCapabilitiesControlInput(
            _raw[1],
            _socket,
          ),
        };
      case 1:
        return {
          variant: "SidechainOnly",
          value:
            VAPI.AudioEngine.lift.CompressorCapabilitiesControlSidechainOnly(
              _raw[1],
              _socket,
            ),
        };
    }
  },
  InfoDelays: (
    _raw: [[number, number], [number, number]],
    _socket: VScript.VSocket,
  ): InfoDelays => {
    return {
      writer: VAPI.AudioEngine.lift.Resource(_raw[0], _socket),
      reader: VAPI.AudioEngine.lift.Resource(_raw[1], _socket),
    };
  },
  DownMixLevels: (
    _raw: [number, number, number, number, number, number, number, number],
    _socket: VScript.VSocket,
  ): DownMixLevels => {
    return {
      master: _raw[0],
      l_r: _raw[1],
      center: _raw[2],
      lfe: _raw[3],
      sl_sr: _raw[4],
      sbl_sbr: _raw[5],
      tl_tr: _raw[6],
      tbl_tbr: _raw[7],
    };
  },
  CompressorLookahead: (
    _raw: [boolean, [0, [number]] | [1, [number]]],
    _socket: VScript.VSocket,
  ): CompressorLookahead => {
    return {
      enabled: _raw[0],
      delay: VAPI.AudioEngine.lift.DelayParameter(_raw[1], _socket),
    };
  },
  InfoMeasurement: (
    _raw: [
      null | [number, number],
      null | [number, number],
      null | [number, number],
    ],
    _socket: VScript.VSocket,
  ): InfoMeasurement => {
    return {
      truepeak:
        _raw[0] === null
          ? null
          : VAPI.AudioEngine.lift.Resource(_raw[0], _socket),
      rms_meter:
        _raw[1] === null
          ? null
          : VAPI.AudioEngine.lift.Resource(_raw[1], _socket),
      kfilter:
        _raw[2] === null
          ? null
          : VAPI.AudioEngine.lift.Resource(_raw[2], _socket),
    };
  },
  MidSideParams: (
    _raw: [number, number, number],
    _socket: VScript.VSocket,
  ): MidSideParams => {
    return {
      gain: _raw[0],
      width: _raw[1],
      rotation: _raw[2],
    };
  },
} as const;
export const lower = {
  CompressorCurveAutoGain: (
    _x: {
      cutoff: VAPI.AudioEngine.CompressorGain;
      target: VAPI.AudioEngine.CompressorGain;
      width: number;
      ratio: VAPI.AudioEngine.CompressorRatio;
    },
    _socket: VScript.VSocket,
  ): [number, number, number, number] => [
    _x.cutoff,
    _x.target,
    _x.width,
    _x.ratio,
  ],
  StereoPanBalanceBalanceCenterLinear: (
    _x: { balance: VAPI.AudioEngine.PanValue },
    _socket: VScript.VSocket,
  ): [number] => [_x.balance],
  CompressorARTime: (
    _x:
      | { variant: "Samples"; value: VAPI.AudioEngine.CompressorARTimeSamples }
      | { variant: "Time"; value: VAPI.AudioEngine.CompressorARTimeTime },
    _socket: VScript.VSocket,
  ): [0, [number]] | [1, [number]] => {
    switch (_x.variant) {
      case "Samples":
        return [
          0,
          VAPI.AudioEngine.lower.CompressorARTimeSamples(_x.value, _socket),
        ];
      case "Time":
        return [
          1,
          VAPI.AudioEngine.lower.CompressorARTimeTime(_x.value, _socket),
        ];
    }
  },
  CompressorCapabilities: (
    _x: {
      channels: number;
      control: VAPI.AudioEngine.CompressorCapabilitiesControl;
      lookahead: boolean;
    },
    _socket: VScript.VSocket,
  ): [number, [0, [boolean]] | [1, []], boolean] => [
    _x.channels,
    VAPI.AudioEngine.lower.CompressorCapabilitiesControl(_x.control, _socket),
    _x.lookahead,
  ],
  CompressorCurve: (
    _x:
      | { variant: "SoftKnee"; value: VAPI.AudioEngine.CompressorCurveSoftKnee }
      | { variant: "HardKnee"; value: VAPI.AudioEngine.CompressorCurveHardKnee }
      | { variant: "Ducking"; value: VAPI.AudioEngine.CompressorCurveDucking }
      | { variant: "Gate"; value: VAPI.AudioEngine.CompressorCurveGate }
      | {
          variant: "AutoGain";
          value: VAPI.AudioEngine.CompressorCurveAutoGain;
        },
    _socket: VScript.VSocket,
  ):
    | [0, [number, number, number]]
    | [1, [number, number]]
    | [2, [number, number, number]]
    | [3, [number, number]]
    | [4, [number, number, number, number]] => {
    switch (_x.variant) {
      case "SoftKnee":
        return [
          0,
          VAPI.AudioEngine.lower.CompressorCurveSoftKnee(_x.value, _socket),
        ];
      case "HardKnee":
        return [
          1,
          VAPI.AudioEngine.lower.CompressorCurveHardKnee(_x.value, _socket),
        ];
      case "Ducking":
        return [
          2,
          VAPI.AudioEngine.lower.CompressorCurveDucking(_x.value, _socket),
        ];
      case "Gate":
        return [
          3,
          VAPI.AudioEngine.lower.CompressorCurveGate(_x.value, _socket),
        ];
      case "AutoGain":
        return [
          4,
          VAPI.AudioEngine.lower.CompressorCurveAutoGain(_x.value, _socket),
        ];
    }
  },
  CompressorCurvePoint: (
    _x: {
      i: VAPI.AudioEngine.CompressorCurveValue;
      o: VAPI.AudioEngine.CompressorCurveValue;
      c: null | VAPI.AudioEngine.CompressorCurveValue;
    },
    _socket: VScript.VSocket,
  ): [number, number, null | number] => [_x.i, _x.o, _x.c],
  CompressorParameter: (
    _x: {
      attack: VAPI.AudioEngine.CompressorARTime;
      release: VAPI.AudioEngine.CompressorARTime;
      hold: VAPI.AudioEngine.CompressorARTime;
      gain: VAPI.AudioEngine.CompressorGain;
    },
    _socket: VScript.VSocket,
  ): [
    [0, [number]] | [1, [number]],
    [0, [number]] | [1, [number]],
    [0, [number]] | [1, [number]],
    number,
  ] => [
    VAPI.AudioEngine.lower.CompressorARTime(_x.attack, _socket),
    VAPI.AudioEngine.lower.CompressorARTime(_x.release, _socket),
    VAPI.AudioEngine.lower.CompressorARTime(_x.hold, _socket),
    _x.gain,
  ],
  CompressorSource: (_x: CompressorSource) => _x.raw.kwl,
  DelayCapabilities: (
    _x: { channels: number; taps: number },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.channels, _x.taps],
  DelayParameter: (
    _x:
      | { variant: "Samples"; value: VAPI.AudioEngine.DelayParameterSamples }
      | { variant: "Time"; value: VAPI.AudioEngine.DelayParameterTime },
    _socket: VScript.VSocket,
  ): [0, [number]] | [1, [number]] => {
    switch (_x.variant) {
      case "Samples":
        return [
          0,
          VAPI.AudioEngine.lower.DelayParameterSamples(_x.value, _socket),
        ];
      case "Time":
        return [
          1,
          VAPI.AudioEngine.lower.DelayParameterTime(_x.value, _socket),
        ];
    }
  },
  DownMixCapabilities: (
    _x: { channels: VAPI.AudioEngine.DownMixCapabilitiesChannels },
    _socket: VScript.VSocket,
  ): [VAPI.AudioEngine.DownMixCapabilitiesChannels] => [_x.channels],
  CompressorCurveDucking: (
    _x: {
      threshold: VAPI.AudioEngine.CompressorGain;
      width: number;
      gain: VAPI.AudioEngine.CompressorGain;
    },
    _socket: VScript.VSocket,
  ): [number, number, number] => [_x.threshold, _x.width, _x.gain],
  Fader: (_x: Fader) => _x.raw.kwl,
  FilterCapabilities: (
    _x: { channels: number; bands: number },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.channels, _x.bands],
  FilterCoeffs: (
    _x: {
      a0: VAPI.Primitives.Float32;
      a1: VAPI.Primitives.Float32;
      a2: VAPI.Primitives.Float32;
      b1: VAPI.Primitives.Float32;
      b2: VAPI.Primitives.Float32;
    },
    _socket: VScript.VSocket,
  ): [number, number, number, number, number] => [
    _x.a0,
    _x.a1,
    _x.a2,
    _x.b1,
    _x.b2,
  ],
  FilterHighPass: (
    _x: { fc: VAPI.AudioEngine.FilterFrequency; q: VAPI.AudioEngine.FilterQ },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.fc, _x.q],
  FilterHighShelf: (
    _x: {
      fc: VAPI.AudioEngine.FilterFrequency;
      gain: VAPI.AudioEngine.FilterGain;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.fc, _x.gain],
  FilterLowPass: (
    _x: { fc: VAPI.AudioEngine.FilterFrequency; q: VAPI.AudioEngine.FilterQ },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.fc, _x.q],
  FilterLowShelf: (
    _x: {
      fc: VAPI.AudioEngine.FilterFrequency;
      gain: VAPI.AudioEngine.FilterGain;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.fc, _x.gain],
  FilterParameter: (
    _x:
      | { variant: "LowPass"; value: VAPI.AudioEngine.FilterLowPass }
      | { variant: "HighPass"; value: VAPI.AudioEngine.FilterHighPass }
      | { variant: "Peak"; value: VAPI.AudioEngine.FilterPeak }
      | { variant: "LowShelf"; value: VAPI.AudioEngine.FilterLowShelf }
      | { variant: "HighShelf"; value: VAPI.AudioEngine.FilterHighShelf },
    _socket: VScript.VSocket,
  ):
    | [0, [number, number]]
    | [1, [number, number]]
    | [2, [number, number, number]]
    | [3, [number, number]]
    | [4, [number, number]] => {
    switch (_x.variant) {
      case "LowPass":
        return [0, VAPI.AudioEngine.lower.FilterLowPass(_x.value, _socket)];
      case "HighPass":
        return [1, VAPI.AudioEngine.lower.FilterHighPass(_x.value, _socket)];
      case "Peak":
        return [2, VAPI.AudioEngine.lower.FilterPeak(_x.value, _socket)];
      case "LowShelf":
        return [3, VAPI.AudioEngine.lower.FilterLowShelf(_x.value, _socket)];
      case "HighShelf":
        return [4, VAPI.AudioEngine.lower.FilterHighShelf(_x.value, _socket)];
    }
  },
  FilterPeak: (
    _x: {
      fc: VAPI.AudioEngine.FilterFrequency;
      q: VAPI.AudioEngine.FilterQ;
      gain: VAPI.AudioEngine.FilterGain;
    },
    _socket: VScript.VSocket,
  ): [number, number, number] => [_x.fc, _x.q, _x.gain],
  CompressorCurveGate: (
    _x: { threshold: VAPI.AudioEngine.CompressorGain; width: number },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.threshold, _x.width],
  Group: (_x: Group) => _x.raw.kwl,
  HWInputAssignment: (
    _x: { value: VAPI.Primitives.Unsigned16 },
    _socket: VScript.VSocket,
  ): [number] => [_x.value],
  CompressorCurveHardKnee: (
    _x: {
      threshold: VAPI.AudioEngine.CompressorGain;
      ratio: VAPI.AudioEngine.CompressorRatio;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.threshold, _x.ratio],
  Info: (
    _x: {
      engine_load: VAPI.Primitives.Normalized;
      planning_time: VScript.Duration;
      inputs: VAPI.AudioEngine.Resource;
      outputs: VAPI.AudioEngine.Resource;
      faders: VAPI.AudioEngine.Resource;
      biquads: VAPI.AudioEngine.Resource;
      delays: null | VAPI.AudioEngine.InfoDelays;
      measurement: VAPI.AudioEngine.InfoMeasurement;
      compressor: null | VAPI.AudioEngine.InfoCompressor;
    },
    _socket: VScript.VSocket,
  ): [
    number,
    number,
    [number, number],
    [number, number],
    [number, number],
    [number, number],
    null | [[number, number], [number, number]],
    [null | [number, number], null | [number, number], null | [number, number]],
    null | [[number, number], [number, number], [number, number]],
  ] => [
    _x.engine_load,
    VScript.VAPIHelpers.lowerNanoseconds(_x.planning_time, _socket),
    VAPI.AudioEngine.lower.Resource(_x.inputs, _socket),
    VAPI.AudioEngine.lower.Resource(_x.outputs, _socket),
    VAPI.AudioEngine.lower.Resource(_x.faders, _socket),
    VAPI.AudioEngine.lower.Resource(_x.biquads, _socket),
    _x.delays === null
      ? null
      : VAPI.AudioEngine.lower.InfoDelays(_x.delays, _socket),
    VAPI.AudioEngine.lower.InfoMeasurement(_x.measurement, _socket),
    _x.compressor === null
      ? null
      : VAPI.AudioEngine.lower.InfoCompressor(_x.compressor, _socket),
  ],
  CompressorCapabilitiesControlInput: (
    _x: { bandpass: boolean },
    _socket: VScript.VSocket,
  ): [boolean] => [_x.bandpass],
  LoudnessCapabilities: (
    _x: {
      front_channels: number;
      surround_channels: number;

      /**
            Disable k-weighting only when using this element to control a
            compressor, the resulting Loudness measurements will then NOT
            match the ITU-R BS.1170-4
          */
      k_weighting: boolean;
    },
    _socket: VScript.VSocket,
  ): [number, number, boolean] => [
    _x.front_channels,
    _x.surround_channels,
    _x.k_weighting,
  ],
  LoudnessMeasurement: (
    _x: {
      /**
            Measured over the last 400 ms
          */
      momentary: null | number;

      /**
            Measured over the last 3 s
          */
      short_term: null | number;
      gated: null | number;

      /**
            How much data has been recorded for the gated loudness
            measurement so far
          */
      gated_recorded: VScript.Duration;
    },
    _socket: VScript.VSocket,
  ): [null | number, null | number, null | number, number] => [
    _x.momentary,
    _x.short_term,
    _x.gated,
    VScript.VAPIHelpers.lowerNanoseconds(_x.gated_recorded, _socket),
  ],
  MSFader: (
    _x: { gain: VAPI.AudioEngine.FaderGain; mute: boolean },
    _socket: VScript.VSocket,
  ): [number, boolean] => [_x.gain, _x.mute],
  MidSideCapabilities: (
    _x: { input_mode: VAPI.AudioEngine.MidSideCapabilitiesInputMode },
    _socket: VScript.VSocket,
  ): [VAPI.AudioEngine.MidSideCapabilitiesInputMode] => [_x.input_mode],
  MonoMixCapabilities: (
    _x: { channels: number; master_fader: boolean },
    _socket: VScript.VSocket,
  ): [number, boolean] => [_x.channels, _x.master_fader],
  NMinus1Capabilities: (
    _x: { channels: number },
    _socket: VScript.VSocket,
  ): [number] => [_x.channels],
  StereoPanBalancePanCenterLinear: (
    _x: { pan: VAPI.AudioEngine.PanValue },
    _socket: VScript.VSocket,
  ): [number] => [_x.pan],
  StereoPanBalancePanConstantPower: (
    _x: { pan: VAPI.AudioEngine.PanValue },
    _socket: VScript.VSocket,
  ): [number] => [_x.pan],
  StereoPanBalancePanFullLinear: (
    _x: { pan: VAPI.AudioEngine.PanValue },
    _socket: VScript.VSocket,
  ): [number] => [_x.pan],
  Resource: (
    _x: {
      used: VAPI.Primitives.Unsigned16;
      available: VAPI.Primitives.Unsigned16;
    },
    _socket: VScript.VSocket,
  ): [number, number] => [_x.used, _x.available],
  CompressorARTimeSamples: (
    _x: { samples: number },
    _socket: VScript.VSocket,
  ): [number] => [_x.samples],
  DelayParameterSamples: (
    _x: { samples: number },
    _socket: VScript.VSocket,
  ): [number] => [_x.samples],
  CompressorCapabilitiesControlSidechainOnly: (
    _x: {},
    _socket: VScript.VSocket,
  ): [] => [],
  CompressorCurveSoftKnee: (
    _x: {
      threshold: VAPI.AudioEngine.CompressorGain;
      width: number;
      ratio: VAPI.AudioEngine.CompressorRatio;
    },
    _socket: VScript.VSocket,
  ): [number, number, number] => [_x.threshold, _x.width, _x.ratio],
  StereoMixCapabilities: (
    _x: { channels: number; master_fader: boolean },
    _socket: VScript.VSocket,
  ): [number, boolean] => [_x.channels, _x.master_fader],
  StereoPanBalance: (
    _x:
      | {
          variant: "PanCenterLinear";
          value: VAPI.AudioEngine.StereoPanBalancePanCenterLinear;
        }
      | {
          variant: "PanFullLinear";
          value: VAPI.AudioEngine.StereoPanBalancePanFullLinear;
        }
      | {
          variant: "PanConstantPower";
          value: VAPI.AudioEngine.StereoPanBalancePanConstantPower;
        }
      | {
          variant: "BalanceCenterLinear";
          value: VAPI.AudioEngine.StereoPanBalanceBalanceCenterLinear;
        },
    _socket: VScript.VSocket,
  ): [0, [number]] | [1, [number]] | [2, [number]] | [3, [number]] => {
    switch (_x.variant) {
      case "PanCenterLinear":
        return [
          0,
          VAPI.AudioEngine.lower.StereoPanBalancePanCenterLinear(
            _x.value,
            _socket,
          ),
        ];
      case "PanFullLinear":
        return [
          1,
          VAPI.AudioEngine.lower.StereoPanBalancePanFullLinear(
            _x.value,
            _socket,
          ),
        ];
      case "PanConstantPower":
        return [
          2,
          VAPI.AudioEngine.lower.StereoPanBalancePanConstantPower(
            _x.value,
            _socket,
          ),
        ];
      case "BalanceCenterLinear":
        return [
          3,
          VAPI.AudioEngine.lower.StereoPanBalanceBalanceCenterLinear(
            _x.value,
            _socket,
          ),
        ];
    }
  },
  CompressorARTimeTime: (
    _x: { time: VScript.Duration },
    _socket: VScript.VSocket,
  ): [number] => [VScript.VAPIHelpers.lowerNanoseconds(_x.time, _socket)],
  DelayParameterTime: (
    _x: { time: VScript.Duration },
    _socket: VScript.VSocket,
  ): [number] => [VScript.VAPIHelpers.lowerNanoseconds(_x.time, _socket)],
  TruePeakCapabilities: (
    _x: { channels: number },
    _socket: VScript.VSocket,
  ): [number] => [_x.channels],
  CompressorBandpass: (
    _x: {
      enabled: boolean;
      lowcut: VAPI.AudioEngine.FilterHighPass;
      highcut: VAPI.AudioEngine.FilterLowPass;
    },
    _socket: VScript.VSocket,
  ): [boolean, [number, number], [number, number]] => [
    _x.enabled,
    VAPI.AudioEngine.lower.FilterHighPass(_x.lowcut, _socket),
    VAPI.AudioEngine.lower.FilterLowPass(_x.highcut, _socket),
  ],
  FilterBands: (_x: FilterBands) => _x.raw.kwl,
  InfoCompressor: (
    _x: {
      curve_ram: VAPI.AudioEngine.Resource;
      engines: VAPI.AudioEngine.Resource;
      channels: VAPI.AudioEngine.Resource;
    },
    _socket: VScript.VSocket,
  ): [[number, number], [number, number], [number, number]] => [
    VAPI.AudioEngine.lower.Resource(_x.curve_ram, _socket),
    VAPI.AudioEngine.lower.Resource(_x.engines, _socket),
    VAPI.AudioEngine.lower.Resource(_x.channels, _socket),
  ],
  CompressorCapabilitiesControl: (
    _x:
      | {
          variant: "Input";
          value: VAPI.AudioEngine.CompressorCapabilitiesControlInput;
        }
      | {
          variant: "SidechainOnly";
          value: VAPI.AudioEngine.CompressorCapabilitiesControlSidechainOnly;
        },
    _socket: VScript.VSocket,
  ): [0, [boolean]] | [1, []] => {
    switch (_x.variant) {
      case "Input":
        return [
          0,
          VAPI.AudioEngine.lower.CompressorCapabilitiesControlInput(
            _x.value,
            _socket,
          ),
        ];
      case "SidechainOnly":
        return [
          1,
          VAPI.AudioEngine.lower.CompressorCapabilitiesControlSidechainOnly(
            _x.value,
            _socket,
          ),
        ];
    }
  },
  InfoDelays: (
    _x: {
      writer: VAPI.AudioEngine.Resource;
      reader: VAPI.AudioEngine.Resource;
    },
    _socket: VScript.VSocket,
  ): [[number, number], [number, number]] => [
    VAPI.AudioEngine.lower.Resource(_x.writer, _socket),
    VAPI.AudioEngine.lower.Resource(_x.reader, _socket),
  ],
  DownMixLevels: (
    _x: {
      master: VAPI.AudioEngine.FaderGain;
      l_r: VAPI.AudioEngine.FaderGain;
      center: VAPI.AudioEngine.FaderGain;
      lfe: VAPI.AudioEngine.FaderGain;
      sl_sr: VAPI.AudioEngine.FaderGain;
      sbl_sbr: VAPI.AudioEngine.FaderGain;
      tl_tr: VAPI.AudioEngine.FaderGain;
      tbl_tbr: VAPI.AudioEngine.FaderGain;
    },
    _socket: VScript.VSocket,
  ): [number, number, number, number, number, number, number, number] => [
    _x.master,
    _x.l_r,
    _x.center,
    _x.lfe,
    _x.sl_sr,
    _x.sbl_sbr,
    _x.tl_tr,
    _x.tbl_tbr,
  ],
  CompressorLookahead: (
    _x: { enabled: boolean; delay: VAPI.AudioEngine.DelayParameter },
    _socket: VScript.VSocket,
  ): [boolean, [0, [number]] | [1, [number]]] => [
    _x.enabled,
    VAPI.AudioEngine.lower.DelayParameter(_x.delay, _socket),
  ],
  InfoMeasurement: (
    _x: {
      truepeak: null | VAPI.AudioEngine.Resource;
      rms_meter: null | VAPI.AudioEngine.Resource;
      kfilter: null | VAPI.AudioEngine.Resource;
    },
    _socket: VScript.VSocket,
  ): [
    null | [number, number],
    null | [number, number],
    null | [number, number],
  ] => [
    _x.truepeak === null
      ? null
      : VAPI.AudioEngine.lower.Resource(_x.truepeak, _socket),
    _x.rms_meter === null
      ? null
      : VAPI.AudioEngine.lower.Resource(_x.rms_meter, _socket),
    _x.kfilter === null
      ? null
      : VAPI.AudioEngine.lower.Resource(_x.kfilter, _socket),
  ],
  MidSideParams: (
    _x: {
      gain: VAPI.AudioEngine.FaderGain;
      width: number;
      rotation: VAPI.AudioEngine.PanValue;
    },
    _socket: VScript.VSocket,
  ): [number, number, number] => [_x.gain, _x.width, _x.rotation],
} as const;
export interface CompressorCurveAutoGain {
  cutoff: VAPI.AudioEngine.CompressorGain;
  target: VAPI.AudioEngine.CompressorGain;
  width: number;
  ratio: VAPI.AudioEngine.CompressorRatio;
}
export interface StereoPanBalanceBalanceCenterLinear {
  balance: VAPI.AudioEngine.PanValue;
}
export type CompressorARTime =
  | { variant: "Samples"; value: VAPI.AudioEngine.CompressorARTimeSamples }
  | { variant: "Time"; value: VAPI.AudioEngine.CompressorARTimeTime };
export interface CompressorCapabilities {
  channels: number;
  control: VAPI.AudioEngine.CompressorCapabilitiesControl;
  lookahead: boolean;
}
export type CompressorCurve =
  | { variant: "SoftKnee"; value: VAPI.AudioEngine.CompressorCurveSoftKnee }
  | { variant: "HardKnee"; value: VAPI.AudioEngine.CompressorCurveHardKnee }
  | { variant: "Ducking"; value: VAPI.AudioEngine.CompressorCurveDucking }
  | { variant: "Gate"; value: VAPI.AudioEngine.CompressorCurveGate }
  | { variant: "AutoGain"; value: VAPI.AudioEngine.CompressorCurveAutoGain };
export interface CompressorCurvePoint {
  i: VAPI.AudioEngine.CompressorCurveValue;
  o: VAPI.AudioEngine.CompressorCurveValue;
  c: null | VAPI.AudioEngine.CompressorCurveValue;
}
export type CompressorCurveValue = number;
export type CompressorGain = number;
export interface CompressorParameter {
  attack: VAPI.AudioEngine.CompressorARTime;
  release: VAPI.AudioEngine.CompressorARTime;
  hold: VAPI.AudioEngine.CompressorARTime;
  gain: VAPI.AudioEngine.CompressorGain;
}
export type CompressorRatio = number;
export class CompressorSource
  implements VScript.Referenceable<"AudioEngine::Data::CompressorSource">
{
  readonly type_identifier = "AudioEngine::Data::CompressorSource" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get brief(): VScript.rKeyword<
    VScript.VSocket,
    string,
    string,
    VAPI.AudioEngine.CompressorSource
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      string,
      string,
      VAPI.AudioEngine.CompressorSource
    >(this, "brief" as VScript.SysName, {
      lift: (x: any /* FIXME */, _: VScript.VSocket) => x,
      lower: (x: any /* FIXME */, _: VScript.VSocket) => x,
    });
  }
}
export interface DelayCapabilities {
  channels: number;
  taps: number;
}
export type DelayParameter =
  | { variant: "Samples"; value: VAPI.AudioEngine.DelayParameterSamples }
  | { variant: "Time"; value: VAPI.AudioEngine.DelayParameterTime };
export interface DownMixCapabilities {
  channels: VAPI.AudioEngine.DownMixCapabilitiesChannels;
}
export interface CompressorCurveDucking {
  threshold: VAPI.AudioEngine.CompressorGain;
  width: number;
  gain: VAPI.AudioEngine.CompressorGain;
}
export class Fader
  implements VScript.Referenceable<"AudioEngine::Data::Fader">
{
  readonly type_identifier = "AudioEngine::Data::Fader" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get label(): VScript.rwKeyword<
    VScript.VSocket,
    string,
    string,
    string,
    string,
    VAPI.AudioEngine.Fader
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      string,
      string,
      string,
      string,
      VAPI.AudioEngine.Fader
    >(
      this,
      "label" 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 gain(): VScript.rwKeyword<
    VScript.VSocket,
    number,
    number,
    VAPI.AudioEngine.FaderGain,
    VAPI.AudioEngine.FaderGain,
    VAPI.AudioEngine.Fader
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      number,
      number,
      VAPI.AudioEngine.FaderGain,
      VAPI.AudioEngine.FaderGain,
      VAPI.AudioEngine.Fader
    >(
      this,
      "gain" 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 mute(): VScript.rwKeyword<
    VScript.VSocket,
    boolean,
    boolean,
    boolean,
    boolean,
    VAPI.AudioEngine.Fader
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      boolean,
      boolean,
      boolean,
      boolean,
      VAPI.AudioEngine.Fader
    >(
      this,
      "mute" 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 solo(): VScript.rwKeyword<
    VScript.VSocket,
    boolean,
    boolean,
    boolean,
    boolean,
    VAPI.AudioEngine.Fader
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      boolean,
      boolean,
      boolean,
      boolean,
      VAPI.AudioEngine.Fader
    >(
      this,
      "solo" 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 FaderGain = number;
export interface FilterCapabilities {
  channels: number;
  bands: number;
}
export interface FilterCoeffs {
  a0: VAPI.Primitives.Float32;
  a1: VAPI.Primitives.Float32;
  a2: VAPI.Primitives.Float32;
  b1: VAPI.Primitives.Float32;
  b2: VAPI.Primitives.Float32;
}
export type FilterFrequency = number;
export type FilterGain = number;
export interface FilterHighPass {
  fc: VAPI.AudioEngine.FilterFrequency;
  q: VAPI.AudioEngine.FilterQ;
}
export interface FilterHighShelf {
  fc: VAPI.AudioEngine.FilterFrequency;
  gain: VAPI.AudioEngine.FilterGain;
}
export interface FilterLowPass {
  fc: VAPI.AudioEngine.FilterFrequency;
  q: VAPI.AudioEngine.FilterQ;
}
export interface FilterLowShelf {
  fc: VAPI.AudioEngine.FilterFrequency;
  gain: VAPI.AudioEngine.FilterGain;
}
export type FilterParameter =
  | { variant: "LowPass"; value: VAPI.AudioEngine.FilterLowPass }
  | { variant: "HighPass"; value: VAPI.AudioEngine.FilterHighPass }
  | { variant: "Peak"; value: VAPI.AudioEngine.FilterPeak }
  | { variant: "LowShelf"; value: VAPI.AudioEngine.FilterLowShelf }
  | { variant: "HighShelf"; value: VAPI.AudioEngine.FilterHighShelf };
export interface FilterPeak {
  fc: VAPI.AudioEngine.FilterFrequency;
  q: VAPI.AudioEngine.FilterQ;
  gain: VAPI.AudioEngine.FilterGain;
}
export type FilterQ = number;
export interface CompressorCurveGate {
  threshold: VAPI.AudioEngine.CompressorGain;
  width: number;
}
export class Group
  implements VScript.Referenceable<"AudioEngine::Data::Group">
{
  readonly type_identifier = "AudioEngine::Data::Group" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get desc(): VScript.rwKeyword<
    VScript.VSocket,
    string,
    string,
    string,
    string,
    VAPI.AudioEngine.Group
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      string,
      string,
      string,
      string,
      VAPI.AudioEngine.Group
    >(
      this,
      "desc" 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 parent_group(): VScript.rwKeyword<
    VScript.VSocket,
    null | string,
    null | string,
    null | VAPI.AudioEngine.Group,
    | null
    | (VScript.Referenceable<"AudioEngine::Data::Group"> &
        VScript.StronglyTypedSubtree<VScript.VSocket>),
    VAPI.AudioEngine.Group
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      null | string,
      null | string,
      null | VAPI.AudioEngine.Group,
      | null
      | (VScript.Referenceable<"AudioEngine::Data::Group"> &
          VScript.StronglyTypedSubtree<VScript.VSocket>),
      VAPI.AudioEngine.Group
    >(
      this,
      "parent_group" as VScript.SysName,
      {
        lift: VScript.VAPIHelpers.liftOrLowerNullable(
          (raw_kwl: string, _socket: VScript.VSocket) =>
            new VAPI.AudioEngine.Group(
              VScript.VAPIHelpers.get_subtree(
                _socket,
                raw_kwl as VScript.KWLName<"full">,
              ),
            ),
        ),
        lower: VScript.VAPIHelpers.liftOrLowerNullable(
          (
            x: VScript.Referenceable<"AudioEngine::Data::Group"> &
              VScript.StronglyTypedSubtree<VScript.VSocket>,
            _: VScript.VSocket,
          ) => x.raw.kwl,
        ),
      },
      {
        lift: VScript.VAPIHelpers.liftOrLowerNullable(
          (raw_kwl: string, _socket: VScript.VSocket) =>
            new VAPI.AudioEngine.Group(
              VScript.VAPIHelpers.get_subtree(
                _socket,
                raw_kwl as VScript.KWLName<"full">,
              ),
            ),
        ),
        lower: VScript.VAPIHelpers.liftOrLowerNullable(
          (
            x: VScript.Referenceable<"AudioEngine::Data::Group"> &
              VScript.StronglyTypedSubtree<VScript.VSocket>,
            _: VScript.VSocket,
          ) => x.raw.kwl,
        ),
      },
      null,
    );
  }
}
export class GroupAsNamedTableRow extends Group {
  readonly index: number;
  constructor(
    readonly raw: VScript.DataViews.SubtreeNamedTableRow<VScript.VSocket>,
  ) {
    super(raw);
    this.index = raw.index;
  }
  async rename(name: string, opts?: VScript.CommonWriteOptions) {
    await this.raw.rename(name, opts);
  }
  async row_name(opts?: VScript.CommonCommandOptions) {
    return await this.raw.row_name(opts);
  }
  async delete(opts?: VScript.CommonWriteOptions) {
    await this.raw.delete(opts);
  }
}
export interface HWInputAssignment {
  value: VAPI.Primitives.Unsigned16;
}
export interface CompressorCurveHardKnee {
  threshold: VAPI.AudioEngine.CompressorGain;
  ratio: VAPI.AudioEngine.CompressorRatio;
}
export interface Info {
  engine_load: VAPI.Primitives.Normalized;
  planning_time: VScript.Duration;
  inputs: VAPI.AudioEngine.Resource;
  outputs: VAPI.AudioEngine.Resource;
  faders: VAPI.AudioEngine.Resource;
  biquads: VAPI.AudioEngine.Resource;
  delays: null | VAPI.AudioEngine.InfoDelays;
  measurement: VAPI.AudioEngine.InfoMeasurement;
  compressor: null | VAPI.AudioEngine.InfoCompressor;
}
export interface CompressorCapabilitiesControlInput {
  bandpass: boolean;
}
export interface LoudnessCapabilities {
  front_channels: number;
  surround_channels: number;

  /**
    Disable k-weighting only when using this element to control a compressor,
    the resulting Loudness measurements will then NOT match the ITU-R
    BS.1170-4
  */
  k_weighting: boolean;
}
export interface LoudnessMeasurement {
  /**
    Measured over the last 400 ms
  */
  momentary: null | number;

  /**
    Measured over the last 3 s
  */
  short_term: null | number;
  gated: null | number;

  /**
    How much data has been recorded for the gated loudness measurement so far
  */
  gated_recorded: VScript.Duration;
}
export interface MSFader {
  gain: VAPI.AudioEngine.FaderGain;
  mute: boolean;
}
export interface MidSideCapabilities {
  input_mode: VAPI.AudioEngine.MidSideCapabilitiesInputMode;
}
export interface MonoMixCapabilities {
  channels: number;
  master_fader: boolean;
}
export interface NMinus1Capabilities {
  channels: number;
}
export interface StereoPanBalancePanCenterLinear {
  pan: VAPI.AudioEngine.PanValue;
}
export interface StereoPanBalancePanConstantPower {
  pan: VAPI.AudioEngine.PanValue;
}
export interface StereoPanBalancePanFullLinear {
  pan: VAPI.AudioEngine.PanValue;
}
export type PanValue = number;
export interface Resource {
  used: VAPI.Primitives.Unsigned16;
  available: VAPI.Primitives.Unsigned16;
}
export interface CompressorARTimeSamples {
  samples: number;
}
export interface DelayParameterSamples {
  samples: number;
}
export interface CompressorCapabilitiesControlSidechainOnly {}
export interface CompressorCurveSoftKnee {
  threshold: VAPI.AudioEngine.CompressorGain;
  width: number;
  ratio: VAPI.AudioEngine.CompressorRatio;
}
export interface StereoMixCapabilities {
  channels: number;
  master_fader: boolean;
}
export type StereoPanBalance =
  | {
      variant: "PanCenterLinear";
      value: VAPI.AudioEngine.StereoPanBalancePanCenterLinear;
    }
  | {
      variant: "PanFullLinear";
      value: VAPI.AudioEngine.StereoPanBalancePanFullLinear;
    }
  | {
      variant: "PanConstantPower";
      value: VAPI.AudioEngine.StereoPanBalancePanConstantPower;
    }
  | {
      variant: "BalanceCenterLinear";
      value: VAPI.AudioEngine.StereoPanBalanceBalanceCenterLinear;
    };
export interface CompressorARTimeTime {
  time: VScript.Duration;
}
export interface DelayParameterTime {
  time: VScript.Duration;
}
export interface TruePeakCapabilities {
  channels: number;
}
export interface CompressorBandpass {
  enabled: boolean;
  lowcut: VAPI.AudioEngine.FilterHighPass;
  highcut: VAPI.AudioEngine.FilterLowPass;
}
export class FilterBands
  implements VScript.Referenceable<"AudioEngine::Data::Filter::Bands">
{
  readonly type_identifier = "AudioEngine::Data::Filter::Bands" as const;
  constructor(readonly raw: VScript.DataViews.Subtree<VScript.VSocket>) {}
  get param(): VScript.rwKeyword<
    VScript.VSocket,
    | [0, [number, number]]
    | [1, [number, number]]
    | [2, [number, number, number]]
    | [3, [number, number]]
    | [4, [number, number]],
    | [0, [number, number]]
    | [1, [number, number]]
    | [2, [number, number, number]]
    | [3, [number, number]]
    | [4, [number, number]],
    VAPI.AudioEngine.FilterParameter,
    VAPI.AudioEngine.FilterParameter,
    VAPI.AudioEngine.FilterBands
  > {
    return new VScript.rwKeyword<
      VScript.VSocket,
      | [0, [number, number]]
      | [1, [number, number]]
      | [2, [number, number, number]]
      | [3, [number, number]]
      | [4, [number, number]],
      | [0, [number, number]]
      | [1, [number, number]]
      | [2, [number, number, number]]
      | [3, [number, number]]
      | [4, [number, number]],
      VAPI.AudioEngine.FilterParameter,
      VAPI.AudioEngine.FilterParameter,
      VAPI.AudioEngine.FilterBands
    >(
      this,
      "param" as VScript.SysName,
      {
        lift: VAPI.AudioEngine.lift.FilterParameter,
        lower: VAPI.AudioEngine.lower.FilterParameter,
      },
      {
        lift: VAPI.AudioEngine.lift.FilterParameter,
        lower: VAPI.AudioEngine.lower.FilterParameter,
      },
      null,
    );
  }
  get coeffs(): VScript.rKeyword<
    VScript.VSocket,
    null | [number, number, number, number, number],
    null | VAPI.AudioEngine.FilterCoeffs,
    VAPI.AudioEngine.FilterBands
  > {
    return new VScript.rKeyword<
      VScript.VSocket,
      null | [number, number, number, number, number],
      null | VAPI.AudioEngine.FilterCoeffs,
      VAPI.AudioEngine.FilterBands
    >(this, "coeffs" as VScript.SysName, {
      lift: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.AudioEngine.lift.FilterCoeffs,
      ),
      lower: VScript.VAPIHelpers.liftOrLowerNullable(
        VAPI.AudioEngine.lower.FilterCoeffs,
      ),
    });
  }
}
export type DownMixCapabilitiesChannels =
  | "SURROUND_5_1"
  | "SURROUND_7_1"
  | "FULL";
export interface InfoCompressor {
  curve_ram: VAPI.AudioEngine.Resource;
  engines: VAPI.AudioEngine.Resource;
  channels: VAPI.AudioEngine.Resource;
}
export type CompressorCapabilitiesControl =
  | {
      variant: "Input";
      value: VAPI.AudioEngine.CompressorCapabilitiesControlInput;
    }
  | {
      variant: "SidechainOnly";
      value: VAPI.AudioEngine.CompressorCapabilitiesControlSidechainOnly;
    };
export interface InfoDelays {
  writer: VAPI.AudioEngine.Resource;
  reader: VAPI.AudioEngine.Resource;
}
export type MidSideCapabilitiesInputMode = "Stereo" | "Mid_Side";
export type CompressorIssues = {
  bandpass_unavailable_capabilities: boolean;
  bandpass_unavailable_sidechain: boolean;
  control_missing: boolean;
  curve_update_delayed: boolean;
  cycle_detected: boolean;
  invalid_input_channel: boolean;
  lookahead_not_available: boolean;
};
export type DelayIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type DownMixIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type FilterIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type LoudnessIssues = {
  cant_disable_k_weighting: boolean;
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type MidSideIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type MonoMixIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type NMinus1Issues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type StereoMixIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export type TruePeakIssues = {
  cycle_detected: boolean;
  invalid_input_channel: boolean;
};
export interface DownMixLevels {
  master: VAPI.AudioEngine.FaderGain;
  l_r: VAPI.AudioEngine.FaderGain;
  center: VAPI.AudioEngine.FaderGain;
  lfe: VAPI.AudioEngine.FaderGain;
  sl_sr: VAPI.AudioEngine.FaderGain;
  sbl_sbr: VAPI.AudioEngine.FaderGain;
  tl_tr: VAPI.AudioEngine.FaderGain;
  tbl_tbr: VAPI.AudioEngine.FaderGain;
}
export interface CompressorLookahead {
  enabled: boolean;
  delay: VAPI.AudioEngine.DelayParameter;
}
export interface InfoMeasurement {
  truepeak: null | VAPI.AudioEngine.Resource;
  rms_meter: null | VAPI.AudioEngine.Resource;
  kfilter: null | VAPI.AudioEngine.Resource;
}
export interface MidSideParams {
  gain: VAPI.AudioEngine.FaderGain;
  width: number;
  rotation: VAPI.AudioEngine.PanValue;
}