@blibliki/engine 0.1.27 → 0.3.1

package/dist/src/Engine.d.ts

@@ -1,83 +0,0 @@
-import { AnyObject, Optional } from './types';
-import { RouteInterface } from './routes';
-import { AudioModule } from './core/Module';
-import { MidiDeviceManager } from './core/midi';
-
-type LatencyHint = "interactive" | "playback" | "balanced";
-interface ContextInterface {
-    latencyHint: LatencyHint;
-    lookAhead: number;
-}
-interface InitializeInterface {
-    context?: Partial<ContextInterface>;
-}
-export interface UpdateModuleProps {
-    id: string;
-    changes: {
-        name?: string;
-        numberOfVoices?: number;
-        props?: AnyObject;
-    };
-}
-declare class Engine {
-    midiDeviceManager: MidiDeviceManager;
-    private static instance;
-    private context;
-    private propsUpdateCallbacks;
-    private _isStarted;
-    modules: {
-        [Identifier: string]: AudioModule;
-    };
-    routes: {
-        [Identifier: string]: RouteInterface;
-    };
-    private constructor();
-    static getInstance(): Engine;
-    initialize(props: InitializeInterface): Promise<unknown>;
-    addModule(params: {
-        id?: string;
-        name: string;
-        numberOfVoices?: number;
-        type: string;
-        props?: AnyObject;
-    }): {
-        id: string;
-        name: string;
-        type: string;
-        props: any;
-        inputs: import('.').IOProps[];
-        outputs: import('.').IOProps[];
-    };
-    removeModule(id: string): string[];
-    updateModule(params: UpdateModuleProps): {
-        id: string;
-        name: string;
-        type: string;
-        props: any;
-        inputs: import('.').IOProps[];
-        outputs: import('.').IOProps[];
-    };
-    onPropsUpdate(callback: (id: string, props: AnyObject) => void): void;
-    _triggerPropsUpdate(id: string, props: AnyObject): void;
-    addRoute(props: Optional<RouteInterface, "id">): {
-        id: string;
-        sourceId: string;
-        sourceIOId: string;
-        destinationId: string;
-        destinationIOId: string;
-    };
-    validRoute(props: Optional<RouteInterface, "id">): boolean;
-    removeRoute(id: string): void;
-    triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
-    dispose(): void;
-    findById(id: string): AudioModule;
-    get isStarted(): boolean;
-    start(): void;
-    stop(): void;
-    get bpm(): number;
-    set bpm(value: number);
-    updateRoutes(): void;
-    private moduleRouteIds;
-}
-declare const _default: Engine;
-export default _default;

package/dist/src/core/IO/AudioNode.d.ts

@@ -1,36 +0,0 @@
-import { AnyAudioInput, AnyAudioOuput } from '.';
-import { AnyObject } from '../../types';
-import { default as MonoModule, Connectable } from '../Module/index';
-import { default as IONode, IOType, IIONode } from './Node';
-import { InputNode } from 'tone';
-
-export type AudioIO = AudioInput | AudioOutput;
-export interface IAudioInput extends IIONode {
-    ioType: IOType.AudioInput;
-    internalModule: InputNode;
-}
-export interface IAudioOutput extends IIONode {
-    ioType: IOType.AudioOutput;
-    internalModule: IInternalModule;
-}
-interface IInternalModule extends Connectable {
-}
-export declare class AudioInput extends IONode implements IAudioInput {
-    ioType: IOType.AudioInput;
-    internalModule: InputNode;
-    connections: AudioOutput[];
-    constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioInput);
-    plug(io: AnyAudioOuput, plugOther?: boolean): void;
-    unPlug(io: AnyAudioOuput, plugOther?: boolean): void;
-    unPlugAll(): void;
-}
-export declare class AudioOutput extends IONode implements IAudioOutput {
-    ioType: IOType.AudioOutput;
-    internalModule: IInternalModule;
-    connections: AudioInput[];
-    constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioOutput);
-    plug(io: AnyAudioInput, plugOther?: boolean): void;
-    unPlug(io: AnyAudioInput, plugOther?: boolean): void;
-    unPlugAll(): void;
-}
-export {};

package/dist/src/core/IO/Collection.d.ts

