@blibliki/engine 0.1.26 → 0.3.1

package/dist/build/core/IO/ForwardNode.d.ts

@@ -1,38 +0,0 @@
-import IONode, { IOType, IIONode } from "./Node";
-import Module, { Connectable, PolyModule } from "../Module";
-import { AnyObject } from "../../types";
-import { AnyInput, AnyOuput } from ".";
-export interface IForwardInput extends IIONode {
-    ioType: IOType.ForwardInput;
-}
-export interface IForwardOutput extends IIONode {
-    ioType: IOType.ForwardOutput;
-}
-export declare class ForwardInput extends IONode implements IForwardInput {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    ioType: IOType.ForwardInput;
-    connections: ForwardOutput[];
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardInput);
-    get subInputs(): (import("./AudioNode").AudioInput | import("./MidiNode").MidiInput)[];
-    get subModules(): Module<Connectable, AnyObject>[];
-    subModule(voiceNo: number): Module<Connectable, AnyObject>;
-    subInput(voiceNo: number): import("./AudioNode").AudioInput | import("./MidiNode").MidiInput;
-    plug(io: AnyOuput, plugOther?: boolean): void;
-    unPlug(io: AnyOuput, plugOther?: boolean): void;
-    unPlugAll(): void;
-    private checkNameValidity;
-}
-export declare class ForwardOutput extends IONode implements IForwardOutput {
-    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
-    ioType: IOType.ForwardOutput;
-    connections: ForwardInput[];
-    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardOutput);
-    get subOutputs(): (import("./AudioNode").AudioOutput | import("./MidiNode").MidiOutput)[];
-    get subModules(): Module<Connectable, AnyObject>[];
-    subModule(voiceNo: number): Module<Connectable, AnyObject>;
-    subOutput(voiceNo: number): import("./AudioNode").AudioOutput | import("./MidiNode").MidiOutput;
-    plug(io: AnyInput, plugOther?: boolean): void;
-    unPlug(io: AnyInput, plugOther?: boolean): void;
-    unPlugAll(): void;
-    private checkNameValidity;
-}

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

@@ -1,30 +0,0 @@
-import { AnyMidiInput, AnyMidiOuput } from ".";
-import { AudioModule } from "../Module";
-import { MidiEvent } from "../midi";
-import IONode, { IOType, IIONode } from "./Node";
-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/build/core/IO/Node.d.ts

@@ -1,40 +0,0 @@
-import { AudioModule } from "../Module";
-import { AnyIO } from ".";
-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/build/core/IO/index.d.ts

@@ -1,21 +0,0 @@
-import { default as IOCollection } from "./Collection";
-import { IIONode, IOType, IIOSerialize } from "./Node";
-import { AudioInput, AudioOutput, IAudioInput, IAudioOutput } from "./AudioNode";
-import { IMidiInput, IMidiOutput, MidiInput, MidiOutput } from "./MidiNode";
-import { ForwardAudioInput, ForwardAudioOutput, IForwardAudioInput, IForwardAudioOutput } from "./ForwardNode";
-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/build/core/Module/MonoModule.d.ts

@@ -1,67 +0,0 @@
-import { InputNode } from "tone";
-import { IOCollection, AudioInput, AudioOutput, MidiInput, IMidiInput, IAudioInput, IAudioOutput, MidiOutput, IMidiOutput } from "../IO";
-import { MidiEvent } from "../../core/midi";
-import { AudioModule } from "./index";
-import Note from "../../core/Note";
-import { AtLeast } from "../../types";
-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/build/core/Module/PolyModule.d.ts

@@ -1,61 +0,0 @@
-import { MidiEvent } from "../midi";
-import Module, { Connectable } from "./MonoModule";
-import { IOCollection, IMidiInput, IMidiOutput, MidiOutput, MidiInput, AnyInput, AnyOuput, ForwardAudioInput } from "../IO";
-import { AudioModule } from "./index";
-import { ForwardAudioOutput, IForwardAudioInput, IForwardAudioOutput } from "../IO/ForwardNode";
-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/build/core/Module/index.d.ts

@@ -1,6 +0,0 @@
-import Module, { Connectable } from "./MonoModule";
-import PolyModule from "./PolyModule";
-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/build/core/Note/frequencyTable.d.ts

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

package/dist/build/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/build/core/midi/ComputerKeyboardInput.d.ts

@@ -1,11 +0,0 @@
-import { IMidiInput, TMidiPortState } from "./MidiDevice";
-import MidiEvent from "./MidiEvent";
-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/build/core/midi/MidiDevice.d.ts

@@ -1,29 +0,0 @@
-import 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/build/core/midi/MidiDeviceManager.d.ts

@@ -1,14 +0,0 @@
-import 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/build/core/midi/MidiEvent.d.ts

@@ -1,21 +0,0 @@
-import { ISequence } from "../../modules";
-import Note, { INote } from "../Note";
-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/build/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/build/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/build/modules/BitCrusher.d.ts

@@ -1,16 +0,0 @@
-import { BitCrusher as InternalBitCrasher } from "tone";
-import Effect, { EffectInterface } from "./Effect";
-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/build/modules/Delay.d.ts

