@superbuilders/mureka/dist/index.d.ts

TypeScript client for the Mureka AI API, providing type-safe access to music generation, lyrics creation, speech synthesis, and fine-tuning capabilities

import * as z from "zod";
/**
 * Error code 400: Invalid request parameters.
 */
export declare const ErrInvalidRequest: Readonly<Error>;
/**
 * Error code 401: Invalid authentication.
 */
export declare const ErrInvalidAuthentication: Readonly<Error>;
/**
 * Error code 403: Access from an unsupported region.
 */
export declare const ErrForbidden: Readonly<Error>;
/**
 * Error code 429: Rate limit reached or current quota exceeded.
 */
export declare const ErrRateLimitOrQuotaExceeded: Readonly<Error>;
/**
 * Error code 500: Server error.
 */
export declare const ErrServerError: Readonly<Error>;
/**
 * Error code 503: Engine overloaded.
 */
export declare const ErrEngineOverloaded: Readonly<Error>;
/**
 * The purposes available for file uploads.
 */
declare const PURPOSES: readonly ["reference", "vocal", "melody", "instrumental", "voice", "fine-tuning"];
type Purpose = (typeof PURPOSES)[number];
/**
 * The models available for music generation.
 */
declare const MODELS: readonly ["auto", "mureka-6", "mureka-5.5"];
type Model = (typeof MODELS)[number];
/**
 * The voices available for speech generation.
 */
declare const VOICES: readonly ["Ethan", "Victoria", "Jake", "Luna", "Ema"];
type Voice = (typeof VOICES)[number];
/**
 * Schema for the request body of the upload file endpoint.
 */
interface UploadFileInput {
    /** The File object (not file name) to be uploaded. */
    file: File;
    /** The intended purpose of the uploaded file. Valid values: reference (mp3, max 30s), vocal (mp3, max 30s), melody (mp3, max 60s), instrumental (mp3, max 30s), voice (mp3, max 15s). */
    purpose: Exclude<Purpose, "fine-tuning">;
}
/**
 * Schema for the response body of the upload file endpoint.
 */
declare const UploadFileResponseSchema: z.ZodObject<{
    id: z.ZodString;
    bytes: z.ZodNumber;
    created_at: z.ZodNumber;
    filename: z.ZodString;
    purpose: z.ZodString;
}, "strip", z.ZodTypeAny, {
    id: string;
    bytes: number;
    created_at: number;
    filename: string;
    purpose: string;
}, {
    id: string;
    bytes: number;
    created_at: number;
    filename: string;
    purpose: string;
}>;
type UploadFileResponse = z.infer<typeof UploadFileResponseSchema>;
/**
 * Schema for the request body of the generate lyrics endpoint.
 */
interface GenerateLyricsInput {
    /** The prompt to generate lyrics for. */
    prompt: string;
}
/**
 * Schema for the response body of the generate lyrics endpoint.
 */
declare const GenerateLyricsResponseSchema: z.ZodObject<{
    title: z.ZodString;
    lyrics: z.ZodString;
}, "strip", z.ZodTypeAny, {
    title: string;
    lyrics: string;
}, {
    title: string;
    lyrics: string;
}>;
type GenerateLyricsResponse = z.infer<typeof GenerateLyricsResponseSchema>;
/**
 * Schema for the request body of the extend lyrics endpoint.
 */
interface ExtendLyricsInput {
    /** Lyrics to be continued. */
    lyrics: string;
}
/**
 * Schema for the response body of the extend lyrics endpoint.
 */
declare const ExtendLyricsResponseSchema: z.ZodObject<{
    lyrics: z.ZodString;
}, "strip", z.ZodTypeAny, {
    lyrics: string;
}, {
    lyrics: string;
}>;
type ExtendLyricsResponse = z.infer<typeof ExtendLyricsResponseSchema>;
/**
 * Schema for the request body of the generate song endpoint.
 */
