@vocalstack/js-sdk 1.1.0 → 2.0.0-alpha.1

package/dist/resources.d.ts

@@ -0,0 +1,374 @@
+import type { AppStreamKey, AudioSourceCheck, Batch, BatchPage, AutoTopUpSettings, AutoTopUpView, BillingDetails, BillingView, CheckPromoCode, CheckoutView, CreateCheckout, LowBalanceAlertSettings, LowBalanceAlertView, PaymentDocument, PaymentMethodList, PaymentPage, PortalLink, PromoCodeView, SetInterval, SubscriptionView, YearlyOptIn, UsageChargePage, UsageReport, Broadcast, Correction, CorrectionBatch, CorrectionPage, CreateAppStreamKey, CreateAudioSource, CreateBatch, CreateLiveTranscription, CreateBroadcast, CreateShareLink, CreateTag, CreateTranscription, CreateVoiceFromSpeaker, CreatedAppStreamKey, ChargePage, ExportFormat, ClientApp, ClientPolicy, Health, LanguageLists, LedgerPage, LinkProbe, PatchVoice, PlanList, PublishGrant, Recording, RecordingEvent, RecordingEvents, RecordingPage, RetranscribeLine, RtmpStatus, SearchResults, SettingsPatch, ShareLink, SharedTranscript, StartRecording, StartJob, SummaryStatus, Tag, TagTranscriptions, Transcription, TranscriptionJob, TranscriptionPage, TranscriptSnapshot, UpdateBroadcast, UpdateTag, UpdateTranscription, UpdateShareLink, UploadRecording, Voice, VoiceCatalogue, VoiceTrack, ManyResult } from '@vocalstack/contract';
+import { Transport, type CallOptions, type ReadAs } from './http.js';
+import { RealtimeSession, type ConnectOptions } from './realtime.js';
+import { Subscription, type SubscribeOptions } from './subscription.js';
+import { type WsLike } from './ws.js';
+export type Upload = Blob | Uint8Array | ArrayBuffer | string;
+export type LifecycleFilter = 'active' | 'archived' | 'all';
+export interface RecordingPageOptions extends PageOptions {
+    lifecycle?: 'active' | 'archived';
+}
+declare abstract class ParentResource<T, U> {
+    protected readonly t: Transport;
+    protected abstract readonly base: '/v1/broadcasts' | '/v1/transcriptions';
+    protected abstract readonly key: 'broadcasts' | 'transcriptions';
+    constructor(t: Transport);
+    protected p(id: string, rest?: string): string;
+    list(lifecycle?: LifecycleFilter): Promise<T[]>;
+    get(id: string): Promise<T>;
+    update(id: string, req: U): Promise<T>;
+    archive(id: string): Promise<T>;
+    restore(id: string): Promise<T>;
+    purge(id: string): Promise<void>;
+    archiveMany(ids: string[]): Promise<ManyResult>;
+    restoreMany(ids: string[]): Promise<ManyResult>;
+    purgeMany(ids: string[]): Promise<ManyResult>;
+    listRecordings(id: string, lifecycle?: 'active' | 'archived'): Promise<Recording[]>;
+    listRecordingsPage(id: string, opts?: RecordingPageOptions): Promise<RecordingPage>;
+    startRecording(id: string, req?: StartRecording, call?: CallOptions): Promise<PublishGrant>;
+    listShareLinks(id: string): Promise<ShareLink[]>;
+    createShareLink(id: string, req: CreateShareLink): Promise<ShareLink>;
+    events(id: string, as?: ReadAs & {
+        asOwner?: boolean;
+    }): Promise<WsLike>;
+}
+export declare class Broadcasts extends ParentResource<Broadcast, UpdateBroadcast> {
+    protected readonly base: "/v1/broadcasts";
+    protected readonly key: "broadcasts";
+    create(req: CreateBroadcast, call?: CallOptions): Promise<Broadcast>;
+    addAudioSource(id: string, req: CreateAudioSource): Promise<Broadcast>;
+    removeAudioSource(id: string, sourceId: string): Promise<Broadcast>;
+    checkAudioSource(id: string, sourceId: string, opts?: {
+        fresh?: boolean;
+    }): Promise<AudioSourceCheck>;
+}
+export type CreateTranscriptionInput = CreateTranscription & {
+    file?: Upload;
+    fileName?: string;
+};
+export declare class Transcriptions extends ParentResource<Transcription, UpdateTranscription> {
+    protected readonly base: "/v1/transcriptions";
+    protected readonly key: "transcriptions";
+    listPage(opts?: PageOptions & {
+        lifecycle?: LifecycleFilter;
+    }): Promise<TranscriptionPage>;
+    uploadRecording(id: string, req?: UploadRecording, call?: CallOptions): Promise<PublishGrant>;
+    create(req: CreateTranscriptionInput, call?: CallOptions): Promise<Transcription>;
+    createFromUrl(url: string, opts?: Omit<CreateTranscription, 'url'>, call?: CallOptions): Promise<Transcription>;
+    createLive(req: CreateLiveTranscription, call?: CallOptions): Promise<Transcription>;
+    probe(url: string): Promise<LinkProbe>;
+    attachBroadcast(id: string, broadcastId: string): Promise<Transcription>;
+    detachBroadcast(id: string, broadcastId: string): Promise<Transcription>;
+}
+export type AddBatchFileInput = Pick<CreateTranscription, 'url' | 'name' | 'startS' | 'endS' | 'durationS'> & {
+    file?: Upload;
+    fileName?: string;
+};
+export declare class Batches {
+    #private;
+    constructor(t: Transport);
+    create(req?: CreateBatch, call?: CallOptions): Promise<Batch>;
+    list(): Promise<Batch[]>;
+    listPage(opts?: PageOptions): Promise<BatchPage>;
+    get(id: string): Promise<Batch>;
+    delete(id: string): Promise<void>;
+    addFile(id: string, req: AddBatchFileInput, call?: CallOptions): Promise<Transcription>;
+    addUrl(id: string, url: string, opts?: Omit<AddBatchFileInput, 'url' | 'file' | 'fileName'>, call?: CallOptions): Promise<Transcription>;
+    start(id: string, call?: CallOptions): Promise<Batch>;
+    export(id: string, format: ExportFormat): Promise<Response>;
+    stop(id: string): Promise<Batch>;
+    wait(id: string, opts?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+        onProgress?(batch: Batch): void;
+    }): Promise<Batch>;
+}
+export declare class Recordings {
+    #private;
+    constructor(t: Transport);
+    get(id: string, as?: ReadAs): Promise<Recording>;
+    pause(id: string): Promise<Recording>;
+    resume(id: string): Promise<Recording>;
+    stop(id: string, reason?: string): Promise<Recording>;
+    settings(id: string, patch: SettingsPatch): Promise<Recording>;
+    publishToken(id: string, opts?: {
+        takeover?: boolean;
+    }): Promise<PublishGrant>;
+    publish(grant: PublishGrant, opts?: ConnectOptions): Promise<RealtimeSession>;
+    archive(id: string): Promise<Recording>;
+    restore(id: string): Promise<Recording>;
+    purge(id: string): Promise<void>;
+    archiveMany(ids: string[]): Promise<ManyResult>;
+    restoreMany(ids: string[]): Promise<ManyResult>;
+    purgeMany(ids: string[]): Promise<ManyResult>;
+    transcript(id: string, opts?: {
+        after?: number;
+        lang?: string;
+        asListener?: boolean;
+    } & ReadAs): Promise<TranscriptSnapshot>;
+    translation(id: string, lang: string, sentences?: number[], as?: ReadAs): Promise<{
+        lang: string;
+        translations: Record<string, string>;
+    }>;
+    summarize(id: string, call?: CallOptions): Promise<SummaryStatus>;
+    summary(id: string, opts?: {
+        lang?: string;
+    } & ReadAs): Promise<SummaryStatus>;
+    export(id: string, format: ExportFormat, opts?: {
+        lang?: string;
+    } & ReadAs): Promise<Response>;
+    exportUrl(id: string, format: ExportFormat, opts?: {
+        lang?: string;
+        shareCode?: string;
+        listenerToken?: string;
+    }): Promise<string>;
+    audioUrl(id: string, opts?: {
+        kind?: 'delivery' | 'background' | 'speech' | 'master' | 'source' | 'video';
+        lang?: string;
+        format?: string;
+    } & ReadAs): Promise<string>;
+    audioSrc(id: string, opts?: {
+        kind?: AudioKind;
+        lang?: string;
+        voice?: string;
+        format?: MediaFormat;
+    } & MediaAuth): string;
+    clipSrc(id: string, startS: number, endS: number, opts?: {
+        clean?: boolean;
+    } & MediaAuth): string;
+    voiceClipSrc(id: string, sentence: number, lang: string, opts?: {
+        voice?: string;
+        format?: 'ogg' | 'caf';
+        part?: number;
+        v?: string;
+    } & MediaAuth): string;
+    clip(id: string, startS: number, endS: number, as?: ReadAs): Promise<Response>;
+    voice(id: string, lang?: string, as?: ReadAs): Promise<VoiceTrack[]>;
+    renderVoice(id: string, langs: string[], call?: CallOptions): Promise<VoiceTrack[]>;
+    renderVoice(id: string, req: RenderVoice & ReadAs, call?: CallOptions): Promise<VoiceTrack[]>;
+    voiceClip(id: string, sentence: number, lang: string, opts?: {
+        format?: 'ogg' | 'caf';
+    } & ReadAs): Promise<Response>;
+    mediaToken(id: string): Promise<{
+        token: string;
+        expiresAt: string;
+    }>;
+    nameSpeaker(id: string, speaker: number, name: string | null): Promise<void>;
+    events(id: string, opts?: {
+        after?: number;
+        limit?: number;
+    }): Promise<RecordingEvent[]>;
+    eventsPage(id: string, opts?: {
+        cursor?: string;
+        after?: number;
+        limit?: number;
+    }): Promise<RecordingEvents>;
+    subscribe(id: string, opts?: SubscribeOptions): Promise<Subscription>;
+}
+export type AudioKind = 'delivery' | 'voice' | 'background' | 'speech' | 'master' | 'source' | 'video';
+export type MediaFormat = 'ogg' | 'caf' | 'mp3';
+export interface RenderVoice {
+    langs: string[];
+    voice?: string;
+    voiceBySpeaker?: Record<string, string>;
+    near?: number;
+}
+export interface MediaAuth extends ReadAs {
+    token?: string;
+    media?: string;
+}
+export declare function playableFormat(): 'ogg' | 'caf';
+export declare class Jobs {
+    #private;
+    constructor(t: Transport);
+    get(recordingId: string): Promise<TranscriptionJob>;
+    start(recordingId: string, window?: StartJob): Promise<TranscriptionJob>;
+    retry(recordingId: string): Promise<TranscriptionJob>;
+    preview(recordingId: string): Promise<Response>;
+    wait(recordingId: string, opts?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+        onProgress?(job: TranscriptionJob): void;
+    }): Promise<TranscriptionJob>;
+}
+export declare class Corrections {
+    #private;
+    constructor(t: Transport);
+    list(recordingId: string): Promise<Correction[]>;
+    listPage(recordingId: string, opts?: PageOptions): Promise<CorrectionPage>;
+    apply(recordingId: string, batch: CorrectionBatch): Promise<Correction[]>;
+    retranscribe(recordingId: string, req: RetranscribeLine): Promise<Correction[]>;
+    revert(correctionId: string): Promise<Correction>;
+}
+export declare class ShareLinks {
+    #private;
+    constructor(t: Transport);
+    open(code: string): Promise<SharedTranscript>;
+    update(id: string, req: UpdateShareLink): Promise<ShareLink>;
+    revoke(id: string): Promise<ShareLink>;
+}
+export declare class Tags {
+    #private;
+    constructor(t: Transport);
+    list(): Promise<Tag[]>;
+    create(req: CreateTag): Promise<Tag>;
+    update(id: string, req: UpdateTag): Promise<Tag>;
+    delete(id: string): Promise<void>;
+    tagTranscriptions(id: string, req: TagTranscriptions): Promise<Tag>;
+}
+export declare class Voices {
+    #private;
+    constructor(t: Transport);
+    list(opts?: {
+        lifecycle?: 'active' | 'archived';
+    }): Promise<Voice[]>;
+    get(id: string): Promise<Voice>;
+    archive(id: string): Promise<Voice>;
+    restore(id: string): Promise<Voice>;
+    archiveMany(ids: string[]): Promise<ManyResult>;
+    restoreMany(ids: string[]): Promise<ManyResult>;
+    deleteMany(ids: string[]): Promise<ManyResult>;
+    create(req: {
+        name: string;
+        sample?: Upload;
+        sampleUrl?: string;
+        fileName?: string;
+        gender?: 'male' | 'female';
+        color?: string;
+        draft?: boolean;
+    }, call?: CallOptions): Promise<Voice>;
+    createFromSpeaker(req: Omit<CreateVoiceFromSpeaker, 'consent'>, call?: CallOptions): Promise<Voice>;
+    setConsent(id: string, consent: 'granted' | 'refused', opts?: {
+        name?: string;
+    }): Promise<Voice>;
+    update(id: string, patch: PatchVoice): Promise<Voice>;
+    delete(id: string): Promise<void>;
+    available(lang: string, opts?: {
+        recording?: string;
+        asOwner?: boolean;
+    } & ReadAs): Promise<VoiceCatalogue>;
+    preview(voice: string, lang: string, opts?: {
+        format?: 'ogg' | 'caf';
+    }): Promise<Response>;
+    clonePreview(id: string, opts?: {
+        lang?: string;
+        format?: 'ogg' | 'caf';
+        recording?: string;
+        asOwner?: boolean;
+    } & ReadAs): Promise<Response>;
+    sample(id: string): Promise<Response>;
+}
+export interface SearchOptions {
+    broadcasts?: string[];
+    listenerTokens?: string[];
+    recording?: string;
+    lang?: string;
+    limit?: number;
+}
+export declare class Search {
+    #private;
+    constructor(t: Transport);
+    query(q: string, opts?: SearchOptions): Promise<SearchResults>;
+}
+export interface Me {
+    userId?: string | null;
+    apiKeyId?: string | null;
+    displayName: string;
+    principalId: string;
+    principals: unknown[];
+    scopes: string[];
+}
+export declare class MeApi {
+    #private;
+    constructor(t: Transport);
+    get(): Promise<Me>;
+}
+export interface ConnectTokenInput {
+    code: string;
+    codeVerifier: string;
+    redirectUri: string;
+}
+export interface ConnectToken {
+    access_token: string;
+    token_type: 'api_key';
+    key_id: string;
+    scope: string;
+    account: {
+        name: string;
+    };
+}
+export declare class Connect {
+    #private;
+    constructor(t: Transport);
+    token(input: ConnectTokenInput, opts?: CallOptions): Promise<ConnectToken>;
+}
+export interface PageOptions {
+    cursor?: string;
+    limit?: number;
+}
+export interface UsageOptions {
+    startDate?: string;
+    endDate?: string;
+    tz?: string;
+}
+export interface UsageChargesOptions extends UsageOptions, PageOptions {
+    kind?: 'file' | 'live';
+    source?: string;
+}
+export declare class Billing {
+    #private;
+    constructor(t: Transport);
+    get(): Promise<BillingView>;
+    plans(): Promise<PlanList>;
+    ledger(opts?: PageOptions): Promise<LedgerPage>;
+    charges(opts?: PageOptions): Promise<ChargePage>;
+    createCheckout(req: CreateCheckout, opts?: CallOptions): Promise<CheckoutView>;
+    getCheckout(id: string): Promise<CheckoutView>;
+    cancelSubscription(): Promise<SubscriptionView>;
+    uncancelSubscription(): Promise<SubscriptionView>;
+    setAutoTopUp(req: AutoTopUpSettings): Promise<AutoTopUpView>;
+    portal(): Promise<PortalLink>;
+    retryAutoTopUp(): Promise<AutoTopUpView>;
+    setLowBalanceAlert(req: LowBalanceAlertSettings): Promise<LowBalanceAlertView>;
+    setInterval(req: SetInterval): Promise<SubscriptionView>;
+    optInYearly(req: YearlyOptIn): Promise<SubscriptionView>;
+    unsetInterval(): Promise<SubscriptionView>;
+    usage(opts?: UsageOptions): Promise<UsageReport>;
+    usageCharges(opts?: UsageChargesOptions): Promise<UsageChargePage>;
+    payments(opts?: PageOptions): Promise<PaymentPage>;
+    paymentDocument(id: string): Promise<PaymentDocument>;
+    paymentMethods(): Promise<PaymentMethodList>;
+    deletePaymentMethod(id: string): Promise<void>;
+    managePaymentMethods(): Promise<PortalLink>;
+    details(): Promise<BillingDetails>;
+    setDetails(req: BillingDetails): Promise<BillingDetails>;
+    checkPromoCode(req: CheckPromoCode): Promise<PromoCodeView>;
+}
+export declare class Languages {
+    #private;
+    constructor(t: Transport);
+    list(): Promise<LanguageLists>;
+}
+export declare class Rtmp {
+    #private;
+    constructor(t: Transport);
+    status(): Promise<RtmpStatus>;
+    createKey(req: CreateAppStreamKey): Promise<CreatedAppStreamKey>;
+    listKeys(): Promise<AppStreamKey[]>;
+    deleteKey(id: string): Promise<void>;
+}
+export declare class Events {
+    #private;
+    constructor(t: Transport);
+    account(): Promise<WsLike>;
+}
+export declare class Meta {
+    #private;
+    constructor(t: Transport);
+    health(): Promise<Health>;
+    openapi(): Promise<Record<string, unknown>>;
+    clientPolicy(client: ClientApp): Promise<ClientPolicy>;
+}
+export {};