dhd-control-api/dist/index.cjs

Typescript library for the DHD Control API

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  DHD: () => DHD
});
module.exports = __toCommonJS(src_exports);
var import_zod40 = require("zod");

// src/api/audio/levels/index.ts
var import_zod2 = require("zod");

// src/utils.ts
var import_zod = require("zod");
var assertNever = (value) => {
  throw new Error(`Unexpected value: ${value}`);
};
var numberedObject = (schema) => import_zod.z.record(import_zod.z.coerce.number(), schema);

// src/api/audio/levels/index.ts
var audioLevelsImmutable = import_zod2.z.object({
  _name: import_zod2.z.string(),
  _mode: import_zod2.z.union([import_zod2.z.literal("PPM"), import_zod2.z.literal("VU"), import_zod2.z.literal("TruePeak")]),
  _left: import_zod2.z.number(),
  _right: import_zod2.z.number(),
  _correlation: import_zod2.z.number()
});
var audioLevels = audioLevelsImmutable;
var audioLevelsGetHandlers = {
  ["/audio/levels"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioLevels)
  },
  ["/audio/levels/{levelDetectID}"]: {
    paramsSchema: import_zod2.z.object({
      levelDetectID: import_zod2.z.number()
    }),
    responseSchema: audioLevels
  }
};

// src/api/audio/loudness/index.ts
var import_zod3 = require("zod");
var audioLoudnessImmutable = import_zod3.z.object({
  _leveli: import_zod3.z.number(),
  _levelm: import_zod3.z.number(),
  _levelo: import_zod3.z.number(),
  _levels: import_zod3.z.number(),
  _levelu: import_zod3.z.number(),
  _maxm: import_zod3.z.number(),
  _maxpeak: import_zod3.z.number(),
  _maxs: import_zod3.z.number(),
  _mode: import_zod3.z.string(),
  // TODO: Request modes and change to enum
  _name: import_zod3.z.string(),
  _peak: import_zod3.z.number()
});
var audioLoudness = audioLoudnessImmutable;
var audioLoudnessGetHandlers = {
  ["/audio/loudness"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioLoudness)
  },
  ["/audio/loudness/{levelDetectID}"]: {
    paramsSchema: import_zod3.z.object({
      levelDetectID: import_zod3.z.number()
    }),
    responseSchema: audioLoudness
  }
};

// src/api/audio/mixers/index.ts
var import_zod28 = require("zod");

// src/api/audio/mixers/automix/index.ts
var import_zod4 = require("zod");
var audioMixersAutomixImmutable = import_zod4.z.object({
  _active: import_zod4.z.boolean()
});
var audioMixersAutomixMutable = import_zod4.z.object({
  maxattenuation: import_zod4.z.number(),
  passiveattenuation: import_zod4.z.number(),
  hold: import_zod4.z.number(),
  ratio: import_zod4.z.number(),
  release: import_zod4.z.number()
});
var audioMixersAutomix = audioMixersAutomixImmutable.merge(
  audioMixersAutomixMutable
);
var audioMixersAutomixGetHandlers = {
  ["/audio/mixers/{mixerID}/automix"]: {
    paramsSchema: import_zod4.z.object({
      mixerID: import_zod4.z.number(),
      automixID: import_zod4.z.number()
    }),
    responseSchema: numberedObject(audioMixersAutomix)
  },
  ["/audio/mixers/{mixerID}/automix/{automixID}"]: {
    paramsSchema: import_zod4.z.object({
      mixerID: import_zod4.z.number(),
      automixID: import_zod4.z.number()
    }),
    responseSchema: audioMixersAutomix
  }
};
var audioMixersAutomixSetHandlers = {
  ["/audio/mixers/{mixerID}/automix/{automixID}"]: {
    paramsSchema: import_zod4.z.object({
      mixerID: import_zod4.z.number(),
      automixID: import_zod4.z.number()
    }),
    payloadSchema: audioMixersAutomixMutable,
    responseSchema: audioMixersAutomixMutable
  }
};

// src/api/audio/mixers/cleanfeeds/index.ts
var import_zod5 = require("zod");
var audioMixersCleanfeedsImmutable = import_zod5.z.object({
  _active: import_zod5.z.boolean()
});
var audioMixersCleanfeedsMutable = import_zod5.z.object({
  cut: import_zod5.z.boolean(),
  n: import_zod5.z.boolean(),
  outgain: import_zod5.z.number(),
  outsel: import_zod5.z.boolean(),
  srcsel: import_zod5.z.number()
});
var audioMixersCleanfeeds = audioMixersCleanfeedsImmutable.merge(
  audioMixersCleanfeedsMutable
);
var audioMixersCleanfeedsGetHandlers = {
  ["/audio/mixers/{mixerID}/cleanfeeds"]: {
    paramsSchema: import_zod5.z.object({
      mixerID: import_zod5.z.number()
    }),
    responseSchema: numberedObject(audioMixersCleanfeeds)
  },
  ["/audio/mixers/{mixerID}/cleanfeeds/{cleanfeedID}"]: {
    paramsSchema: import_zod5.z.object({
      mixerID: import_zod5.z.number(),
      cleanfeedID: import_zod5.z.number()
    }),
    responseSchema: audioMixersCleanfeeds
  }
};
var audioMixersCleanfeedsSetHandlers = {
  ["/audio/mixers/{mixerID}/cleanfeeds/{cleanfeedID}"]: {
    paramsSchema: import_zod5.z.object({
      mixerID: import_zod5.z.number(),
      cleanfeedID: import_zod5.z.number()
    }),
    payloadSchema: audioMixersCleanfeedsMutable,
    responseSchema: audioMixersCleanfeedsMutable
  }
};

// src/api/audio/mixers/faders/index.ts
var import_zod24 = require("zod");

// src/api/audio/mixers/faders/meters/index.ts
var import_zod6 = require("zod");
var audioMixersFadersFaderMeterImmutable = import_zod6.z.object({
  _afl: import_zod6.z.array(import_zod6.z.number()),
  _input: import_zod6.z.array(import_zod6.z.number()),
  _pfl: import_zod6.z.array(import_zod6.z.number())
});
var audioMixersFadersFaderMeters = audioMixersFadersFaderMeterImmutable;