interface GenerateSongInput {
    /** Lyrics for generated music. */
    lyrics: string;
    /** The model to use. Use auto to select the latest model. You can also use a model via fine-tuning. In this case, only the prompt or reference_id control options are available. */
    model: Model;
    /** Control music generation by inputting a prompt. When this option is selected, other control options (reference_id, vocal_id, melody_id) cannot be selected. */
    prompt?: string;
    /** Control music generation by referencing music, generated through the files/upload API (for reference purpose). When this option is selected, other control options (prompt, melody_id) cannot be selected. */
    reference_id?: string;
    /** Control music generation by any voice you like, generated through the files/upload API (for vocal purpose). When this option is selected, other control options (prompt, melody_id) cannot be selected. */
    vocal_id?: string;
    /** Control music generation by melody idea, generated through the files/upload API (for melody purpose). When this option is selected, other control options (prompt, reference_id, vocal_id) cannot be selected. */
    melody_id?: string;
}
/**
 * Schema for the response body of the generate song endpoint.
 */
declare const GenerateSongResponseSchema: z.ZodObject<{
    id: z.ZodString;
    created_at: z.ZodNumber;
    finished_at: z.ZodOptional<z.ZodNumber>;
    model: z.ZodString;
    status: z.ZodEnum<["preparing", "queued", "running", "succeeded", "failed", "timeouted", "cancelled"]>;
    failed_reason: z.ZodOptional<z.ZodString>;
    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
        index: z.ZodOptional<z.ZodNumber>;
        url: z.ZodString;
        flac_url: z.ZodString;
        duration: z.ZodNumber;
        lyrics_sections: z.ZodArray<z.ZodObject<{
            section_type: z.ZodEnum<["intro", "verse", "pre-chorus", "chorus", "bridge", "breakdown", "outro"]>;
            start: z.ZodNumber;
            end: z.ZodNumber;
            lines: z.ZodOptional<z.ZodArray<z.ZodObject<{
                start: z.ZodNumber;
                end: z.ZodNumber;
                text: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                start: number;
                end: number;
                text: string;
            }, {
                start: number;
                end: number;
                text: string;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }, {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }, {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    model: string;
    finished_at?: number | undefined;
    failed_reason?: string | undefined;
    choices?: {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }[] | undefined;
}, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    model: string;
    finished_at?: number | undefined;
    failed_reason?: string | undefined;
    choices?: {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }[] | undefined;
}>;
type GenerateSongResponse = z.infer<typeof GenerateSongResponseSchema>;
/**
 * Schema for the request params of the query song task endpoint.
 */
interface QuerySongTaskInput {
    /** The task_id of the music generation task. */
    task_id: string;
}
/**
 * Schema for the response body of the query song task endpoint.
 */
declare const QuerySongTaskResponseSchema: z.ZodObject<{
    id: z.ZodString;
    created_at: z.ZodNumber;
    finished_at: z.ZodOptional<z.ZodNumber>;
    model: z.ZodString;
    status: z.ZodEnum<["preparing", "queued", "running", "succeeded", "failed", "timeouted", "cancelled"]>;
    failed_reason: z.ZodOptional<z.ZodString>;
    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
        index: z.ZodOptional<z.ZodNumber>;
        url: z.ZodString;
        flac_url: z.ZodString;
        duration: z.ZodNumber;
        lyrics_sections: z.ZodArray<z.ZodObject<{
            section_type: z.ZodEnum<["intro", "verse", "pre-chorus", "chorus", "bridge", "breakdown", "outro"]>;
            start: z.ZodNumber;
            end: z.ZodNumber;
            lines: z.ZodOptional<z.ZodArray<z.ZodObject<{
                start: z.ZodNumber;
                end: z.ZodNumber;
                text: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                start: number;
                end: number;
                text: string;
            }, {
                start: number;
                end: number;
                text: string;
            }>, "many">>;
        }, "strip", z.ZodTypeAny, {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }, {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }, {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    model: string;
    finished_at?: number | undefined;
    failed_reason?: string | undefined;
    choices?: {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }[] | undefined;
}, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    model: string;
    finished_at?: number | undefined;
    failed_reason?: string | undefined;
    choices?: {
        url: string;
        flac_url: string;
        duration: number;
        lyrics_sections: {
            start: number;
            end: number;
            section_type: "intro" | "verse" | "pre-chorus" | "chorus" | "bridge" | "breakdown" | "outro";
            lines?: {
                start: number;
                end: number;
                text: string;
            }[] | undefined;
        }[];
        index?: number | undefined;
    }[] | undefined;
}>;
type QuerySongTaskResponse = z.infer<typeof QuerySongTaskResponseSchema>;
/**
 * Schema for the request body of the stem song endpoint.
 */
interface StemSongInput {
    /** The URL of the music that needs to be split into tracks. URL in base64 format is also supported, with a maximum data size of 10 MB. */
    url: string;
}
/**
 * Schema for the response body of the stem song endpoint.
 */
declare const StemSongResponseSchema: z.ZodObject<{
    zip_url: z.ZodString;
    expires_at: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    zip_url: string;
    expires_at: number;
}, {
    zip_url: string;
    expires_at: number;
}>;
type StemSongResponse = z.infer<typeof StemSongResponseSchema>;
/**
 * Schema for the request body of the generate instrumental endpoint.
 */
interface GenerateInstrumentalInput {
    /** The model to use. Use auto to select the latest model. */
    model: Exclude<Model, "mureka-5.5">;
    /** Control instrumental generation by inputting a prompt. When this option is selected, other control options (instrumental_id) cannot be selected. */
    prompt?: string;
    /** Control instrumental generation by referencing music, generated through the files/upload API (for instrumental purpose). When this option is selected, other control options (prompt) cannot be selected. */
    instrumental_id?: string;
}
/**
 * Schema for the response body of the generate instrumental endpoint.
 */
declare const GenerateInstrumentalResponseSchema: z.ZodObject<{
    id: z.ZodString;
    created_at: z.ZodNumber;
    finished_at: z.ZodNumber;
    model: z.ZodString;
    status: z.ZodEnum<["preparing", "queued", "running", "succeeded", "failed", "timeouted", "cancelled"]>;
    failed_reason: z.ZodOptional<z.ZodString>;
    choices: z.ZodArray<z.ZodObject<{
        index: z.ZodNumber;
        url: z.ZodString;
        flac_url: z.ZodString;
        duration: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }, {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    choices: {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }[];
    failed_reason?: string | undefined;
}, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    choices: {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }[];
    failed_reason?: string | undefined;
}>;
type GenerateInstrumentalResponse = z.infer<typeof GenerateInstrumentalResponseSchema>;
/**
 * Schema for the request params of the query instrumental task endpoint.
 */
interface QueryInstrumentalTaskInput {
    /** The task_id of the instrumental generation task. */
    task_id: string;
}
/**
 * Schema for the response body of the query instrumental task endpoint.
 */
declare const QueryInstrumentalTaskResponseSchema: z.ZodObject<{
    id: z.ZodString;
    created_at: z.ZodNumber;
    finished_at: z.ZodNumber;
    model: z.ZodString;
    status: z.ZodEnum<["preparing", "queued", "running", "succeeded", "failed", "timeouted", "cancelled"]>;
    failed_reason: z.ZodOptional<z.ZodString>;
    choices: z.ZodArray<z.ZodObject<{
        index: z.ZodNumber;
        url: z.ZodString;
        flac_url: z.ZodString;
        duration: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }, {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    choices: {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }[];
    failed_reason?: string | undefined;
}, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    choices: {
        index: number;
        url: string;
        flac_url: string;
        duration: number;
    }[];
    failed_reason?: string | undefined;
}>;
type QueryInstrumentalTaskResponse = z.infer<typeof QueryInstrumentalTaskResponseSchema>;
/**
 * Schema for the request body of the create upload endpoint.
 */
interface CreateUploadInput {
    /** Give a name for this upload, or the name of the large file to upload. */
    upload_name: string;
    /** The intended purpose of this upload. */
    purpose: Extract<Purpose, "fine-tuning">;
    /** The total size of this upload. If not provided, the size will not be checked at the end. */
    bytes?: number;
}
/**
 * Schema for the response body of the create upload endpoint.
 */
declare const CreateUploadResponseSchema: z.ZodObject<{
    id: z.ZodString;
    upload_name: z.ZodString;
    purpose: z.ZodString;
    bytes: z.ZodNumber;
    created_at: z.ZodNumber;
    expires_at: z.ZodNumber;
    status: z.ZodEnum<["pending", "completed", "cancelled"]>;
    parts: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    id: string;
    bytes: number;
    created_at: number;
    purpose: string;
    status: "cancelled" | "pending" | "completed";
    expires_at: number;
    upload_name: string;
    parts: string[];
}, {
    id: string;
    bytes: number;
    created_at: number;
    purpose: string;
    status: "cancelled" | "pending" | "completed";
    expires_at: number;
    upload_name: string;
    parts: string[];
}>;
type CreateUploadResponse = z.infer<typeof CreateUploadResponseSchema>;
/**
 * Schema for the request body of the add upload part endpoint.
 */
interface AddUploadPartInput {
    /** The File object (not file name) to be uploaded. For the following purposes: fine-tuning: Supported format (mp3). The audio duration is between 30 seconds and 270 seconds. */
    file: File;
    /** The ID of the Upload object that this Part was added to. */
    upload_id: string;
}
/**
 * Schema for the response body of the add upload part endpoint.
 */
declare const AddUploadPartResponseSchema: z.ZodObject<{
    id: z.ZodString;
    upload_id: z.ZodString;
    created_at: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    upload_id: string;
}, {
    id: string;
    created_at: number;
    upload_id: string;
}>;
type AddUploadPartResponse = z.infer<typeof AddUploadPartResponseSchema>;
/**
 * Schema for the request body of the complete upload endpoint.
 */
interface CompleteUploadInput {
    /** The ID of the Upload object. */
    upload_id: string;
    /** The ordered list of part IDs. If this parameter is empty, it means using all parts added by uploads/add, in the order they were added. */
    part_ids?: string[];
}
/**
 * Schema for the response body of the complete upload endpoint.
 */
declare const CompleteUploadResponseSchema: z.ZodObject<{
    id: z.ZodString;
    upload_name: z.ZodString;
    purpose: z.ZodString;
    bytes: z.ZodNumber;
    created_at: z.ZodNumber;
    expires_at: z.ZodNumber;
    status: z.ZodEnum<["pending", "completed", "cancelled"]>;
    parts: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    id: string;
    bytes: number;
    created_at: number;
    purpose: string;
    status: "cancelled" | "pending" | "completed";
    expires_at: number;
    upload_name: string;
    parts: string[];
}, {
    id: string;
    bytes: number;
    created_at: number;
    purpose: string;
    status: "cancelled" | "pending" | "completed";
    expires_at: number;
    upload_name: string;
    parts: string[];
}>;
type CompleteUploadResponse = z.infer<typeof CompleteUploadResponseSchema>;
/**
 * Schema for the request body of the create fine-tuning task endpoint.
 */
interface CreateFineTuningTaskInput {
    /** The ID of the upload object with status completed. An effective fine-tuning requires uploading 100-200 songs. */
    upload_id: string;
    /** A string of up to 32 characters that will be added to your fine-tuned model name. Only lowercase letters, numbers, and hyphens are allowed. */
    suffix: string;
}
/**
 * Schema for the response body of the create fine-tuning task endpoint.
 */
declare const CreateFineTuningTaskResponseSchema: z.ZodObject<{
    id: z.ZodString;
    upload_id: z.ZodString;
    model: z.ZodString;
    created_at: z.ZodNumber;
    finished_at: z.ZodNumber;
    status: z.ZodEnum<["preparing", "queued", "running", "succeeded", "failed", "timeouted", "cancelled"]>;
    failed_reason: z.ZodOptional<z.ZodString>;
    fine_tuned_model: z.ZodString;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    upload_id: string;
    fine_tuned_model: string;
    failed_reason?: string | undefined;
}, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    upload_id: string;
    fine_tuned_model: string;
    failed_reason?: string | undefined;
}>;
type CreateFineTuningTaskResponse = z.infer<typeof CreateFineTuningTaskResponseSchema>;
/**
 * Schema for the request params of the query fine-tuning task endpoint.
 */
