import * as z from "zod/v3";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import * as components from "../components/index.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
/**
 * The format of the transcript output, in one of these options: json, text, srt, verbose_json, or vtt.
 */
export declare const CreateTranscriptionResponseFormat: {
    readonly Json: "json";
    readonly Text: "text";
    readonly Srt: "srt";
    readonly VerboseJson: "verbose_json";
    readonly Vtt: "vtt";
};
/**
 * The format of the transcript output, in one of these options: json, text, srt, verbose_json, or vtt.
 */
export type CreateTranscriptionResponseFormat = ClosedEnum<typeof CreateTranscriptionResponseFormat>;
/**
 * The granularity of the timestamps in the transcription. Word provides word-level timestamps and character provides character-level timestamps per word.
 */
export declare const TimestampsGranularity: {
    readonly None: "none";
    readonly Word: "word";
    readonly Character: "character";
};
/**
 * The granularity of the timestamps in the transcription. Word provides word-level timestamps and character provides character-level timestamps per word.
 */
export type TimestampsGranularity = ClosedEnum<typeof TimestampsGranularity>;
export declare const TimestampGranularities: {
    readonly Word: "word";
    readonly Segment: "segment";
};
export type TimestampGranularities = ClosedEnum<typeof TimestampGranularities>;
export type CreateTranscriptionFallbacks = {
    /**
     * Fallback model identifier
     */
    model: string;
};
/**
 * Retry configuration for the request
 */
export type CreateTranscriptionRetry = {
    /**
     * Number of retry attempts (1-5)
     */
    count?: number | undefined;
    /**
     * HTTP status codes that trigger retry logic
     */
    onCodes?: Array<number> | undefined;
};
export declare const CreateTranscriptionLoadBalancerType: {
    readonly WeightBased: "weight_based";
};
export type CreateTranscriptionLoadBalancerType = ClosedEnum<typeof CreateTranscriptionLoadBalancerType>;
export type CreateTranscriptionLoadBalancerModels = {
    /**
     * Model identifier for load balancing
     */
    model: string;
    /**
     * Weight assigned to this model for load balancing
     */
    weight?: number | undefined;
};
export type CreateTranscriptionLoadBalancer1 = {
    type: CreateTranscriptionLoadBalancerType;
    models: Array<CreateTranscriptionLoadBalancerModels>;
};
/**
 * Load balancer configuration for the request.
 */
export type CreateTranscriptionLoadBalancer = CreateTranscriptionLoadBalancer1;
/**
 * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
 */
export type CreateTranscriptionTimeout = {
    /**
     * Timeout value in milliseconds
     */
    callTimeout: number;
};
export type CreateTranscriptionRouterAudioTranscriptionsFallbacks = {
    /**
     * Fallback model identifier
     */
    model: string;
};
/**
 * Retry configuration for the request
 */
export type CreateTranscriptionRouterAudioTranscriptionsRetry = {
    /**
     * Number of retry attempts (1-5)
     */
    count?: number | undefined;
    /**
     * HTTP status codes that trigger retry logic
     */
    onCodes?: Array<number> | undefined;
};
export declare const CreateTranscriptionLoadBalancerRouterAudioTranscriptionsType: {
    readonly WeightBased: "weight_based";
};
export type CreateTranscriptionLoadBalancerRouterAudioTranscriptionsType = ClosedEnum<typeof CreateTranscriptionLoadBalancerRouterAudioTranscriptionsType>;
export type CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels = {
    /**
     * Model identifier for load balancing
     */
    model: string;
    /**
     * Weight assigned to this model for load balancing
     */
    weight?: number | undefined;
};
export type CreateTranscriptionLoadBalancerRouterAudioTranscriptions1 = {
    type: CreateTranscriptionLoadBalancerRouterAudioTranscriptionsType;
    models: Array<CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels>;
};
/**
 * Array of models with weights for load balancing requests
 */
export type CreateTranscriptionRouterAudioTranscriptionsLoadBalancer = CreateTranscriptionLoadBalancerRouterAudioTranscriptions1;
/**
 * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
 */
