@speechmatics/batch-client/dist/index.d.ts

Javascript client for the Speechmatics batch jobs API

interface CreateJobResponse {
    id: string;
}

interface AlignmentConfig {
    language: string;
}

interface AudioEventsConfig {
    types?: Array<string>;
}

interface DataFetchConfig {
    url: string;
    auth_headers?: Array<string>;
}

declare const JobType: {
    readonly Alignment: "alignment";
    readonly Transcription: "transcription";
};
type JobType = (typeof JobType)[keyof typeof JobType];

interface LanguageIdentificationConfig {
    expected_languages?: Array<string>;
    low_confidence_action?: LanguageIdentificationConfigLowConfidenceActionEnum;
    default_language?: string;
}
declare const LanguageIdentificationConfigLowConfidenceActionEnum: {
    readonly Allow: "allow";
    readonly Reject: "reject";
    readonly UseDefaultLanguage: "use_default_language";
};
type LanguageIdentificationConfigLowConfidenceActionEnum = (typeof LanguageIdentificationConfigLowConfidenceActionEnum)[keyof typeof LanguageIdentificationConfigLowConfidenceActionEnum];

interface NotificationConfig {
    url: string;
    contents?: Array<NotificationConfigContentsEnum>;
    method?: NotificationConfigMethodEnum;
    auth_headers?: Array<string>;
}
declare const NotificationConfigContentsEnum: {
    readonly Jobinfo: "jobinfo";
    readonly Transcript: "transcript";
    readonly TranscriptJsonV2: "transcript.json-v2";
    readonly TranscriptTxt: "transcript.txt";
    readonly TranscriptSrt: "transcript.srt";
    readonly Alignment: "alignment";
    readonly AlignmentWordStartAndEnd: "alignment.word_start_and_end";
    readonly AlignmentOnePerLine: "alignment.one_per_line";
    readonly Data: "data";
    readonly Text: "text";
};
type NotificationConfigContentsEnum = (typeof NotificationConfigContentsEnum)[keyof typeof NotificationConfigContentsEnum];
declare const NotificationConfigMethodEnum: {
    readonly Post: "post";
    readonly Put: "put";
};
type NotificationConfigMethodEnum = (typeof NotificationConfigMethodEnum)[keyof typeof NotificationConfigMethodEnum];

interface OutputConfigSrtOverrides {
    max_line_length?: number;
    max_lines?: number;
}

interface OutputConfig {
    srt_overrides?: OutputConfigSrtOverrides;
}

interface SummarizationConfig {
    content_type?: SummarizationConfigContentTypeEnum;
    summary_length?: SummarizationConfigSummaryLengthEnum;
    summary_type?: SummarizationConfigSummaryTypeEnum;
}
declare const SummarizationConfigContentTypeEnum: {
    readonly Auto: "auto";
    readonly Informative: "informative";
    readonly Conversational: "conversational";
};
type SummarizationConfigContentTypeEnum = (typeof SummarizationConfigContentTypeEnum)[keyof typeof SummarizationConfigContentTypeEnum];
declare const SummarizationConfigSummaryLengthEnum: {
    readonly Brief: "brief";
    readonly Detailed: "detailed";
};
type SummarizationConfigSummaryLengthEnum = (typeof SummarizationConfigSummaryLengthEnum)[keyof typeof SummarizationConfigSummaryLengthEnum];
declare const SummarizationConfigSummaryTypeEnum: {
    readonly Paragraphs: "paragraphs";
    readonly Bullets: "bullets";
};
type SummarizationConfigSummaryTypeEnum = (typeof SummarizationConfigSummaryTypeEnum)[keyof typeof SummarizationConfigSummaryTypeEnum];

interface TopicDetectionConfig {
    topics?: Array<string>;
}

interface TrackingData {
    title?: string;
    reference?: string;
    tags?: Array<string>;
    details?: object;
}

declare const OperatingPoint: {
    readonly Standard: "standard";
    readonly Enhanced: "enhanced";
};
type OperatingPoint = (typeof OperatingPoint)[keyof typeof OperatingPoint];