interface QueryFineTuningTaskInput {
    /** The task_id of the fine-tuning task. */
    task_id: string;
}
/**
 * Schema for the response body of the query fine-tuning task endpoint.
 */
declare const QueryFineTuningTaskResponseSchema: z.ZodObject<{
    id: z.ZodString;
    upload_id: z.ZodString;
    model: z.ZodString;
    created_at: z.ZodNumber;
    finished_at: z.ZodNumber;
    status: z.ZodEnum<["preparing", "queued", "running", "succeeded", "failed", "timeouted", "cancelled"]>;
    failed_reason: z.ZodOptional<z.ZodString>;
    fine_tuned_model: z.ZodString;
}, "strip", z.ZodTypeAny, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    upload_id: string;
    fine_tuned_model: string;
    failed_reason?: string | undefined;
}, {
    id: string;
    created_at: number;
    status: "preparing" | "queued" | "running" | "succeeded" | "failed" | "timeouted" | "cancelled";
    finished_at: number;
    model: string;
    upload_id: string;
    fine_tuned_model: string;
    failed_reason?: string | undefined;
}>;
type QueryFineTuningTaskResponse = z.infer<typeof QueryFineTuningTaskResponseSchema>;
/**
 * Schema for the request body of the generate speech endpoint.
 */