@@ -1,14 +0,0 @@
-import { IAnyIO } from '.';
-import { default as IO } from './Node';
-import { AudioModule } from '../Module';
-
-export default class IOCollection<AnyIO extends IO> {
-    plugableModule: AudioModule;
-    collection: AnyIO[];
-    constructor(plugableModule: AudioModule);
-    add<CurrentIO extends AnyIO>(props: IAnyIO): CurrentIO;
-    unPlugAll(): void;
-    find(id: string): AnyIO | undefined;
-    findByName(name: string): AnyIO | undefined;
-    serialize(): import('./Node').IIOSerialize[];
-}

package/dist/src/core/IO/ForwardNode/Base.d.ts

@@ -1,19 +0,0 @@
-import { AnyIO } from '..';
-import { AnyObject } from '../../../types';
-import { default as Module, Connectable, PolyModule } from '../../Module';
-import { default as IONode, IIONode } from '../Node';
-
-export default class ForwardBaseNode extends IONode {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IIONode);
-    get voices(): number;
-    get subModules(): Module<Connectable, AnyObject>[];
-    subModule(voiceNo: number): Module<Connectable, AnyObject>;
-    get subIOs(): IONode[];
-    subIO(voiceNo: number): import('..').AudioInput | import('..').MidiInput | import('..').AudioOutput | import('..').MidiOutput;
-    plug(io: AnyIO, plugOther?: boolean): void;
-    unPlug(io: AnyIO, plugOther?: boolean): void;
-    unPlugAll(): void;
-    private plugUnplug;
-    private checkNameValidity;
-}

package/dist/src/core/IO/ForwardNode/index.d.ts

@@ -1,28 +0,0 @@
-import { default as ForwardBaseNode } from './Base';
-import { AnyAudioInput, AnyAudioOuput, AnyInput, AnyOuput } from '..';
-import { AnyObject } from '../../../types';
-import { default as Module, Connectable, PolyModule } from '../../Module';
-import { IOType, IIONode } from '../Node';
-
-export interface IForwardAudioInput extends IIONode {
-    ioType: IOType.ForwardAudioInput;
-}
-export interface IForwardAudioOutput extends IIONode {
-    ioType: IOType.ForwardAudioOutput;
-}
-export declare class ForwardAudioInput extends ForwardBaseNode implements IForwardAudioInput {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    ioType: IOType.ForwardAudioInput;
-    connections: AnyAudioOuput[];
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardAudioInput);
-    plug(io: AnyOuput, plugOther?: boolean): void;
-    unPlug(io: AnyOuput, plugOther?: boolean): void;
-}
-export declare class ForwardAudioOutput extends ForwardBaseNode implements IForwardAudioOutput {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    ioType: IOType.ForwardAudioOutput;
-    connections: AnyAudioInput[];
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardAudioOutput);
-    plug(io: AnyInput, plugOther?: boolean): void;
-    unPlug(io: AnyInput, plugOther?: boolean): void;
-}

package/dist/src/core/IO/MidiNode.d.ts

@@ -1,31 +0,0 @@
-import { default as IONode, IOType, IIONode } from './Node';
-import { MidiEvent } from '../midi';
-import { AudioModule } from '../Module';
-import { AnyMidiInput, AnyMidiOuput } from '.';
-
-export interface IMidiInput extends IIONode {
-    ioType: IOType.MidiInput;
-    onMidiEvent: (event: MidiEvent) => void;
-}
-export interface IMidiOutput extends IIONode {
-    ioType: IOType.MidiOutput;
-}
-export declare class MidiInput extends IONode implements IMidiInput {
-    ioType: IOType.MidiInput;
-    connections: MidiOutput[];
-    onMidiEvent: (event: MidiEvent) => void;
-    constructor(plugableModule: AudioModule, props: IMidiInput);
-    plug(io: AnyMidiOuput, plugOther?: boolean): void;
-    unPlug(io: AnyMidiOuput, plugOther?: boolean): void;
-    unPlugAll(): void;
-}
-export declare class MidiOutput extends IONode implements IMidiOutput {
-    ioType: IOType.MidiOutput;
-    connections: MidiInput[];
-    constructor(plugableModule: AudioModule, props: IIONode);
-    plug(io: AnyMidiInput, plugOther?: boolean): void;
-    unPlug(io: AnyMidiInput, plugOther?: boolean): void;
-    unPlugAll(): void;
-    onMidiEvent: (event: MidiEvent) => void;
-    private get midiConnections();
-}

package/dist/src/core/IO/Node.d.ts