// src/api/audio/mixers/faders/mutegroups/index.ts
var import_zod7 = require("zod");
var audioMixersFadersFaderMutegroupsMutegroupMutable = import_zod7.z.boolean();
var audioMixersFadersFaderMutegroupsMutegroup = audioMixersFadersFaderMutegroupsMutegroupMutable;
var audioMixersFadersFaderMutegroupsGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/mutegroups"]: {
    paramsSchema: import_zod7.z.object({
      mixerID: import_zod7.z.number(),
      faderID: import_zod7.z.number()
    }),
    responseSchema: numberedObject(audioMixersFadersFaderMutegroupsMutegroup)
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/mutegroups/{mutegroupID}"]: {
    paramsSchema: import_zod7.z.object({
      mixerID: import_zod7.z.number(),
      faderID: import_zod7.z.number(),
      mutegroupID: import_zod7.z.number()
    }),
    responseSchema: audioMixersFadersFaderMutegroupsMutegroup
  }
};
var audioMixersFadersFaderMutegroupsSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/mutegroups/{mutegroupID}"]: {
    paramsSchema: import_zod7.z.object({
      mixerID: import_zod7.z.number(),
      faderID: import_zod7.z.number(),
      mutegroupID: import_zod7.z.number()
    }),
    payloadSchema: audioMixersFadersFaderMutegroupsMutegroupMutable,
    responseSchema: audioMixersFadersFaderMutegroupsMutegroupMutable
  }
};

// src/api/audio/mixers/faders/options/index.ts
var import_zod8 = require("zod");
var audioMixersFadersFaderOptionsMutable = import_zod8.z.object({
  autooffair: import_zod8.z.boolean(),
  combilogic0: import_zod8.z.boolean(),
  timerreset: import_zod8.z.boolean()
});
var audioMixersFadersFaderOptions = audioMixersFadersFaderOptionsMutable;

// src/api/audio/mixers/faders/paramlist/index.ts
var import_zod9 = require("zod");
var audioMixersFadersFaderParamlistImmutable = import_zod9.z.array(
  // TODO: Ask for all possible values
  import_zod9.z.enum([
    "subsonic",
    "agc",
    "expander",
    "eq1",
    "eq2",
    "eq3",
    "eq4",
    "deesser2",
    "compressor",
    "limiter"
  ])
);
var audioMixersFadersFaderParamlist = audioMixersFadersFaderParamlistImmutable;

// src/api/audio/mixers/faders/params/index.ts
var import_zod23 = require("zod");

// src/api/audio/mixers/faders/params/agc.ts
var import_zod10 = require("zod");
var audioMixersFadersFaderParamsParamAGCImmutable = import_zod10.z.object({
  _active: import_zod10.z.boolean(),
  _gainreduction: import_zod10.z.number()
});
var audioMixersFadersFaderParamsParamAGCMutable = import_zod10.z.object({
  freeze: import_zod10.z.boolean(),
  gain: import_zod10.z.number(),
  level: import_zod10.z.number(),
  on: import_zod10.z.boolean(),
  threshold: import_zod10.z.number(),
  velocity: import_zod10.z.number()
});
var audioMixersFadersFaderParamsParamAGC = audioMixersFadersFaderParamsParamAGCImmutable.merge(
  audioMixersFadersFaderParamsParamAGCMutable
);
var audioMixersFadersFaderParamsParamAGCGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/agc"]: {
    paramsSchema: import_zod10.z.object({
      mixerID: import_zod10.z.number(),
      faderID: import_zod10.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamAGC
  }
};
var audioMixersFadersFaderParamsParamAGCSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/agc"]: {
    paramsSchema: import_zod10.z.object({
      mixerID: import_zod10.z.number(),
      faderID: import_zod10.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamAGCMutable,
    responseSchema: audioMixersFadersFaderParamsParamAGCMutable
  }
};

// src/api/audio/mixers/faders/params/compressor.ts
var import_zod11 = require("zod");
var audioMixersFadersFaderParamsParamCompressorImmutable = import_zod11.z.object({
  _active: import_zod11.z.boolean(),
  _gainreduction: import_zod11.z.number()
});
var audioMixersFadersFaderParamsParamCompressorMutable = import_zod11.z.object({
  attack: import_zod11.z.number(),
  gain: import_zod11.z.number(),
  on: import_zod11.z.boolean(),
  ratio: import_zod11.z.number(),
  release: import_zod11.z.number(),
  threshold: import_zod11.z.number()
});
var audioMixersFadersFaderParamsParamCompressor = audioMixersFadersFaderParamsParamCompressorImmutable.merge(
  audioMixersFadersFaderParamsParamCompressorMutable
);
var audioMixersFadersFaderParamsParamCompressorGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/compressor"]: {
    paramsSchema: import_zod11.z.object({
      mixerID: import_zod11.z.number(),
      faderID: import_zod11.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamCompressor
  }
};
var audioMixersFadersFaderParamsParamCompressorSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/compressor"]: {
    paramsSchema: import_zod11.z.object({
      mixerID: import_zod11.z.number(),
      faderID: import_zod11.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamCompressorMutable,
    responseSchema: audioMixersFadersFaderParamsParamCompressorMutable
  }
};