@@ -1,19 +0,0 @@
-import { FeedbackDelay } from "tone";
-import Effect, { EffectInterface } from "./Effect";
-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/build/modules/Distortion.d.ts

@@ -1,16 +0,0 @@
-import { Distortion as InternalDistortion } from "tone";
-import Effect, { EffectInterface } from "./Effect";
-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/build/modules/Effect.d.ts

@@ -1,19 +0,0 @@
-import { Signal } from "tone";
-import Module, { Connectable } from "../core/Module";
-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/build/modules/Envelope/AmpEnvelope.d.ts

@@ -1,18 +0,0 @@
-import { AmplitudeEnvelope } from "tone";
-import Base, { EnvelopeInterface, PolyBase } from "./Base";
-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 {};

package/dist/build/modules/Envelope/Base.d.ts

@@ -1,66 +0,0 @@
-import { Envelope as Env } from "tone";
-import Module, { PolyModule, Connectable, Triggerable } from "../../core/Module";
-import Note from "../../core/Note";
-export declare const enum EnvelopeStages {
-    Attack = "attack",
-    Decay = "decay",
-    Sustain = "sustain",
-    Release = "release"
-}
-export interface EnvelopeInterface {
-    attack: number;
-    decay: number;
-    sustain: number;
-    release: number;
-}
-export default abstract class EnvelopeModule<EnvelopeLike extends Env> extends Module<EnvelopeLike, EnvelopeInterface> implements Triggerable {
-    activeNote?: string;
-    triggeredAt: number;
-    constructor(params: {
-        id?: string;
-        name: string;
-        internalModule: EnvelopeLike;
-        props: EnvelopeInterface;
-    });
-    get attack(): number;
-    set attack(value: number);
-    get decay(): number;
-    set decay(value: number);
-    get sustain(): number;
-    set sustain(value: number);
-    get release(): number;
-    set release(value: number);
-    setStage(stage: EnvelopeStages, value: number): void;
-    triggerAttack: (note: Note, triggeredAt: number) => void;
-    triggerRelease: (note: Note, triggeredAt: number) => void;
-    private maxTime;
-    private minTime;
-}
-export declare abstract class PolyBase<EnvelopeModule extends Module<Connectable, EnvelopeInterface>> extends PolyModule<EnvelopeModule, EnvelopeInterface> {
-    constructor(params: {
-        id?: string;
-        name: string;
-        child: new (params: {
-            id?: string;
-            name: string;
-            props: EnvelopeInterface;
-        }) => EnvelopeModule;
-        props: Partial<EnvelopeInterface>;
-    });
-}
-declare class MonoEnvelope extends EnvelopeModule<Env> {
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: EnvelopeInterface;
-    });
-}
-export declare class Envelope extends PolyBase<MonoEnvelope> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<EnvelopeInterface>;
-    });
-}
-export {};

package/dist/build/modules/Envelope/FreqEnvelope.d.ts

@@ -1,25 +0,0 @@
-import { FrequencyEnvelope } from "tone";
-import Filter from "../Filter";
-import Base, { EnvelopeInterface, PolyBase } from "./Base";
-export declare class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
-    private _frequency;
-    private _amount;
-    filter: Filter;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: EnvelopeInterface;
-    });
-    get frequency(): number;
-    set frequency(value: number);
-    get amount(): number;
-    set amount(value: number);
-}
-export default class FreqEnvelope extends PolyBase<MonoFreqEnvelope> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<EnvelopeInterface>;
-    });
-}

package/dist/build/modules/Envelope/index.d.ts

@@ -1,3 +0,0 @@
-export { default, Envelope, EnvelopeStages } from "./Base";
-export { default as AmpEnvelope } from "./AmpEnvelope";
-export { default as FreqEnvelope, MonoFreqEnvelope } from "./FreqEnvelope";

package/dist/build/modules/Filter.d.ts

@@ -1,42 +0,0 @@
-import { Filter as InternalFilter, FilterRollOff } from "tone";
-import Module, { PolyModule } from "../core/Module";
-interface FilterInterface {
-    cutoff: number;
-    filterType: BiquadFilterType;
-    resonance: number;
-    slope: FilterRollOff;
-    envelopeAmount: number;
-}
-type FilterProps = Partial<FilterInterface>;
-declare class MonoFilter extends Module<InternalFilter, FilterInterface> {
-    private _cutoff;
-    private _amount;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: FilterProps;
-    });
-    get cutoff(): number;
-    set cutoff(value: number);
-    get filterType(): BiquadFilterType;
-    set filterType(value: BiquadFilterType);
-    get slope(): FilterRollOff;
-    set slope(value: FilterRollOff);
-    get frequency(): import("tone").Signal<"frequency">;
-    get resonance(): number;
-    set resonance(value: number);
-    get envelopeAmount(): number;
-    set envelopeAmount(value: number);
-    private registerOutputs;
-    private updateAmountFactor;
-}
-export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<FilterInterface>;
-    });
-    private registerOutputs;
-}
-export {};