interface TranscriptionConfigAdditionalVocabInner {
    content: string;
    sounds_like?: Array<string>;
}

interface TranscriptionConfigPunctuationOverrides {
    sensitivity?: number;
    permitted_marks?: Array<string>;
}

interface TranscriptionConfigSpeakerDiarizationConfig {
    prefer_current_speaker?: boolean;
    speaker_sensitivity?: number;
}

interface TranscriptionConfigTranscriptFilteringConfig {
    remove_disfluencies?: boolean;
    replacements?: Array<object>;
}

interface TranscriptionConfig {
    language: string;
    domain?: string;
    output_locale?: string;
    operating_point?: OperatingPoint;
    additional_vocab?: Array<TranscriptionConfigAdditionalVocabInner>;
    punctuation_overrides?: TranscriptionConfigPunctuationOverrides;
    diarization?: TranscriptionConfigDiarizationEnum;
    channel_diarization_labels?: Array<string>;
    enable_entities?: boolean;
    max_delay_mode?: TranscriptionConfigMaxDelayModeEnum;
    transcript_filtering_config?: TranscriptionConfigTranscriptFilteringConfig;
    speaker_diarization_config?: TranscriptionConfigSpeakerDiarizationConfig;
}
declare const TranscriptionConfigDiarizationEnum: {
    readonly None: "none";
    readonly Speaker: "speaker";
    readonly Channel: "channel";
};
type TranscriptionConfigDiarizationEnum = (typeof TranscriptionConfigDiarizationEnum)[keyof typeof TranscriptionConfigDiarizationEnum];
declare const TranscriptionConfigMaxDelayModeEnum: {
    readonly Fixed: "fixed";
    readonly Flexible: "flexible";
};
type TranscriptionConfigMaxDelayModeEnum = (typeof TranscriptionConfigMaxDelayModeEnum)[keyof typeof TranscriptionConfigMaxDelayModeEnum];

interface TranslationConfig {
    target_languages: Array<string>;
}

interface JobConfig {
    type: JobType;
    fetch_data?: DataFetchConfig;
    fetch_text?: DataFetchConfig;
    alignment_config?: AlignmentConfig;
    transcription_config?: TranscriptionConfig;
    notification_config?: Array<NotificationConfig>;
    tracking?: TrackingData;
    output_config?: OutputConfig;
    translation_config?: TranslationConfig;
    language_identification_config?: LanguageIdentificationConfig;
    summarization_config?: SummarizationConfig;
    sentiment_analysis_config?: object;
    topic_detection_config?: TopicDetectionConfig;
    auto_chapters_config?: object;
    audio_events_config?: AudioEventsConfig;
}

interface JobDetailError {
    timestamp: string;
    message: string;
}

interface JobDetails {
    created_at: string;
    data_name: string;
    text_name?: string;
    duration?: number;
    id: string;
    status: JobDetailsStatusEnum;
    config?: JobConfig;
    lang?: string;
    errors?: Array<JobDetailError>;
}
declare const JobDetailsStatusEnum: {
    readonly Running: "running";
    readonly Done: "done";
    readonly Rejected: "rejected";
    readonly Deleted: "deleted";
    readonly Expired: "expired";
};
type JobDetailsStatusEnum = (typeof JobDetailsStatusEnum)[keyof typeof JobDetailsStatusEnum];

interface RetrieveJobResponse {
    job: JobDetails;
}

interface AudioEventItem {
    type?: string;
    start_time?: number;
    end_time?: number;
    confidence?: number;
    channel?: string;
}

interface Chapter {
    title?: string;
    summary?: string;
    start_time?: number;
    end_time?: number;
}

interface JobInfo {
    created_at: string;
    data_name: string;
    duration: number;
    id: string;
    text_name?: string;
    tracking?: TrackingData;
}