// src/api/audio/mixers/faders/params/deesser.ts
var import_zod12 = require("zod");
var audioMixersFadersFaderParamsParamDeesserImmutable = import_zod12.z.object({
  _active: import_zod12.z.boolean()
});
var audioMixersFadersFaderParamsParamDeesserMutable = import_zod12.z.object({
  bandwidth: import_zod12.z.number(),
  on: import_zod12.z.boolean(),
  ratio: import_zod12.z.number(),
  sharpness: import_zod12.z.number()
});
var audioMixersFadersFaderParamsParamDeesser = audioMixersFadersFaderParamsParamDeesserImmutable.merge(
  audioMixersFadersFaderParamsParamDeesserMutable
);
var audioMixersFadersFaderParamsParamDeesser2Immutable = import_zod12.z.object({
  _active: import_zod12.z.boolean(),
  _gainreduction: import_zod12.z.number()
});
var audioMixersFadersFaderParamsParamDeesser2Mutable = import_zod12.z.object({
  frequency: import_zod12.z.number(),
  on: import_zod12.z.boolean(),
  threshold: import_zod12.z.number()
});
var audioMixersFadersFaderParamsParamDeesser2 = audioMixersFadersFaderParamsParamDeesser2Immutable.merge(
  audioMixersFadersFaderParamsParamDeesser2Mutable
);
var audioMixersFadersFaderParamsParamDeesserGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/deesser"]: {
    paramsSchema: import_zod12.z.object({
      mixerID: import_zod12.z.number(),
      faderID: import_zod12.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamDeesser
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/deesser2"]: {
    paramsSchema: import_zod12.z.object({
      mixerID: import_zod12.z.number(),
      faderID: import_zod12.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamDeesser2
  }
};
var audioMixersFadersFaderParamsParamDeesserSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/deesser"]: {
    paramsSchema: import_zod12.z.object({
      mixerID: import_zod12.z.number(),
      faderID: import_zod12.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamDeesserMutable,
    responseSchema: audioMixersFadersFaderParamsParamDeesserMutable
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/deesser2"]: {
    paramsSchema: import_zod12.z.object({
      mixerID: import_zod12.z.number(),
      faderID: import_zod12.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamDeesser2Mutable,
    responseSchema: audioMixersFadersFaderParamsParamDeesser2Mutable
  }
};

// src/api/audio/mixers/faders/params/eq.ts
var import_zod13 = require("zod");
var audioMixersFadersFaderParamsParamEQImmutable = import_zod13.z.object({
  _active: import_zod13.z.boolean()
});
var audioMixersFadersFaderParamsParamEQMutable = import_zod13.z.object({
  frequency: import_zod13.z.number(),
  gain: import_zod13.z.number(),
  on: import_zod13.z.boolean(),
  q: import_zod13.z.number(),
  type: import_zod13.z.number()
});
var audioMixersFadersFaderParamsParamEQ = audioMixersFadersFaderParamsParamEQImmutable.merge(
  audioMixersFadersFaderParamsParamEQMutable
);
var audioMixersFadersFaderParamsParamEQGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/eq{eqID}"]: {
    paramsSchema: import_zod13.z.object({
      mixerID: import_zod13.z.number(),
      faderID: import_zod13.z.number(),
      eqID: import_zod13.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamEQ
  }
};
var audioMixersFadersFaderParamsParamEQSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/eq{eqID}"]: {
    paramsSchema: import_zod13.z.object({
      mixerID: import_zod13.z.number(),
      faderID: import_zod13.z.number(),
      eqID: import_zod13.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamEQMutable,
    responseSchema: audioMixersFadersFaderParamsParamEQMutable
  }
};

// src/api/audio/mixers/faders/params/expander.ts
var import_zod14 = require("zod");
var audioMixersFadersFaderParamsParamExpanderImmutable = import_zod14.z.object({
  _active: import_zod14.z.boolean(),
  _gainreduction: import_zod14.z.number()
});
var audioMixersFadersFaderParamsParamExpanderMutable = import_zod14.z.object({
  attack: import_zod14.z.number(),
  gain: import_zod14.z.number(),
  on: import_zod14.z.boolean(),
  ratio: import_zod14.z.number(),
  release: import_zod14.z.number(),
  threshold: import_zod14.z.number()
});
var audioMixersFadersFaderParamsParamExpander = audioMixersFadersFaderParamsParamExpanderImmutable.merge(
  audioMixersFadersFaderParamsParamExpanderMutable
);
var audioMixersFadersFaderParamsParamExpanderGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/expander"]: {
    paramsSchema: import_zod14.z.object({
      mixerID: import_zod14.z.number(),
      faderID: import_zod14.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamExpander
  }
};
var audioMixersFadersFaderParamsParamExpanderSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/expander"]: {
    paramsSchema: import_zod14.z.object({
      mixerID: import_zod14.z.number(),
      faderID: import_zod14.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamExpanderMutable,
    responseSchema: audioMixersFadersFaderParamsParamExpanderMutable
  }
};

// src/api/audio/mixers/faders/params/gain.ts
var import_zod15 = require("zod");
var audioMixersFadersFaderParamsParamGainAGainImmutable = import_zod15.z.object({
  _max: import_zod15.z.number(),
  _min: import_zod15.z.number(),
  _step: import_zod15.z.number()
});
var audioMixersFadersFaderParamsParamGainAGainMutable = import_zod15.z.object({
  inc: import_zod15.z.number(),
  value: import_zod15.z.number()
});
var audioMixersFadersFaderParamsParamGainAGain = audioMixersFadersFaderParamsParamGainAGainImmutable.merge(
  audioMixersFadersFaderParamsParamGainAGainMutable
);
var audioMixersFadersFaderParamsParamGainImmutable = import_zod15.z.object({
  _active: import_zod15.z.boolean(),
  _hasagain: import_zod15.z.boolean(),
  _hasp48: import_zod15.z.boolean(),
  // TODO: Check if including again in the immutable schema is correct
  // or if it should be extended in the exported schema
  again: audioMixersFadersFaderParamsParamGainAGain
});
var audioMixersFadersFaderParamsParamGainMutable = import_zod15.z.object({
  dgain: import_zod15.z.number(),
  p48: import_zod15.z.boolean(),
  phase: import_zod15.z.boolean()
});
var audioMixersFadersFaderParamsParamGain = audioMixersFadersFaderParamsParamGainImmutable.merge(
  audioMixersFadersFaderParamsParamGainMutable
);
var audioMixersFadersFaderParamsParamGainGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain"]: {
    paramsSchema: import_zod15.z.object({
      mixerID: import_zod15.z.number(),
      faderID: import_zod15.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamGain
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain/again"]: {
    paramsSchema: import_zod15.z.object({
      mixerID: import_zod15.z.number(),
      faderID: import_zod15.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamGainAGain
  }
};
var audioMixersFadersFaderParamsParamGainSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain"]: {
    paramsSchema: import_zod15.z.object({
      mixerID: import_zod15.z.number(),
      faderID: import_zod15.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamGainMutable,
    responseSchema: audioMixersFadersFaderParamsParamGainMutable
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain/again"]: {
    paramsSchema: import_zod15.z.object({
      mixerID: import_zod15.z.number(),
      faderID: import_zod15.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamGainAGainMutable,
    responseSchema: audioMixersFadersFaderParamsParamGainAGainMutable
  }
};

// src/api/audio/mixers/faders/params/gate.ts
var import_zod16 = require("zod");
var audioMixersFadersFaderParamsParamGateImmutable = import_zod16.z.object({
  _active: import_zod16.z.boolean(),
  _gainreduction: import_zod16.z.number()
});
var audioMixersFadersFaderParamsParamGateMutable = import_zod16.z.object({
  attack: import_zod16.z.number(),
  attenuation: import_zod16.z.number(),
  on: import_zod16.z.boolean(),
  release: import_zod16.z.number(),
  threshold: import_zod16.z.number()
});
var audioMixersFadersFaderParamsParamGate = audioMixersFadersFaderParamsParamGateImmutable.merge(
  audioMixersFadersFaderParamsParamGateMutable
);
var audioMixersFadersFaderParamsParamGateGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gate"]: {
    paramsSchema: import_zod16.z.object({
      mixerID: import_zod16.z.number(),
      faderID: import_zod16.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamGate
  }
};
var audioMixersFadersFaderParamsParamGateSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gate"]: {
    paramsSchema: import_zod16.z.object({
      mixerID: import_zod16.z.number(),
      faderID: import_zod16.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamGateMutable,
    responseSchema: audioMixersFadersFaderParamsParamGateMutable
  }
};

// src/api/audio/mixers/faders/params/limiter.ts
var import_zod17 = require("zod");
var audioMixersFadersFaderParamsParamLimiterImmutable = import_zod17.z.object({
  _active: import_zod17.z.boolean(),
  _gainreduction: import_zod17.z.number()
});
var audioMixersFadersFaderParamsParamLimiterMutable = import_zod17.z.object({
  on: import_zod17.z.boolean(),
  release: import_zod17.z.number(),
  threshold: import_zod17.z.number()
});
var audioMixersFadersFaderParamsParamLimiter = audioMixersFadersFaderParamsParamLimiterImmutable.merge(
  audioMixersFadersFaderParamsParamLimiterMutable
);
var audioMixersFadersFaderParamsParamLimiterGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/limiter"]: {
    paramsSchema: import_zod17.z.object({
      mixerID: import_zod17.z.number(),
      faderID: import_zod17.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamLimiter
  }
};
var audioMixersFadersFaderParamsParamLimiterSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/limiter"]: {
    paramsSchema: import_zod17.z.object({
      mixerID: import_zod17.z.number(),
      faderID: import_zod17.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamLimiterMutable,
    responseSchema: audioMixersFadersFaderParamsParamLimiterMutable
  }
};

// src/api/audio/mixers/faders/params/panbal.ts
var import_zod18 = require("zod");
var audioMixersFadersFaderParamsParamPanbalImmutable = import_zod18.z.object({
  _active: import_zod18.z.boolean()
});
var audioMixersFadersFaderParamsParamPanbalMutable = import_zod18.z.object({
  divergency: import_zod18.z.number(),
  lfeonly: import_zod18.z.boolean(),
  lfesend: import_zod18.z.number(),
  matrix: import_zod18.z.number(),
  panbal: import_zod18.z.number(),
  rear: import_zod18.z.number()
});
var audioMixersFadersFaderParamsParamPanbal = audioMixersFadersFaderParamsParamPanbalImmutable.merge(
  audioMixersFadersFaderParamsParamPanbalMutable
);
var audioMixersFadersFaderParamsParamPanbalGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/panbal"]: {
    paramsSchema: import_zod18.z.object({
      mixerID: import_zod18.z.number(),
      faderID: import_zod18.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamPanbal
  }
};
var audioMixersFadersFaderParamsParamPanbalSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/panbal"]: {
    paramsSchema: import_zod18.z.object({
      mixerID: import_zod18.z.number(),
      faderID: import_zod18.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamPanbalMutable,
    responseSchema: audioMixersFadersFaderParamsParamPanbalMutable
  }
};

// src/api/audio/mixers/faders/params/r128agc.ts
var import_zod19 = require("zod");
var audioMixersFadersFaderParamsParamR128AGCImmutable = import_zod19.z.object({
  _active: import_zod19.z.boolean(),
  _gainreduction: import_zod19.z.number()
});
var audioMixersFadersFaderParamsParamR128AGCMutable = import_zod19.z.object({
  freeze: import_zod19.z.boolean(),
  gain: import_zod19.z.number(),
  level: import_zod19.z.number(),
  on: import_zod19.z.boolean(),
  threshold: import_zod19.z.number(),
  velocity: import_zod19.z.number()
});
var audioMixersFadersFaderParamsParamR128AGC = audioMixersFadersFaderParamsParamR128AGCImmutable.merge(
  audioMixersFadersFaderParamsParamR128AGCMutable
);
var audioMixersFadersFaderParamsParamR128AGCGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/r128agc"]: {
    paramsSchema: import_zod19.z.object({
      mixerID: import_zod19.z.number(),
      faderID: import_zod19.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamR128AGC
  }
};
var audioMixersFadersFaderParamsParamR128AGCSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/r128agc"]: {
    paramsSchema: import_zod19.z.object({
      mixerID: import_zod19.z.number(),
      faderID: import_zod19.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamR128AGCMutable,
    responseSchema: audioMixersFadersFaderParamsParamR128AGCMutable
  }
};

// src/api/audio/mixers/faders/params/subsonic.ts
var import_zod20 = require("zod");
var audioMixersFadersFaderParamsParamSubsonicImmutable = import_zod20.z.object({
  _active: import_zod20.z.boolean()
});
var audioMixersFadersFaderParamsParamSubsonicMutable = import_zod20.z.object({
  frequency: import_zod20.z.number(),
  on: import_zod20.z.boolean()
});
var audioMixersFadersFaderParamsParamSubsonic = audioMixersFadersFaderParamsParamSubsonicImmutable.merge(
  audioMixersFadersFaderParamsParamSubsonicMutable
);
var audioMixersFadersFaderParamsParamSubsonicGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gate"]: {
    paramsSchema: import_zod20.z.object({
      mixerID: import_zod20.z.number(),
      faderID: import_zod20.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamSubsonic
  }
};
var audioMixersFadersFaderParamsParamSubsonicSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gate"]: {
    paramsSchema: import_zod20.z.object({
      mixerID: import_zod20.z.number(),
      faderID: import_zod20.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamSubsonicMutable,
    responseSchema: audioMixersFadersFaderParamsParamSubsonicMutable
  }
};

// src/api/audio/mixers/faders/params/swc.ts
var import_zod21 = require("zod");
var audioMixersFadersFaderParamsParamSwcImmutable = import_zod21.z.object({
  _active: import_zod21.z.boolean()
});
var audioMixersFadersFaderParamsParamSwcMutable = import_zod21.z.object({
  direction: import_zod21.z.number(),
  type: import_zod21.z.boolean(),
  width: import_zod21.z.number()
});
var audioMixersFadersFaderParamsParamSwc = audioMixersFadersFaderParamsParamSwcImmutable.merge(
  audioMixersFadersFaderParamsParamSwcMutable
);
var audioMixersFadersFaderParamsParamSwcGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/swc"]: {
    paramsSchema: import_zod21.z.object({
      mixerID: import_zod21.z.number(),
      faderID: import_zod21.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamSwc
  }
};
var audioMixersFadersFaderParamsParamSwcSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/swc"]: {
    paramsSchema: import_zod21.z.object({
      mixerID: import_zod21.z.number(),
      faderID: import_zod21.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamSwcMutable,
    responseSchema: audioMixersFadersFaderParamsParamSwcMutable
  }
};

// src/api/audio/mixers/faders/params/varfilter.ts
var import_zod22 = require("zod");
var audioMixersFadersFaderParamsParamVarfilterImmutable = import_zod22.z.object({
  _active: import_zod22.z.boolean()
});
var audioMixersFadersFaderParamsParamVarfilterMutable = import_zod22.z.object({
  frequency: import_zod22.z.number(),
  hipass: import_zod22.z.boolean(),
  on: import_zod22.z.boolean(),
  order: import_zod22.z.number()
});
var audioMixersFadersFaderParamsParamVarfilter = audioMixersFadersFaderParamsParamVarfilterImmutable.merge(
  audioMixersFadersFaderParamsParamVarfilterMutable
);
var audioMixersFadersFaderParamsParamVarfilterGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/varfilter{filtID}"]: {
    paramsSchema: import_zod22.z.object({
      mixerID: import_zod22.z.number(),
      faderID: import_zod22.z.number(),
      filtID: import_zod22.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamVarfilter
  }
};
var audioMixersFadersFaderParamsParamVarfilterSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/varfilter{filtID}"]: {
    paramsSchema: import_zod22.z.object({
      mixerID: import_zod22.z.number(),
      faderID: import_zod22.z.number(),
      filtID: import_zod22.z.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamVarfilterMutable,
    responseSchema: audioMixersFadersFaderParamsParamVarfilterMutable
  }
};

// src/api/audio/mixers/faders/params/index.ts
var audioMixersFadersFaderParamsParams = import_zod23.z.object({
  agc: audioMixersFadersFaderParamsParamAGC,
  compressor: audioMixersFadersFaderParamsParamCompressor,
  deesser: audioMixersFadersFaderParamsParamDeesser,
  deesser2: audioMixersFadersFaderParamsParamDeesser2,
  // TODO: Check if eq is correct, or if it should be eq1, eq2, eq3 and eq4
  eq: audioMixersFadersFaderParamsParamEQ,
  expander: audioMixersFadersFaderParamsParamExpander,
  gain: audioMixersFadersFaderParamsParamGain,
  gate: audioMixersFadersFaderParamsParamGate,
  limiter: audioMixersFadersFaderParamsParamLimiter,
  panbal: audioMixersFadersFaderParamsParamPanbal,
  r128agc: audioMixersFadersFaderParamsParamR128AGC,
  subsonic: audioMixersFadersFaderParamsParamSubsonic,
  swc: audioMixersFadersFaderParamsParamSwc,
  varfilter: audioMixersFadersFaderParamsParamVarfilter
});
var audioMixersFadersFaderParamsGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params"]: {
    paramsSchema: import_zod23.z.object({
      mixerID: import_zod23.z.number(),
      faderID: import_zod23.z.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParams
  },
  ...audioMixersFadersFaderParamsParamAGCGetHandlers,
  ...audioMixersFadersFaderParamsParamCompressorGetHandlers,
  ...audioMixersFadersFaderParamsParamDeesserGetHandlers,
  ...audioMixersFadersFaderParamsParamEQGetHandlers,
  ...audioMixersFadersFaderParamsParamExpanderGetHandlers,
  ...audioMixersFadersFaderParamsParamGainGetHandlers,
  ...audioMixersFadersFaderParamsParamGateGetHandlers,
  ...audioMixersFadersFaderParamsParamLimiterGetHandlers,
  ...audioMixersFadersFaderParamsParamPanbalGetHandlers,
  ...audioMixersFadersFaderParamsParamR128AGCGetHandlers,
  ...audioMixersFadersFaderParamsParamSubsonicGetHandlers,
  ...audioMixersFadersFaderParamsParamSwcGetHandlers,
  ...audioMixersFadersFaderParamsParamVarfilterGetHandlers
};
var audioMixersFadersFaderParamsSetHandlers = {
  ...audioMixersFadersFaderParamsParamAGCSetHandlers,
  ...audioMixersFadersFaderParamsParamCompressorSetHandlers,
  ...audioMixersFadersFaderParamsParamDeesserSetHandlers,
  ...audioMixersFadersFaderParamsParamEQSetHandlers,
  ...audioMixersFadersFaderParamsParamExpanderSetHandlers,
  ...audioMixersFadersFaderParamsParamGainSetHandlers,
  ...audioMixersFadersFaderParamsParamGateSetHandlers,
  ...audioMixersFadersFaderParamsParamLimiterSetHandlers,
  ...audioMixersFadersFaderParamsParamPanbalSetHandlers,
  ...audioMixersFadersFaderParamsParamR128AGCSetHandlers,
  ...audioMixersFadersFaderParamsParamSubsonicSetHandlers,
  ...audioMixersFadersFaderParamsParamSwcSetHandlers,
  ...audioMixersFadersFaderParamsParamVarfilterSetHandlers
};

// src/api/audio/mixers/faders/index.ts
var audioMixersFadersFaderImmutable = import_zod24.z.object({
  _channelcnt: import_zod24.z.number(),
  _defaultlabel: import_zod24.z.string(),
  _faderstart: import_zod24.z.boolean(),
  _lastloadedsnap: import_zod24.z.string(),
  _poolavailable: import_zod24.z.boolean(),
  _readystate: import_zod24.z.boolean(),
  _usecleanfeed: import_zod24.z.number(),
  meter: audioMixersFadersFaderMeters,
  mutegroups: numberedObject(audioMixersFadersFaderMutegroupsMutegroup),
  _paramlist: audioMixersFadersFaderParamlist,
  options: audioMixersFadersFaderOptions,
  params: audioMixersFadersFaderParamsParams
});
var audioMixersFadersFaderMutable = import_zod24.z.object({
  altinput: import_zod24.z.boolean(),
  bypass: import_zod24.z.boolean(),
  fader: import_zod24.z.number(),
  isolate: import_zod24.z.boolean(),
  label: import_zod24.z.string(),
  memo: import_zod24.z.boolean(),
  offair: import_zod24.z.boolean(),
  on: import_zod24.z.boolean(),
  pfl1: import_zod24.z.boolean(),
  pfl2: import_zod24.z.boolean(),
  preparation: import_zod24.z.boolean(),
  solo: import_zod24.z.boolean(),
  sourceid: import_zod24.z.number(),
  vcagroup: import_zod24.z.number(),
  voice: import_zod24.z.boolean()
});
var audioMixersFadersFader = audioMixersFadersFaderImmutable.merge(
  audioMixersFadersFaderMutable
);
var audioMixersFadersFaderGetHandlers = {
  ["/audio/mixers/{mixerID}/faders"]: {
    paramsSchema: import_zod24.z.object({
      mixerID: import_zod24.z.number()
    }),
    responseSchema: numberedObject(audioMixersFadersFader)
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}"]: {
    paramsSchema: import_zod24.z.object({
      mixerID: import_zod24.z.number(),
      faderID: import_zod24.z.number()
    }),
    responseSchema: audioMixersFadersFader
  },
  ...audioMixersFadersFaderMutegroupsGetHandlers,
  ...audioMixersFadersFaderParamsGetHandlers
};
var audioMixersFadersFaderSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}"]: {
    paramsSchema: import_zod24.z.object({
      mixerID: import_zod24.z.number(),
      faderID: import_zod24.z.number()
    }),
    payloadSchema: audioMixersFadersFaderMutable,
    responseSchema: audioMixersFadersFaderMutable
  },
  ...audioMixersFadersFaderMutegroupsSetHandlers,
  ...audioMixersFadersFaderParamsSetHandlers
};

// src/api/audio/mixers/mutegroups/index.ts
var import_zod25 = require("zod");
var audioMixersMutegroupsMutegroupImmutable = import_zod25.z.boolean();
var audioMixersMutegroupsMutegroup = audioMixersMutegroupsMutegroupImmutable;
var audioMixersMutegroupsGetHandlers = {
  ["/audio/mixers/{mixerID}/mutegroups"]: {
    paramsSchema: import_zod25.z.object({
      mixerID: import_zod25.z.number()
    }),
    responseSchema: numberedObject(audioMixersMutegroupsMutegroup)
  },
  ["/audio/mixers/{mixerID}/mutegroups/{mutegroupID}"]: {
    paramsSchema: import_zod25.z.object({
      mixerID: import_zod25.z.number(),
      mutegroupID: import_zod25.z.number()
    }),
    responseSchema: audioMixersMutegroupsMutegroup
  }
};

// src/api/audio/mixers/options/index.ts
var import_zod26 = require("zod");
var audioMixersOptionsPflMutable = import_zod26.z.object({
  afl: import_zod26.z.boolean(),
  aflwhenon: import_zod26.z.boolean(),
  mix: import_zod26.z.boolean(),
  reset: import_zod26.z.boolean(),
  resetfader: import_zod26.z.boolean(),
  return: import_zod26.z.boolean()
});
var audioMixersOptionsPfl = audioMixersOptionsPflMutable;
var audioMixersOptionsImmutable = import_zod26.z.object({
  pfl1: audioMixersOptionsPfl,
  pfl2: audioMixersOptionsPfl
});
var audioMixersOptionsMutable = import_zod26.z.object({
  directoffair: import_zod26.z.boolean()
});
var audioMixersOptions = audioMixersOptionsImmutable.merge(
  audioMixersOptionsMutable
);
var audioMixersOptionsGetHandlers = {
  ["/audio/mixers/{mixerID}/options"]: {
    paramsSchema: import_zod26.z.object({
      mixerID: import_zod26.z.number()
    }),
    responseSchema: audioMixersOptions
  },
  ["/audio/mixers/{mixerID}/options/pfl1"]: {
    paramsSchema: import_zod26.z.object({
      mixerID: import_zod26.z.number()
    }),
    responseSchema: audioMixersOptionsPfl
  },
  ["/audio/mixers/{mixerID}/options/pfl2"]: {
    paramsSchema: import_zod26.z.object({
      mixerID: import_zod26.z.number()
    }),
    responseSchema: audioMixersOptionsPfl
  }
};
var audioMixersOptionsSetHandlers = {
  ["/audio/mixers/{mixerID}/options"]: {
    paramsSchema: import_zod26.z.object({
      mixerID: import_zod26.z.number()
    }),
    payloadSchema: audioMixersOptionsMutable,
    responseSchema: audioMixersOptionsMutable
  },
  ["/audio/mixers/{mixerID}/options/pfl1"]: {
    paramsSchema: import_zod26.z.object({
      mixerID: import_zod26.z.number()
    }),
    payloadSchema: audioMixersOptionsPflMutable,
    responseSchema: audioMixersOptionsPflMutable
  },
  ["/audio/mixers/{mixerID}/options/pfl2"]: {
    paramsSchema: import_zod26.z.object({
      mixerID: import_zod26.z.number()
    }),
    payloadSchema: audioMixersOptionsPflMutable,
    responseSchema: audioMixersOptionsPflMutable
  }
};

// src/api/audio/mixers/sourcelist/index.ts
var import_zod27 = require("zod");
var audioMixersSourcelistItemImmutable = import_zod27.z.object({
  _defaultlabel: import_zod27.z.string(),
  _label: import_zod27.z.string(),
  _sourceid: import_zod27.z.number()
});
var audioMixersSourcelistItem = audioMixersSourcelistItemImmutable;
var audioMixersSourcelist = import_zod27.z.array(audioMixersSourcelistItem);
var audioMixersSourcelistGetHandlers = {
  ["/audio/mixers/{mixerID}/sourcelist"]: {
    paramsSchema: import_zod27.z.object({
      mixerID: import_zod27.z.number()
    }),
    responseSchema: audioMixersSourcelist
  }
};

// src/api/audio/mixers/index.ts
var audioMixersMixerImmutable = import_zod28.z.object({
  _lastloadedsnap: import_zod28.z.string(),
  automix: numberedObject(audioMixersAutomix),
  cleanfeeds: numberedObject(audioMixersCleanfeeds),
  faders: numberedObject(audioMixersFadersFader),
  mutegroups: numberedObject(audioMixersMutegroupsMutegroup),
  options: audioMixersOptions,
  sourcelist: audioMixersSourcelist
});
var audioMixersMixer = audioMixersMixerImmutable;
var audioMixersGetHandlers = {
  ["/audio/mixers"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioMixersMixer)
  },
  ["/audio/mixers/{mixerID}"]: {
    paramsSchema: import_zod28.z.object({
      mixerID: import_zod28.z.number()
    }),
    responseSchema: audioMixersMixer
  },
  ...audioMixersAutomixGetHandlers,
  ...audioMixersCleanfeedsGetHandlers,
  ...audioMixersFadersFaderGetHandlers,
  ...audioMixersMutegroupsGetHandlers,
  ...audioMixersOptionsGetHandlers,
  ...audioMixersSourcelistGetHandlers
};
var audioMixersSetHandlers = {
  ...audioMixersAutomixSetHandlers,
  ...audioMixersCleanfeedsSetHandlers,
  ...audioMixersFadersFaderSetHandlers,
  ...audioMixersOptionsSetHandlers
};

// src/api/audio/pots/index.ts
var import_zod29 = require("zod");
var audioPotsPotImmutable = import_zod29.z.object({
  _max: import_zod29.z.number(),
  _min: import_zod29.z.number(),
  _name: import_zod29.z.string(),
  _step: import_zod29.z.number()
});
var audioPotsPotMutable = import_zod29.z.object({
  value: import_zod29.z.number()
});
var audioPotsPot = audioPotsPotImmutable.merge(audioPotsPotMutable);
var audioPotsGetHandlers = {
  ["/audio/pots"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioPotsPot)
  },
  ["/audio/pots/{potID}"]: {
    paramsSchema: import_zod29.z.object({
      potID: import_zod29.z.number()
    }),
    responseSchema: audioPotsPot
  }
};
var audioPotsSetHandlers = {
  ["/audio/pots/{potID}"]: {
    paramsSchema: import_zod29.z.object({
      potID: import_zod29.z.number()
    }),
    payloadSchema: audioPotsPotMutable,
    responseSchema: audioPotsPotMutable
  }
};

// src/api/audio/routing/index.ts
var import_zod33 = require("zod");

// src/api/audio/routing/inputs/index.ts
var import_zod30 = require("zod");
var audioRoutingInputImmutable = import_zod30.z.object({
  _channels: import_zod30.z.number(),
  _device: import_zod30.z.string(),
  _name: import_zod30.z.string()
});
var audioRoutingInput = audioRoutingInputImmutable;
var audioRoutingInputsGetHandlers = {
  ["/audio/routing/inputs"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioRoutingInput)
  },
  ["/audio/routing/inputs/{inputID}"]: {
    paramsSchema: import_zod30.z.object({
      inputID: import_zod30.z.number()
    }),
    responseSchema: audioRoutingInput
  }
};

// src/api/audio/routing/outputs/index.ts
var import_zod31 = require("zod");
var audioRoutingOutputImmutable = import_zod31.z.object({
  _channels: import_zod31.z.number(),
  _device: import_zod31.z.string(),
  _name: import_zod31.z.string()
});
var audioRoutingOutput = audioRoutingOutputImmutable;
var audioRoutingOutputsGetHandlers = {
  ["/audio/routing/outputs"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioRoutingOutput)
  },
  ["/audio/routing/outputs/{outputID}"]: {
    paramsSchema: import_zod31.z.object({
      outputID: import_zod31.z.number()
    }),
    responseSchema: audioRoutingOutput
  }
};