interface GenerateSpeechInput {
    /** The text to generate audio for. The maximum length is 500 characters. */
    text: string;
    /** The voice to use when generating the audio. When this option is selected, other control options (voice_id) cannot be selected. */
    voice?: Voice;
    /** Control audio generation by referencing voice, generated through the files/upload API (for voice purpose). When this option is selected, other control options (voice) cannot be selected. */
    voice_id?: string;
}
/**
 * Schema for the response body of the generate speech endpoint.
 */
declare const GenerateSpeechResponseSchema: z.ZodObject<{
    url: z.ZodString;
    expires_at: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    url: string;
    expires_at: number;
}, {
    url: string;
    expires_at: number;
}>;
type GenerateSpeechResponse = z.infer<typeof GenerateSpeechResponseSchema>;
/**
 * Schema for a single conversation item in the podcast endpoint.
 */
interface PodcastConversationItem {
    /** The text to generate audio for. The maximum length is 400 characters. */
    text: string;
    /** The voice to use. */
    voice: Voice;
}
/**
 * Schema for the request body of the generate podcast endpoint.
 */
interface GeneratePodcastInput {
    /** Conversation array, The maximum length of the array is 10. */
    conversations: PodcastConversationItem[];
}
/**
 * Schema for the response body of the generate podcast endpoint.
 */
