import { ChipName, VGMObject } from "./vgm_object";
export declare const VGMWriteDataTargetId: {
    readonly sn76489: 48;
    readonly sn76489_2: 80;
    readonly gameGearStereo: 63;
    readonly gameGearStereo_2: 79;
    readonly ym2413: 81;
    readonly ym2413_2: 161;
    readonly ym2612_p0: 82;
    readonly ym2612_p1: 83;
    readonly ym2612_2_p0: 162;
    readonly ym2612_2_p1: 163;
    readonly ym2151: 84;
    readonly ym2151_2: 164;
    readonly ym2203: 85;
    readonly ym2203_2: 165;
    readonly ym2608_p0: 86;
    readonly ym2608_p1: 87;
    readonly ym2608_2_p0: 166;
    readonly ym2608_2_p1: 167;
    readonly ym2610_p0: 88;
    readonly ym2610_p1: 89;
    readonly ym2610_2_p0: 168;
    readonly ym2610_2_p1: 169;
    readonly ym3812: 90;
    readonly ym3812_2: 170;
    readonly ym3526: 91;
    readonly ym3526_2: 171;
    readonly y8950: 92;
    readonly y8950_2: 172;
    readonly ymz280b: 93;
    readonly ymz280b_2: 173;
    readonly ymf262_p0: 94;
    readonly ymf262_p1: 95;
    readonly ymf262_2_p0: 174;
    readonly ymf262_2_p1: 175;
    readonly ay8910: 160;
    readonly rf5c68: 176;
    readonly rf5c164: 177;
    readonly pwm: 178;
    readonly gameBoyDmg: 179;
    readonly nesApu: 180;
    readonly multiPcm: 181;
    readonly upd7759: 182;
    readonly okim6258: 183;
    readonly okim6295: 184;
    readonly huc6280: 185;
    readonly k053260: 186;
    readonly pokey: 187;
    readonly wonderSwan: 188;
    readonly saa1099: 189;
    readonly es5506: 190;
    readonly ga20: 191;
    readonly segaPcm: 192;
    readonly rf5c68_2: 193;
    readonly rf5c164_2: 194;
    readonly multiPcm_2: 195;
    readonly qsound: 196;
    readonly scsp: 197;
    readonly wonderSwan_2: 198;
    readonly vsu: 199;
    readonly x1_010: 200;
    readonly ymf278b: 208;
    readonly ymf271: 209;
    readonly k051649: 210;
    readonly k054539: 211;
    readonly c140: 212;
    readonly es5503: 213;
    readonly es5506_2: 214;
    readonly c352: 225;
};
export type VGMWriteDataTargetId = (typeof VGMWriteDataTargetId)[keyof typeof VGMWriteDataTargetId];
export type VGMCommandObject = {
    cmd: number;
    size: number;
    chip?: ChipName;
    index?: number;
    type?: number;
    port?: number | null;
    addr?: number | null;
    data?: number;
    blockType?: number;
    blockSize?: number;
    blockData?: Uint8Array;
    readOffset?: number;
    writeOffset?: number;
    writeSize?: number;
    count?: number;
    streamId?: number;
    offset?: number;
    channel?: number;
    dataBankId?: number;
    stepBase?: number;
    stepSize?: number;
    frequency?: number;
    lengthMode?: number;
    dataLength?: number;
    blockId?: number;
    flags?: number;
};
export declare function blockTypeToChipName(blockType: number): ChipName;
export declare function dataTargetIdToChipName(id: VGMWriteDataTargetId): ChipName;
export declare abstract class VGMCommand implements VGMCommandObject {
    cmd: number;
    constructor(cmd: number);
    abstract get size(): number;
    abstract toUint8Array(): Uint8Array;
    abstract toObject(): VGMCommandObject;
    abstract clone(): VGMCommand;
    abstract copy(arg: unknown): VGMCommand;
    toJSON(): VGMCommandObject;
}
export type VGMDataBlockCommandArgs = {
    blockType: number;
    blockSize: number;
    blockData: Uint8Array;
};
export declare class VGMDataBlockCommand extends VGMCommand {
    blockType: number;
    blockSize: number;
    blockData: Uint8Array;
    constructor(args: VGMDataBlockCommandArgs);
    copy(args: Partial<VGMDataBlockCommandArgs>): VGMDataBlockCommand;
    clone(): VGMDataBlockCommand;
    get chip(): ChipName;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset: number): VGMDataBlockCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMDataBlockCommand | null;
}
export declare class VGMEndCommand extends VGMCommand {
    constructor();
    copy(args: unknown): VGMEndCommand;
    clone(): VGMEndCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMEndCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMEndCommand | null;
}
export declare abstract class VGMWaitCommand extends VGMCommand {
    count: number;
    constructor(cmd: number, count: number);
    get size(): number;
    toUint8Array(): Uint8Array;
    toObject(): VGMCommandObject;
}
export type VGMWaitWordCommandArgs = {
    count: number;
};
export declare class VGMWaitWordCommand extends VGMWaitCommand {
    constructor(args: VGMWaitWordCommandArgs);
    copy(args: Partial<VGMWaitWordCommandArgs>): VGMWaitWordCommand;
    clone(): VGMWaitWordCommand;
    static parse(buf: ArrayLike<number>, offset?: number): VGMWaitWordCommand | null;
    static fromObject(obj: VGMCommandObject): VGMWaitWordCommand | null;
}
export type VGMWaitNibbleCommandArgs = {
    count: number;
};
export declare class VGMWaitNibbleCommand extends VGMWaitCommand {
    constructor(args: VGMWaitNibbleCommandArgs);
    copy(args: Partial<VGMWaitNibbleCommandArgs>): VGMWaitNibbleCommand;
    clone(): VGMWaitNibbleCommand;
    static parse(buf: ArrayLike<number>, offset?: number): VGMWaitNibbleCommand | null;
    static fromObject(obj: VGMCommandObject): VGMWaitNibbleCommand | null;
}
export declare class VGMWait735Command extends VGMWaitCommand {
    constructor();
    copy(args: unknown): VGMWait735Command;
    clone(): VGMWait735Command;
    static parse(buf: ArrayLike<number>, offset?: number): VGMWait735Command | null;
    static fromObject(obj: VGMCommandObject): VGMWait735Command | null;
}
export declare class VGMWait882Command extends VGMWaitCommand {
    constructor();
    copy(args: unknown): VGMWait882Command;
    clone(): VGMWait882Command;
    static parse(buf: ArrayLike<number>, offset?: number): VGMWait882Command | null;
    static fromObject(obj: VGMCommandObject): VGMWait882Command | null;
}
export type VGMWrite2ACommandArgs = {
    count: number;
};
export declare class VGMWrite2ACommand extends VGMCommand {
    constructor(args: VGMWrite2ACommandArgs);
    copy(args: Partial<VGMWrite2ACommand>): VGMWrite2ACommand;
    clone(): VGMWrite2ACommand;
    get count(): number;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMWrite2ACommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMWrite2ACommand | null;
}
export type VGMPCMRAMWriteCommandArgs = {
    blockType: number;
    readOffset: number;
    writeOffset: number;
    writeSize: number;
};
export declare class VGMPCMRAMWriteCommand extends VGMCommand {
    blockType: number;
    readOffset: number;
    writeOffset: number;
    writeSize: number;
    constructor(args: VGMPCMRAMWriteCommandArgs);
    copy(args: Partial<VGMPCMRAMWriteCommandArgs>): VGMPCMRAMWriteCommand;
    clone(): VGMPCMRAMWriteCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMPCMRAMWriteCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMPCMRAMWriteCommand | null;
}
export type VGMWriteDataCommandArgs = {
    target?: VGMWriteDataTargetId;
    cmd?: VGMWriteDataTargetId;
    index?: number | null;
    port?: number | null;
    addr?: number | null;
    data: number;
};
export declare class VGMWriteDataCommand extends VGMCommand {
    chip: ChipName;
    index: number;
    port: number;
    addr: number;
    data: number;
    size: number;
    constructor(args: VGMWriteDataCommandArgs);
    copy(args: Partial<VGMWriteDataCommandArgs>): VGMWriteDataCommand;
    clone(): VGMWriteDataCommand;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMWriteDataCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMWriteDataCommand | null;
}
export declare abstract class VGMStreamCommand extends VGMCommand {
    streamId: number;
    constructor(cmd: number, streamId: number);
}
export type VGMSetupStreamCommandArgs = {
    streamId: number;
    type: number;
    port: number;
    channel: number;
};
export declare class VGMSetupStreamCommand extends VGMStreamCommand {
    type: number;
    port: number;
    channel: number;
    constructor(args: VGMSetupStreamCommandArgs);
    copy(args: Partial<VGMSetupStreamCommandArgs>): VGMSetupStreamCommand;
    clone(): VGMSetupStreamCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMSetupStreamCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMSetupStreamCommand | null;
}
export type VGMSetStreamDataCommandArgs = {
    streamId: number;
    dataBankId: number;
    stepSize: number;
    stepBase: number;
};
export declare class VGMSetStreamDataCommand extends VGMStreamCommand {
    dataBankId: number;
    stepSize: number;
    stepBase: number;
    constructor(args: VGMSetStreamDataCommandArgs);
    copy(args: Partial<VGMSetStreamDataCommandArgs>): VGMSetStreamDataCommand;
    clone(): VGMSetStreamDataCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMSetStreamDataCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMSetStreamDataCommand | null;
}
export type VGMSetStreamFrequencyCommandArgs = {
    streamId: number;
    frequency: number;
};
export declare class VGMSetStreamFrequencyCommand extends VGMStreamCommand {
    frequency: number;
    constructor(args: VGMSetStreamFrequencyCommandArgs);
    copy(args: Partial<VGMSetStreamFrequencyCommandArgs>): VGMSetStreamFrequencyCommand;
    clone(): VGMSetStreamFrequencyCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMSetStreamFrequencyCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMSetStreamFrequencyCommand | null;
}
export type VGMStartStreamCommandArgs = {
    streamId: number;
    offset: number;
    lengthMode: number;
    dataLength: number;
};
export declare class VGMStartStreamCommand extends VGMStreamCommand {
    offset: number;
    lengthMode: number;
    dataLength: number;
    constructor(args: VGMStartStreamCommandArgs);
    copy(args: Partial<VGMStartStreamCommandArgs>): VGMStartStreamCommand;
    clone(): VGMStartStreamCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMStartStreamCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMStartStreamCommand | null;
}
export type VGMStopStreamCommandArgs = {
    streamId: number;
};
export declare class VGMStopStreamCommand extends VGMStreamCommand {
    constructor(args: VGMStopStreamCommandArgs);
    copy(args: Partial<VGMStopStreamCommandArgs>): VGMStopStreamCommand;
    clone(): VGMStopStreamCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMStopStreamCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMStopStreamCommand | null;
}
export type VGMStartStreamFastCommandArgs = {
    streamId: number;
    blockId: number;
    flags: number;
};
export declare class VGMStartStreamFastCommand extends VGMStreamCommand {
    blockId: number;
    flags: number;
    constructor(args: VGMStartStreamFastCommandArgs);
    copy(args: Partial<VGMStartStreamFastCommandArgs>): VGMStartStreamFastCommand;
    clone(): VGMStartStreamFastCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMStartStreamFastCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMStartStreamFastCommand | null;
}
export type VGMSeekPCMCommandArgs = {
    offset: number;
};
export declare class VGMSeekPCMCommand extends VGMCommand {
    offset: number;
    constructor(args: VGMSeekPCMCommandArgs);
    copy(args: Partial<VGMSeekPCMCommandArgs>): VGMSeekPCMCommand;
    clone(): VGMSeekPCMCommand;
    get size(): number;
    toUint8Array(): Uint8Array;
    static parse(buf: ArrayLike<number>, offset?: number): VGMSeekPCMCommand | null;
    toObject(): VGMCommandObject;
    static fromObject(obj: VGMCommandObject): VGMSeekPCMCommand | null;
}
export declare function parseVGMCommand(buf: ArrayLike<number>, offset: number): VGMCommand;
export declare function fromVGMCommandObject(obj: VGMCommandObject): VGMCommand;
export declare class VGMDataStream {
    commands: Array<VGMCommand>;
    byteLength: number;
    totalSamples: number;
    loopSamples: number;
    loopIndexOffset: number;
    loopByteOffset: number;
    private _loop;
    constructor(commands?: Array<VGMCommand>);
    clone(): VGMDataStream;
    clear(): void;
    get length(): number;
    push(cmd: VGMCommand): void;
    markLoopPoint(): void;
    static parse(vgm: VGMObject): VGMDataStream;
    build(): ArrayBuffer;
    toJSON(): {
        byteLength: number;
        loopSamples: number;
        totalSamples: number;
        loopIndexOffset: number;
        loopByteOffset: number;
        commands: VGMCommand[];
    };
}