// src/api/audio/routing/routes/index.ts
var import_zod32 = require("zod");
var audioRoutingRouteMutable = import_zod32.z.string();
var audioRoutingRoute = audioRoutingRouteMutable;
var audioRoutingRoutesGetHandlers = {
  ["/audio/routing/routes"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioRoutingRoute)
  },
  ["/audio/routing/routes/{routeID}"]: {
    paramsSchema: import_zod32.z.object({
      routeID: import_zod32.z.number()
    }),
    responseSchema: audioRoutingRoute
  }
};
var audioRoutingRoutesSetHandlers = {
  ["/audio/routing/routes/{routeID}"]: {
    paramsSchema: import_zod32.z.object({
      // TODO: Check if routeID is actually a number.
      routeID: import_zod32.z.number()
    }),
    responseSchema: audioRoutingRouteMutable,
    payloadSchema: audioRoutingRouteMutable
  }
};

// src/api/audio/routing/index.ts
var audioRouting = import_zod33.z.object({
  inputs: numberedObject(audioRoutingInput),
  outputs: numberedObject(audioRoutingOutput),
  routes: numberedObject(audioRoutingRoute)
});
var audioRoutingGetHandlers = {
  ["/audio/routing"]: {
    paramsSchema: null,
    responseSchema: audioRouting
  },
  ...audioRoutingInputsGetHandlers,
  ...audioRoutingOutputsGetHandlers,
  ...audioRoutingRoutesGetHandlers
};
var audioRoutingSetHandlers = {
  ...audioRoutingRoutesSetHandlers
};