interface AutoChaptersResultError {
    type?: AutoChaptersResultErrorTypeEnum;
    message?: string;
}
declare const AutoChaptersResultErrorTypeEnum: {
    readonly AutoChaptersFailed: "auto_chapters_failed";
    readonly UnsupportedLanguage: "unsupported_language";
};
type AutoChaptersResultErrorTypeEnum = (typeof AutoChaptersResultErrorTypeEnum)[keyof typeof AutoChaptersResultErrorTypeEnum];

interface LanguageIdentificationResultAlternative {
    language?: string;
    confidence?: number;
}

interface LanguageIdentificationResultItem {
    alternatives?: Array<LanguageIdentificationResultAlternative>;
    start_time?: number;
    end_time?: number;
}

interface LanguageIdentificationResult {
    results?: Array<LanguageIdentificationResultItem>;
    error?: LanguageIdentificationResultErrorEnum;
    message?: string;
}
declare const LanguageIdentificationResultErrorEnum: {
    readonly LowConfidence: "LOW_CONFIDENCE";
    readonly UnexpectedLanguage: "UNEXPECTED_LANGUAGE";
    readonly NoSpeech: "NO_SPEECH";
    readonly FileUnreadable: "FILE_UNREADABLE";
    readonly Other: "OTHER";
};
type LanguageIdentificationResultErrorEnum = (typeof LanguageIdentificationResultErrorEnum)[keyof typeof LanguageIdentificationResultErrorEnum];

interface LanguagePackInfo {
    language_description?: string;
    word_delimiter: string;
    writing_direction?: LanguagePackInfoWritingDirectionEnum;
    itn?: boolean;
    adapted?: boolean;
}
declare const LanguagePackInfoWritingDirectionEnum: {
    readonly LeftToRight: "left-to-right";
    readonly RightToLeft: "right-to-left";
};
type LanguagePackInfoWritingDirectionEnum = (typeof LanguagePackInfoWritingDirectionEnum)[keyof typeof LanguagePackInfoWritingDirectionEnum];

interface SentimentAnalysisError {
    type?: SentimentAnalysisErrorTypeEnum;
    message?: string;
}
declare const SentimentAnalysisErrorTypeEnum: {
    readonly SentimentAnalysisFailed: "sentiment_analysis_failed";
    readonly UnsupportedLanguage: "unsupported_language";
};
type SentimentAnalysisErrorTypeEnum = (typeof SentimentAnalysisErrorTypeEnum)[keyof typeof SentimentAnalysisErrorTypeEnum];

interface SummarizationError {
    type?: SummarizationErrorTypeEnum;
    message?: string;
}
declare const SummarizationErrorTypeEnum: {
    readonly SummarizationFailed: "summarization_failed";
    readonly UnsupportedLanguage: "unsupported_language";
};
type SummarizationErrorTypeEnum = (typeof SummarizationErrorTypeEnum)[keyof typeof SummarizationErrorTypeEnum];

interface TopicDetectionError {
    type?: TopicDetectionErrorTypeEnum;
    message?: string;
}
declare const TopicDetectionErrorTypeEnum: {
    readonly TopicDetectionFailed: "topic_detection_failed";
    readonly UnsupportedListOfTopics: "unsupported_list_of_topics";
    readonly UnsupportedLanguage: "unsupported_language";
};
type TopicDetectionErrorTypeEnum = (typeof TopicDetectionErrorTypeEnum)[keyof typeof TopicDetectionErrorTypeEnum];

interface TranslationError {
    type?: TranslationErrorTypeEnum;
    message?: string;
}
declare const TranslationErrorTypeEnum: {
    readonly TranslationFailed: "translation_failed";
    readonly UnsupportedTranslationPair: "unsupported_translation_pair";
};
type TranslationErrorTypeEnum = (typeof TranslationErrorTypeEnum)[keyof typeof TranslationErrorTypeEnum];

