import * as zod from 'zod';
import { z } from 'zod';

declare const dhdHandlers: {
    get: {
        "/general": {
            paramsSchema: null;
            responseSchema: zod.ZodObject<{
                _api_version: zod.ZodString;
                _firmware_version: zod.ZodString;
                _hardwareserial: zod.ZodString;
                _hourmeter: zod.ZodNumber;
                _sync2ok: zod.ZodBoolean;
                _syncsource: zod.ZodNumber;
                _systemfrequency: zod.ZodNumber;
                _systemtime: zod.ZodNumber;
                _uptime: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                _api_version: string;
                _firmware_version: string;
                _hardwareserial: string;
                _hourmeter: number;
                _sync2ok: boolean;
                _syncsource: number;
                _systemfrequency: number;
                _systemtime: number;
                _uptime: number;
            }, {
                _api_version: string;
                _firmware_version: string;
                _hardwareserial: string;
                _hourmeter: number;
                _sync2ok: boolean;
                _syncsource: number;
                _systemfrequency: number;
                _systemtime: number;
                _uptime: number;
            }>;
        };
        "/control/logics": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                _name: zod.ZodString;
                _path: zod.ZodString;
            }, {
                value: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                value: boolean;
                _name: string;
                _path: string;
            }, {
                value: boolean;
                _name: string;
                _path: string;
            }>>;
        };
        "/control/logics/{logicID}": {
            paramsSchema: zod.ZodObject<{
                logicID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                logicID: number;
            }, {
                logicID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _name: zod.ZodString;
                _path: zod.ZodString;
            }, {
                value: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                value: boolean;
                _name: string;
                _path: string;
            }, {
                value: boolean;
                _name: string;
                _path: string;
            }>;
        };
        "/audio/selectors/sourcelists": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                _name: zod.ZodString;
                entries: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                    _label: zod.ZodString;
                    _sourcel: zod.ZodString;
                    _sourcer: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }>>;
            }, "strip", zod.ZodTypeAny, {
                entries: Record<number, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }>;
                _name: string;
            }, {
                entries: Record<number, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }>;
                _name: string;
            }>>;
        };
        "/audio/selectors/sourcelists/{sourcelistID}": {
            paramsSchema: zod.ZodObject<{
                sourcelistID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                sourcelistID: number;
            }, {
                sourcelistID: number;
            }>;
            responseSchema: zod.ZodObject<{
                _name: zod.ZodString;
                entries: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                    _label: zod.ZodString;
                    _sourcel: zod.ZodString;
                    _sourcer: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }>>;
            }, "strip", zod.ZodTypeAny, {
                entries: Record<number, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }>;
                _name: string;
            }, {
                entries: Record<number, {
                    _label: string;
                    _sourcel: string;
                    _sourcer: string;
                }>;
                _name: string;
            }>;
        };
        "/audio/selectors/selectors": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                _name: zod.ZodString;
                _sourcelist: zod.ZodString;
            }, {
                left: zod.ZodString;
                right: zod.ZodString;
            }>, "strip", zod.ZodTypeAny, {
                _name: string;
                _sourcelist: string;
                left: string;
                right: string;
            }, {
                _name: string;
                _sourcelist: string;
                left: string;
                right: string;
            }>>;
        };
        "/audio/selectors/selectors/{selectorID}": {
            paramsSchema: zod.ZodObject<{
                selectorID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                selectorID: number;
            }, {
                selectorID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _name: zod.ZodString;
                _sourcelist: zod.ZodString;
            }, {
                left: zod.ZodString;
                right: zod.ZodString;
            }>, "strip", zod.ZodTypeAny, {
                _name: string;
                _sourcelist: string;
                left: string;
                right: string;
            }, {
                _name: string;
                _sourcelist: string;
                left: string;
                right: string;
            }>;
        };
        "/audio/selectors": {
            paramsSchema: null;
            responseSchema: zod.ZodObject<{
                selectors: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _name: zod.ZodString;
                    _sourcelist: zod.ZodString;
                }, {
                    left: zod.ZodString;
                    right: zod.ZodString;
                }>, "strip", zod.ZodTypeAny, {
                    _name: string;
                    _sourcelist: string;
                    left: string;
                    right: string;
                }, {
                    _name: string;
                    _sourcelist: string;
                    left: string;
                    right: string;
                }>>;
                sourcelists: zod.ZodAny;
            }, "strip", zod.ZodTypeAny, {
                selectors: Record<number, {
                    _name: string;
                    _sourcelist: string;
                    left: string;
                    right: string;
                }>;
                sourcelists?: any;
            }, {
                selectors: Record<number, {
                    _name: string;
                    _sourcelist: string;
                    left: string;
                    right: string;
                }>;
                sourcelists?: any;
            }>;
        };
        "/audio/routing/routes": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodString>;
        };
        "/audio/routing/routes/{routeID}": {
            paramsSchema: zod.ZodObject<{
                routeID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                routeID: number;
            }, {
                routeID: number;
            }>;
            responseSchema: zod.ZodString;
        };
        "/audio/routing/outputs": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                _channels: zod.ZodNumber;
                _device: zod.ZodString;
                _name: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _channels: number;
                _device: string;
            }, {
                _name: string;
                _channels: number;
                _device: string;
            }>>;
        };
        "/audio/routing/outputs/{outputID}": {
            paramsSchema: zod.ZodObject<{
                outputID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                outputID: number;
            }, {
                outputID: number;
            }>;
            responseSchema: zod.ZodObject<{
                _channels: zod.ZodNumber;
                _device: zod.ZodString;
                _name: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _channels: number;
                _device: string;
            }, {
                _name: string;
                _channels: number;
                _device: string;
            }>;
        };
        "/audio/routing/inputs": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                _channels: zod.ZodNumber;
                _device: zod.ZodString;
                _name: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _channels: number;
                _device: string;
            }, {
                _name: string;
                _channels: number;
                _device: string;
            }>>;
        };
        "/audio/routing/inputs/{inputID}": {
            paramsSchema: zod.ZodObject<{
                inputID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                inputID: number;
            }, {
                inputID: number;
            }>;
            responseSchema: zod.ZodObject<{
                _channels: zod.ZodNumber;
                _device: zod.ZodString;
                _name: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _channels: number;
                _device: string;
            }, {
                _name: string;
                _channels: number;
                _device: string;
            }>;
        };
        "/audio/routing": {
            paramsSchema: null;
            responseSchema: zod.ZodObject<{
                inputs: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                    _channels: zod.ZodNumber;
                    _device: zod.ZodString;
                    _name: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }>>;
                outputs: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                    _channels: zod.ZodNumber;
                    _device: zod.ZodString;
                    _name: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }>>;
                routes: zod.ZodRecord<zod.ZodNumber, zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                inputs: Record<number, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }>;
                outputs: Record<number, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }>;
                routes: Record<number, string>;
            }, {
                inputs: Record<number, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }>;
                outputs: Record<number, {
                    _name: string;
                    _channels: number;
                    _device: string;
                }>;
                routes: Record<number, string>;
            }>;
        };
        "/audio/pots": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                _max: zod.ZodNumber;
                _min: zod.ZodNumber;
                _name: zod.ZodString;
                _step: zod.ZodNumber;
            }, {
                value: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                value: number;
                _name: string;
                _max: number;
                _min: number;
                _step: number;
            }, {
                value: number;
                _name: string;
                _max: number;
                _min: number;
                _step: number;
            }>>;
        };
        "/audio/pots/{potID}": {
            paramsSchema: zod.ZodObject<{
                potID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                potID: number;
            }, {
                potID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _max: zod.ZodNumber;
                _min: zod.ZodNumber;
                _name: zod.ZodString;
                _step: zod.ZodNumber;
            }, {
                value: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                value: number;
                _name: string;
                _max: number;
                _min: number;
                _step: number;
            }, {
                value: number;
                _name: string;
                _max: number;
                _min: number;
                _step: number;
            }>;
        };
        "/audio/mixers/{mixerID}/sourcelist": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodArray<zod.ZodObject<{
                _defaultlabel: zod.ZodString;
                _label: zod.ZodString;
                _sourceid: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                _defaultlabel: string;
                _label: string;
                _sourceid: number;
            }, {
                _defaultlabel: string;
                _label: string;
                _sourceid: number;
            }>, "many">;
        };
        "/audio/mixers/{mixerID}/options": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                pfl1: zod.ZodObject<{
                    afl: zod.ZodBoolean;
                    aflwhenon: zod.ZodBoolean;
                    mix: zod.ZodBoolean;
                    reset: zod.ZodBoolean;
                    resetfader: zod.ZodBoolean;
                    return: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                }, {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                }>;
                pfl2: zod.ZodObject<{
                    afl: zod.ZodBoolean;
                    aflwhenon: zod.ZodBoolean;
                    mix: zod.ZodBoolean;
                    reset: zod.ZodBoolean;
                    resetfader: zod.ZodBoolean;
                    return: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                }, {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                }>;
            }, {
                directoffair: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                pfl1: {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                };
                pfl2: {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                };
                directoffair: boolean;
            }, {
                pfl1: {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                };
                pfl2: {
                    afl: boolean;
                    aflwhenon: boolean;
                    mix: boolean;
                    reset: boolean;
                    resetfader: boolean;
                    return: boolean;
                };
                directoffair: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/options/pfl1": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodObject<{
                afl: zod.ZodBoolean;
                aflwhenon: zod.ZodBoolean;
                mix: zod.ZodBoolean;
                reset: zod.ZodBoolean;
                resetfader: zod.ZodBoolean;
                return: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/options/pfl2": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodObject<{
                afl: zod.ZodBoolean;
                aflwhenon: zod.ZodBoolean;
                mix: zod.ZodBoolean;
                reset: zod.ZodBoolean;
                resetfader: zod.ZodBoolean;
                return: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/mutegroups": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
        };
        "/audio/mixers/{mixerID}/mutegroups/{mutegroupID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                mutegroupID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                mutegroupID: number;
            }, {
                mixerID: number;
                mutegroupID: number;
            }>;
            responseSchema: zod.ZodBoolean;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/varfilter{filtID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
                filtID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
                filtID: number;
            }, {
                mixerID: number;
                faderID: number;
                filtID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                frequency: zod.ZodNumber;
                hipass: zod.ZodBoolean;
                on: zod.ZodBoolean;
                order: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                on: boolean;
                frequency: number;
                hipass: boolean;
                order: number;
            }, {
                _active: boolean;
                on: boolean;
                frequency: number;
                hipass: boolean;
                order: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/swc": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                direction: zod.ZodNumber;
                type: zod.ZodBoolean;
                width: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                type: boolean;
                _active: boolean;
                direction: number;
                width: number;
            }, {
                type: boolean;
                _active: boolean;
                direction: number;
                width: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/gate": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                frequency: zod.ZodNumber;
                on: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                on: boolean;
                frequency: number;
            }, {
                _active: boolean;
                on: boolean;
                frequency: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/r128agc": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _gainreduction: zod.ZodNumber;
            }, {
                freeze: zod.ZodBoolean;
                gain: zod.ZodNumber;
                level: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
                velocity: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                _gainreduction: number;
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }, {
                _active: boolean;
                _gainreduction: number;
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/panbal": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                divergency: zod.ZodNumber;
                lfeonly: zod.ZodBoolean;
                lfesend: zod.ZodNumber;
                matrix: zod.ZodNumber;
                panbal: zod.ZodNumber;
                rear: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                divergency: number;
                lfeonly: boolean;
                lfesend: number;
                matrix: number;
                panbal: number;
                rear: number;
            }, {
                _active: boolean;
                divergency: number;
                lfeonly: boolean;
                lfesend: number;
                matrix: number;
                panbal: number;
                rear: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/limiter": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _gainreduction: zod.ZodNumber;
            }, {
                on: zod.ZodBoolean;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                release: number;
                _gainreduction: number;
                on: boolean;
                threshold: number;
            }, {
                _active: boolean;
                release: number;
                _gainreduction: number;
                on: boolean;
                threshold: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/gain": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _hasagain: zod.ZodBoolean;
                _hasp48: zod.ZodBoolean;
                again: zod.ZodObject<zod.objectUtil.extendShape<{
                    _max: zod.ZodNumber;
                    _min: zod.ZodNumber;
                    _step: zod.ZodNumber;
                }, {
                    inc: zod.ZodNumber;
                    value: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    value: number;
                    _max: number;
                    _min: number;
                    _step: number;
                    inc: number;
                }, {
                    value: number;
                    _max: number;
                    _min: number;
                    _step: number;
                    inc: number;
                }>;
            }, {
                dgain: zod.ZodNumber;
                p48: zod.ZodBoolean;
                phase: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                _hasagain: boolean;
                _hasp48: boolean;
                again: {
                    value: number;
                    _max: number;
                    _min: number;
                    _step: number;
                    inc: number;
                };
                dgain: number;
                p48: boolean;
                phase: boolean;
            }, {
                _active: boolean;
                _hasagain: boolean;
                _hasp48: boolean;
                again: {
                    value: number;
                    _max: number;
                    _min: number;
                    _step: number;
                    inc: number;
                };
                dgain: number;
                p48: boolean;
                phase: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/gain/again": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _max: zod.ZodNumber;
                _min: zod.ZodNumber;
                _step: zod.ZodNumber;
            }, {
                inc: zod.ZodNumber;
                value: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                value: number;
                _max: number;
                _min: number;
                _step: number;
                inc: number;
            }, {
                value: number;
                _max: number;
                _min: number;
                _step: number;
                inc: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/expander": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _gainreduction: zod.ZodNumber;
            }, {
                attack: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                ratio: number;
                release: number;
                _gainreduction: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }, {
                _active: boolean;
                ratio: number;
                release: number;
                _gainreduction: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/eq{eqID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
                eqID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
                eqID: number;
            }, {
                mixerID: number;
                faderID: number;
                eqID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                frequency: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                q: zod.ZodNumber;
                type: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                type: number;
                _active: boolean;
                gain: number;
                on: boolean;
                frequency: number;
                q: number;
            }, {
                type: number;
                _active: boolean;
                gain: number;
                on: boolean;
                frequency: number;
                q: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/deesser": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                bandwidth: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                sharpness: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                ratio: number;
                on: boolean;
                bandwidth: number;
                sharpness: number;
            }, {
                _active: boolean;
                ratio: number;
                on: boolean;
                bandwidth: number;
                sharpness: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/deesser2": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _gainreduction: zod.ZodNumber;
            }, {
                frequency: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                _gainreduction: number;
                on: boolean;
                threshold: number;
                frequency: number;
            }, {
                _active: boolean;
                _gainreduction: number;
                on: boolean;
                threshold: number;
                frequency: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/compressor": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _gainreduction: zod.ZodNumber;
            }, {
                attack: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                ratio: number;
                release: number;
                _gainreduction: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }, {
                _active: boolean;
                ratio: number;
                release: number;
                _gainreduction: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/agc": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
                _gainreduction: zod.ZodNumber;
            }, {
                freeze: zod.ZodBoolean;
                gain: zod.ZodNumber;
                level: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
                velocity: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                _gainreduction: number;
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }, {
                _active: boolean;
                _gainreduction: number;
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<{
                agc: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    freeze: zod.ZodBoolean;
                    gain: zod.ZodNumber;
                    level: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    threshold: zod.ZodNumber;
                    velocity: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                }, {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                }>;
                compressor: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    attack: zod.ZodNumber;
                    gain: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    ratio: zod.ZodNumber;
                    release: zod.ZodNumber;
                    threshold: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                }, {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                }>;
                deesser: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    bandwidth: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    ratio: zod.ZodNumber;
                    sharpness: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    ratio: number;
                    on: boolean;
                    bandwidth: number;
                    sharpness: number;
                }, {
                    _active: boolean;
                    ratio: number;
                    on: boolean;
                    bandwidth: number;
                    sharpness: number;
                }>;
                deesser2: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    frequency: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    threshold: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    frequency: number;
                }, {
                    _active: boolean;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    frequency: number;
                }>;
                eq: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    frequency: zod.ZodNumber;
                    gain: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    q: zod.ZodNumber;
                    type: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    type: number;
                    _active: boolean;
                    gain: number;
                    on: boolean;
                    frequency: number;
                    q: number;
                }, {
                    type: number;
                    _active: boolean;
                    gain: number;
                    on: boolean;
                    frequency: number;
                    q: number;
                }>;
                expander: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    attack: zod.ZodNumber;
                    gain: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    ratio: zod.ZodNumber;
                    release: zod.ZodNumber;
                    threshold: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                }, {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                }>;
                gain: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _hasagain: zod.ZodBoolean;
                    _hasp48: zod.ZodBoolean;
                    again: zod.ZodObject<zod.objectUtil.extendShape<{
                        _max: zod.ZodNumber;
                        _min: zod.ZodNumber;
                        _step: zod.ZodNumber;
                    }, {
                        inc: zod.ZodNumber;
                        value: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        value: number;
                        _max: number;
                        _min: number;
                        _step: number;
                        inc: number;
                    }, {
                        value: number;
                        _max: number;
                        _min: number;
                        _step: number;
                        inc: number;
                    }>;
                }, {
                    dgain: zod.ZodNumber;
                    p48: zod.ZodBoolean;
                    phase: zod.ZodBoolean;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    _hasagain: boolean;
                    _hasp48: boolean;
                    again: {
                        value: number;
                        _max: number;
                        _min: number;
                        _step: number;
                        inc: number;
                    };
                    dgain: number;
                    p48: boolean;
                    phase: boolean;
                }, {
                    _active: boolean;
                    _hasagain: boolean;
                    _hasp48: boolean;
                    again: {
                        value: number;
                        _max: number;
                        _min: number;
                        _step: number;
                        inc: number;
                    };
                    dgain: number;
                    p48: boolean;
                    phase: boolean;
                }>;
                gate: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    attack: zod.ZodNumber;
                    attenuation: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    release: zod.ZodNumber;
                    threshold: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                    attenuation: number;
                }, {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                    attenuation: number;
                }>;
                limiter: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    on: zod.ZodBoolean;
                    release: zod.ZodNumber;
                    threshold: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                }, {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                }>;
                panbal: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    divergency: zod.ZodNumber;
                    lfeonly: zod.ZodBoolean;
                    lfesend: zod.ZodNumber;
                    matrix: zod.ZodNumber;
                    panbal: zod.ZodNumber;
                    rear: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    divergency: number;
                    lfeonly: boolean;
                    lfesend: number;
                    matrix: number;
                    panbal: number;
                    rear: number;
                }, {
                    _active: boolean;
                    divergency: number;
                    lfeonly: boolean;
                    lfesend: number;
                    matrix: number;
                    panbal: number;
                    rear: number;
                }>;
                r128agc: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                    _gainreduction: zod.ZodNumber;
                }, {
                    freeze: zod.ZodBoolean;
                    gain: zod.ZodNumber;
                    level: zod.ZodNumber;
                    on: zod.ZodBoolean;
                    threshold: zod.ZodNumber;
                    velocity: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                }, {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                }>;
                subsonic: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    frequency: zod.ZodNumber;
                    on: zod.ZodBoolean;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                }, {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                }>;
                swc: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    direction: zod.ZodNumber;
                    type: zod.ZodBoolean;
                    width: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    type: boolean;
                    _active: boolean;
                    direction: number;
                    width: number;
                }, {
                    type: boolean;
                    _active: boolean;
                    direction: number;
                    width: number;
                }>;
                varfilter: zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    frequency: zod.ZodNumber;
                    hipass: zod.ZodBoolean;
                    on: zod.ZodBoolean;
                    order: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                    hipass: boolean;
                    order: number;
                }, {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                    hipass: boolean;
                    order: number;
                }>;
            }, "strip", zod.ZodTypeAny, {
                subsonic: {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                };
                agc: {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                };
                expander: {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                };
                deesser2: {
                    _active: boolean;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    frequency: number;
                };
                compressor: {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                };
                limiter: {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                };
                gain: {
                    _active: boolean;
                    _hasagain: boolean;
                    _hasp48: boolean;
                    again: {
                        value: number;
                        _max: number;
                        _min: number;
                        _step: number;
                        inc: number;
                    };
                    dgain: number;
                    p48: boolean;
                    phase: boolean;
                };
                deesser: {
                    _active: boolean;
                    ratio: number;
                    on: boolean;
                    bandwidth: number;
                    sharpness: number;
                };
                eq: {
                    type: number;
                    _active: boolean;
                    gain: number;
                    on: boolean;
                    frequency: number;
                    q: number;
                };
                gate: {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                    attenuation: number;
                };
                panbal: {
                    _active: boolean;
                    divergency: number;
                    lfeonly: boolean;
                    lfesend: number;
                    matrix: number;
                    panbal: number;
                    rear: number;
                };
                r128agc: {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                };
                swc: {
                    type: boolean;
                    _active: boolean;
                    direction: number;
                    width: number;
                };
                varfilter: {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                    hipass: boolean;
                    order: number;
                };
            }, {
                subsonic: {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                };
                agc: {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                };
                expander: {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                };
                deesser2: {
                    _active: boolean;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    frequency: number;
                };
                compressor: {
                    _active: boolean;
                    ratio: number;
                    release: number;
                    _gainreduction: number;
                    gain: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                };
                limiter: {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                };
                gain: {
                    _active: boolean;
                    _hasagain: boolean;
                    _hasp48: boolean;
                    again: {
                        value: number;
                        _max: number;
                        _min: number;
                        _step: number;
                        inc: number;
                    };
                    dgain: number;
                    p48: boolean;
                    phase: boolean;
                };
                deesser: {
                    _active: boolean;
                    ratio: number;
                    on: boolean;
                    bandwidth: number;
                    sharpness: number;
                };
                eq: {
                    type: number;
                    _active: boolean;
                    gain: number;
                    on: boolean;
                    frequency: number;
                    q: number;
                };
                gate: {
                    _active: boolean;
                    release: number;
                    _gainreduction: number;
                    on: boolean;
                    threshold: number;
                    attack: number;
                    attenuation: number;
                };
                panbal: {
                    _active: boolean;
                    divergency: number;
                    lfeonly: boolean;
                    lfesend: number;
                    matrix: number;
                    panbal: number;
                    rear: number;
                };
                r128agc: {
                    _active: boolean;
                    _gainreduction: number;
                    freeze: boolean;
                    gain: number;
                    level: number;
                    on: boolean;
                    threshold: number;
                    velocity: number;
                };
                swc: {
                    type: boolean;
                    _active: boolean;
                    direction: number;
                    width: number;
                };
                varfilter: {
                    _active: boolean;
                    on: boolean;
                    frequency: number;
                    hipass: boolean;
                    order: number;
                };
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/mutegroups": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/mutegroups/{mutegroupID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
                mutegroupID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
                mutegroupID: number;
            }, {
                mixerID: number;
                faderID: number;
                mutegroupID: number;
            }>;
            responseSchema: zod.ZodBoolean;
        };
        "/audio/mixers/{mixerID}/faders": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                _channelcnt: zod.ZodNumber;
                _defaultlabel: zod.ZodString;
                _faderstart: zod.ZodBoolean;
                _lastloadedsnap: zod.ZodString;
                _poolavailable: zod.ZodBoolean;
                _readystate: zod.ZodBoolean;
                _usecleanfeed: zod.ZodNumber;
                meter: zod.ZodObject<{
                    _afl: zod.ZodArray<zod.ZodNumber, "many">;
                    _input: zod.ZodArray<zod.ZodNumber, "many">;
                    _pfl: zod.ZodArray<zod.ZodNumber, "many">;
                }, "strip", zod.ZodTypeAny, {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                }, {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                }>;
                mutegroups: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
                _paramlist: zod.ZodArray<zod.ZodEnum<["subsonic", "agc", "expander", "eq1", "eq2", "eq3", "eq4", "deesser2", "compressor", "limiter"]>, "many">;
                options: zod.ZodObject<{
                    autooffair: zod.ZodBoolean;
                    combilogic0: zod.ZodBoolean;
                    timerreset: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                }, {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                }>;
                params: zod.ZodObject<{
                    agc: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        freeze: zod.ZodBoolean;
                        gain: zod.ZodNumber;
                        level: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        threshold: zod.ZodNumber;
                        velocity: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }>;
                    compressor: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        attack: zod.ZodNumber;
                        gain: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        ratio: zod.ZodNumber;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }>;
                    deesser: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        bandwidth: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        ratio: zod.ZodNumber;
                        sharpness: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    }, {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    }>;
                    deesser2: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        frequency: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    }, {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    }>;
                    eq: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        frequency: zod.ZodNumber;
                        gain: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        q: zod.ZodNumber;
                        type: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    }, {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    }>;
                    expander: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        attack: zod.ZodNumber;
                        gain: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        ratio: zod.ZodNumber;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }>;
                    gain: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _hasagain: zod.ZodBoolean;
                        _hasp48: zod.ZodBoolean;
                        again: zod.ZodObject<zod.objectUtil.extendShape<{
                            _max: zod.ZodNumber;
                            _min: zod.ZodNumber;
                            _step: zod.ZodNumber;
                        }, {
                            inc: zod.ZodNumber;
                            value: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        }, {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        }>;
                    }, {
                        dgain: zod.ZodNumber;
                        p48: zod.ZodBoolean;
                        phase: zod.ZodBoolean;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    }, {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    }>;
                    gate: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        attack: zod.ZodNumber;
                        attenuation: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    }, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    }>;
                    limiter: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        on: zod.ZodBoolean;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    }, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    }>;
                    panbal: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        divergency: zod.ZodNumber;
                        lfeonly: zod.ZodBoolean;
                        lfesend: zod.ZodNumber;
                        matrix: zod.ZodNumber;
                        panbal: zod.ZodNumber;
                        rear: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    }, {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    }>;
                    r128agc: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        freeze: zod.ZodBoolean;
                        gain: zod.ZodNumber;
                        level: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        threshold: zod.ZodNumber;
                        velocity: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }>;
                    subsonic: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        frequency: zod.ZodNumber;
                        on: zod.ZodBoolean;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    }, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    }>;
                    swc: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        direction: zod.ZodNumber;
                        type: zod.ZodBoolean;
                        width: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    }, {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    }>;
                    varfilter: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        frequency: zod.ZodNumber;
                        hipass: zod.ZodBoolean;
                        on: zod.ZodBoolean;
                        order: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    }, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                }, {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                }>;
            }, {
                altinput: zod.ZodBoolean;
                bypass: zod.ZodBoolean;
                fader: zod.ZodNumber;
                isolate: zod.ZodBoolean;
                label: zod.ZodString;
                memo: zod.ZodBoolean;
                offair: zod.ZodBoolean;
                on: zod.ZodBoolean;
                pfl1: zod.ZodBoolean;
                pfl2: zod.ZodBoolean;
                preparation: zod.ZodBoolean;
                solo: zod.ZodBoolean;
                sourceid: zod.ZodNumber;
                vcagroup: zod.ZodNumber;
                voice: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                params: {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                };
                options: {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                };
                _lastloadedsnap: string;
                _channelcnt: number;
                _defaultlabel: string;
                _faderstart: boolean;
                _poolavailable: boolean;
                _readystate: boolean;
                _usecleanfeed: number;
                meter: {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                };
                mutegroups: Record<number, boolean>;
                _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }, {
                params: {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                };
                options: {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                };
                _lastloadedsnap: string;
                _channelcnt: number;
                _defaultlabel: string;
                _faderstart: boolean;
                _poolavailable: boolean;
                _readystate: boolean;
                _usecleanfeed: number;
                meter: {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                };
                mutegroups: Record<number, boolean>;
                _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }>>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _channelcnt: zod.ZodNumber;
                _defaultlabel: zod.ZodString;
                _faderstart: zod.ZodBoolean;
                _lastloadedsnap: zod.ZodString;
                _poolavailable: zod.ZodBoolean;
                _readystate: zod.ZodBoolean;
                _usecleanfeed: zod.ZodNumber;
                meter: zod.ZodObject<{
                    _afl: zod.ZodArray<zod.ZodNumber, "many">;
                    _input: zod.ZodArray<zod.ZodNumber, "many">;
                    _pfl: zod.ZodArray<zod.ZodNumber, "many">;
                }, "strip", zod.ZodTypeAny, {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                }, {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                }>;
                mutegroups: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
                _paramlist: zod.ZodArray<zod.ZodEnum<["subsonic", "agc", "expander", "eq1", "eq2", "eq3", "eq4", "deesser2", "compressor", "limiter"]>, "many">;
                options: zod.ZodObject<{
                    autooffair: zod.ZodBoolean;
                    combilogic0: zod.ZodBoolean;
                    timerreset: zod.ZodBoolean;
                }, "strip", zod.ZodTypeAny, {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                }, {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                }>;
                params: zod.ZodObject<{
                    agc: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        freeze: zod.ZodBoolean;
                        gain: zod.ZodNumber;
                        level: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        threshold: zod.ZodNumber;
                        velocity: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }>;
                    compressor: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        attack: zod.ZodNumber;
                        gain: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        ratio: zod.ZodNumber;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }>;
                    deesser: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        bandwidth: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        ratio: zod.ZodNumber;
                        sharpness: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    }, {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    }>;
                    deesser2: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        frequency: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    }, {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    }>;
                    eq: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        frequency: zod.ZodNumber;
                        gain: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        q: zod.ZodNumber;
                        type: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    }, {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    }>;
                    expander: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        attack: zod.ZodNumber;
                        gain: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        ratio: zod.ZodNumber;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }, {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    }>;
                    gain: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _hasagain: zod.ZodBoolean;
                        _hasp48: zod.ZodBoolean;
                        again: zod.ZodObject<zod.objectUtil.extendShape<{
                            _max: zod.ZodNumber;
                            _min: zod.ZodNumber;
                            _step: zod.ZodNumber;
                        }, {
                            inc: zod.ZodNumber;
                            value: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        }, {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        }>;
                    }, {
                        dgain: zod.ZodNumber;
                        p48: zod.ZodBoolean;
                        phase: zod.ZodBoolean;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    }, {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    }>;
                    gate: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        attack: zod.ZodNumber;
                        attenuation: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    }, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    }>;
                    limiter: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        on: zod.ZodBoolean;
                        release: zod.ZodNumber;
                        threshold: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    }, {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    }>;
                    panbal: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        divergency: zod.ZodNumber;
                        lfeonly: zod.ZodBoolean;
                        lfesend: zod.ZodNumber;
                        matrix: zod.ZodNumber;
                        panbal: zod.ZodNumber;
                        rear: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    }, {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    }>;
                    r128agc: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                        _gainreduction: zod.ZodNumber;
                    }, {
                        freeze: zod.ZodBoolean;
                        gain: zod.ZodNumber;
                        level: zod.ZodNumber;
                        on: zod.ZodBoolean;
                        threshold: zod.ZodNumber;
                        velocity: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }, {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    }>;
                    subsonic: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        frequency: zod.ZodNumber;
                        on: zod.ZodBoolean;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    }, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    }>;
                    swc: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        direction: zod.ZodNumber;
                        type: zod.ZodBoolean;
                        width: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    }, {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    }>;
                    varfilter: zod.ZodObject<zod.objectUtil.extendShape<{
                        _active: zod.ZodBoolean;
                    }, {
                        frequency: zod.ZodNumber;
                        hipass: zod.ZodBoolean;
                        on: zod.ZodBoolean;
                        order: zod.ZodNumber;
                    }>, "strip", zod.ZodTypeAny, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    }, {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                }, {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                }>;
            }, {
                altinput: zod.ZodBoolean;
                bypass: zod.ZodBoolean;
                fader: zod.ZodNumber;
                isolate: zod.ZodBoolean;
                label: zod.ZodString;
                memo: zod.ZodBoolean;
                offair: zod.ZodBoolean;
                on: zod.ZodBoolean;
                pfl1: zod.ZodBoolean;
                pfl2: zod.ZodBoolean;
                preparation: zod.ZodBoolean;
                solo: zod.ZodBoolean;
                sourceid: zod.ZodNumber;
                vcagroup: zod.ZodNumber;
                voice: zod.ZodBoolean;
            }>, "strip", zod.ZodTypeAny, {
                params: {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                };
                options: {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                };
                _lastloadedsnap: string;
                _channelcnt: number;
                _defaultlabel: string;
                _faderstart: boolean;
                _poolavailable: boolean;
                _readystate: boolean;
                _usecleanfeed: number;
                meter: {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                };
                mutegroups: Record<number, boolean>;
                _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }, {
                params: {
                    subsonic: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                    };
                    agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    expander: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    deesser2: {
                        _active: boolean;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        frequency: number;
                    };
                    compressor: {
                        _active: boolean;
                        ratio: number;
                        release: number;
                        _gainreduction: number;
                        gain: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                    };
                    limiter: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                    };
                    gain: {
                        _active: boolean;
                        _hasagain: boolean;
                        _hasp48: boolean;
                        again: {
                            value: number;
                            _max: number;
                            _min: number;
                            _step: number;
                            inc: number;
                        };
                        dgain: number;
                        p48: boolean;
                        phase: boolean;
                    };
                    deesser: {
                        _active: boolean;
                        ratio: number;
                        on: boolean;
                        bandwidth: number;
                        sharpness: number;
                    };
                    eq: {
                        type: number;
                        _active: boolean;
                        gain: number;
                        on: boolean;
                        frequency: number;
                        q: number;
                    };
                    gate: {
                        _active: boolean;
                        release: number;
                        _gainreduction: number;
                        on: boolean;
                        threshold: number;
                        attack: number;
                        attenuation: number;
                    };
                    panbal: {
                        _active: boolean;
                        divergency: number;
                        lfeonly: boolean;
                        lfesend: number;
                        matrix: number;
                        panbal: number;
                        rear: number;
                    };
                    r128agc: {
                        _active: boolean;
                        _gainreduction: number;
                        freeze: boolean;
                        gain: number;
                        level: number;
                        on: boolean;
                        threshold: number;
                        velocity: number;
                    };
                    swc: {
                        type: boolean;
                        _active: boolean;
                        direction: number;
                        width: number;
                    };
                    varfilter: {
                        _active: boolean;
                        on: boolean;
                        frequency: number;
                        hipass: boolean;
                        order: number;
                    };
                };
                options: {
                    autooffair: boolean;
                    combilogic0: boolean;
                    timerreset: boolean;
                };
                _lastloadedsnap: string;
                _channelcnt: number;
                _defaultlabel: string;
                _faderstart: boolean;
                _poolavailable: boolean;
                _readystate: boolean;
                _usecleanfeed: number;
                meter: {
                    _input: number[];
                    _afl: number[];
                    _pfl: number[];
                };
                mutegroups: Record<number, boolean>;
                _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/cleanfeeds": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                cut: zod.ZodBoolean;
                n: zod.ZodBoolean;
                outgain: zod.ZodNumber;
                outsel: zod.ZodBoolean;
                srcsel: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }, {
                _active: boolean;
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }>>;
        };
        "/audio/mixers/{mixerID}/cleanfeeds/{cleanfeedID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                cleanfeedID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                cleanfeedID: number;
            }, {
                mixerID: number;
                cleanfeedID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                cut: zod.ZodBoolean;
                n: zod.ZodBoolean;
                outgain: zod.ZodNumber;
                outsel: zod.ZodBoolean;
                srcsel: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }, {
                _active: boolean;
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }>;
        };
        "/audio/mixers/{mixerID}/automix": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                automixID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                automixID: number;
            }, {
                mixerID: number;
                automixID: number;
            }>;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                maxattenuation: zod.ZodNumber;
                passiveattenuation: zod.ZodNumber;
                hold: zod.ZodNumber;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }, {
                _active: boolean;
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }>>;
        };
        "/audio/mixers/{mixerID}/automix/{automixID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                automixID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                automixID: number;
            }, {
                mixerID: number;
                automixID: number;
            }>;
            responseSchema: zod.ZodObject<zod.objectUtil.extendShape<{
                _active: zod.ZodBoolean;
            }, {
                maxattenuation: zod.ZodNumber;
                passiveattenuation: zod.ZodNumber;
                hold: zod.ZodNumber;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
            }>, "strip", zod.ZodTypeAny, {
                _active: boolean;
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }, {
                _active: boolean;
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }>;
        };
        "/audio/mixers": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                _lastloadedsnap: zod.ZodString;
                automix: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    maxattenuation: zod.ZodNumber;
                    passiveattenuation: zod.ZodNumber;
                    hold: zod.ZodNumber;
                    ratio: zod.ZodNumber;
                    release: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }>>;
                cleanfeeds: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    cut: zod.ZodBoolean;
                    n: zod.ZodBoolean;
                    outgain: zod.ZodNumber;
                    outsel: zod.ZodBoolean;
                    srcsel: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }>>;
                faders: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _channelcnt: zod.ZodNumber;
                    _defaultlabel: zod.ZodString;
                    _faderstart: zod.ZodBoolean;
                    _lastloadedsnap: zod.ZodString;
                    _poolavailable: zod.ZodBoolean;
                    _readystate: zod.ZodBoolean;
                    _usecleanfeed: zod.ZodNumber;
                    meter: zod.ZodObject<{
                        _afl: zod.ZodArray<zod.ZodNumber, "many">;
                        _input: zod.ZodArray<zod.ZodNumber, "many">;
                        _pfl: zod.ZodArray<zod.ZodNumber, "many">;
                    }, "strip", zod.ZodTypeAny, {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    }, {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    }>;
                    mutegroups: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
                    _paramlist: zod.ZodArray<zod.ZodEnum<["subsonic", "agc", "expander", "eq1", "eq2", "eq3", "eq4", "deesser2", "compressor", "limiter"]>, "many">;
                    options: zod.ZodObject<{
                        autooffair: zod.ZodBoolean;
                        combilogic0: zod.ZodBoolean;
                        timerreset: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    }, {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    }>;
                    params: zod.ZodObject<{
                        agc: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            freeze: zod.ZodBoolean;
                            gain: zod.ZodNumber;
                            level: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            threshold: zod.ZodNumber;
                            velocity: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }>;
                        compressor: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            attack: zod.ZodNumber;
                            gain: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            ratio: zod.ZodNumber;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }>;
                        deesser: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            bandwidth: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            ratio: zod.ZodNumber;
                            sharpness: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        }, {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        }>;
                        deesser2: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            frequency: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        }, {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        }>;
                        eq: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            frequency: zod.ZodNumber;
                            gain: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            q: zod.ZodNumber;
                            type: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        }, {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        }>;
                        expander: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            attack: zod.ZodNumber;
                            gain: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            ratio: zod.ZodNumber;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }>;
                        gain: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _hasagain: zod.ZodBoolean;
                            _hasp48: zod.ZodBoolean;
                            again: zod.ZodObject<zod.objectUtil.extendShape<{
                                _max: zod.ZodNumber;
                                _min: zod.ZodNumber;
                                _step: zod.ZodNumber;
                            }, {
                                inc: zod.ZodNumber;
                                value: zod.ZodNumber;
                            }>, "strip", zod.ZodTypeAny, {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            }, {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            }>;
                        }, {
                            dgain: zod.ZodNumber;
                            p48: zod.ZodBoolean;
                            phase: zod.ZodBoolean;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        }, {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        }>;
                        gate: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            attack: zod.ZodNumber;
                            attenuation: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        }, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        }>;
                        limiter: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            on: zod.ZodBoolean;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        }, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        }>;
                        panbal: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            divergency: zod.ZodNumber;
                            lfeonly: zod.ZodBoolean;
                            lfesend: zod.ZodNumber;
                            matrix: zod.ZodNumber;
                            panbal: zod.ZodNumber;
                            rear: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        }, {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        }>;
                        r128agc: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            freeze: zod.ZodBoolean;
                            gain: zod.ZodNumber;
                            level: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            threshold: zod.ZodNumber;
                            velocity: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }>;
                        subsonic: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            frequency: zod.ZodNumber;
                            on: zod.ZodBoolean;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        }, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        }>;
                        swc: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            direction: zod.ZodNumber;
                            type: zod.ZodBoolean;
                            width: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        }, {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        }>;
                        varfilter: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            frequency: zod.ZodNumber;
                            hipass: zod.ZodBoolean;
                            on: zod.ZodBoolean;
                            order: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        }, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        }>;
                    }, "strip", zod.ZodTypeAny, {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    }, {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    }>;
                }, {
                    altinput: zod.ZodBoolean;
                    bypass: zod.ZodBoolean;
                    fader: zod.ZodNumber;
                    isolate: zod.ZodBoolean;
                    label: zod.ZodString;
                    memo: zod.ZodBoolean;
                    offair: zod.ZodBoolean;
                    on: zod.ZodBoolean;
                    pfl1: zod.ZodBoolean;
                    pfl2: zod.ZodBoolean;
                    preparation: zod.ZodBoolean;
                    solo: zod.ZodBoolean;
                    sourceid: zod.ZodNumber;
                    vcagroup: zod.ZodNumber;
                    voice: zod.ZodBoolean;
                }>, "strip", zod.ZodTypeAny, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }>>;
                mutegroups: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
                options: zod.ZodObject<zod.objectUtil.extendShape<{
                    pfl1: zod.ZodObject<{
                        afl: zod.ZodBoolean;
                        aflwhenon: zod.ZodBoolean;
                        mix: zod.ZodBoolean;
                        reset: zod.ZodBoolean;
                        resetfader: zod.ZodBoolean;
                        return: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }>;
                    pfl2: zod.ZodObject<{
                        afl: zod.ZodBoolean;
                        aflwhenon: zod.ZodBoolean;
                        mix: zod.ZodBoolean;
                        reset: zod.ZodBoolean;
                        resetfader: zod.ZodBoolean;
                        return: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }>;
                }, {
                    directoffair: zod.ZodBoolean;
                }>, "strip", zod.ZodTypeAny, {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                }, {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                }>;
                sourcelist: zod.ZodArray<zod.ZodObject<{
                    _defaultlabel: zod.ZodString;
                    _label: zod.ZodString;
                    _sourceid: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }, {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                options: {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                };
                _lastloadedsnap: string;
                automix: Record<number, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }>;
                cleanfeeds: Record<number, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }>;
                faders: Record<number, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }>;
                mutegroups: Record<number, boolean>;
                sourcelist: {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }[];
            }, {
                options: {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                };
                _lastloadedsnap: string;
                automix: Record<number, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }>;
                cleanfeeds: Record<number, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }>;
                faders: Record<number, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }>;
                mutegroups: Record<number, boolean>;
                sourcelist: {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }[];
            }>>;
        };
        "/audio/mixers/{mixerID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            responseSchema: zod.ZodObject<{
                _lastloadedsnap: zod.ZodString;
                automix: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    maxattenuation: zod.ZodNumber;
                    passiveattenuation: zod.ZodNumber;
                    hold: zod.ZodNumber;
                    ratio: zod.ZodNumber;
                    release: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }>>;
                cleanfeeds: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _active: zod.ZodBoolean;
                }, {
                    cut: zod.ZodBoolean;
                    n: zod.ZodBoolean;
                    outgain: zod.ZodNumber;
                    outsel: zod.ZodBoolean;
                    srcsel: zod.ZodNumber;
                }>, "strip", zod.ZodTypeAny, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }>>;
                faders: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<zod.objectUtil.extendShape<{
                    _channelcnt: zod.ZodNumber;
                    _defaultlabel: zod.ZodString;
                    _faderstart: zod.ZodBoolean;
                    _lastloadedsnap: zod.ZodString;
                    _poolavailable: zod.ZodBoolean;
                    _readystate: zod.ZodBoolean;
                    _usecleanfeed: zod.ZodNumber;
                    meter: zod.ZodObject<{
                        _afl: zod.ZodArray<zod.ZodNumber, "many">;
                        _input: zod.ZodArray<zod.ZodNumber, "many">;
                        _pfl: zod.ZodArray<zod.ZodNumber, "many">;
                    }, "strip", zod.ZodTypeAny, {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    }, {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    }>;
                    mutegroups: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
                    _paramlist: zod.ZodArray<zod.ZodEnum<["subsonic", "agc", "expander", "eq1", "eq2", "eq3", "eq4", "deesser2", "compressor", "limiter"]>, "many">;
                    options: zod.ZodObject<{
                        autooffair: zod.ZodBoolean;
                        combilogic0: zod.ZodBoolean;
                        timerreset: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    }, {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    }>;
                    params: zod.ZodObject<{
                        agc: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            freeze: zod.ZodBoolean;
                            gain: zod.ZodNumber;
                            level: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            threshold: zod.ZodNumber;
                            velocity: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }>;
                        compressor: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            attack: zod.ZodNumber;
                            gain: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            ratio: zod.ZodNumber;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }>;
                        deesser: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            bandwidth: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            ratio: zod.ZodNumber;
                            sharpness: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        }, {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        }>;
                        deesser2: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            frequency: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        }, {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        }>;
                        eq: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            frequency: zod.ZodNumber;
                            gain: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            q: zod.ZodNumber;
                            type: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        }, {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        }>;
                        expander: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            attack: zod.ZodNumber;
                            gain: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            ratio: zod.ZodNumber;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }, {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        }>;
                        gain: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _hasagain: zod.ZodBoolean;
                            _hasp48: zod.ZodBoolean;
                            again: zod.ZodObject<zod.objectUtil.extendShape<{
                                _max: zod.ZodNumber;
                                _min: zod.ZodNumber;
                                _step: zod.ZodNumber;
                            }, {
                                inc: zod.ZodNumber;
                                value: zod.ZodNumber;
                            }>, "strip", zod.ZodTypeAny, {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            }, {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            }>;
                        }, {
                            dgain: zod.ZodNumber;
                            p48: zod.ZodBoolean;
                            phase: zod.ZodBoolean;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        }, {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        }>;
                        gate: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            attack: zod.ZodNumber;
                            attenuation: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        }, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        }>;
                        limiter: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            on: zod.ZodBoolean;
                            release: zod.ZodNumber;
                            threshold: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        }, {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        }>;
                        panbal: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            divergency: zod.ZodNumber;
                            lfeonly: zod.ZodBoolean;
                            lfesend: zod.ZodNumber;
                            matrix: zod.ZodNumber;
                            panbal: zod.ZodNumber;
                            rear: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        }, {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        }>;
                        r128agc: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                            _gainreduction: zod.ZodNumber;
                        }, {
                            freeze: zod.ZodBoolean;
                            gain: zod.ZodNumber;
                            level: zod.ZodNumber;
                            on: zod.ZodBoolean;
                            threshold: zod.ZodNumber;
                            velocity: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }, {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        }>;
                        subsonic: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            frequency: zod.ZodNumber;
                            on: zod.ZodBoolean;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        }, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        }>;
                        swc: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            direction: zod.ZodNumber;
                            type: zod.ZodBoolean;
                            width: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        }, {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        }>;
                        varfilter: zod.ZodObject<zod.objectUtil.extendShape<{
                            _active: zod.ZodBoolean;
                        }, {
                            frequency: zod.ZodNumber;
                            hipass: zod.ZodBoolean;
                            on: zod.ZodBoolean;
                            order: zod.ZodNumber;
                        }>, "strip", zod.ZodTypeAny, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        }, {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        }>;
                    }, "strip", zod.ZodTypeAny, {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    }, {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    }>;
                }, {
                    altinput: zod.ZodBoolean;
                    bypass: zod.ZodBoolean;
                    fader: zod.ZodNumber;
                    isolate: zod.ZodBoolean;
                    label: zod.ZodString;
                    memo: zod.ZodBoolean;
                    offair: zod.ZodBoolean;
                    on: zod.ZodBoolean;
                    pfl1: zod.ZodBoolean;
                    pfl2: zod.ZodBoolean;
                    preparation: zod.ZodBoolean;
                    solo: zod.ZodBoolean;
                    sourceid: zod.ZodNumber;
                    vcagroup: zod.ZodNumber;
                    voice: zod.ZodBoolean;
                }>, "strip", zod.ZodTypeAny, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }>>;
                mutegroups: zod.ZodRecord<zod.ZodNumber, zod.ZodBoolean>;
                options: zod.ZodObject<zod.objectUtil.extendShape<{
                    pfl1: zod.ZodObject<{
                        afl: zod.ZodBoolean;
                        aflwhenon: zod.ZodBoolean;
                        mix: zod.ZodBoolean;
                        reset: zod.ZodBoolean;
                        resetfader: zod.ZodBoolean;
                        return: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }>;
                    pfl2: zod.ZodObject<{
                        afl: zod.ZodBoolean;
                        aflwhenon: zod.ZodBoolean;
                        mix: zod.ZodBoolean;
                        reset: zod.ZodBoolean;
                        resetfader: zod.ZodBoolean;
                        return: zod.ZodBoolean;
                    }, "strip", zod.ZodTypeAny, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }, {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    }>;
                }, {
                    directoffair: zod.ZodBoolean;
                }>, "strip", zod.ZodTypeAny, {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                }, {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                }>;
                sourcelist: zod.ZodArray<zod.ZodObject<{
                    _defaultlabel: zod.ZodString;
                    _label: zod.ZodString;
                    _sourceid: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }, {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }>, "many">;
            }, "strip", zod.ZodTypeAny, {
                options: {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                };
                _lastloadedsnap: string;
                automix: Record<number, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }>;
                cleanfeeds: Record<number, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }>;
                faders: Record<number, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }>;
                mutegroups: Record<number, boolean>;
                sourcelist: {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }[];
            }, {
                options: {
                    pfl1: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    pfl2: {
                        afl: boolean;
                        aflwhenon: boolean;
                        mix: boolean;
                        reset: boolean;
                        resetfader: boolean;
                        return: boolean;
                    };
                    directoffair: boolean;
                };
                _lastloadedsnap: string;
                automix: Record<number, {
                    _active: boolean;
                    maxattenuation: number;
                    passiveattenuation: number;
                    hold: number;
                    ratio: number;
                    release: number;
                }>;
                cleanfeeds: Record<number, {
                    _active: boolean;
                    cut: boolean;
                    n: boolean;
                    outgain: number;
                    outsel: boolean;
                    srcsel: number;
                }>;
                faders: Record<number, {
                    params: {
                        subsonic: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                        };
                        agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        expander: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        deesser2: {
                            _active: boolean;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            frequency: number;
                        };
                        compressor: {
                            _active: boolean;
                            ratio: number;
                            release: number;
                            _gainreduction: number;
                            gain: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                        };
                        limiter: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                        };
                        gain: {
                            _active: boolean;
                            _hasagain: boolean;
                            _hasp48: boolean;
                            again: {
                                value: number;
                                _max: number;
                                _min: number;
                                _step: number;
                                inc: number;
                            };
                            dgain: number;
                            p48: boolean;
                            phase: boolean;
                        };
                        deesser: {
                            _active: boolean;
                            ratio: number;
                            on: boolean;
                            bandwidth: number;
                            sharpness: number;
                        };
                        eq: {
                            type: number;
                            _active: boolean;
                            gain: number;
                            on: boolean;
                            frequency: number;
                            q: number;
                        };
                        gate: {
                            _active: boolean;
                            release: number;
                            _gainreduction: number;
                            on: boolean;
                            threshold: number;
                            attack: number;
                            attenuation: number;
                        };
                        panbal: {
                            _active: boolean;
                            divergency: number;
                            lfeonly: boolean;
                            lfesend: number;
                            matrix: number;
                            panbal: number;
                            rear: number;
                        };
                        r128agc: {
                            _active: boolean;
                            _gainreduction: number;
                            freeze: boolean;
                            gain: number;
                            level: number;
                            on: boolean;
                            threshold: number;
                            velocity: number;
                        };
                        swc: {
                            type: boolean;
                            _active: boolean;
                            direction: number;
                            width: number;
                        };
                        varfilter: {
                            _active: boolean;
                            on: boolean;
                            frequency: number;
                            hipass: boolean;
                            order: number;
                        };
                    };
                    options: {
                        autooffair: boolean;
                        combilogic0: boolean;
                        timerreset: boolean;
                    };
                    _lastloadedsnap: string;
                    _channelcnt: number;
                    _defaultlabel: string;
                    _faderstart: boolean;
                    _poolavailable: boolean;
                    _readystate: boolean;
                    _usecleanfeed: number;
                    meter: {
                        _input: number[];
                        _afl: number[];
                        _pfl: number[];
                    };
                    mutegroups: Record<number, boolean>;
                    _paramlist: ("subsonic" | "agc" | "expander" | "eq1" | "eq2" | "eq3" | "eq4" | "deesser2" | "compressor" | "limiter")[];
                    on: boolean;
                    altinput: boolean;
                    bypass: boolean;
                    fader: number;
                    isolate: boolean;
                    label: string;
                    memo: boolean;
                    offair: boolean;
                    pfl1: boolean;
                    pfl2: boolean;
                    preparation: boolean;
                    solo: boolean;
                    sourceid: number;
                    vcagroup: number;
                    voice: boolean;
                }>;
                mutegroups: Record<number, boolean>;
                sourcelist: {
                    _defaultlabel: string;
                    _label: string;
                    _sourceid: number;
                }[];
            }>;
        };
        "/audio/loudness": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                _leveli: zod.ZodNumber;
                _levelm: zod.ZodNumber;
                _levelo: zod.ZodNumber;
                _levels: zod.ZodNumber;
                _levelu: zod.ZodNumber;
                _maxm: zod.ZodNumber;
                _maxpeak: zod.ZodNumber;
                _maxs: zod.ZodNumber;
                _mode: zod.ZodString;
                _name: zod.ZodString;
                _peak: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _mode: string;
                _leveli: number;
                _levelm: number;
                _levelo: number;
                _levels: number;
                _levelu: number;
                _maxm: number;
                _maxpeak: number;
                _maxs: number;
                _peak: number;
            }, {
                _name: string;
                _mode: string;
                _leveli: number;
                _levelm: number;
                _levelo: number;
                _levels: number;
                _levelu: number;
                _maxm: number;
                _maxpeak: number;
                _maxs: number;
                _peak: number;
            }>>;
        };
        "/audio/loudness/{levelDetectID}": {
            paramsSchema: zod.ZodObject<{
                levelDetectID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                levelDetectID: number;
            }, {
                levelDetectID: number;
            }>;
            responseSchema: zod.ZodObject<{
                _leveli: zod.ZodNumber;
                _levelm: zod.ZodNumber;
                _levelo: zod.ZodNumber;
                _levels: zod.ZodNumber;
                _levelu: zod.ZodNumber;
                _maxm: zod.ZodNumber;
                _maxpeak: zod.ZodNumber;
                _maxs: zod.ZodNumber;
                _mode: zod.ZodString;
                _name: zod.ZodString;
                _peak: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _mode: string;
                _leveli: number;
                _levelm: number;
                _levelo: number;
                _levels: number;
                _levelu: number;
                _maxm: number;
                _maxpeak: number;
                _maxs: number;
                _peak: number;
            }, {
                _name: string;
                _mode: string;
                _leveli: number;
                _levelm: number;
                _levelo: number;
                _levels: number;
                _levelu: number;
                _maxm: number;
                _maxpeak: number;
                _maxs: number;
                _peak: number;
            }>;
        };
        "/audio/levels": {
            paramsSchema: null;
            responseSchema: zod.ZodRecord<zod.ZodNumber, zod.ZodObject<{
                _name: zod.ZodString;
                _mode: zod.ZodUnion<[zod.ZodLiteral<"PPM">, zod.ZodLiteral<"VU">, zod.ZodLiteral<"TruePeak">]>;
                _left: zod.ZodNumber;
                _right: zod.ZodNumber;
                _correlation: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _mode: "PPM" | "VU" | "TruePeak";
                _left: number;
                _right: number;
                _correlation: number;
            }, {
                _name: string;
                _mode: "PPM" | "VU" | "TruePeak";
                _left: number;
                _right: number;
                _correlation: number;
            }>>;
        };
        "/audio/levels/{levelDetectID}": {
            paramsSchema: zod.ZodObject<{
                levelDetectID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                levelDetectID: number;
            }, {
                levelDetectID: number;
            }>;
            responseSchema: zod.ZodObject<{
                _name: zod.ZodString;
                _mode: zod.ZodUnion<[zod.ZodLiteral<"PPM">, zod.ZodLiteral<"VU">, zod.ZodLiteral<"TruePeak">]>;
                _left: zod.ZodNumber;
                _right: zod.ZodNumber;
                _correlation: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                _name: string;
                _mode: "PPM" | "VU" | "TruePeak";
                _left: number;
                _right: number;
                _correlation: number;
            }, {
                _name: string;
                _mode: "PPM" | "VU" | "TruePeak";
                _left: number;
                _right: number;
                _correlation: number;
            }>;
        };
    };
    set: {
        "/control/logics/{logicID}": {
            paramsSchema: zod.ZodObject<{
                logicID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                logicID: number;
            }, {
                logicID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                value: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                value: boolean;
            }, {
                value: boolean;
            }>;
            responseSchema: zod.ZodObject<{
                value: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                value: boolean;
            }, {
                value: boolean;
            }>;
        };
        "/audio/selectors/selectors/{selectorID}": {
            paramsSchema: zod.ZodObject<{
                selectorID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                selectorID: number;
            }, {
                selectorID: number;
            }>;
            responseSchema: zod.ZodObject<{
                left: zod.ZodString;
                right: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                left: string;
                right: string;
            }, {
                left: string;
                right: string;
            }>;
            payloadSchema: zod.ZodObject<{
                left: zod.ZodString;
                right: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                left: string;
                right: string;
            }, {
                left: string;
                right: string;
            }>;
        };
        "/audio/routing/routes/{routeID}": {
            paramsSchema: zod.ZodObject<{
                routeID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                routeID: number;
            }, {
                routeID: number;
            }>;
            responseSchema: zod.ZodString;
            payloadSchema: zod.ZodString;
        };
        "/audio/pots/{potID}": {
            paramsSchema: zod.ZodObject<{
                potID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                potID: number;
            }, {
                potID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                value: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                value: number;
            }, {
                value: number;
            }>;
            responseSchema: zod.ZodObject<{
                value: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                value: number;
            }, {
                value: number;
            }>;
        };
        "/audio/mixers/{mixerID}/options": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                directoffair: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                directoffair: boolean;
            }, {
                directoffair: boolean;
            }>;
            responseSchema: zod.ZodObject<{
                directoffair: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                directoffair: boolean;
            }, {
                directoffair: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/options/pfl1": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                afl: zod.ZodBoolean;
                aflwhenon: zod.ZodBoolean;
                mix: zod.ZodBoolean;
                reset: zod.ZodBoolean;
                resetfader: zod.ZodBoolean;
                return: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }>;
            responseSchema: zod.ZodObject<{
                afl: zod.ZodBoolean;
                aflwhenon: zod.ZodBoolean;
                mix: zod.ZodBoolean;
                reset: zod.ZodBoolean;
                resetfader: zod.ZodBoolean;
                return: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/options/pfl2": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
            }, {
                mixerID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                afl: zod.ZodBoolean;
                aflwhenon: zod.ZodBoolean;
                mix: zod.ZodBoolean;
                reset: zod.ZodBoolean;
                resetfader: zod.ZodBoolean;
                return: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }>;
            responseSchema: zod.ZodObject<{
                afl: zod.ZodBoolean;
                aflwhenon: zod.ZodBoolean;
                mix: zod.ZodBoolean;
                reset: zod.ZodBoolean;
                resetfader: zod.ZodBoolean;
                return: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }, {
                afl: boolean;
                aflwhenon: boolean;
                mix: boolean;
                reset: boolean;
                resetfader: boolean;
                return: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/varfilter{filtID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
                filtID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
                filtID: number;
            }, {
                mixerID: number;
                faderID: number;
                filtID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                hipass: zod.ZodBoolean;
                on: zod.ZodBoolean;
                order: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                frequency: number;
                hipass: boolean;
                order: number;
            }, {
                on: boolean;
                frequency: number;
                hipass: boolean;
                order: number;
            }>;
            responseSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                hipass: zod.ZodBoolean;
                on: zod.ZodBoolean;
                order: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                frequency: number;
                hipass: boolean;
                order: number;
            }, {
                on: boolean;
                frequency: number;
                hipass: boolean;
                order: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/swc": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                direction: zod.ZodNumber;
                type: zod.ZodBoolean;
                width: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: boolean;
                direction: number;
                width: number;
            }, {
                type: boolean;
                direction: number;
                width: number;
            }>;
            responseSchema: zod.ZodObject<{
                direction: zod.ZodNumber;
                type: zod.ZodBoolean;
                width: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: boolean;
                direction: number;
                width: number;
            }, {
                type: boolean;
                direction: number;
                width: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/gate": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                on: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                frequency: number;
            }, {
                on: boolean;
                frequency: number;
            }>;
            responseSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                on: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                frequency: number;
            }, {
                on: boolean;
                frequency: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/r128agc": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                freeze: zod.ZodBoolean;
                gain: zod.ZodNumber;
                level: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
                velocity: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }>;
            responseSchema: zod.ZodObject<{
                freeze: zod.ZodBoolean;
                gain: zod.ZodNumber;
                level: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
                velocity: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/panbal": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                divergency: zod.ZodNumber;
                lfeonly: zod.ZodBoolean;
                lfesend: zod.ZodNumber;
                matrix: zod.ZodNumber;
                panbal: zod.ZodNumber;
                rear: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                divergency: number;
                lfeonly: boolean;
                lfesend: number;
                matrix: number;
                panbal: number;
                rear: number;
            }, {
                divergency: number;
                lfeonly: boolean;
                lfesend: number;
                matrix: number;
                panbal: number;
                rear: number;
            }>;
            responseSchema: zod.ZodObject<{
                divergency: zod.ZodNumber;
                lfeonly: zod.ZodBoolean;
                lfesend: zod.ZodNumber;
                matrix: zod.ZodNumber;
                panbal: zod.ZodNumber;
                rear: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                divergency: number;
                lfeonly: boolean;
                lfesend: number;
                matrix: number;
                panbal: number;
                rear: number;
            }, {
                divergency: number;
                lfeonly: boolean;
                lfesend: number;
                matrix: number;
                panbal: number;
                rear: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/limiter": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                on: zod.ZodBoolean;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                release: number;
                on: boolean;
                threshold: number;
            }, {
                release: number;
                on: boolean;
                threshold: number;
            }>;
            responseSchema: zod.ZodObject<{
                on: zod.ZodBoolean;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                release: number;
                on: boolean;
                threshold: number;
            }, {
                release: number;
                on: boolean;
                threshold: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/gain": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                dgain: zod.ZodNumber;
                p48: zod.ZodBoolean;
                phase: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                dgain: number;
                p48: boolean;
                phase: boolean;
            }, {
                dgain: number;
                p48: boolean;
                phase: boolean;
            }>;
            responseSchema: zod.ZodObject<{
                dgain: zod.ZodNumber;
                p48: zod.ZodBoolean;
                phase: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                dgain: number;
                p48: boolean;
                phase: boolean;
            }, {
                dgain: number;
                p48: boolean;
                phase: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/gain/again": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                inc: zod.ZodNumber;
                value: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                value: number;
                inc: number;
            }, {
                value: number;
                inc: number;
            }>;
            responseSchema: zod.ZodObject<{
                inc: zod.ZodNumber;
                value: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                value: number;
                inc: number;
            }, {
                value: number;
                inc: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/expander": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                attack: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }>;
            responseSchema: zod.ZodObject<{
                attack: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/eq{eqID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
                eqID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
                eqID: number;
            }, {
                mixerID: number;
                faderID: number;
                eqID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                q: zod.ZodNumber;
                type: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: number;
                gain: number;
                on: boolean;
                frequency: number;
                q: number;
            }, {
                type: number;
                gain: number;
                on: boolean;
                frequency: number;
                q: number;
            }>;
            responseSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                q: zod.ZodNumber;
                type: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                type: number;
                gain: number;
                on: boolean;
                frequency: number;
                q: number;
            }, {
                type: number;
                gain: number;
                on: boolean;
                frequency: number;
                q: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/deesser": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                bandwidth: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                sharpness: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ratio: number;
                on: boolean;
                bandwidth: number;
                sharpness: number;
            }, {
                ratio: number;
                on: boolean;
                bandwidth: number;
                sharpness: number;
            }>;
            responseSchema: zod.ZodObject<{
                bandwidth: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                sharpness: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ratio: number;
                on: boolean;
                bandwidth: number;
                sharpness: number;
            }, {
                ratio: number;
                on: boolean;
                bandwidth: number;
                sharpness: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/deesser2": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                threshold: number;
                frequency: number;
            }, {
                on: boolean;
                threshold: number;
                frequency: number;
            }>;
            responseSchema: zod.ZodObject<{
                frequency: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                threshold: number;
                frequency: number;
            }, {
                on: boolean;
                threshold: number;
                frequency: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/compressor": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                attack: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }>;
            responseSchema: zod.ZodObject<{
                attack: zod.ZodNumber;
                gain: zod.ZodNumber;
                on: zod.ZodBoolean;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
                threshold: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }, {
                ratio: number;
                release: number;
                gain: number;
                on: boolean;
                threshold: number;
                attack: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/params/agc": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                freeze: zod.ZodBoolean;
                gain: zod.ZodNumber;
                level: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
                velocity: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }>;
            responseSchema: zod.ZodObject<{
                freeze: zod.ZodBoolean;
                gain: zod.ZodNumber;
                level: zod.ZodNumber;
                on: zod.ZodBoolean;
                threshold: zod.ZodNumber;
                velocity: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }, {
                freeze: boolean;
                gain: number;
                level: number;
                on: boolean;
                threshold: number;
                velocity: number;
            }>;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}/mutegroups/{mutegroupID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
                mutegroupID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
                mutegroupID: number;
            }, {
                mixerID: number;
                faderID: number;
                mutegroupID: number;
            }>;
            payloadSchema: zod.ZodBoolean;
            responseSchema: zod.ZodBoolean;
        };
        "/audio/mixers/{mixerID}/faders/{faderID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                faderID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                faderID: number;
            }, {
                mixerID: number;
                faderID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                altinput: zod.ZodBoolean;
                bypass: zod.ZodBoolean;
                fader: zod.ZodNumber;
                isolate: zod.ZodBoolean;
                label: zod.ZodString;
                memo: zod.ZodBoolean;
                offair: zod.ZodBoolean;
                on: zod.ZodBoolean;
                pfl1: zod.ZodBoolean;
                pfl2: zod.ZodBoolean;
                preparation: zod.ZodBoolean;
                solo: zod.ZodBoolean;
                sourceid: zod.ZodNumber;
                vcagroup: zod.ZodNumber;
                voice: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }, {
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }>;
            responseSchema: zod.ZodObject<{
                altinput: zod.ZodBoolean;
                bypass: zod.ZodBoolean;
                fader: zod.ZodNumber;
                isolate: zod.ZodBoolean;
                label: zod.ZodString;
                memo: zod.ZodBoolean;
                offair: zod.ZodBoolean;
                on: zod.ZodBoolean;
                pfl1: zod.ZodBoolean;
                pfl2: zod.ZodBoolean;
                preparation: zod.ZodBoolean;
                solo: zod.ZodBoolean;
                sourceid: zod.ZodNumber;
                vcagroup: zod.ZodNumber;
                voice: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }, {
                on: boolean;
                altinput: boolean;
                bypass: boolean;
                fader: number;
                isolate: boolean;
                label: string;
                memo: boolean;
                offair: boolean;
                pfl1: boolean;
                pfl2: boolean;
                preparation: boolean;
                solo: boolean;
                sourceid: number;
                vcagroup: number;
                voice: boolean;
            }>;
        };
        "/audio/mixers/{mixerID}/cleanfeeds/{cleanfeedID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                cleanfeedID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                cleanfeedID: number;
            }, {
                mixerID: number;
                cleanfeedID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                cut: zod.ZodBoolean;
                n: zod.ZodBoolean;
                outgain: zod.ZodNumber;
                outsel: zod.ZodBoolean;
                srcsel: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }, {
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }>;
            responseSchema: zod.ZodObject<{
                cut: zod.ZodBoolean;
                n: zod.ZodBoolean;
                outgain: zod.ZodNumber;
                outsel: zod.ZodBoolean;
                srcsel: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }, {
                cut: boolean;
                n: boolean;
                outgain: number;
                outsel: boolean;
                srcsel: number;
            }>;
        };
        "/audio/mixers/{mixerID}/automix/{automixID}": {
            paramsSchema: zod.ZodObject<{
                mixerID: zod.ZodNumber;
                automixID: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                mixerID: number;
                automixID: number;
            }, {
                mixerID: number;
                automixID: number;
            }>;
            payloadSchema: zod.ZodObject<{
                maxattenuation: zod.ZodNumber;
                passiveattenuation: zod.ZodNumber;
                hold: zod.ZodNumber;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }, {
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }>;
            responseSchema: zod.ZodObject<{
                maxattenuation: zod.ZodNumber;
                passiveattenuation: zod.ZodNumber;
                hold: zod.ZodNumber;
                ratio: zod.ZodNumber;
                release: zod.ZodNumber;
            }, "strip", zod.ZodTypeAny, {
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }, {
                maxattenuation: number;
                passiveattenuation: number;
                hold: number;
                ratio: number;
                release: number;
            }>;
        };
    };
};
type DHDHandlers = typeof dhdHandlers;