@@ -1,41 +0,0 @@
-import { AnyIO } from '.';
-import { AudioModule } from '../Module';
-
-export interface IIONode {
-    name: string;
-    ioType: IOType;
-}
-export interface IIOSerialize {
-    id: string;
-    name: string;
-    ioType: IOType;
-    moduleId: string;
-    moduleName: string;
-}
-export declare enum IOType {
-    AudioInput = "audioInput",
-    AudioOutput = "audioOutput",
-    MidiInput = "midiInput",
-    MidiOutput = "midiOutput",
-    ForwardAudioInput = "forwardAudioInput",
-    ForwardAudioOutput = "forwardAudioOutput"
-}
-export declare function plugCompatibleIO(io1: AnyIO, io2: AnyIO): void;
-export declare function unPlugCompatibleIO(io1: AnyIO, io2: AnyIO): void;
-export default abstract class IONode implements IIONode {
-    id: string;
-    ioType: IOType;
-    name: string;
-    plugableModule: AudioModule;
-    connections: IONode[];
-    static unPlugAll(io: IONode): void;
-    constructor(plugableModule: AudioModule, props: IIONode);
-    plug(io: IONode, plugOther?: boolean): void;
-    unPlug(io: IONode, plugOther?: boolean): void;
-    get isInput(): boolean;
-    get isOutput(): boolean;
-    get isAudio(): boolean;
-    get isMidi(): boolean;
-    abstract unPlugAll(): void;
-    serialize(): IIOSerialize;
-}

package/dist/src/core/IO/index.d.ts

@@ -1,22 +0,0 @@
-import { ForwardAudioInput, ForwardAudioOutput, IForwardAudioInput, IForwardAudioOutput } from './ForwardNode';
-import { IMidiInput, IMidiOutput, MidiInput, MidiOutput } from './MidiNode';
-import { AudioInput, AudioOutput, IAudioInput, IAudioOutput } from './AudioNode';
-import { IIONode, IOType, IIOSerialize } from './Node';
-import { default as IOCollection } from './Collection';
-
-type AnyAudioInput = AudioInput | ForwardAudioInput;
-type AnyMidiInput = MidiInput;
-type AnyAudioOuput = AudioOutput | ForwardAudioOutput;
-type AnyMidiOuput = MidiOutput;
-type AnyInput = AnyAudioInput | AnyMidiInput;
-type AnyOuput = AnyAudioOuput | AnyMidiOuput;
-type AnyIO = AnyInput | AnyOuput;
-type IAnyAudioInput = IAudioInput | IForwardAudioInput;
-type IAnyMidiInput = IMidiInput;
-type IAnyAudioOuput = IAudioOutput | IForwardAudioOutput;
-type IAnyMidiOuput = IMidiOutput;
-type IAnyInput = IAnyAudioInput | IAnyMidiInput;
-type IAnyOutput = IAnyAudioOuput | IAnyMidiOuput;
-type IAnyIO = IAnyInput | IAnyOutput;
-export { IOCollection, IOType, AudioInput, AudioOutput, MidiInput, MidiOutput, ForwardAudioInput, ForwardAudioOutput, };
-export type { IAnyIO, IIONode, IAudioInput, IAudioOutput, IMidiInput, IMidiOutput, IForwardAudioInput, IForwardAudioOutput, IAnyInput, IAnyOutput, IIOSerialize, AnyAudioInput, AnyMidiInput, AnyAudioOuput, AnyMidiOuput, AnyInput, AnyOuput, AnyIO, };

package/dist/src/core/Module/MonoModule.d.ts