interface RecognitionMetadata {
    created_at: string;
    type: JobType;
    transcription_config?: TranscriptionConfig;
    translation_errors?: Array<TranslationError>;
    summarization_errors?: Array<SummarizationError>;
    sentiment_analysis_errors?: Array<SentimentAnalysisError>;
    topic_detection_errors?: Array<TopicDetectionError>;
    auto_chapters_errors?: Array<AutoChaptersResultError>;
    alignment_config?: AlignmentConfig;
    output_config?: OutputConfig;
    language_pack_info?: LanguagePackInfo;
    language_identification?: LanguageIdentificationResult;
}

interface RecognitionDisplay {
    direction: RecognitionDisplayDirectionEnum;
}
declare const RecognitionDisplayDirectionEnum: {
    readonly Ltr: "ltr";
    readonly Rtl: "rtl";
};
type RecognitionDisplayDirectionEnum = (typeof RecognitionDisplayDirectionEnum)[keyof typeof RecognitionDisplayDirectionEnum];

interface RecognitionAlternative {
    content: string;
    confidence: number;
    language: string;
    display?: RecognitionDisplay;
    speaker?: string;
    tags?: Array<string>;
}

interface SpokenFormRecognitionResult {
    alternatives: Array<RecognitionAlternative>;
    end_time: number;
    start_time: number;
    type: SpokenFormRecognitionResultTypeEnum;
}
declare const SpokenFormRecognitionResultTypeEnum: {
    readonly Word: "word";
    readonly Punctuation: "punctuation";
};
type SpokenFormRecognitionResultTypeEnum = (typeof SpokenFormRecognitionResultTypeEnum)[keyof typeof SpokenFormRecognitionResultTypeEnum];

interface WrittenFormRecognitionResult {
    alternatives: Array<RecognitionAlternative>;
    end_time: number;
    start_time: number;
    type: WrittenFormRecognitionResultTypeEnum;
}
declare const WrittenFormRecognitionResultTypeEnum: {
    readonly Word: "word";
};
type WrittenFormRecognitionResultTypeEnum = (typeof WrittenFormRecognitionResultTypeEnum)[keyof typeof WrittenFormRecognitionResultTypeEnum];

interface RecognitionResult {
    channel?: string;
    start_time: number;
    end_time: number;
    volume?: number;
    is_eos?: boolean;
    type: RecognitionResultTypeEnum;
    written_form?: Array<WrittenFormRecognitionResult>;
    spoken_form?: Array<SpokenFormRecognitionResult>;
    alternatives?: Array<RecognitionAlternative>;
    attaches_to?: RecognitionResultAttachesToEnum;
}
declare const RecognitionResultTypeEnum: {
    readonly Word: "word";
    readonly Punctuation: "punctuation";
    readonly Entity: "entity";
};
type RecognitionResultTypeEnum = (typeof RecognitionResultTypeEnum)[keyof typeof RecognitionResultTypeEnum];
declare const RecognitionResultAttachesToEnum: {
    readonly Previous: "previous";
    readonly Next: "next";
    readonly Both: "both";
    readonly None: "none";
};
type RecognitionResultAttachesToEnum = (typeof RecognitionResultAttachesToEnum)[keyof typeof RecognitionResultAttachesToEnum];

interface AudioEventSummaryItem {
    total_duration?: number;
    count?: number;
}

interface RetrieveTranscriptResponseAudioEventSummary {
    overall?: {
        [key: string]: AudioEventSummaryItem;
    };
    channels?: {
        [key: string]: {
            [key: string]: AudioEventSummaryItem;
        };
    };
}

interface SentimentSegment {
    text?: string;
    start_time?: number;
    end_time?: number;
    sentiment?: string;
    speaker?: string;
    channel?: string;
    confidence?: number;
}

interface SentimentChannelSummary {
    channel?: string;
    positive_count?: number;
    negative_count?: number;
    neutral_count?: number;
}

interface SentimentSpeakerSummary {
    speaker?: string;
    positive_count?: number;
    negative_count?: number;
    neutral_count?: number;
}

interface SentimentSummaryDetail {
    positive_count?: number;
    negative_count?: number;
    neutral_count?: number;
}