declare const GeneratePodcastResponseSchema: z.ZodObject<{
    url: z.ZodString;
    expires_at: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    url: string;
    expires_at: number;
}, {
    url: string;
    expires_at: number;
}>;
type GeneratePodcastResponse = z.infer<typeof GeneratePodcastResponseSchema>;
/**
 * Schema for the response body of the account billing endpoint.
 */
declare const BillingInfoResponseSchema: z.ZodObject<{
    account_id: z.ZodNumber;
    balance: z.ZodNumber;
    total_recharge: z.ZodNumber;
    total_spending: z.ZodNumber;
    concurrent_request_limit: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    account_id: number;
    balance: number;
    total_recharge: number;
    total_spending: number;
    concurrent_request_limit: number;
}, {
    account_id: number;
    balance: number;
    total_recharge: number;
    total_spending: number;
    concurrent_request_limit: number;
}>;
type BillingInfoResponse = z.infer<typeof BillingInfoResponseSchema>;
/**
 * Configuration for the Mureka API client.
 */
interface ClientConfig {
    /** The API key used for authentication. */
    apiKey: string;
    /** Optional custom base URL for the API. Defaults to the official Mureka API endpoint. */
    apiBaseUrl?: string;
}
/**
 * Mureka API client interface providing access to all API endpoints.
 *
 * This interface defines all available methods for interacting with the Mureka AI API,
 * including music generation, lyrics creation, speech synthesis, and fine-tuning capabilities.
 * Each method is type-safe and returns a Promise that resolves to the appropriate response type.
 */
