dhd-control-api/dist/index.js

Typescript library for the DHD Control API

// src/index.ts
import { z as z40, ZodBoolean, ZodString } from "zod";

// src/api/audio/levels/index.ts
import { z as z2 } from "zod";

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

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

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

// src/api/audio/mixers/index.ts
import { z as z28 } from "zod";

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

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

// src/api/audio/mixers/faders/index.ts
import { z as z24 } from "zod";

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

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

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

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

// src/api/audio/mixers/faders/params/index.ts
import { z as z23 } from "zod";

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

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

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

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

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

// src/api/audio/mixers/faders/params/gain.ts
import { z as z15 } from "zod";
var audioMixersFadersFaderParamsParamGainAGainImmutable = z15.object({
  _max: z15.number(),
  _min: z15.number(),
  _step: z15.number()
});
var audioMixersFadersFaderParamsParamGainAGainMutable = z15.object({
  inc: z15.number(),
  value: z15.number()
});
var audioMixersFadersFaderParamsParamGainAGain = audioMixersFadersFaderParamsParamGainAGainImmutable.merge(
  audioMixersFadersFaderParamsParamGainAGainMutable
);
var audioMixersFadersFaderParamsParamGainImmutable = z15.object({
  _active: z15.boolean(),
  _hasagain: z15.boolean(),
  _hasp48: z15.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 = z15.object({
  dgain: z15.number(),
  p48: z15.boolean(),
  phase: z15.boolean()
});
var audioMixersFadersFaderParamsParamGain = audioMixersFadersFaderParamsParamGainImmutable.merge(
  audioMixersFadersFaderParamsParamGainMutable
);
var audioMixersFadersFaderParamsParamGainGetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain"]: {
    paramsSchema: z15.object({
      mixerID: z15.number(),
      faderID: z15.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamGain
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain/again"]: {
    paramsSchema: z15.object({
      mixerID: z15.number(),
      faderID: z15.number()
    }),
    responseSchema: audioMixersFadersFaderParamsParamGainAGain
  }
};
var audioMixersFadersFaderParamsParamGainSetHandlers = {
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain"]: {
    paramsSchema: z15.object({
      mixerID: z15.number(),
      faderID: z15.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamGainMutable,
    responseSchema: audioMixersFadersFaderParamsParamGainMutable
  },
  ["/audio/mixers/{mixerID}/faders/{faderID}/params/gain/again"]: {
    paramsSchema: z15.object({
      mixerID: z15.number(),
      faderID: z15.number()
    }),
    payloadSchema: audioMixersFadersFaderParamsParamGainAGainMutable,
    responseSchema: audioMixersFadersFaderParamsParamGainAGainMutable
  }
};

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

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

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

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

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

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

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

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

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

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

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

// src/api/audio/mixers/index.ts
var audioMixersMixerImmutable = z28.object({
  _lastloadedsnap: z28.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: z28.object({
      mixerID: z28.number()
    }),
    responseSchema: audioMixersMixer
  },
  ...audioMixersAutomixGetHandlers,
  ...audioMixersCleanfeedsGetHandlers,
  ...audioMixersFadersFaderGetHandlers,
  ...audioMixersMutegroupsGetHandlers,
  ...audioMixersOptionsGetHandlers,
  ...audioMixersSourcelistGetHandlers
};
var audioMixersSetHandlers = {
  ...audioMixersAutomixSetHandlers,
  ...audioMixersCleanfeedsSetHandlers,
  ...audioMixersFadersFaderSetHandlers,
  ...audioMixersOptionsSetHandlers
};

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

// src/api/audio/routing/index.ts
import { z as z33 } from "zod";

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

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

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

// src/api/audio/routing/index.ts
var audioRouting = z33.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
import { z as z36 } from "zod";

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

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

// src/api/audio/selectors/index.ts
var audioSelectors = z36.object({
  selectors: numberedObject(audioSelectorsSelector),
  sourcelists: z36.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
import { z as z37 } from "zod";
var controlLogicsLogicImmutable = z37.object({
  _name: z37.string(),
  _path: z37.string()
});
var controlLogicsLogicMutable = z37.object({
  value: z37.boolean()
});
var controlLogicsLogic = controlLogicsLogicImmutable.merge(
  controlLogicsLogicMutable
);
var controlLogicsGetHandlers = {
  ["/control/logics"]: {
    paramsSchema: null,
    responseSchema: numberedObject(controlLogicsLogic)
  },
  ["/control/logics/{logicID}"]: {
    paramsSchema: z37.object({
      logicID: z37.number()
    }),
    responseSchema: controlLogicsLogic
  }
};
var controlLogicsSetHandlers = {
  ["/control/logics/{logicID}"]: {
    paramsSchema: z37.object({
      logicID: z37.number()
    }),
    payloadSchema: controlLogicsLogicMutable,
    responseSchema: controlLogicsLogicMutable
  }
};

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

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

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

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

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

// src/index.ts
var dhdOptionsSchema = z40.object({
  /**
   * The hostname or IP address of the DHD device.
   *
   * @example 10.0.0.1
   * @example dhd.local
   */
  host: z40.string(),
  /**
   * The token used to authenticate with the DHD device.
   */
  token: z40.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: z40.union([z40.literal("websocket"), z40.literal("rest")]).default("websocket"),
  /**
   * Connect to the DHD device using a secure WebSocket connection or HTTPS-requests.
   *
   * @default false
   */
  secure: z40.boolean().default(false),
  /**
   * Connect to the DHD device automatically when the instance is created.
   *
   * @default true
   */
  autoConnect: z40.boolean().default(true),
  /**
   * Automatically reconnect to the DHD device if the connection is lost.
   *
   * @default true
   */
  autoReconnect: z40.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(handler);
  };
  off = (event, handler) => {
    if (!this.eventHandlers.has(event)) {
      return;
    }
    const eventHandlers = this.eventHandlers.get(event);
    if (eventHandlers) {
      this.eventHandlers.set(
        event,
        eventHandlers.filter((h) => h !== handler)
      );
    }
  };
  emit = (event, ...args) => {
    const eventHandlers = this.eventHandlers.get(event);
    if (eventHandlers) {
      for (const handler of eventHandlers) {
        handler(...args);
      }
    }
  };
  /**
   * Connect to the DHD device via WebSocket. This method is called automatically
   * when the instance is created and the `autoConnect` option is not set to `false`.
   * This method does nothing if the `connectionType` option is not set to `websocket`.
   *
   * @returns void
   */
  connect = () => {
    if (this.options.connectionType !== "websocket") {
      return;
    }
    this.clearReconnectTimeout();
    if (this.socket) {
      if (this.socket.readyState === WebSocket.OPEN) {
        this.socket.close();
      }
      this.socket = null;
    }
    const protocol = this.options.secure ? "wss" : "ws";
    const url = new URL("/api/ws", `${protocol}://${this.options.host}`);
    this.socket = new WebSocket(url);
    this.socket.onopen = async () => {
      log.info("Connection open");
      await this.authenticateWebSocket();
      this.emit("connect");
      this.clearReconnectTimeout();
    };
    this.socket.onclose = (close) => {
      if (close.wasClean) {
        log.info("Connection closed cleanly");
      } else {
        log.error("Connection closed unexpectedly");
      }
      this.emit("disconnect");
      if (this.options.autoReconnect !== false) {
        this.reconnect();
      }
    };
    this.socket.onerror = (error) => {
      log.error("Connection error");
      log.error(error);
      this.emit("error", new Error(error.message));
      if (this.options.autoReconnect !== false) {
        this.reconnect();
      }
    };
    this.socket.onmessage = this.handleMessage;
  };
  reconnect = () => {
    if (this.options.autoReconnect !== false) {
      this.reconnectTimeout = setTimeout(() => {
        log.warn("Reconnecting...");
        this.emit("reconnect");
        this.connect();
      }, 1e3);
    }
  };
  clearReconnectTimeout = () => {
    if (this.reconnectTimeout) {
      clearTimeout(this.reconnectTimeout);
      this.reconnectTimeout = null;
    }
  };
  authenticateWebSocket = async () => {
    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
      log.error("WebSocket connection is not open");
      return;
    }
    await this.webSocketRequest({
      requestPayload: {
        method: "auth",
        token: this.options.token
      }
    });
  };
  handleMessage = ({ data }) => {
    try {
      log.debug("Received message from WebSocket", data);
      const parsedMessage = dhdWebSocketResponse.safeParse(JSON.parse(data));
      if (!parsedMessage.success) {
        log.error("Failed to parse message from DHD WebSocket");
        log.error(parsedMessage.error.issues.flat());
        return;
      }
      const message = parsedMessage.data;
      switch (message.method) {
        case "auth": {
          if (message.success) {
            log.info("Successfully authenticated on WebSocket");
            this.emit("authenticated");
            this.emit("ready");
          } else {
            log.error("Failed to authenticate on WebSocket");
          }
          this.requestMap.delete(message.msgID);
          break;
        }
        case "get":
        case "set": {
          if (this.requestMap.has(message.msgID)) {
            const promise = this.requestMap.get(message.msgID);
            if (message.success !== true) {
              log.error("Received error from DHD device");
              log.error(
                `Code ${message.error?.code ?? "Unknown"} ${message.error?.message ?? ""}`.trim()
              );
              promise?.reject(
                // TODO: Create own error class for DHD errors
                new Error(message.error?.message ?? "Unknown error")
              );
            } else {
              promise?.resolve(message.payload);
            }
            this.requestMap.delete(message.msgID);
          }
          break;
        }
        default: {
          assertNever(message);
          break;
        }
      }
    } catch (error) {
      log.error("Failed to parse message");
      log.error(error);
    }
  };
  /**
   * Get data from the DHD device.
   *
   * @example
   * await dhd.get("/audio/levels/{levelDetectID}", {
   *   params: { levelDetectID: 1 },
   * });
   *
   */
  get = async (...[
    path,
    { params } = { params: void 0 }
  ]) => {
    const { paramsSchema, responseSchema } = dhdHandlers.get[path];
    return this.dhdRequest({
      path,
      params: paramsSchema?.parse(params),
      responseSchema
    });
  };
  /**
   * Set data in the DHD device.
   *
   * @example
   * await dhd.set("/audio/selectors/selectors/{selectorID}", {
   *   params: { selectorID: 1 },
   *   payload: { left: "40" },
   * });
   *
   */
  set = async (...[
    path,
    { params, payload }
  ]) => {
    const { paramsSchema, responseSchema, payloadSchema } = dhdHandlers.set[path];
    return this.dhdRequest({
      path,
      params: paramsSchema?.parse(params),
      // TODO: This is a dirty fix for string payloads. Check if there is
      // a better way to handle this.
      responseSchema: responseSchema instanceof ZodString || responseSchema instanceof ZodBoolean ? responseSchema.optional() : responseSchema.partial(),
      payload: (payloadSchema instanceof ZodString || payloadSchema instanceof ZodBoolean ? payloadSchema.optional() : payloadSchema.partial()).parse(payload)
    });
  };
  dhdRequest = async ({
    path,
    params,
    responseSchema,
    payload
  }) => {
    let pathWithParams = path;
    if (params) {
      for (const [key, value] of Object.entries(params)) {
        pathWithParams = pathWithParams.replace(`{${key}}`, `${value}`);
      }
    }
    log.info(`GET ${pathWithParams} via ${this.options.connectionType}`);
    const requestPayload = typeof payload === "undefined" ? {
      method: "get",
      path: pathWithParams
    } : {
      method: "set",
      path: pathWithParams,
      payload
    };
    switch (this.options.connectionType) {
      case "websocket": {
        return this.webSocketRequest({ requestPayload });
      }
      case "rest": {
        const response = await this.fetchRequest({
          requestPayload: {
            ...requestPayload,
            token: this.options.token
          }
        });
        return responseSchema.parse(response);
      }
      default: {
        return assertNever(this.options.connectionType);
      }
    }
  };
  generateMsgID = () => {
    return Math.random().t