interface SentimentSummary {
    overall?: SentimentSummaryDetail;
    speakers?: Array<SentimentSpeakerSummary>;
    channels?: Array<SentimentChannelSummary>;
}

interface SentimentAnalysisResultSentimentAnalysis {
    segments?: Array<SentimentSegment>;
    summary?: SentimentSummary;
}

interface SentimentAnalysisResult {
    sentiment_analysis?: SentimentAnalysisResultSentimentAnalysis;
}

interface SummarizationResult {
    content?: string;
}

interface TopicDetectionSegmentTopic {
    topic?: string;
}

interface TopicDetectionSegment {
    text?: string;
    start_time?: number;
    end_time?: number;
    topics?: Array<TopicDetectionSegmentTopic>;
}

interface TopicDetectionSummary {
    overall?: {
        [key: string]: number;
    };
}

interface TopicDetectionResult {
    segments?: Array<TopicDetectionSegment>;
    summary?: TopicDetectionSummary;
}

interface TranslationSentence {
    start_time?: number;
    end_time?: number;
    content?: string;
    speaker?: string;
    channel?: string;
}

interface RetrieveTranscriptResponse {
    format: string;
    job: JobInfo;
    metadata: RecognitionMetadata;
    results: Array<RecognitionResult>;
    translations?: {
        [key: string]: Array<TranslationSentence>;
    };
    summary?: SummarizationResult;
    sentiment_analysis?: SentimentAnalysisResult;
    topics?: TopicDetectionResult;
    chapters?: Array<Chapter>;
    audio_events?: Array<AudioEventItem>;
    audio_event_summary?: RetrieveTranscriptResponseAudioEventSummary;
}

interface RetrieveJobsResponse {
    jobs: Array<JobDetails>;
}

interface DeleteJobResponse {
    job: JobDetails;
}

/** Language code following the ISO-639-1 standard
 * Note: this list does not indicate all languages supported by Speechmatics,
 * it is just in line with the ISO specification.
 */
type ISO639_1_Language =
  | 'aa'
  | 'ab'
  | 'ae'
  | 'af'
  | 'ak'
  | 'am'
  | 'an'
  | 'ar'
  | 'as'
  | 'av'
  | 'ay'
  | 'az'
  | 'ba'
  | 'be'
  | 'bg'
  | 'bh'
  | 'bi'
  | 'bm'
  | 'bn'
  | 'bo'
  | 'br'
  | 'bs'
  | 'ca'
  | 'ce'
  | 'ch'
  | 'co'
  | 'cr'
  | 'cs'
  | 'cu'
  | 'cv'
  | 'cy'
  // We also include 'cmn' for Mandarin
  | 'cmn'
  | 'da'
  | 'de'
  | 'dv'
  | 'dz'
  | 'ee'
  | 'el'
  | 'en'
  | 'eo'
  | 'es'
  | 'et'
  | 'eu'
  | 'fa'
  | 'ff'
  | 'fi'
  | 'fj'
  | 'fo'
  | 'fr'
  | 'fy'
  | 'ga'
  | 'gd'
  | 'gl'
  | 'gn'
  | 'gu'
  | 'gv'
  | 'ha'
  | 'he'
  | 'hi'
  | 'ho'
  | 'hr'
  | 'ht'
  | 'hu'
  | 'hy'
  | 'hz'
  | 'ia'
  | 'id'
  | 'ie'
  | 'ig'
  | 'ii'
  | 'ik'
  | 'io'
  | 'is'
  | 'it'
  | 'iu'
  | 'ja'
  | 'jv'
  | 'ka'
  | 'kg'
  | 'ki'
  | 'kj'
  | 'kk'
  | 'kl'
  | 'km'
  | 'kn'
  | 'ko'
  | 'kr'
  | 'ks'
  | 'ku'
  | 'kv'
  | 'kw'
  | 'ky'
  | 'la'
  | 'lb'
  | 'lg'
  | 'li'
  | 'ln'
  | 'lo'
  | 'lt'
  | 'lu'
  | 'lv'
  | 'mg'
  | 'mh'
  | 'mi'
  | 'mk'
  | 'ml'
  | 'mn'
  | 'mr'
  | 'ms'
  | 'mt'
  | 'my'
  | 'na'
  | 'nb'
  | 'nd'
  | 'ne'
  | 'ng'
  | 'nl'
  | 'nn'
  | 'no'
  | 'nr'
  | 'nv'
  | 'ny'
  | 'oc'
  | 'oj'
  | 'om'
  | 'or'
  | 'os'
  | 'pa'
  | 'pi'
  | 'pl'
  | 'ps'
  | 'pt'
  | 'qu'
  | 'rm'
  | 'rn'
  | 'ro'
  | 'ru'
  | 'rw'
  | 'sa'
  | 'sc'
  | 'sd'
  | 'se'
  | 'sg'
  | 'si'
  | 'sk'
  | 'sl'
  | 'sm'
  | 'sn'
  | 'so'
  | 'sq'
  | 'sr'
  | 'ss'
  | 'st'
  | 'su'
  | 'sv'
  | 'sw'
  | 'ta'
  | 'te'
  | 'tg'
  | 'th'
  | 'ti'
  | 'tk'
  | 'tl'
  | 'tn'
  | 'to'
  | 'tr'
  | 'ts'
  | 'tt'
  | 'tw'
  | 'ty'
  | 'ug'
  | 'uk'
  | 'ur'
  | 'uz'
  | 've'
  | 'vi'
  | 'vo'
  | 'wa'
  | 'wo'
  | 'xh'
  | 'yi'
  | 'yo'
  // Another exception is 'yue' for Cantonese
  | 'yue'
  | 'za'
  | 'zh'
  | 'zu';