export type CreateTranscriptionRouterAudioTranscriptionsTimeout = {
    /**
     * Timeout value in milliseconds
     */
    callTimeout: number;
};
export type CreateTranscriptionOrq = {
    /**
     * The name to display on the trace. If not specified, the default system name will be used.
     */
    name?: string | undefined;
    /**
     * Array of fallback models to use if primary model fails
     */
    fallbacks?: Array<CreateTranscriptionRouterAudioTranscriptionsFallbacks> | undefined;
    /**
     * Retry configuration for the request
     */
    retry?: CreateTranscriptionRouterAudioTranscriptionsRetry | undefined;
    /**
     * Information about the identity making the request. If the identity does not exist, it will be created automatically.
     */
    identity?: components.PublicIdentity | undefined;
    /**
     * @deprecated Use identity instead. Information about the contact making the request.
     *
     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
     */
    contact?: components.PublicContact | undefined;
    /**
     * Array of models with weights for load balancing requests
     */
    loadBalancer?: CreateTranscriptionLoadBalancerRouterAudioTranscriptions1 | undefined;
    /**
     * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
     */
    timeout?: CreateTranscriptionRouterAudioTranscriptionsTimeout | undefined;
};
export type CreateTranscriptionFile = {
    fileName: string;
    content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
};
/**
 * Transcribes audio into the input language.
 */
export type CreateTranscriptionRequestBody = {
    /**
     * ID of the model to use
     */
    model: string;
    /**
     * An optional text to guide the model's style or continue a previous audio segment. The prompt should match the audio language.
     */
    prompt?: string | undefined;
    /**
     * When enable_logging is set to false, zero retention mode is used. This disables history features like request stitching and is only available to enterprise customers.
     */
    enableLogging?: boolean | undefined;
    /**
     * Whether to annotate which speaker is currently talking in the uploaded file.
     */
    diarize?: boolean | undefined;
    /**
     * The format of the transcript output, in one of these options: json, text, srt, verbose_json, or vtt.
     */
    responseFormat?: CreateTranscriptionResponseFormat | undefined;
    /**
     * Whether to tag audio events like (laughter), (footsteps), etc. in the transcription.
     */
    tagAudioEvents?: boolean | undefined;
    /**
     * The maximum amount of speakers talking in the uploaded file. Helps with predicting who speaks when, the maximum is 32.
     */
    numSpeakers?: number | undefined;
    /**
     * The granularity of the timestamps in the transcription. Word provides word-level timestamps and character provides character-level timestamps per word.
     */
    timestampsGranularity?: TimestampsGranularity | undefined;
    /**
     * The sampling temperature, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. If set to 0, the model will use log probability to automatically increase the temperature until certain thresholds are hit.
     */
    temperature?: number | undefined;
    /**
     * The language of the input audio. Supplying the input language in ISO-639-1 format will improve accuracy and latency.
     */
    language?: string | undefined;
    /**
     * The timestamp granularities to populate for this transcription. response_format must be set to verbose_json to use timestamp granularities. Either or both of these options are supported: "word" or "segment". Note: There is no additional latency for segment timestamps, but generating word timestamps incurs additional latency.
     */
    timestampGranularities?: Array<TimestampGranularities> | undefined;
    /**
     * The name to display on the trace. If not specified, the default system name will be used.
     */
    name?: string | undefined;
    /**
     * Array of fallback models to use if primary model fails
     */
    fallbacks?: Array<CreateTranscriptionFallbacks> | undefined;
    /**
     * Retry configuration for the request
     */
    retry?: CreateTranscriptionRetry | undefined;
    /**
     * Load balancer configuration for the request.
     */
    loadBalancer?: CreateTranscriptionLoadBalancer1 | undefined;
    /**
     * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
     */
    timeout?: CreateTranscriptionTimeout | undefined;
    orq?: CreateTranscriptionOrq | undefined;
    /**
     * The audio file object (not file name) to transcribe, in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
     */
    file?: CreateTranscriptionFile | Blob | undefined;
};
export type Words = {
    word?: string | undefined;
    start?: number | undefined;
    end?: number | undefined;
};
export type Segments = {
    id: number;
    seek: number;
    start: number;
    end: number;
    text: string;
    tokens: Array<number>;
    temperature: number;
    avgLogprob: number;
    compressionRatio: number;
    noSpeechProb: number;
};
export type CreateTranscriptionResponseBody2 = {
    task?: string | undefined;
    language?: string | undefined;
    duration?: number | undefined;
    text: string;
    words?: Array<Words> | undefined;
    segments?: Array<Segments> | undefined;
};
export type CreateTranscriptionResponseBody1 = {
    text: string;
};
/**
 * Returns the transcription or verbose transcription
 */