export interface Client {
    /**
     * Upload a file for various purposes like reference, vocal, melody, etc.
     * @param input - Configuration for the file upload including purpose and file data
     * @returns Promise resolving to upload response with file ID and metadata
     */
    uploadFile: (input: UploadFileInput) => Promise<UploadFileResponse>;
    /**
     * Generate lyrics from a prompt.
     * @param input - Configuration including prompt text and generation parameters
     * @returns Promise resolving to generated lyrics
     */
    generateLyrics: (input: GenerateLyricsInput) => Promise<GenerateLyricsResponse>;
    /**
     * Extend existing lyrics with additional content.
     * @param input - Configuration including existing lyrics and extension parameters
     * @returns Promise resolving to extended lyrics
     */
    extendLyrics: (input: ExtendLyricsInput) => Promise<ExtendLyricsResponse>;
    /**
     * Generate a song using provided lyrics.
     * @param input - Configuration including lyrics and generation parameters
     * @returns Promise resolving to song generation task details
     */
    generateSong: (input: GenerateSongInput) => Promise<GenerateSongResponse>;
    /**
     * Check the status of a song generation task.
     * @param input - Task ID and query parameters
     * @returns Promise resolving to current task status and results if complete
     */
    querySongTask: (input: QuerySongTaskInput) => Promise<QuerySongTaskResponse>;
    /**
     * Split a song into individual tracks.
     * @param input - Configuration including song ID and stemming parameters
     * @returns Promise resolving to separated audio tracks
     */
    stemSong: (input: StemSongInput) => Promise<StemSongResponse>;
    /**
     * Generate instrumental music.
     * @param input - Configuration including generation parameters and style preferences
     * @returns Promise resolving to instrumental generation task details
     */
    generateInstrumental: (input: GenerateInstrumentalInput) => Promise<GenerateInstrumentalResponse>;
    /**
     * Check the status of an instrumental generation task.
     * @param input - Task ID and query parameters
     * @returns Promise resolving to current task status and results if complete
     */
    queryInstrumentalTask: (input: QueryInstrumentalTaskInput) => Promise<QueryInstrumentalTaskResponse>;
    /**
     * Initialize a file upload for fine-tuning.
     * @param input - Configuration for the upload including purpose and metadata
     * @returns Promise resolving to upload initialization details
     */
    createUpload: (input: CreateUploadInput) => Promise<CreateUploadResponse>;
    /**
     * Add parts to an ongoing upload.
     * @param input - Configuration including upload ID, part number, and data
     * @returns Promise resolving to part upload confirmation
     */
    addUploadPart: (input: AddUploadPartInput) => Promise<AddUploadPartResponse>;
    /**
     * Finalize a multipart upload.
     * @param input - Configuration including upload ID and completion parameters
     * @returns Promise resolving to upload completion confirmation
     */
    completeUpload: (input: CompleteUploadInput) => Promise<CompleteUploadResponse>;
    /**
     * Start a fine-tuning task with uploaded files.
     * @param input - Configuration including model parameters and training data
     * @returns Promise resolving to fine-tuning task details
     */
    createFineTuningTask: (input: CreateFineTuningTaskInput) => Promise<CreateFineTuningTaskResponse>;
    /**
     * Check the status of a fine-tuning task.
     * @param input - Task ID and query parameters
     * @returns Promise resolving to current task status and results if complete
     */
    queryFineTuningTask: (input: QueryFineTuningTaskInput) => Promise<QueryFineTuningTaskResponse>;
    /**
     * Convert text to speech using specified voice.
     * @param input - Configuration including text content and voice selection
     * @returns Promise resolving to generated speech audio URL
     */
    generateSpeech: (input: GenerateSpeechInput) => Promise<GenerateSpeechResponse>;
    /**
     * Generate a podcast-style conversation.
     * @param input - Configuration including conversation array and generation parameters
     * @returns Promise resolving to generated podcast audio URL
     */
    generatePodcast: (input: GeneratePodcastInput) => Promise<GeneratePodcastResponse>;
    /**
     * Retrieve account billing information.
     * @returns Promise resolving to account balance, spending history, and limits
     */
    getBillingInfo: () => Promise<BillingInfoResponse>;
}
/**
 * Create a Mureka API client.
 * @param apiKey - The API key to use for the client.
 * @returns A Mureka API client.
 */
export declare function createClient(config: ClientConfig): Client;
export {};
//# sourceMappingURL=index.d.ts.map