@@ -1,68 +0,0 @@
-import { AtLeast } from '../../types';
-import { default as Note } from '../../core/Note';
-import { AudioModule } from './index';
-import { MidiEvent } from '../../core/midi';
-import { IOCollection, AudioInput, AudioOutput, MidiInput, IMidiInput, IAudioInput, IAudioOutput, MidiOutput, IMidiOutput } from '../IO';
-import { InputNode } from 'tone';
-
-export interface Startable {
-    start(time: number): void;
-    stop(time: number): void;
-}
-export interface Connectable {
-    connect: (inputNode: InputNode) => void;
-    disconnect: (inputNode?: InputNode) => void;
-    dispose: () => void;
-}
-export interface Triggerable {
-    triggerAttack: (note: Note, triggeredAt: number) => void;
-    triggerRelease: (note: Note, triggeredAt: number) => void;
-}
-export interface ModuleInterface<PropsInterface> {
-    id: string;
-    name: string;
-    props: PropsInterface;
-    voiceNo?: number;
-}
-export declare class DummnyInternalModule implements Connectable {
-    connect(): void;
-    disconnect(): void;
-    dispose(): void;
-}
-declare abstract class Module<InternalModule extends Connectable, PropsInterface> implements ModuleInterface<PropsInterface> {
-    static readonly moduleName: string;
-    readonly id: string;
-    name: string;
-    internalModule: InternalModule;
-    inputs: IOCollection<AudioInput | MidiInput>;
-    outputs: IOCollection<AudioOutput | MidiOutput>;
-    readonly voiceNo?: number;
-    updatedAt: Date;
-    _props: PropsInterface;
-    constructor(internalModule: InternalModule, props: AtLeast<ModuleInterface<PropsInterface>, "name">);
-    set props(value: PropsInterface);
-    get props(): PropsInterface;
-    plug(audioModule: AudioModule, from: string, to: string): void;
-    unPlugAll(): void;
-    dispose(): void;
-    triggerAttack: (note: Note, triggeredAt: number) => void;
-    triggerRelease: (note: Note, triggeredAt: number) => void;
-    onMidiEvent: (midiEvent: MidiEvent) => void;
-    private triggerer;
-    serialize(): {
-        id: string;
-        name: string;
-        type: string;
-        props: PropsInterface;
-        inputs: import('../IO').IIOSerialize[];
-        outputs: import('../IO').IIOSerialize[];
-    };
-    protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput;
-    protected registerAudioInput(props: Omit<IAudioInput, "ioType">): AudioInput;
-    protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput;
-    protected registerAudioOutput(props: Omit<IAudioOutput, "ioType">): AudioOutput;
-    protected registerBasicOutputs(): void;
-    protected registerBasicInputs(): void;
-    protected registerDefaultMidiInput(): void;
-}
-export default Module;

package/dist/src/core/Module/PolyModule.d.ts

@@ -1,62 +0,0 @@
-import { ForwardAudioOutput, IForwardAudioInput, IForwardAudioOutput } from '../IO/ForwardNode';
-import { AudioModule } from './index';
-import { IOCollection, IMidiInput, IMidiOutput, MidiOutput, MidiInput, AnyInput, AnyOuput, ForwardAudioInput } from '../IO';
-import { default as Module, Connectable } from './MonoModule';
-import { MidiEvent } from '../midi';
-
-interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
-    id?: string;
-    name: string;
-    numberOfVoices?: number;
-    child: new (params: {
-        id?: string;
-        name: string;
-        props: PropsInterface;
-    }) => MonoAudioModule;
-    props: PropsInterface;
-}
-export default abstract class PolyModule<MonoAudioModule extends Module<Connectable, PropsInterface>, PropsInterface> {
-    static readonly moduleName: string;
-    readonly id: string;
-    readonly child: new (params: {
-        id?: string;
-        name: string;
-        props: PropsInterface;
-    }) => MonoAudioModule;
-    _name: string;
-    audioModules: MonoAudioModule[];
-    inputs: IOCollection<AnyInput>;
-    outputs: IOCollection<AnyOuput>;
-    private _numberOfVoices;
-    constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>);
-    get name(): string;
-    set name(value: string);
-    get props(): PropsInterface;
-    set props(value: PropsInterface);
-    get numberOfVoices(): number;
-    set numberOfVoices(value: number);
-    plug(audioModule: AudioModule, from: string, to: string): void;
-    unPlugAll(): void;
-    dispose(): void;
-    onMidiEvent: (midiEvent: MidiEvent) => void;
-    serialize(): {
-        id: string;
-        type: string;
-        numberOfVoices: number;
-        inputs: import('../IO').IIOSerialize[];
-        outputs: import('../IO').IIOSerialize[];
-        name: string;
-        props: PropsInterface;
-    };
-    protected find(callback: (audioModule: MonoAudioModule) => boolean): MonoAudioModule;
-    protected findVoice(voiceNo: number): MonoAudioModule | undefined;
-    protected registerForwardAudioInput(props: Omit<IForwardAudioInput, "ioType">): ForwardAudioInput;
-    protected registerForwardAudioOutput(props: Omit<IForwardAudioOutput, "ioType">): ForwardAudioOutput;
-    protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput;
-    protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput;
-    protected registerBasicOutputs(): void;
-    protected registerBasicInputs(): void;
-    protected registerMidiIn(): void;
-    private adjustNumberOfModules;
-}
-export {};