// src/api/audio/selectors/index.ts
var import_zod36 = require("zod");

// src/api/audio/selectors/selectors/index.ts
var import_zod34 = require("zod");
var audioSelectorSelectorImmutable = import_zod34.z.object({
  _name: import_zod34.z.string(),
  _sourcelist: import_zod34.z.string()
});
var audioSelectorSelectorMutable = import_zod34.z.object({
  left: import_zod34.z.string(),
  right: import_zod34.z.string()
});
var audioSelectorsSelector = audioSelectorSelectorImmutable.merge(
  audioSelectorSelectorMutable
);
var audioSelectorsSelectorsGetHandlers = {
  ["/audio/selectors/selectors"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioSelectorsSelector)
  },
  ["/audio/selectors/selectors/{selectorID}"]: {
    paramsSchema: import_zod34.z.object({
      selectorID: import_zod34.z.number()
    }),
    responseSchema: audioSelectorsSelector
  }
};
var audioSelectorsSelectorsSetHandlers = {
  ["/audio/selectors/selectors/{selectorID}"]: {
    paramsSchema: import_zod34.z.object({
      selectorID: import_zod34.z.number()
    }),
    responseSchema: audioSelectorSelectorMutable,
    payloadSchema: audioSelectorSelectorMutable
  }
};

