@blibliki/engine 0.1.27 → 0.3.2

package/dist/index.d.cts

@@ -0,0 +1,765 @@
+import { Message, Input } from 'webmidi';
+import { Optional, EmptyObject } from '@blibliki/utils';
+
+type BarsBeatsSixteenths = `${number}:${number}:${number}`;
+type TTime = number | BarsBeatsSixteenths | Time;
+declare class Time {
+    private value;
+    private _notation?;
+    private _number?;
+    constructor(value: TTime);
+    add(value: TTime): Time;
+    subtrack(value: TTime): Time;
+    isBefore(value: TTime): boolean;
+    isAfter(value: TTime): boolean;
+    isEqual(value: TTime): boolean;
+    toNotation(): BarsBeatsSixteenths;
+    toNumber(): number;
+    private get transport();
+}
+
+type INote = {
+    name: string;
+    octave: number;
+    frequency: number;
+    duration?: TTime;
+    velocity?: number;
+};
+declare class Note implements INote {
+    static _notes: Note[];
+    name: string;
+    octave: number;
+    velocity: number;
+    duration?: TTime;
+    static fromFrequency(frequency: number): Note;
+    static fromEvent(message: Message): Note;
+    static notes(octave?: number): Note[];
+    constructor(note: Omit<INote, "frequency"> | string);
+    get isSemi(): boolean;
+    get fullName(): string;
+    get frequency(): number;
+    midiData(noteOn?: boolean): Uint8Array;
+    get midiNumber(): number;
+    get noteIndex(): number;
+    valueOf(): string;
+    serialize(): INote;
+    private fromString;
+    private fromProps;
+}
+
+declare enum MidiEventType {
+    noteOn = "noteon",
+    noteOff = "noteoff",
+    cc = "cc"
+}
+declare class MidiEvent {
+    note?: Note;
+    voiceNo?: number;
+    readonly triggeredAt: TTime;
+    private message;
+    static fromNote(noteName: string | Note | Omit<INote, "frequency">, noteOn?: boolean, triggeredAt?: TTime): MidiEvent;
+    static fromCC(cc: number, value: number, triggeredAt?: TTime): MidiEvent;
+    constructor(message: Message, triggeredAt?: TTime);
+    get type(): MidiEventType;
+    get isNote(): boolean;
+    defineNotes(): void;
+    get rawMessage(): Message;
+    clone(voiceNo?: number): MidiEvent;
+}
+
+declare enum MidiPortState {
+    connected = "connected",
+    disconnected = "disconnected"
+}
+type IMidiDevice = {
+    id: string;
+    name: string;
+    state: MidiPortState;
+};
+type IMidiInput = IMidiDevice & {
+    eventListerCallbacks: EventListerCallback[];
+};
+type EventListerCallback = (event: MidiEvent) => void;
+declare class MidiDevice implements IMidiDevice {
+    id: string;
+    name: string;
+    eventListerCallbacks: EventListerCallback[];
+    private input;
+    constructor(input: Input);
+    get state(): MidiPortState;
+    connect(): void;
+    disconnect(): void;
+    serialize(): {
+        id: string;
+        name: string;
+        state: MidiPortState;
+    };
+    addEventListener(callback: EventListerCallback): void;
+    removeEventListener(callback: EventListerCallback): void;
+    private processEvent;
+}
+
+declare class ComputerKeyboardInput implements IMidiInput {
+    id: string;
+    name: string;
+    state: MidiPortState;
+    eventListerCallbacks: EventListerCallback[];
+    constructor();
+    addEventListener(callback: EventListerCallback): void;
+    removeEventListener(callback: EventListerCallback): void;
+    serialize(): {
+        id: string;
+        name: string;
+        state: MidiPortState;
+    };
+    onKeyTrigger: (noteOn: boolean) => (event: KeyboardEvent) => void;
+    private extractNote;
+}
+
+type AudioInputProps = IOProps & {
+    ioType: IOType.AudioInput;
+    getAudioNode: () => AudioNode | AudioParam | AudioDestinationNode;
+};
+type AudioOutputProps = IOProps & {
+    ioType: IOType.AudioOutput;
+    getAudioNode: () => AudioNode;
+};
+declare class AudioInput extends IO<AudioOutput | PolyAudioOutput> implements AudioInputProps {
+    ioType: IOType.AudioInput;
+    getAudioNode: AudioInputProps["getAudioNode"];
+    constructor(module: Module<ModuleType>, props: AudioInputProps);
+}
+declare class AudioOutput extends IO<AudioInput | PolyAudioInput> implements AudioOutputProps {
+    ioType: IOType.AudioOutput;
+    getAudioNode: AudioOutputProps["getAudioNode"];
+    constructor(module: Module<ModuleType>, props: AudioOutputProps);
+    plug(io: AudioInput | PolyAudioInput, plugOther?: boolean): void;
+    unPlug(io: AudioInput | PolyAudioInput, plugOther?: boolean): void;
+}
+
+type PolyAudioInputProps = IOProps & {
+    ioType: IOType.PolyAudioInput;
+};
+type PolyAudioOutputProps = IOProps & {
+    ioType: IOType.PolyAudioOutput;
+};
+declare class PolyAudioInput extends IO<PolyAudioOutput | AudioOutput> implements PolyAudioInputProps {
+    ioType: IOType.PolyAudioInput;
+    module: PolyModule<ModuleType>;
+    plug(io: PolyAudioOutput | AudioOutput, plugOther?: boolean): void;
+    unPlug(io: PolyAudioOutput | AudioOutput, plugOther?: boolean): void;
+    findIOByVoice(voice: number): AudioInput;
+}
+declare class PolyAudioOutput extends IO<PolyAudioInput | AudioInput> implements PolyAudioOutputProps {
+    ioType: IOType.PolyAudioOutput;
+    module: PolyModule<ModuleType>;
+    plug(io: PolyAudioInput | AudioInput, plugOther?: boolean): void;
+    unPlug(io: PolyAudioInput | AudioInput, plugOther?: boolean): void;
+    findIOByVoice(voice: number): AudioOutput;
+}
+
+declare enum TransportState {
+    playing = "playing",
+    stopped = "stopped",
+    paused = "paused"
+}
+type TPlaybackCallback = (actionAt: TTime) => void;
+type TransportProps = {
+    onStart?: TPlaybackCallback;
+    onStop?: TPlaybackCallback;
+};
+declare class Transport {
+    bpm: number;
+    timeSignature: [number, number];
+    loopStart: TTime;
+    loopEnd?: TTime;
+    state: TransportState;
+    offset: TTime;
+    private startTime;
+    private onStart;
+    private onStop;
+    private scheduler;
+    constructor(props: TransportProps);
+    start({ offset, actionAt, }: {
+        offset?: TTime;
+        actionAt?: TTime;
+    }): TTime | undefined;
+    stop({ actionAt: actionAt }: {
+        actionAt?: TTime;
+    }): TTime | undefined;
+    pause({ actionAt: actionAt }: {
+        actionAt?: TTime;
+    }): TTime | undefined;
+    get playhead(): Time;
+    private validateFutureTime;
+}
+
+type IPolyModule<T extends ModuleType> = Omit<IModule<T>, "voiceNo"> & {
+    voices: number;
+};
+type IPolyModuleSerialize<T extends ModuleType> = IPolyModule<T> & {
+    inputs: IIOSerialize[];
+    outputs: IIOSerialize[];
+};
+type IPolyModuleConstructor<T extends ModuleType> = Optional<IPolyModule<T>, "id"> & {
+    monoModuleConstructor: (engineId: string, params: IModuleConstructor<T>) => Module<T>;
+};
+declare abstract class PolyModule<T extends ModuleType> implements IPolyModule<T> {
+    id: string;
+    engineId: string;
+    moduleType: T;
+    audioModules: Module<T>[];
+    inputs: InputCollection;
+    outputs: OutputCollection;
+    protected monoModuleConstructor: IPolyModuleConstructor<T>["monoModuleConstructor"];
+    protected _props: ModuleTypeToPropsMapping[T];
+    protected superInitialized: boolean;
+    private _voices;
+    private _name;
+    constructor(engineId: string, params: IPolyModuleConstructor<T>);
+    get name(): string;
+    set name(value: string);
+    get props(): ModuleTypeToPropsMapping[T];
+    set props(value: Partial<ModuleTypeToPropsMapping[T]>);
+    get voices(): number;
+    set voices(value: number);
+    start(time: TTime): void;
+    stop(time: TTime): void;
+    serialize(): IPolyModuleSerialize<T>;
+    plug({ audioModule, from, to, }: {
+        audioModule: Module<ModuleType> | PolyModule<ModuleType>;
+        from: string;
+        to: string;
+    }): void;
+    rePlugAll(callback?: () => void): void;
+    protected unPlugAll(): void;
+    dispose(): void;
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    findVoice(voiceNo: number): Module<T>;
+    protected registerDefaultIOs(value?: "both" | "in" | "out"): void;
+    protected registerAudioInput(props: Omit<PolyAudioInputProps, "ioType">): PolyAudioInput;
+    protected registerAudioOutput(props: Omit<PolyAudioOutputProps, "ioType">): PolyAudioOutput;
+    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput;
+    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput;
+    private adjustNumberOfModules;
+    protected get engine(): Engine;
+    protected get context(): IAnyAudioContext;
+}
+
+type MidiInputProps = IOProps & {
+    ioType: IOType.MidiInput;
+    onMidiEvent: (event: MidiEvent) => void;
+};
+type MidiOutputProps = IOProps & {
+    ioType: IOType.MidiOutput;
+};
+declare class MidiInput extends IO<MidiOutput> implements MidiInputProps {
+    ioType: IOType.MidiInput;
+    onMidiEvent: MidiInputProps["onMidiEvent"];
+    constructor(module: Module<ModuleType> | PolyModule<ModuleType>, props: MidiInputProps);
+}
+declare class MidiOutput extends IO<MidiInput> implements MidiOutputProps {
+    ioType: IOType.MidiOutput;
+    onMidiEvent: (event: MidiEvent) => void;
+    private get midiConnections();
+}
+
+declare enum CollectionType {
+    Input = "Input",
+    Output = "Output"
+}
+type IMappedIOProps = {
+    [CollectionType.Input]: AudioInputProps | PolyAudioInputProps | MidiInputProps;
+    [CollectionType.Output]: AudioOutputProps | PolyAudioOutputProps | MidiOutputProps;
+};
+type IIOTypeTOClass = {
+    [IOType.AudioInput]: AudioInput;
+    [IOType.AudioOutput]: AudioOutput;
+    [IOType.PolyAudioInput]: PolyAudioInput;
+    [IOType.PolyAudioOutput]: PolyAudioOutput;
+    [IOType.MidiInput]: MidiInput;
+    [IOType.MidiOutput]: MidiOutput;
+};
+declare abstract class IOCollection<T extends CollectionType> {
+    module: Module<ModuleType> | PolyModule<ModuleType>;
+    collection: Base[];
+    collectionType: T;
+    constructor(collectionType: T, module: Module<ModuleType> | PolyModule<ModuleType>);
+    add<TT extends IMappedIOProps[T]>(props: TT): IIOTypeTOClass[TT["ioType"]];
+    unPlugAll(): void;
+    rePlugAll(callback?: () => void): void;
+    find(id: string): Base;
+    findByName(name: string): Base;
+    serialize(): IIOSerialize[];
+    private validateUniqName;
+}
+declare class InputCollection extends IOCollection<CollectionType.Input> {
+    constructor(module: Module<ModuleType> | PolyModule<ModuleType>);
+}
+declare class OutputCollection extends IOCollection<CollectionType.Output> {
+    constructor(module: Module<ModuleType> | PolyModule<ModuleType>);
+}
+
+type IModule<T extends ModuleType> = {
+    id: string;
+    name: string;
+    voiceNo: number;
+    moduleType: T;
+    props: ModuleTypeToPropsMapping[T];
+};
+type IModuleSerialize<T extends ModuleType> = IModule<T> & {
+    inputs: IIOSerialize[];
+    outputs: IIOSerialize[];
+};
+type IModuleConstructor<T extends ModuleType> = Optional<IModule<T>, "id" | "voiceNo"> & {
+    audioNodeConstructor?: (context: IAnyAudioContext) => AudioNode;
+};
+declare abstract class Module<T extends ModuleType> implements IModule<T> {
+    id: string;
+    engineId: string;
+    name: string;
+    moduleType: T;
+    voiceNo: number;
+    audioNode: AudioNode | undefined;
+    inputs: InputCollection;
+    outputs: OutputCollection;
+    protected _props: ModuleTypeToPropsMapping[T];
+    protected superInitialized: boolean;
+    protected activeNotes: Note[];
+    constructor(engineId: string, params: IModuleConstructor<T>);
+    get props(): ModuleTypeToPropsMapping[T];
+    set props(value: Partial<ModuleTypeToPropsMapping[T]>);
+    serialize(): IModuleSerialize<T>;
+    plug({ audioModule, from, to, }: {
+        audioModule: AnyModule;
+        from: string;
+        to: string;
+    }): void;
+    protected rePlugAll(callback?: () => void): void;
+    protected unPlugAll(): void;
+    start(_time: TTime): void;
+    stop(_time: TTime): void;
+    triggerAttack(note: Note, _triggeredAt: TTime): void;
+    triggerRelease(note: Note, _triggeredAt: TTime): void;
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    protected triggerPropsUpdate(): void;
+    dispose(): void;
+    protected registerDefaultIOs(value?: "both" | "in" | "out"): void;
+    protected registerAudioInput(props: Omit<AudioInputProps, "ioType">): AudioInput;
+    protected registerAudioOutput(props: Omit<AudioOutputProps, "ioType">): AudioOutput;
+    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput;
+    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput;
+    protected get engine(): Engine;
+    protected get context(): IAnyAudioContext;
+}
+
+type IPlug = {
+    moduleId: string;
+    ioName: string;
+};
+type IRoute = {
+    id: string;
+    source: IPlug;
+    destination: IPlug;
+};
+declare class Routes {
+    engine: Engine;
+    routes: Map<string, IRoute>;
+    constructor(engine: Engine);
+    addRoute(props: Optional<IRoute, "id">): IRoute;
+    removeRoute(id: string): void;
+    clear(): void;
+    private plug;
+    private unPlug;
+    private find;
+    private getIOs;
+}
+
+type ListenerCallback = (device: MidiDevice) => void;
+declare class MidiDeviceManager {
+    devices: Map<string, MidiDevice | ComputerKeyboardInput>;
+    private initialized;
+    private listeners;
+    constructor();
+    initialize(): Promise<void>;
+    find(id: string): MidiDevice | ComputerKeyboardInput | undefined;
+    addListener(callback: ListenerCallback): void;
+    private initializeDevices;
+    private listenChanges;
+}
+
+type BasePropType = {
+    label?: string;
+    description?: string;
+};
+type NumberProp = BasePropType & {
+    kind: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+};
+type EnumProp<T extends string | number> = BasePropType & {
+    kind: "enum";
+    options: T[];
+};
+type StringProp = BasePropType & {
+    kind: "string";
+    pattern?: RegExp;
+};
+type BooleanProp = BasePropType & {
+    kind: "boolean";
+};
+type ArrayProp = BasePropType & {
+    kind: "array";
+};
+type PropDefinition<T> = T extends number ? NumberProp | EnumProp<number> : T extends boolean ? BooleanProp : T extends string ? StringProp | EnumProp<string> : T extends (string | number)[] ? ArrayProp : never;
+type PropSchema<T> = {
+    [K in keyof T]: PropDefinition<T[K]>;
+};
+
+type IAnyAudioContext = AudioContext | OfflineAudioContext;
+
+type IVoiceSchedulerProps = EmptyObject;
+declare class Voice extends Module<ModuleType.VoiceScheduler> {
+    audioNode: undefined;
+    activeNote: string | null;
+    triggeredAt: TTime;
+    constructor(engineId: string, params: ICreateModule<ModuleType.VoiceScheduler>);
+    midiTriggered: (midiEvent: MidiEvent) => void;
+}
+declare class VoiceScheduler extends PolyModule<ModuleType.VoiceScheduler> {
+    audioModules: Voice[];
+    midiOutput: MidiOutput;
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.VoiceScheduler>);
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    private findFreeVoice;
+    private registerInputs;
+    private registerOutputs;
+}
+
+type IBiquadFilterProps = {
+    cutoff: number;
+    envelopeAmount: number;
+    type: BiquadFilterType;
+    Q: number;
+};
+declare class BiquadFilter extends PolyModule<ModuleType.BiquadFilter> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.BiquadFilter>);
+    private registerInputs;
+}
+
+type IConstantProps = {
+    value: number;
+};
+declare class Constant extends Module<ModuleType.Constant> {
+    audioNode: ConstantSourceNode;
+    isStated: boolean;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Constant>);
+    protected onSetValue(value: IConstantProps["value"]): void;
+    start(time: TTime): void;
+    stop(time: TTime): void;
+    triggerAttack: (note: Note, triggeredAt: TTime) => void;
+    triggerRelease: () => void;
+}
+
+type IEnvelopeProps = {
+    attack: number;
+    decay: number;
+    sustain: number;
+    release: number;
+};
+declare class Envelope extends PolyModule<ModuleType.Envelope> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Envelope>);
+}
+
+type IFilterProps = {
+    cutoff: number;
+    envelopeAmount: number;
+    resonance: number;
+};
+declare class Filter extends PolyModule<ModuleType.Filter> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Filter>);
+    private registerInputs;
+}
+
+type IGain = IModule<ModuleType.Gain>;
+type IGainProps = {
+    gain: number;
+};
+declare class Gain extends PolyModule<ModuleType.Gain> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Gain>);
+    private registerAdditionalInputs;
+}
+
+type IInspectorProps = {
+    fftSize: number;
+};
+declare class Inspector extends Module<ModuleType.Inspector> {
+    audioNode: AnalyserNode;
+    private _buffer?;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Inspector>);
+    protected onSetFftSize(value: number): void;
+    get buffer(): Float32Array<ArrayBuffer>;
+    getValue(): number;
+    getValues(): Float32Array;
+}
+
+type IMaster = IModule<ModuleType.Master>;
+type IMasterProps = EmptyObject;
+declare class Master extends Module<ModuleType.Master> {
+    audioNode: AudioDestinationNode;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Master>);
+}
+
+type IMidiSelectorProps = {
+    selectedId: string | undefined | null;
+};
+declare class MidiSelector extends Module<ModuleType.MidiSelector> {
+    audioNode: undefined;
+    midiOutput: MidiOutput;
+    _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
+    constructor(engineId: string, params: ICreateModule<ModuleType.MidiSelector>);
+    protected onSetSelectedId(value: string | null): void;
+    private get forwardMidiEvent();
+    private addEventListener;
+    private removeEventListener;
+    private registerOutputs;
+}
+
+type IOscillator = IModule<ModuleType.Oscillator>;
+declare enum OscillatorWave {
+    sine = "sine",
+    triangle = "triangle",
+    square = "square",
+    sawtooth = "sawtooth"
+}
+/**
+ * Props for the Oscillator module.
+ *
+ * @property wave - Waveform shape of the oscillator.
+ *                  One of: "sine", "square", "sawtooth", "triangle", or "custom".
+ * @property frequency - Base frequency in Hz (e.g. 440 for A4).
+ * @property fine - Fine tuning factor in the range [-1, 1], where ±1 represents ±1 semitone.
+ * @property coarse - Coarse tuning factor in the range [-1, 1], scaled to ±12 semitones.
+ * @property octave - Octave transposition value (e.g. +1 for one octave up, -2 for two octaves down).
+ * @property lowGain - Whether to gain reduction (-18dB). When false, oscillator runs at full gain.
+ */
+type IOscillatorProps = {
+    wave: OscillatorWave;
+    frequency: number;
+    fine: number;
+    coarse: number;
+    octave: number;
+    lowGain: boolean;
+};
+declare class Oscillator extends PolyModule<ModuleType.Oscillator> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Oscillator>);
+    start(time: TTime): void;
+    stop(time: TTime): void;
+    private registerInputs;
+}
+
+type IScaleProps = {
+    min: number;
+    max: number;
+    current: number;
+};
+declare class Scale extends Module<ModuleType.Scale> {
+    audioNode: AudioWorkletNode;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Scale>);
+    get current(): AudioParam;
+    get min(): AudioParam;
+    get max(): AudioParam;
+    protected onSetMin(value: number): void;
+    protected onSetMax(value: number): void;
+    protected onSetCurrent(value: number): void;
+}
+
+type IStepSequencer = IModule<ModuleType.StepSequencer>;
+type ISequence = {
+    active: boolean;
+    time: BarsBeatsSixteenths;
+    duration: string;
+    notes: INote[];
+};
+type IStepSequencerProps = {
+    bars: number;
+    steps: number;
+    sequences: ISequence[][];
+};
+declare class StepSequencer extends Module<ModuleType.StepSequencer> {
+    audioNode: undefined;
+    midiOutput: MidiOutput;
+    constructor(engineId: string, params: ICreateModule<ModuleType.StepSequencer>);
+}
+
+type IVirtualMidiProps = {
+    activeNotes: string[];
+};
+declare class VirtualMidi extends Module<ModuleType.VirtualMidi> {
+    audioNode: undefined;
+    midiOutput: MidiOutput;
+    constructor(engineId: string, params: ICreateModule<ModuleType.VirtualMidi>);
+    sendMidi(midiEvent: MidiEvent): void;
+    triggerAttack: (note: Note, triggerAttack: TTime) => void;
+    triggerRelease: (note: Note, triggerAttack: TTime) => void;
+    private registerInputs;
+    private registerOutputs;
+}
+
+declare enum ModuleType {
+    Master = "Master",
+    Oscillator = "Oscillator",
+    Gain = "Gain",
+    MidiSelector = "MidiSelector",
+    Envelope = "Envelope",
+    Filter = "Filter",
+    BiquadFilter = "BiquadFilter",
+    Scale = "Scale",
+    Inspector = "Inspector",
+    Constant = "Constant",
+    VirtualMidi = "VirtualMidi",
+    StepSequencer = "StepSequencer",
+    VoiceScheduler = "VoiceScheduler"
+}
+type ModuleTypeToPropsMapping = {
+    [ModuleType.Oscillator]: IOscillatorProps;
+    [ModuleType.Gain]: IGainProps;
+    [ModuleType.Master]: IMasterProps;
+    [ModuleType.MidiSelector]: IMidiSelectorProps;
+    [ModuleType.Envelope]: IEnvelopeProps;
+    [ModuleType.Filter]: IFilterProps;
+    [ModuleType.BiquadFilter]: IBiquadFilterProps;
+    [ModuleType.Scale]: IScaleProps;
+    [ModuleType.Inspector]: IInspectorProps;
+    [ModuleType.Constant]: IConstantProps;
+    [ModuleType.VirtualMidi]: IVirtualMidiProps;
+    [ModuleType.StepSequencer]: IStepSequencerProps;
+    [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
+};
+type ModuleTypeToModuleMapping = {
+    [ModuleType.Oscillator]: Oscillator;
+    [ModuleType.Gain]: Gain;
+    [ModuleType.Master]: Master;
+    [ModuleType.MidiSelector]: MidiSelector;
+    [ModuleType.Envelope]: Envelope;
+    [ModuleType.Filter]: Filter;
+    [ModuleType.BiquadFilter]: BiquadFilter;
+    [ModuleType.Scale]: Scale;
+    [ModuleType.Inspector]: Inspector;
+    [ModuleType.Constant]: Constant;
+    [ModuleType.VirtualMidi]: VirtualMidi;
+    [ModuleType.StepSequencer]: StepSequencer;
+    [ModuleType.VoiceScheduler]: VoiceScheduler;
+};
+declare const moduleSchemas: {
+    [K in ModuleType]: PropSchema<Partial<ModuleTypeToPropsMapping[K]>>;
+};
+
+type AnyModule = Module<ModuleType>;
+type ICreateModule<T extends ModuleType> = {
+    id?: string;
+    name: string;
+    moduleType: T;
+    props: Partial<ModuleTypeToPropsMapping[T]>;
+};
+type ModuleParams = {
+    [K in ModuleType]: K extends ModuleType.Oscillator | ModuleType.Gain | ModuleType.Envelope | ModuleType.Filter | ModuleType.BiquadFilter | ModuleType.VoiceScheduler ? IPolyModuleConstructor<K> : ICreateModule<K>;
+}[ModuleType];
+
+type IOProps = {
+    name: string;
+    ioType: IOType;
+};
+type IIOSerialize = IOProps & {
+    id: string;
+    moduleId: string;
+};
+declare enum IOType {
+    AudioInput = "audioInput",
+    AudioOutput = "audioOutput",
+    PolyAudioInput = "polyAudioInput",
+    PolyAudioOutput = "polyAudioOutput",
+    MidiOutput = "midiOutput",
+    MidiInput = "midiInput"
+}
+type IIO = {
+    id: string;
+    module: Module<ModuleType> | PolyModule<ModuleType>;
+} & IOProps;
+declare abstract class Base implements IIO {
+    id: string;
+    ioType: IOType;
+    name: string;
+    module: Module<ModuleType> | PolyModule<ModuleType>;
+    connections: Base[];
+    constructor(module: Module<ModuleType> | PolyModule<ModuleType>, props: IOProps);
+    plug(io: Base, plugOther?: boolean): void;
+    unPlug(io: Base, plugOther?: boolean): void;
+    rePlugAll(callback?: () => void): void;
+    unPlugAll(): void;
+    isAudio(): this is AudioInput | AudioOutput | PolyAudioInput | PolyAudioOutput;
+    isMidi(): this is MidiInput | MidiOutput;
+    serialize(): IIOSerialize;
+}
+declare abstract class IO<Connection extends Base> extends Base {
+    connections: Connection[];
+    plug(io: Connection, plugOther?: boolean): void;
+    unPlug(io: Connection, plugOther?: boolean): void;
+}
+
+type IUpdateModule<T extends ModuleType> = {
+    id: string;
+    moduleType: T;
+    changes: Partial<Omit<ICreateModule<T>, "id" | "moduleType" | "voice">> & {
+        voices?: number;
+    };
+};
+type ICreateRoute = Optional<IRoute, "id">;
+declare class Engine {
+    private static _engines;
+    private static _currentId;
+    private propsUpdateCallbacks;
+    readonly id: string;
+    context: IAnyAudioContext;
+    isInitialized: boolean;
+    routes: Routes;
+    transport: Transport;
+    modules: Map<string, ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping]>;
+    midiDeviceManager: MidiDeviceManager;
+    static getById(id: string): Engine;
+    static get current(): Engine;
+    constructor(context: IAnyAudioContext);
+    get state(): TransportState;
+    initialize(): Promise<void>;
+    addModule<T extends ModuleType>(params: ICreateModule<T>): IModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.BiquadFilter> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiSelector> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer>;
+    updateModule<T extends ModuleType>(params: IUpdateModule<T>): IModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.BiquadFilter> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiSelector> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer>;
+    removeModule(id: string): void;
+    addRoute(props: ICreateRoute): IRoute;
+    removeRoute(id: string): void;
+    validRoute(props: Optional<IRoute, "id">): boolean;
+    start(props?: {
+        offset?: TTime;
+        actionAt?: TTime;
+    }): void;
+    stop(props?: {
+        actionAt?: TTime;
+    }): void;
+    pause(props?: {
+        actionAt?: TTime;
+    }): void;
+    get bpm(): number;
+    set bpm(value: number);
+    resume(): Promise<void>;
+    dispose(): void;
+    findModule(id: string): ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping];
+    findIO(moduleId: string, ioName: string, type: "input" | "output"): Base;
+    findMidiDevice(id: string): MidiDevice | ComputerKeyboardInput | undefined;
+    onPropsUpdate(callback: <T extends ModuleType>(params: IModule<T>) => void): void;
+    _triggerPropsUpdate<T extends ModuleType>(params: IModule<T>): void;
+    triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
+    private onStart;
+    private onStop;
+}
+
+export { type ArrayProp, type BooleanProp, Engine, type EnumProp, type ICreateModule, type ICreateRoute, type IGain, type IIOSerialize, type IMaster, type IMidiDevice, type IModule, type IModuleSerialize, type INote, type IOscillator, type IPolyModuleSerialize, type IRoute, type ISequence, type IStepSequencer, type IStepSequencerProps, type IUpdateModule, MidiDevice, MidiPortState, type ModuleParams, ModuleType, type ModuleTypeToPropsMapping, Note, type NumberProp, OscillatorWave, type PropDefinition, type PropSchema, type StringProp, TransportState, moduleSchemas };