package/dist/src/core/Module/index.d.ts

@@ -1,7 +0,0 @@
-import { default as PolyModule } from './PolyModule';
-import { default as Module, Connectable } from './MonoModule';
-
-export { default, DummnyInternalModule } from './MonoModule';
-export { default as PolyModule } from './PolyModule';
-export type { ModuleInterface, Connectable, Triggerable, Startable, } from './MonoModule';
-export type AudioModule = Module<Connectable, any> | PolyModule<Module<Connectable, any>, any>;

package/dist/src/core/Note/frequencyTable.d.ts

@@ -1,4 +0,0 @@
-declare const frequencyTable: {
-    [key: string]: number;
-};
-export default frequencyTable;

package/dist/src/core/Note/index.d.ts

@@ -1,28 +0,0 @@
-export interface INote {
-    note: string;
-    frequency: number;
-    duration: string;
-    velocity?: number;
-}
-export default class Note {
-    static _notes: Note[];
-    name: string;
-    octave: number;
-    velocity: number;
-    duration: string;
-    frequency: number;
-    constructor(eventOrString: Partial<INote> | MIDIMessageEvent | string | number);
-    static notes(octave?: number): Note[];
-    get isSemi(): boolean;
-    get fullName(): string;
-    midiData(noteOn?: boolean): Uint8Array;
-    get midiNumber(): number;
-    get noteIndex(): number;
-    adjustFrequency(range?: number, coarse?: number): number;
-    valueOf(): string;
-    serialize(): INote;
-    private fromFrequency;
-    private fromString;
-    private fromEvent;
-    private fromProps;
-}

package/dist/src/core/midi/ComputerKeyboardInput.d.ts

@@ -1,12 +0,0 @@
-import { default as MidiEvent } from './MidiEvent';
-import { IMidiInput, TMidiPortState } from './MidiDevice';
-
-export default class ComputerKeyboardInput implements IMidiInput {
-    id: string;
-    name: string;
-    state: TMidiPortState;
-    onmidimessage: ((e: MidiEvent) => void) | null;
-    constructor();
-    onKeyTrigger: (noteOn: boolean) => (event: KeyboardEvent) => void;
-    private extractNote;
-}

package/dist/src/core/midi/MidiDevice.d.ts

@@ -1,30 +0,0 @@
-import { default as MidiEvent } from './MidiEvent';
-
-export type TMidiPortState = "connected" | "disconnected";
-export interface MidiDeviceInterface {
-    id: string;
-    name: string;
-    state: TMidiPortState;
-}
-export interface IMidiInput extends MidiDeviceInterface {
-    onmidimessage: ((e: MidiEvent) => void) | null;
-}
-export type EventListerCallback = (event: MidiEvent) => void;
-export default class MidiDevice implements MidiDeviceInterface {
-    id: string;
-    name: string;
-    state: TMidiPortState;
-    eventListerCallbacks: EventListerCallback[];
-    private _midi;
-    constructor(midi: IMidiInput);
-    connect(): void;
-    disconnect(): void;
-    serialize(): {
-        id: string;
-        name: string;
-        state: TMidiPortState;
-    };
-    addEventListener(callback: EventListerCallback): void;
-    removeEventListener(callback: EventListerCallback): void;
-    private processEvent;
-}

package/dist/src/core/midi/MidiDeviceManager.d.ts

@@ -1,15 +0,0 @@
-import { default as MidiDevice } from './MidiDevice';
-
-export default class MidiDeviceManager {
-    devices: {
-        [Key: string]: MidiDevice;
-    };
-    private initialized;
-    private computerKeyboardInput;
-    constructor();
-    find(id: string): MidiDevice | null;
-    onStateChange(callback: (device: MidiDevice) => void): void;
-    private listenChanges;
-    private initializeDevices;
-    private inputs;
-}

package/dist/src/core/midi/MidiEvent.d.ts