interface BatchFeatureDiscovery {
  metadata: {
    language_pack_info: Partial<
      Record<
        ISO639_1_Language,
        {
          language_description: string;
          locales: Record<string, { name: string }>;
        }
      >
    >;
  };
  batch: {
    transcription: TranscriptionVersion[];
    translation: TranslationVersion[];
    languageId: ISO639_1_Language[];
  };
}

interface TranscriptionVersion {
  version: string;
  languages: ISO639_1_Language[];
  locales: Partial<Record<ISO639_1_Language, string[]>>;
  domains?: Partial<Record<ISO639_1_Language, string[]>>;
}

interface TranslationVersion {
  version: string;
  languages: Partial<Record<ISO639_1_Language, ISO639_1_Language[]>>;
  languageId: ISO639_1_Language[];
}

declare class BatchClient {
    apiKey: string;
    private apiUrl;
    readonly appId: string;
    constructor({ apiKey, apiUrl, appId, }: {
        apiKey: string;
        apiUrl?: string;
        appId: string;
    });
    private get;
    private post;
    private delete;
    transcribe(input: JobInput, jobConfig: Parameters<typeof this.createTranscriptionJob>[1], format?: TranscriptionFormat, timeoutMS?: number): Promise<RetrieveTranscriptResponse | string>;
    createTranscriptionJob(input: JobInput, jobConfig: CreateJobConfig): Promise<CreateJobResponse>;
    listJobs(filters?: RetrieveJobsFilters): Promise<RetrieveJobsResponse>;
    getJob(id: string): Promise<RetrieveJobResponse>;
    deleteJob(id: string, force?: boolean): Promise<DeleteJobResponse>;
    getJobResult(jobId: string): Promise<RetrieveTranscriptResponse>;
    getJobResult(jobId: string, format: 'json-v2'): Promise<RetrieveTranscriptResponse>;
    getJobResult(jobId: string, format: 'text' | 'srt'): Promise<string>;
    getJobResult(jobId: string, format?: TranscriptionFormat): Promise<RetrieveTranscriptResponse | string>;
    getDataFile(jobId: string): Promise<unknown>;
    getFeatureDiscovery(): Promise<BatchFeatureDiscovery>;
}
type TranscriptionFormat = 'json-v2' | 'text' | 'srt';
type JobInput = File | {
    data: Blob;
    fileName: string;
} | DataFetchConfig;
type CreateJobConfig = Omit<JobConfig, 'type' | 'fetch_data'> & {
    transcription_config: TranscriptionConfig;
};
interface RetrieveJobsFilters {
    created_before?: string;
    limit?: number;
    include_deleted?: boolean;
}