// src/api/audio/selectors/sourcelists/index.ts
var import_zod35 = require("zod");
var audioSelectorsSourcelistImmutable = import_zod35.z.object({
  _name: import_zod35.z.string(),
  entries: numberedObject(
    import_zod35.z.object({
      _label: import_zod35.z.string(),
      _sourcel: import_zod35.z.string(),
      _sourcer: import_zod35.z.string()
    })
  )
});
var audioSelectorsSourcelist = audioSelectorsSourcelistImmutable;
var audioSelectorsSourcelistsGetHandlers = {
  ["/audio/selectors/sourcelists"]: {
    paramsSchema: null,
    responseSchema: numberedObject(audioSelectorsSourcelist)
  },
  ["/audio/selectors/sourcelists/{sourcelistID}"]: {
    paramsSchema: import_zod35.z.object({
      sourcelistID: import_zod35.z.number()
    }),
    responseSchema: audioSelectorsSourcelist
  }
};

// src/api/audio/selectors/index.ts
var audioSelectors = import_zod36.z.object({
  selectors: numberedObject(audioSelectorsSelector),
  sourcelists: import_zod36.z.any()
  // TODO: Implement sourcelists
});
var audioSelectorsGetHandlers = {
  ["/audio/selectors"]: {
    paramsSchema: null,
    responseSchema: audioSelectors
  },
  ...audioSelectorsSelectorsGetHandlers,
  ...audioSelectorsSourcelistsGetHandlers
};
var audioSelectorsSetHandlers = {
  ...audioSelectorsSelectorsSetHandlers
};