export type CreateTranscriptionResponseBody = CreateTranscriptionResponseBody1 | CreateTranscriptionResponseBody2 | string;
/** @internal */
export declare const CreateTranscriptionResponseFormat$outboundSchema: z.ZodNativeEnum<typeof CreateTranscriptionResponseFormat>;
/** @internal */
export declare const TimestampsGranularity$outboundSchema: z.ZodNativeEnum<typeof TimestampsGranularity>;
/** @internal */
export declare const TimestampGranularities$outboundSchema: z.ZodNativeEnum<typeof TimestampGranularities>;
/** @internal */
export type CreateTranscriptionFallbacks$Outbound = {
    model: string;
};
/** @internal */
export declare const CreateTranscriptionFallbacks$outboundSchema: z.ZodType<CreateTranscriptionFallbacks$Outbound, z.ZodTypeDef, CreateTranscriptionFallbacks>;
export declare function createTranscriptionFallbacksToJSON(createTranscriptionFallbacks: CreateTranscriptionFallbacks): string;
/** @internal */
export type CreateTranscriptionRetry$Outbound = {
    count: number;
    on_codes?: Array<number> | undefined;
};
/** @internal */
export declare const CreateTranscriptionRetry$outboundSchema: z.ZodType<CreateTranscriptionRetry$Outbound, z.ZodTypeDef, CreateTranscriptionRetry>;
export declare function createTranscriptionRetryToJSON(createTranscriptionRetry: CreateTranscriptionRetry): string;
/** @internal */
export declare const CreateTranscriptionLoadBalancerType$outboundSchema: z.ZodNativeEnum<typeof CreateTranscriptionLoadBalancerType>;
/** @internal */
export type CreateTranscriptionLoadBalancerModels$Outbound = {
    model: string;
    weight: number;
};
/** @internal */
export declare const CreateTranscriptionLoadBalancerModels$outboundSchema: z.ZodType<CreateTranscriptionLoadBalancerModels$Outbound, z.ZodTypeDef, CreateTranscriptionLoadBalancerModels>;
export declare function createTranscriptionLoadBalancerModelsToJSON(createTranscriptionLoadBalancerModels: CreateTranscriptionLoadBalancerModels): string;
/** @internal */
export type CreateTranscriptionLoadBalancer1$Outbound = {
    type: string;
    models: Array<CreateTranscriptionLoadBalancerModels$Outbound>;
};
/** @internal */
export declare const CreateTranscriptionLoadBalancer1$outboundSchema: z.ZodType<CreateTranscriptionLoadBalancer1$Outbound, z.ZodTypeDef, CreateTranscriptionLoadBalancer1>;
export declare function createTranscriptionLoadBalancer1ToJSON(createTranscriptionLoadBalancer1: CreateTranscriptionLoadBalancer1): string;
/** @internal */
export type CreateTranscriptionLoadBalancer$Outbound = CreateTranscriptionLoadBalancer1$Outbound;
/** @internal */
export declare const CreateTranscriptionLoadBalancer$outboundSchema: z.ZodType<CreateTranscriptionLoadBalancer$Outbound, z.ZodTypeDef, CreateTranscriptionLoadBalancer>;
export declare function createTranscriptionLoadBalancerToJSON(createTranscriptionLoadBalancer: CreateTranscriptionLoadBalancer): string;
/** @internal */
export type CreateTranscriptionTimeout$Outbound = {
    call_timeout: number;
};
/** @internal */
export declare const CreateTranscriptionTimeout$outboundSchema: z.ZodType<CreateTranscriptionTimeout$Outbound, z.ZodTypeDef, CreateTranscriptionTimeout>;
export declare function createTranscriptionTimeoutToJSON(createTranscriptionTimeout: CreateTranscriptionTimeout): string;
/** @internal */
export type CreateTranscriptionRouterAudioTranscriptionsFallbacks$Outbound = {
    model: string;
};
/** @internal */
export declare const CreateTranscriptionRouterAudioTranscriptionsFallbacks$outboundSchema: z.ZodType<CreateTranscriptionRouterAudioTranscriptionsFallbacks$Outbound, z.ZodTypeDef, CreateTranscriptionRouterAudioTranscriptionsFallbacks>;
export declare function createTranscriptionRouterAudioTranscriptionsFallbacksToJSON(createTranscriptionRouterAudioTranscriptionsFallbacks: CreateTranscriptionRouterAudioTranscriptionsFallbacks): string;
/** @internal */
export type CreateTranscriptionRouterAudioTranscriptionsRetry$Outbound = {
    count: number;
    on_codes?: Array<number> | undefined;
};
/** @internal */
export declare const CreateTranscriptionRouterAudioTranscriptionsRetry$outboundSchema: z.ZodType<CreateTranscriptionRouterAudioTranscriptionsRetry$Outbound, z.ZodTypeDef, CreateTranscriptionRouterAudioTranscriptionsRetry>;
export declare function createTranscriptionRouterAudioTranscriptionsRetryToJSON(createTranscriptionRouterAudioTranscriptionsRetry: CreateTranscriptionRouterAudioTranscriptionsRetry): string;
/** @internal */
export declare const CreateTranscriptionLoadBalancerRouterAudioTranscriptionsType$outboundSchema: z.ZodNativeEnum<typeof CreateTranscriptionLoadBalancerRouterAudioTranscriptionsType>;
/** @internal */
export type CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels$Outbound = {
    model: string;
    weight: number;
};
/** @internal */
export declare const CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels$outboundSchema: z.ZodType<CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels$Outbound, z.ZodTypeDef, CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels>;
export declare function createTranscriptionLoadBalancerRouterAudioTranscriptionsModelsToJSON(createTranscriptionLoadBalancerRouterAudioTranscriptionsModels: CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels): string;
/** @internal */
export type CreateTranscriptionLoadBalancerRouterAudioTranscriptions1$Outbound = {
    type: string;
    models: Array<CreateTranscriptionLoadBalancerRouterAudioTranscriptionsModels$Outbound>;
};
/** @internal */
export declare const CreateTranscriptionLoadBalancerRouterAudioTranscriptions1$outboundSchema: z.ZodType<CreateTranscriptionLoadBalancerRouterAudioTranscriptions1$Outbound, z.ZodTypeDef, CreateTranscriptionLoadBalancerRouterAudioTranscriptions1>;
export declare function createTranscriptionLoadBalancerRouterAudioTranscriptions1ToJSON(createTranscriptionLoadBalancerRouterAudioTranscriptions1: CreateTranscriptionLoadBalancerRouterAudioTranscriptions1): string;
/** @internal */
export type CreateTranscriptionRouterAudioTranscriptionsLoadBalancer$Outbound = CreateTranscriptionLoadBalancerRouterAudioTranscriptions1$Outbound;
/** @internal */
export declare const CreateTranscriptionRouterAudioTranscriptionsLoadBalancer$outboundSchema: z.ZodType<CreateTranscriptionRouterAudioTranscriptionsLoadBalancer$Outbound, z.ZodTypeDef, CreateTranscriptionRouterAudioTranscriptionsLoadBalancer>;
export declare function createTranscriptionRouterAudioTranscriptionsLoadBalancerToJSON(createTranscriptionRouterAudioTranscriptionsLoadBalancer: CreateTranscriptionRouterAudioTranscriptionsLoadBalancer): string;
/** @internal */
export type CreateTranscriptionRouterAudioTranscriptionsTimeout$Outbound = {
    call_timeout: number;
};
/** @internal */
export declare const CreateTranscriptionRouterAudioTranscriptionsTimeout$outboundSchema: z.ZodType<CreateTranscriptionRouterAudioTranscriptionsTimeout$Outbound, z.ZodTypeDef, CreateTranscriptionRouterAudioTranscriptionsTimeout>;
export declare function createTranscriptionRouterAudioTranscriptionsTimeoutToJSON(createTranscriptionRouterAudioTranscriptionsTimeout: CreateTranscriptionRouterAudioTranscriptionsTimeout): string;
/** @internal */
export type CreateTranscriptionOrq$Outbound = {
    name?: string | undefined;
    fallbacks?: Array<CreateTranscriptionRouterAudioTranscriptionsFallbacks$Outbound> | undefined;
    retry?: CreateTranscriptionRouterAudioTranscriptionsRetry$Outbound | undefined;
    identity?: components.PublicIdentity$Outbound | undefined;
    contact?: components.PublicContact$Outbound | undefined;
    load_balancer?: CreateTranscriptionLoadBalancerRouterAudioTranscriptions1$Outbound | undefined;
    timeout?: CreateTranscriptionRouterAudioTranscriptionsTimeout$Outbound | undefined;
};
/** @internal */
export declare const CreateTranscriptionOrq$outboundSchema: z.ZodType<CreateTranscriptionOrq$Outbound, z.ZodTypeDef, CreateTranscriptionOrq>;
export declare function createTranscriptionOrqToJSON(createTranscriptionOrq: CreateTranscriptionOrq): string;
/** @internal */
export type CreateTranscriptionFile$Outbound = {
    fileName: string;
    content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
};
/** @internal */
export declare const CreateTranscriptionFile$outboundSchema: z.ZodType<CreateTranscriptionFile$Outbound, z.ZodTypeDef, CreateTranscriptionFile>;
export declare function createTranscriptionFileToJSON(createTranscriptionFile: CreateTranscriptionFile): string;
/** @internal */
export type CreateTranscriptionRequestBody$Outbound = {
    model: string;
    prompt?: string | undefined;
    enable_logging: boolean;
    diarize: boolean;
    response_format?: string | undefined;
    tag_audio_events: boolean;
    num_speakers?: number | undefined;
    timestamps_granularity: string;
    temperature?: number | undefined;
    language?: string | undefined;
    timestamp_granularities?: Array<string> | undefined;
    name?: string | undefined;
    fallbacks?: Array<CreateTranscriptionFallbacks$Outbound> | undefined;
    retry?: CreateTranscriptionRetry$Outbound | undefined;
    load_balancer?: CreateTranscriptionLoadBalancer1$Outbound | undefined;
    timeout?: CreateTranscriptionTimeout$Outbound | undefined;
    orq?: CreateTranscriptionOrq$Outbound | undefined;
    file?: CreateTranscriptionFile$Outbound | Blob | undefined;
};
/** @internal */
export declare const CreateTranscriptionRequestBody$outboundSchema: z.ZodType<CreateTranscriptionRequestBody$Outbound, z.ZodTypeDef, CreateTranscriptionRequestBody>;
export declare function createTranscriptionRequestBodyToJSON(createTranscriptionRequestBody: CreateTranscriptionRequestBody): string;
/** @internal */
export declare const Words$inboundSchema: z.ZodType<Words, z.ZodTypeDef, unknown>;
export declare function wordsFromJSON(jsonString: string): SafeParseResult<Words, SDKValidationError>;
/** @internal */
export declare const Segments$inboundSchema: z.ZodType<Segments, z.ZodTypeDef, unknown>;
export declare function segmentsFromJSON(jsonString: string): SafeParseResult<Segments, SDKValidationError>;
/** @internal */
export declare const CreateTranscriptionResponseBody2$inboundSchema: z.ZodType<CreateTranscriptionResponseBody2, z.ZodTypeDef, unknown>;
export declare function createTranscriptionResponseBody2FromJSON(jsonString: string): SafeParseResult<CreateTranscriptionResponseBody2, SDKValidationError>;
/** @internal */
export declare const CreateTranscriptionResponseBody1$inboundSchema: z.ZodType<CreateTranscriptionResponseBody1, z.ZodTypeDef, unknown>;
export declare function createTranscriptionResponseBody1FromJSON(jsonString: string): SafeParseResult<CreateTranscriptionResponseBody1, SDKValidationError>;
/** @internal */
export declare const CreateTranscriptionResponseBody$inboundSchema: z.ZodType<CreateTranscriptionResponseBody, z.ZodTypeDef, unknown>;
export declare function createTranscriptionResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateTranscriptionResponseBody, SDKValidationError>;
//# sourceMappingURL=createtranscription.d.ts.map