interface ErrorResponse {
    code: number;
    error: ErrorResponseErrorEnum;
    detail?: string;
}
declare const ErrorResponseErrorEnum: {
    readonly BadRequest: "Bad Request";
    readonly FileExpired: "File Expired";
    readonly Forbidden: "Forbidden";
    readonly ResourceLocked: "Resource Locked";
    readonly FormatNotSupported: "Format Not Supported";
    readonly InternalServerError: "Internal Server Error";
    readonly JobError: "Job error";
    readonly JobExpired: "Job Expired";
    readonly JobInProgress: "Job In Progress";
    readonly JobIsNotOfTypeAlignment: "Job is not of type alignment";
    readonly JobIsNotOfTypeTranscription: "Job is not of type transcription";
    readonly JobNotFound: "Job not found";
    readonly JobRejected: "Job rejected";
    readonly JobRejectedDueToInvalidAudio: "Job rejected due to invalid audio";
    readonly JobRejectedDueToInvalidText: "Job rejected due to invalid text";
    readonly MalformedRequest: "Malformed request";
    readonly MissingCallback: "Missing callback";
    readonly MissingDataFile: "Missing data_file";
    readonly MissingTextFile: "Missing text_file";
    readonly NoLanguageSelected: "No language selected";
    readonly NotImplemented: "Not Implemented";
    readonly PermissionDenied: "Permission Denied";
    readonly RequestedProductNotAvailable: "Requested product not available";
    readonly TranscriptionNotReady: "Transcription not ready";
    readonly LogFileNotAvailable: "Log file not available";
    readonly RequestedEarlyAccessReleaseNotAvailable: "Requested Early Access Release not available";
    readonly UnprocessableEntity: "Unprocessable Entity";
};
type ErrorResponseErrorEnum = (typeof ErrorResponseErrorEnum)[keyof typeof ErrorResponseErrorEnum];

type SpeechamticsErrorEnum = InternalErrorEnum | ErrorResponseErrorEnum;
interface SpeechmaticsErrorInterface extends Error {
    error: SpeechamticsErrorEnum;
}
declare class SpeechmaticsResponseError extends Error implements SpeechmaticsErrorInterface {
    response: ErrorResponse;
    error: ErrorResponseErrorEnum;
    constructor(errorResponse: ErrorResponse | unknown);
}
declare const InternalErrorEnum: {
    readonly ConfigurationError: "Configuration error";
    readonly NetworkError: "Network error";
    readonly UnsupportedEnvironment: "Unsupported environment";
    readonly UnexpectedMessage: "Unexpected message";
    readonly UnexpectedResponse: "Unexpected response";
    readonly InvalidTypeError: "Invalid type error";
};
type InternalErrorEnum = (typeof InternalErrorEnum)[keyof typeof InternalErrorEnum];
declare class SpeechmaticsInternalError extends Error {
    error: InternalErrorEnum;
    cause?: unknown;
    constructor(error: InternalErrorEnum, message?: string, cause?: unknown);
}
declare class SpeechmaticsConfigurationError extends SpeechmaticsInternalError {
    constructor(message?: string);
}
declare class SpeechmaticsNetworkError extends SpeechmaticsInternalError {
    constructor(message?: string, cause?: unknown);
}
declare class SpeechmaticsUnsupportedEnvironment extends SpeechmaticsInternalError {
    constructor(message?: string);
}
declare class SpeechmaticsUnexpectedMessage extends SpeechmaticsInternalError {
    constructor(message?: string);
}
declare class SpeechmaticsUnexpectedResponse extends SpeechmaticsInternalError {
    constructor(message?: string, response?: unknown);
}
declare class SpeechmaticsInvalidTypeError extends SpeechmaticsInternalError {
    constructor(message?: string, cause?: unknown);
}
type SpeechmaticsError = SpeechmaticsInternalError | SpeechmaticsResponseError;

