@blibliki/engine 0.1.25 → 0.1.27

package/dist/{build → src}/Engine.d.ts

@@ -1,7 +1,8 @@
-import { MidiDeviceManager } from "./core/midi";
-import { AudioModule } from "./core/Module";
-import { RouteInterface } from "./routes";
-import { AnyObject, Optional } from "./types";
+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;
@@ -44,8 +45,8 @@ declare class Engine {
         name: string;
         type: string;
         props: any;
-        inputs: import(".").IOProps[];
-        outputs: import(".").IOProps[];
+        inputs: import('.').IOProps[];
+        outputs: import('.').IOProps[];
     };
     removeModule(id: string): string[];
     updateModule(params: UpdateModuleProps): {
@@ -53,8 +54,8 @@ declare class Engine {
         name: string;
         type: string;
         props: any;
-        inputs: import(".").IOProps[];
-        outputs: import(".").IOProps[];
+        inputs: import('.').IOProps[];
+        outputs: import('.').IOProps[];
     };
     onPropsUpdate(callback: (id: string, props: AnyObject) => void): void;
     _triggerPropsUpdate(id: string, props: AnyObject): void;
@@ -65,6 +66,7 @@ declare class Engine {
         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;

package/dist/{build → src}/core/IO/AudioNode.d.ts

@@ -1,8 +1,9 @@
-import { InputNode } from "tone";
-import IONode, { IOType, IIONode } from "./Node";
-import MonoModule, { Connectable } from "../Module/index";
-import { AnyObject } from "../../types";
-import { ForwardInput, ForwardOutput } from "./ForwardNode";
+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;
@@ -19,8 +20,8 @@ export declare class AudioInput extends IONode implements IAudioInput {
     internalModule: InputNode;
     connections: AudioOutput[];
     constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioInput);
-    plug(io: AudioOutput | ForwardOutput, plugOther?: boolean): void;
-    unPlug(io: AudioOutput | ForwardOutput, plugOther?: boolean): void;
+    plug(io: AnyAudioOuput, plugOther?: boolean): void;
+    unPlug(io: AnyAudioOuput, plugOther?: boolean): void;
     unPlugAll(): void;
 }
 export declare class AudioOutput extends IONode implements IAudioOutput {
@@ -28,8 +29,8 @@ export declare class AudioOutput extends IONode implements IAudioOutput {
     internalModule: IInternalModule;
     connections: AudioInput[];
     constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioOutput);
-    plug(io: AudioInput | ForwardInput, plugOther?: boolean): void;
-    unPlug(io: AudioInput | ForwardInput, plugOther?: boolean): void;
+    plug(io: AnyAudioInput, plugOther?: boolean): void;
+    unPlug(io: AnyAudioInput, plugOther?: boolean): void;
     unPlugAll(): void;
 }
 export {};

package/dist/{build → src}/core/IO/Collection.d.ts

@@ -1,6 +1,7 @@
-import { AudioModule } from "../Module";
-import IO from "./Node";
-import { IAnyIO } from ".";
+import { IAnyIO } from '.';
+import { default as IO } from './Node';
+import { AudioModule } from '../Module';
+
 export default class IOCollection<AnyIO extends IO> {
     plugableModule: AudioModule;
     collection: AnyIO[];
@@ -9,5 +10,5 @@ export default class IOCollection<AnyIO extends IO> {
     unPlugAll(): void;
     find(id: string): AnyIO | undefined;
     findByName(name: string): AnyIO | undefined;
-    serialize(): import("./Node").IIOSerialize[];
+    serialize(): import('./Node').IIOSerialize[];
 }

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,28 @@
+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/{build → src}/core/IO/MidiNode.d.ts

@@ -1,7 +1,8 @@
-import { AudioModule } from "../Module";
-import { MidiEvent } from "../midi";
-import { ForwardInput, ForwardOutput } from "./ForwardNode";
-import IONode, { IOType, IIONode } from "./Node";
+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;
@@ -14,16 +15,16 @@ export declare class MidiInput extends IONode implements IMidiInput {
     connections: MidiOutput[];
     onMidiEvent: (event: MidiEvent) => void;
     constructor(plugableModule: AudioModule, props: IMidiInput);
-    plug(io: MidiOutput | ForwardOutput, plugOther?: boolean): void;
-    unPlug(io: MidiOutput | ForwardOutput, plugOther?: boolean): void;
+    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: MidiInput | ForwardInput, plugOther?: boolean): void;
-    unPlug(io: MidiInput | ForwardOutput, plugOther?: boolean): void;
+    plug(io: AnyMidiInput, plugOther?: boolean): void;
+    unPlug(io: AnyMidiInput, plugOther?: boolean): void;
     unPlugAll(): void;
     onMidiEvent: (event: MidiEvent) => void;
     private get midiConnections();

package/dist/{build → src}/core/IO/Node.d.ts

@@ -1,5 +1,6 @@
-import { AudioModule } from "../Module";
-import { AnyInput, AnyOuput } from ".";
+import { AnyIO } from '.';
+import { AudioModule } from '../Module';
+
 export interface IIONode {
     name: string;
     ioType: IOType;
@@ -16,11 +17,11 @@ export declare enum IOType {
     AudioOutput = "audioOutput",
     MidiInput = "midiInput",
     MidiOutput = "midiOutput",
-    ForwardInput = "forwardInput",
-    ForwardOutput = "forwardOutput"
+    ForwardAudioInput = "forwardAudioInput",
+    ForwardAudioOutput = "forwardAudioOutput"
 }
-export declare function plugCompatibleIO(input: AnyInput, output: AnyOuput): void;
-export declare function unPlugCompatibleIO(input: AnyInput, output: AnyOuput): void;
+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;
@@ -31,6 +32,10 @@ export default abstract class IONode implements IIONode {
     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

@@ -0,0 +1,22 @@
+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/{build → src}/core/Module/MonoModule.d.ts

@@ -1,9 +1,10 @@
-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";
+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;
@@ -53,8 +54,8 @@ declare abstract class Module<InternalModule extends Connectable, PropsInterface
         name: string;
         type: string;
         props: PropsInterface;
-        inputs: import("../IO").IIOSerialize[];
-        outputs: import("../IO").IIOSerialize[];
+        inputs: import('../IO').IIOSerialize[];
+        outputs: import('../IO').IIOSerialize[];
     };
     protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput;
     protected registerAudioInput(props: Omit<IAudioInput, "ioType">): AudioInput;

package/dist/{build → src}/core/Module/PolyModule.d.ts

@@ -1,7 +1,9 @@
-import { MidiEvent } from "../midi";
-import Module, { Connectable } from "./MonoModule";
-import { IOCollection, ForwardInput, ForwardOutput, IMidiInput, IMidiOutput, IForwardInput, IForwardOutput, MidiOutput, MidiInput } from "../IO";
-import { AudioModule } from "./index";
+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;
@@ -23,8 +25,8 @@ export default abstract class PolyModule<MonoAudioModule extends Module<Connecta
     }) => MonoAudioModule;
     _name: string;
     audioModules: MonoAudioModule[];
-    inputs: IOCollection<ForwardInput | MidiInput>;
-    outputs: IOCollection<ForwardOutput | MidiOutput>;
+    inputs: IOCollection<AnyInput>;
+    outputs: IOCollection<AnyOuput>;
     private _numberOfVoices;
     constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>);
     get name(): string;