// src/api/audio/index.ts
var audioGetHandlers = {
  ...audioLevelsGetHandlers,
  ...audioLoudnessGetHandlers,
  ...audioMixersGetHandlers,
  ...audioPotsGetHandlers,
  ...audioRoutingGetHandlers,
  ...audioSelectorsGetHandlers
};
var audioSetHandlers = {
  ...audioMixersSetHandlers,
  ...audioPotsSetHandlers,
  ...audioRoutingSetHandlers,
  ...audioSelectorsSetHandlers
};

// src/api/control/logics/index.ts
var import_zod37 = require("zod");
var controlLogicsLogicImmutable = import_zod37.z.object({
  _name: import_zod37.z.string(),
  _path: import_zod37.z.string()
});
var controlLogicsLogicMutable = import_zod37.z.object({
  value: import_zod37.z.boolean()
});
var controlLogicsLogic = controlLogicsLogicImmutable.merge(
  controlLogicsLogicMutable
);
var controlLogicsGetHandlers = {
  ["/control/logics"]: {
    paramsSchema: null,
    responseSchema: numberedObject(controlLogicsLogic)
  },
  ["/control/logics/{logicID}"]: {
    paramsSchema: import_zod37.z.object({
      logicID: import_zod37.z.number()
    }),
    responseSchema: controlLogicsLogic
  }
};
var controlLogicsSetHandlers = {
  ["/control/logics/{logicID}"]: {
    paramsSchema: import_zod37.z.object({
      logicID: import_zod37.z.number()
    }),
    payloadSchema: controlLogicsLogicMutable,
    responseSchema: controlLogicsLogicMutable
  }
};