declare const JobMode: {
    readonly Batch: "batch";
};
type JobMode = (typeof JobMode)[keyof typeof JobMode];

interface TranscriptionConfigAudioFilteringConfig {
    volume_threshold?: number;
}

interface UsageDetails {
    mode: JobMode;
    type: JobType;
    language?: string;
    operating_point?: OperatingPoint;
    count: number;
    duration_hrs: number;
}

interface UsageResponse {
    since: string;
    until: string;
    summary: Array<UsageDetails>;
    details: Array<UsageDetails>;
}

export { type AlignmentConfig, type AudioEventItem, type AudioEventSummaryItem, type AudioEventsConfig, type AutoChaptersResultError, AutoChaptersResultErrorTypeEnum, BatchClient, type Chapter, type CreateJobResponse, type DataFetchConfig, type DeleteJobResponse, type ErrorResponse, ErrorResponseErrorEnum, InternalErrorEnum, type JobConfig, type JobDetailError, type JobDetails, JobDetailsStatusEnum, type JobInfo, type JobInput, JobMode, JobType, type LanguageIdentificationConfig, LanguageIdentificationConfigLowConfidenceActionEnum, type LanguageIdentificationResult, type LanguageIdentificationResultAlternative, LanguageIdentificationResultErrorEnum, type LanguageIdentificationResultItem, type LanguagePackInfo, LanguagePackInfoWritingDirectionEnum, type NotificationConfig, NotificationConfigContentsEnum, NotificationConfigMethodEnum, OperatingPoint, type OutputConfig, type OutputConfigSrtOverrides, type RecognitionAlternative, type RecognitionDisplay, RecognitionDisplayDirectionEnum, type RecognitionMetadata, type RecognitionResult, RecognitionResultAttachesToEnum, RecognitionResultTypeEnum, type RetrieveJobResponse, type RetrieveJobsFilters, type RetrieveJobsResponse, type RetrieveTranscriptResponse, type RetrieveTranscriptResponseAudioEventSummary, type SentimentAnalysisError, SentimentAnalysisErrorTypeEnum, type SentimentAnalysisResult, type SentimentAnalysisResultSentimentAnalysis, type SentimentChannelSummary, type SentimentSegment, type SentimentSpeakerSummary, type SentimentSummary, type SentimentSummaryDetail, SpeechmaticsConfigurationError, type SpeechmaticsError, SpeechmaticsInvalidTypeError, SpeechmaticsNetworkError, SpeechmaticsResponseError, SpeechmaticsUnexpectedMessage, SpeechmaticsUnexpectedResponse, SpeechmaticsUnsupportedEnvironment, type SpokenFormRecognitionResult, SpokenFormRecognitionResultTypeEnum, type SummarizationConfig, SummarizationConfigContentTypeEnum, SummarizationConfigSummaryLengthEnum, SummarizationConfigSummaryTypeEnum, type SummarizationError, SummarizationErrorTypeEnum, type SummarizationResult, type TopicDetectionConfig, type TopicDetectionError, TopicDetectionErrorTypeEnum, type TopicDetectionResult, type TopicDetectionSegment, type TopicDetectionSegmentTopic, type TopicDetectionSummary, type TrackingData, type TranscriptionConfig, type TranscriptionConfigAdditionalVocabInner, type TranscriptionConfigAudioFilteringConfig, TranscriptionConfigDiarizationEnum, TranscriptionConfigMaxDelayModeEnum, type TranscriptionConfigPunctuationOverrides, type TranscriptionConfigSpeakerDiarizationConfig, type TranscriptionConfigTranscriptFilteringConfig, type TranscriptionFormat, type TranslationConfig, type TranslationError, TranslationErrorTypeEnum, type TranslationSentence, type UsageDetails, type UsageResponse, type WrittenFormRecognitionResult, WrittenFormRecognitionResultTypeEnum };