@@ -41,19 +43,20 @@ export default abstract class PolyModule<MonoAudioModule extends Module<Connecta
         id: string;
         type: string;
         numberOfVoices: number;
-        inputs: import("../IO").IIOSerialize[];
-        outputs: import("../IO").IIOSerialize[];
+        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 registerInput(props: Omit<IForwardInput, "ioType">): ForwardInput;
-    protected registerOutput(props: Omit<IForwardOutput, "ioType">): ForwardOutput;
+    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

@@ -0,0 +1,7 @@
+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/{build → src}/core/midi/ComputerKeyboardInput.d.ts

@@ -1,5 +1,6 @@
-import { IMidiInput, TMidiPortState } from "./MidiDevice";
-import MidiEvent from "./MidiEvent";
+import { default as MidiEvent } from './MidiEvent';
+import { IMidiInput, TMidiPortState } from './MidiDevice';
+
 export default class ComputerKeyboardInput implements IMidiInput {
     id: string;
     name: string;

package/dist/{build → src}/core/midi/MidiDevice.d.ts

@@ -1,4 +1,5 @@
-import MidiEvent from "./MidiEvent";
+import { default as MidiEvent } from './MidiEvent';
+
 export type TMidiPortState = "connected" | "disconnected";
 export interface MidiDeviceInterface {
     id: string;

package/dist/{build → src}/core/midi/MidiDeviceManager.d.ts

@@ -1,4 +1,5 @@
-import MidiDevice from "./MidiDevice";
+import { default as MidiDevice } from './MidiDevice';
+
 export default class MidiDeviceManager {
     devices: {
         [Key: string]: MidiDevice;

package/dist/{build → src}/core/midi/MidiEvent.d.ts

@@ -1,5 +1,6 @@
-import { ISequence } from "../../modules";
-import Note, { INote } from "../Note";
+import { default as Note, INote } from '../Note';
+import { ISequence } from '../../modules';
+
 export type MidiEventType = "noteOn" | "noteOff" | "cc";
 export default class MidiEvent {
     note: Note;

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,9 @@
+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 → src}/modules/BitCrusher.d.ts

@@ -1,5 +1,6 @@
-import { BitCrusher as InternalBitCrasher } from "tone";
-import Effect, { EffectInterface } from "./Effect";
+import { default as Effect, EffectInterface } from './Effect';
+import { BitCrusher as InternalBitCrasher } from 'tone';
+
 interface BitCrusherInterface extends EffectInterface {
     bits: number;
 }

package/dist/{build → src}/modules/Delay.d.ts

@@ -1,5 +1,6 @@
-import { FeedbackDelay } from "tone";
-import Effect, { EffectInterface } from "./Effect";
+import { default as Effect, EffectInterface } from './Effect';
+import { FeedbackDelay } from 'tone';
+
 interface DelayInterface extends EffectInterface {
     delayTime: number;
     feedback: number;

package/dist/{build → src}/modules/Distortion.d.ts

@@ -1,5 +1,6 @@
-import { Distortion as InternalDistortion } from "tone";
-import Effect, { EffectInterface } from "./Effect";
+import { default as Effect, EffectInterface } from './Effect';
+import { Distortion as InternalDistortion } from 'tone';
+
 interface DistortionInterface extends EffectInterface {
     drive: number;
 }

package/dist/{build → src}/modules/Effect.d.ts

@@ -1,5 +1,6 @@
-import { Signal } from "tone";
-import Module, { Connectable } from "../core/Module";
+import { default as Module, Connectable } from '../core/Module';
+import { Signal } from 'tone';
+
 interface EffectLike extends Connectable {
     wet: Signal<"normalRange">;
 }

package/dist/{build → src}/modules/Envelope/AmpEnvelope.d.ts

@@ -1,5 +1,6 @@
-import { AmplitudeEnvelope } from "tone";
-import Base, { EnvelopeInterface, PolyBase } from "./Base";
+import { default as Base, EnvelopeInterface, PolyBase } from './Base';
+import { AmplitudeEnvelope } from 'tone';
+
 declare class MonoAmpEnvelope extends Base<AmplitudeEnvelope> {
     constructor(params: {
         id?: string;

package/dist/{build → src}/modules/Envelope/Base.d.ts

@@ -1,6 +1,7 @@
-import { Envelope as Env } from "tone";
-import Module, { PolyModule, Connectable, Triggerable } from "../../core/Module";
-import Note from "../../core/Note";
+import { default as Note } from '../../core/Note';
+import { default as Module, PolyModule, Connectable, Triggerable } from '../../core/Module';
+import { Envelope as Env } from 'tone';
+
 export declare const enum EnvelopeStages {
     Attack = "attack",
     Decay = "decay",

package/dist/{build → src}/modules/Envelope/FreqEnvelope.d.ts

@@ -1,6 +1,7 @@
-import { FrequencyEnvelope } from "tone";
-import Filter from "../Filter";
-import Base, { EnvelopeInterface, PolyBase } from "./Base";
+import { default as Base, EnvelopeInterface, PolyBase } from './Base';
+import { default as Filter } from '../Filter';
+import { FrequencyEnvelope } from 'tone';
+
 export declare class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
     private _frequency;
     private _amount;

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

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

package/dist/{build → src}/modules/Filter.d.ts

@@ -1,5 +1,6 @@
-import { Filter as InternalFilter, FilterRollOff } from "tone";
-import Module, { PolyModule } from "../core/Module";
+import { default as Module, PolyModule } from '../core/Module';
+import { Filter as InternalFilter, FilterRollOff } from 'tone';
+
 interface FilterInterface {
     cutoff: number;
     filterType: BiquadFilterType;
@@ -22,7 +23,7 @@ declare class MonoFilter extends Module<InternalFilter, FilterInterface> {
     set filterType(value: BiquadFilterType);
     get slope(): FilterRollOff;
     set slope(value: FilterRollOff);
-    get frequency(): import("tone").Signal<"frequency">;
+    get frequency(): import('tone').Signal<"frequency">;
     get resonance(): number;
     set resonance(value: number);
     get envelopeAmount(): number;

package/dist/{build → src}/modules/LFO.d.ts

@@ -1,7 +1,8 @@
-import { LFO as LFOInternal } from "tone";
-import Module, { PolyModule, Startable } from "../core/Module";
-import { TWave } from "./Oscillator";
-import Note from "../core/Note";
+import { default as Note } from '../core/Note';
+import { TWave } from './Oscillator';
+import { default as Module, PolyModule, Startable } from '../core/Module';
+import { LFO as LFOInternal } from 'tone';
+
 export interface LFOInterface {
     wave: TWave;
     frequency: number;

package/dist/{build → src}/modules/Master.d.ts

@@ -1,5 +1,6 @@
-import { Destination } from "tone";
-import Module from "../core/Module";
+import { default as Module } from '../core/Module';
+import { Destination } from 'tone';
+
 export interface MasterInterface {
 }
 export default class Master extends Module<typeof Destination, MasterInterface> {

package/dist/{build → src}/modules/MidiSelector.d.ts

@@ -1,5 +1,6 @@
-import Module, { DummnyInternalModule } from "../core/Module";
-import { MidiOutput } from "../core/IO";
+import { MidiOutput } from '../core/IO';
+import { default as Module, DummnyInternalModule } from '../core/Module';
+
 export interface MidiSelectorInterface {
     selectedId: string | null;
 }

package/dist/{build → src}/modules/Oscillator.d.ts

@@ -1,6 +1,7 @@
-import { Multiply, Oscillator as Osc } from "tone";
-import Note from "../core/Note";
-import Module, { PolyModule, Startable } from "../core/Module";
+import { default as Module, PolyModule, Startable } from '../core/Module';
+import { default as Note } from '../core/Note';
+import { Oscillator as Osc, Signal } from 'tone';
+
 export type TWave = "sine" | "triangle" | "square" | "sawtooth";
 export interface OscillatorInterface {
     noteName: string;
@@ -10,8 +11,9 @@ export interface OscillatorInterface {
     volume: number;
     range: number;
 }
-declare class MonoOscillator extends Module<Osc, OscillatorInterface> implements Startable {
+export declare class MonoOscillator extends Module<Osc, OscillatorInterface> implements Startable {
     private _note;
+    private _fineMulti;
     private _fineSignal;
     constructor(params: {
         id?: string;
@@ -23,7 +25,7 @@ declare class MonoOscillator extends Module<Osc, OscillatorInterface> implements
     set note(value: Note | string);
     get noteName(): string;
     set noteName(value: string);
-    get fineSingal(): Multiply<"number">;
+    get fineSingal(): Signal<"number">;
     get fine(): number;
     set fine(value: number);
     get coarse(): number;
@@ -52,4 +54,3 @@ export default class Oscillator extends PolyModule<MonoOscillator, OscillatorInt
     start(time: number): void;
     stop(time?: number): void;
 }
-export {};

package/dist/{build → src}/modules/Reverb.d.ts

@@ -1,5 +1,6 @@
-import { Reverb as InternalReverb } from "tone";
-import Effect, { EffectInterface } from "./Effect";
+import { default as Effect, EffectInterface } from './Effect';
+import { Reverb as InternalReverb } from 'tone';
+
 interface ReverbInterface extends EffectInterface {
     decay: number;
     preDelay: number;

package/dist/{build → src}/modules/Sequencer.d.ts

@@ -1,6 +1,7 @@
-import Module, { DummnyInternalModule } from "../core/Module";
-import { INote } from "../core/Note";
-import { MidiOutput } from "../core/IO";
+import { MidiOutput } from '../core/IO';
+import { INote } from '../core/Note';
+import { default as Module, DummnyInternalModule } from '../core/Module';
+
 export interface ISequence {
     active: boolean;
     time: string;

package/dist/{build → src}/modules/VirtualMidi.d.ts

@@ -1,7 +1,8 @@
-import { MidiEvent } from "../core/midi";
-import Note from "../core/Note";
-import Module, { DummnyInternalModule } from "../core/Module";
-import { MidiOutput } from "../core/IO";
+import { MidiOutput } from '../core/IO';
+import { default as Module, DummnyInternalModule } from '../core/Module';
+import { default as Note } from '../core/Note';
+import { MidiEvent } from '../core/midi';
+
 export interface VirtualMidiInterface {
     activeNotes: string[];
 }
@@ -24,8 +25,8 @@ export default class VirtualMidi extends Module<DummnyInternalModule, VirtualMid
         name: string;
         type: string;
         props: VirtualMidiInterface;
-        inputs: import("../core/IO").IIOSerialize[];
-        outputs: import("../core/IO").IIOSerialize[];
+        inputs: import('../core/IO').IIOSerialize[];
+        outputs: import('../core/IO').IIOSerialize[];
     };
     private registerInputs;
     private registerOutputs;

package/dist/{build → src}/modules/VoiceScheduler.d.ts

@@ -1,6 +1,7 @@
-import { MidiEvent } from "../core/midi";
-import Module, { PolyModule, DummnyInternalModule } from "../core/Module";
-import { MidiOutput } from "../core/IO";
+import { MidiOutput } from '../core/IO';
+import { default as Module, PolyModule, DummnyInternalModule } from '../core/Module';
+import { MidiEvent } from '../core/midi';
+
 export interface VoiceSchedulerInterface {
     polyNumber: number;
 }
@@ -22,8 +23,8 @@ export default class VoiceScheduler extends PolyModule<Voice, VoiceSchedulerInte
         id: string;
         type: string;
         numberOfVoices: number;
-        inputs: import("../core/IO").IIOSerialize[];
-        outputs: import("../core/IO").IIOSerialize[];
+        inputs: import('../core/IO').IIOSerialize[];
+        outputs: import('../core/IO').IIOSerialize[];
         name: string;
     };
     private findFreeVoice;