// src/api/control/index.ts
var controlGetHandlers = {
  ...controlLogicsGetHandlers
};
var controlSetHandlers = {
  ...controlLogicsSetHandlers
};

// src/api/general/index.ts
var import_zod38 = require("zod");
var general = import_zod38.z.object({
  _api_version: import_zod38.z.string(),
  _firmware_version: import_zod38.z.string(),
  _hardwareserial: import_zod38.z.string(),
  _hourmeter: import_zod38.z.number(),
  _sync2ok: import_zod38.z.boolean(),
  _syncsource: import_zod38.z.number(),
  _systemfrequency: import_zod38.z.number(),
  _systemtime: import_zod38.z.number(),
  _uptime: import_zod38.z.number()
});
var generalGetHandlers = {
  ["/general"]: {
    paramsSchema: null,
    responseSchema: general
  }
};

// src/api/index.ts
var dhdHandlers = {
  get: {
    ...audioGetHandlers,
    ...controlGetHandlers,
    ...generalGetHandlers
  },
  set: {
    ...audioSetHandlers,
    ...controlSetHandlers
  }
};

// src/log.ts
var import_debug = __toESM(require("debug"), 1);
var log = {
  debug: (0, import_debug.default)("dhd-control-api:debug"),
  error: (0, import_debug.default)("dhd-control-api:error"),
  info: (0, import_debug.default)("dhd-control-api:info"),
  warn: (0, import_debug.default)("dhd-control-api:warn")
};
log.error.color = "1";
log.info.color = "2";
log.debug.color = "4";
log.warn.color = "3";

// src/schemas.ts
var import_zod39 = require("zod");
var dhdWebSocketAuthResponse = import_zod39.z.object({
  msgID: import_zod39.z.string(),
  method: import_zod39.z.literal("auth"),
  success: import_zod39.z.literal(true)
});
var dhdWebSocketBaseResponse = (method) => import_zod39.z.object({
  msgID: import_zod39.z.string(),
  method: import_zod39.z.literal(method),
  success: import_zod39.z.literal(true),
  path: import_zod39.z.string(),
  payload: import_zod39.z.any()
});
var dhdWebSocketErrorResponse = (method) => import_zod39.z.object({
  msgID: import_zod39.z.string(),
  method: import_zod39.z.literal(method),
  success: import_zod39.z.literal(false),
  error: import_zod39.z.object({
    code: import_zod39.z.number(),
    message: import_zod39.z.string()
  })
});
var dhdWebSocketResponse = import_zod39.z.union([
  dhdWebSocketAuthResponse,
  dhdWebSocketErrorResponse("auth"),
  dhdWebSocketBaseResponse("get"),
  dhdWebSocketErrorResponse("get"),
  dhdWebSocketBaseResponse("set"),
  dhdWebSocketErrorResponse("set")
]);

// src/index.ts
var dhdOptionsSchema = import_zod40.z.object({
  /**
   * The hostname or IP address of the DHD device.
   *
   * @example 10.0.0.1
   * @example dhd.local
   */
  host: import_zod40.z.string(),
  /**
   * The token used to authenticate with the DHD device.
   */
  token: import_zod40.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{8}-[0-9a-f]{8}-[0-9a-f]{8}$/i, {
    message: "Invalid token format"
  }),
  /**
   * The type of connection to use when connecting to the DHD device. Please
   * note that the connection via REST has a rate limit of 1 request per second.
   *
   * @default 'websocket'
   */
  connectionType: import_zod40.z.union([import_zod40.z.literal("websocket"), import_zod40.z.literal("rest")]).default("websocket"),
  /**
   * Connect to the DHD device using a secure WebSocket connection or HTTPS-requests.
   *
   * @default false
   */
  secure: import_zod40.z.boolean().default(false),
  /**
   * Connect to the DHD device automatically when the instance is created.
   *
   * @default true
   */
  autoConnect: import_zod40.z.boolean().default(true),
  /**
   * Automatically reconnect to the DHD device if the connection is lost.
   *
   * @default true
   */
  autoReconnect: import_zod40.z.boolean().default(true)
});
var DHD = class {
  options;
  socket = null;
  reconnectTimeout = null;
  requestMap = /* @__PURE__ */ new Map();
  eventHandlers = /* @__PURE__ */ new Map();
  constructor(options) {
    this.options = dhdOptionsSchema.parse(options);
    if (this.options.autoConnect !== false) {
      this.connect();
    }
    if (this.options.connectionType === "rest") {
      setTimeout(() => this.emit("ready"), 0);
    }
  }
  on = (event, handler) => {
    if (!this.eventHandlers.has(event)) {
      this.eventHandlers.set(event, []);
    }
    this.eventHandlers.get(event).push(handl