declare const dhdOptionsSchema: z.ZodObject<{
    /**
     * The hostname or IP address of the DHD device.
     *
     * @example 10.0.0.1
     * @example dhd.local
     */
    host: z.ZodString;
    /**
     * The token used to authenticate with the DHD device.
     */
    token: z.ZodString;
    /**
     * 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: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"websocket">, z.ZodLiteral<"rest">]>>;
    /**
     * Connect to the DHD device using a secure WebSocket connection or HTTPS-requests.
     *
     * @default false
     */
    secure: z.ZodDefault<z.ZodBoolean>;
    /**
     * Connect to the DHD device automatically when the instance is created.
     *
     * @default true
     */
    autoConnect: z.ZodDefault<z.ZodBoolean>;
    /**
     * Automatically reconnect to the DHD device if the connection is lost.
     *
     * @default true
     */
    autoReconnect: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    host: string;
    token: string;
    connectionType: "websocket" | "rest";
    secure: boolean;
    autoConnect: boolean;
    autoReconnect: boolean;
}, {
    host: string;
    token: string;
    connectionType?: "websocket" | "rest" | undefined;
    secure?: boolean | undefined;
    autoConnect?: boolean | undefined;
    autoReconnect?: boolean | undefined;
}>;
type DHDOptionsInput = z.input<typeof dhdOptionsSchema>;
type DHDOptionsOutput = z.infer<typeof dhdOptionsSchema>;
type DHDEvents = {
    connect: () => void;
    disconnect: () => void;
    error: (error: Error) => void;
    reconnect: () => void;
    authenticated: () => void;
    ready: () => void;
};
declare class DHD {
    private options;
    private socket;
    private reconnectTimeout;
    private requestMap;
    private eventHandlers;
    constructor(options: DHDOptionsInput);
    on: <Event extends keyof DHDEvents, Handler extends DHDEvents[Event]>(event: Event, handler: (...args: Parameters<Handler>) => ReturnType<Handler>) => void;
    off: <Event extends keyof DHDEvents, Handler extends DHDEvents[Event]>(event: Event, handler: (...args: Parameters<Handler>) => ReturnType<Handler>) => void;
    private emit;
    /**
     * 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: () => void;
    private reconnect;
    private clearReconnectTimeout;
    private authenticateWebSocket;
    private handleMessage;
    /**
     * Get data from the DHD device.
     *
     * @example
     * await dhd.get("/audio/levels/{levelDetectID}", {
     *   params: { levelDetectID: 1 },
     * });
     *
     */
    get: <Path extends keyof DHDHandlers["get"], Response extends z.infer<DHDHandlers["get"][Path]["responseSchema"]>>(...[path, { params },]: DHDHandlers["get"][Path]["paramsSchema"] extends z.ZodSchema ? [path: Path, {
        params: z.infer<DHDHandlers["get"][Path]["paramsSchema"]>;
    }] : [path: Path]) => Promise<Response>;
    /**
     * Set data in the DHD device.
     *
     * @example
     * await dhd.set("/audio/selectors/selectors/{selectorID}", {
     *   params: { selectorID: 1 },
     *   payload: { left: "40" },
     * });
     *
     */
    set: <Path extends keyof DHDHandlers["set"], Payload extends Partial<z.infer<DHDHandlers["set"][Path]["payloadSchema"]>>>(...[path, { params, payload },]: DHDHandlers["set"][Path]["paramsSchema"] extends z.ZodSchema ? [path: Path, {
        params: z.infer<DHDHandlers["set"][Path]["paramsSchema"]>;
        payload: Payload;
    }] : [path: Path, {
        params?: never;
        payload: Payload;
    }]) => Promise<Payload>;
    private dhdRequest;
    private generateMsgID;
    private webSocketRequest;
    private fetchRequest;
}

export { DHD, type DHDOptionsInput, type DHDOptionsOutput };