@@ -1,22 +0,0 @@
-import { default as Note, INote } from '../Note';
-import { ISequence } from '../../modules';
-
-export type MidiEventType = "noteOn" | "noteOff" | "cc";
-export default class MidiEvent {
-    note: Note;
-    voiceNo?: number;
-    readonly triggeredAt: number;
-    _type: MidiEventType;
-    private data;
-    private event;
-    static fromSequence(sequence: ISequence, triggeredAt: number): MidiEvent[];
-    static fromNote(noteName: string | Note | INote, noteOn?: boolean, triggeredAt?: number): MidiEvent;
-    static fromCC(cc: number, value: number, triggeredAt?: number): MidiEvent;
-    constructor(event: MIDIMessageEvent, triggeredAt?: number);
-    get statusByte(): number;
-    get firstData(): number;
-    get secondData(): number;
-    get type(): MidiEventType;
-    get isNote(): boolean;
-    defineNotes(): void;
-}

package/dist/src/core/midi/index.d.ts

@@ -1,5 +0,0 @@
-export { default as MidiEvent } from './MidiEvent';
-export { default as MidiDevice } from './MidiDevice';
-export { default as MidiDeviceManager } from './MidiDeviceManager';
-export type { MidiDeviceInterface } from './MidiDevice';
-export type { MidiEventType } from './MidiEvent';

package/dist/src/index.d.ts

@@ -1,9 +0,0 @@
-export { default } from './Engine';
-export { MidiDevice, MidiDeviceManager } from './core/midi';
-export { default as Note } from './core/Note';
-export type { MidiDeviceInterface } from './core/midi';
-export type { INote } from './core/Note';
-export type { ModuleInterface, AudioModule } from './core/Module';
-export type { ISequence } from './modules';
-export type { RouteInterface, RouteProps } from './routes';
-export type { IIOSerialize as IOProps } from './core/IO';

package/dist/src/modules/BitCrusher.d.ts

@@ -1,17 +0,0 @@
-import { default as Effect, EffectInterface } from './Effect';
-import { BitCrusher as InternalBitCrasher } from 'tone';
-
-interface BitCrusherInterface extends EffectInterface {
-    bits: number;
-}
-export default class BitCrusher extends Effect<InternalBitCrasher, BitCrusherInterface> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<BitCrusherInterface>;
-    });
-    get bits(): number;
-    set bits(value: number);
-}
-export {};

package/dist/src/modules/Delay.d.ts

@@ -1,20 +0,0 @@
-import { default as Effect, EffectInterface } from './Effect';
-import { FeedbackDelay } from 'tone';
-
-interface DelayInterface extends EffectInterface {
-    delayTime: number;
-    feedback: number;
-}
-export default class Delay extends Effect<FeedbackDelay, DelayInterface> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<DelayInterface>;
-    });
-    get delayTime(): number;
-    set delayTime(value: number);
-    get feedback(): number;
-    set feedback(value: number);
-}
-export {};

package/dist/src/modules/Distortion.d.ts

@@ -1,17 +0,0 @@
-import { default as Effect, EffectInterface } from './Effect';
-import { Distortion as InternalDistortion } from 'tone';
-
-interface DistortionInterface extends EffectInterface {
-    drive: number;
-}
-export default class Distortion extends Effect<InternalDistortion, DistortionInterface> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<DistortionInterface>;
-    });
-    get drive(): number;
-    set drive(value: number);
-}
-export {};

package/dist/src/modules/Effect.d.ts

@@ -1,20 +0,0 @@
-import { default as Module, Connectable } from '../core/Module';
-import { Signal } from 'tone';
-
-interface EffectLike extends Connectable {
-    wet: Signal<"normalRange">;
-}
-export interface EffectInterface {
-    wet: number;
-}
-export default abstract class Effect<InternalEffect extends EffectLike, ModuleInterface extends EffectInterface> extends Module<InternalEffect, ModuleInterface> {
-    constructor(params: {
-        id?: string;
-        name: string;
-        internalModule: InternalEffect;
-        props: Partial<ModuleInterface>;
-    });
-    get wet(): number;
-    set wet(value: number);
-}
-export {};

package/dist/src/modules/Envelope/AmpEnvelope.d.ts

@@ -1,19 +0,0 @@
-import { default as Base, EnvelopeInterface, PolyBase } from './Base';
-import { AmplitudeEnvelope } from 'tone';
-
-declare class MonoAmpEnvelope extends Base<AmplitudeEnvelope> {
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: EnvelopeInterface;
-    });
-}
-export default class AmpEnvelope extends PolyBase<MonoAmpEnvelope> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<EnvelopeInterface>;
-    });
-}
-export {};