@vocalstack/js-sdk 1.0.13 → 2.0.0-alpha.0

package/dist/resources.d.ts

@@ -0,0 +1,521 @@
+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, CreateTranscription, CreateVoiceFromSpeaker, CreatedAppStreamKey, ChargePage, ExportFormat, Health, LanguageLists, LedgerPage, LinkProbe, PatchVoice, PlanList, PublishGrant, Recording, RecordingEvent, RecordingEvents, RecordingPage, RetranscribeLine, RtmpStatus, SearchResults, SettingsPatch, ShareLink, StartRecording, StartJob, SummaryStatus, Transcription, TranscriptionJob, TranscriptionPage, TranscriptSnapshot, UpdateBroadcast, UpdateTranscription, UpdateShareLink, UploadRecording, Voice, VoiceCatalogue, VoiceTrack } 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';
+/** A file to upload: a `Blob`/`File`, bytes, or (Node) a path. */
+export type Upload = Blob | Uint8Array | ArrayBuffer | string;
+/** Which of a principal's broadcasts or transcriptions a list returns
+ * (`?lifecycle=`): `all` is the active and the archived in one answer. */
+export type LifecycleFilter = 'active' | 'archived' | 'all';
+/** One page of a broadcast's or a transcription's recordings. */
+export interface RecordingPageOptions extends PageOptions {
+    lifecycle?: 'active' | 'archived';
+}
+/** What broadcasts and transcriptions have in common: both hold
+ * recordings and share links. */
+declare abstract class ParentResource<T, U> {
+    protected readonly t: Transport;
+    protected abstract readonly base: '/v1/broadcasts' | '/v1/transcriptions';
+    /** The list's key: what it holds. */
+    protected abstract readonly key: 'broadcasts' | 'transcriptions';
+    constructor(t: Transport);
+    protected p(id: string, rest?: string): string;
+    /** Every one, newest first: a paged list is read to its last page
+     * (`transcriptions.listPage` reads one). */
+    list(lifecycle?: LifecycleFilter): Promise<T[]>;
+    get(id: string): Promise<T>;
+    /** Rename, change the default capture settings (a broadcast: also its access, password or link). */
+    update(id: string, req: U): Promise<T>;
+    /** Hidden, its links dead, its data kept until `restore` or `purge`. */
+    archive(id: string): Promise<T>;
+    restore(id: string): Promise<T>;
+    /** Delete an archived one and everything in it, for good. */
+    purge(id: string): Promise<void>;
+    /** Every recording, newest first (every page of `listRecordingsPage`). */
+    listRecordings(id: string, lifecycle?: 'active' | 'archived'): Promise<Recording[]>;
+    /** One page of recordings, newest first: pass its `nextCursor` as `cursor` for the next. */
+    listRecordingsPage(id: string, opts?: RecordingPageOptions): Promise<RecordingPage>;
+    /** Start a live recording.  The grant's `streamUrl` is the publisher
+     * socket (`vs.recordings.publish(grant)`).  A 409 `conflict` with
+     * `details.takeover` means another device is recording: retry with
+     * `{ takeover: true }` to record here instead. */
+    startRecording(id: string, req?: StartRecording, call?: CallOptions): Promise<PublishGrant>;
+    listShareLinks(id: string): Promise<ShareLink[]>;
+    createShareLink(id: string, req: CreateShareLink): Promise<ShareLink>;
+    /** The events socket a waiting screen needs: `recording.started` (it is
+     * live), `recording.ended`, `job.progress`, `stream.ingest`.
+     * Each names the transcription the recording is made in (`transcriptionId`). */
+    events(id: string, as?: ReadAs & {
+        asOwner?: boolean;
+    }): Promise<WsLike>;
+}
+/** `vs.broadcasts`: the links listeners open (design 77). */
+export declare class Broadcasts extends ParentResource<Broadcast, UpdateBroadcast> {
+    protected readonly base: "/v1/broadcasts";
+    protected readonly key: "broadcasts";
+    create(req: CreateBroadcast, call?: CallOptions): Promise<Broadcast>;
+    /** Give a broadcast a stream it can record from (a YouTube live, an
+     * internet radio address).  Returns the broadcast. */
+    addAudioSource(id: string, req: CreateAudioSource): Promise<Broadcast>;
+    removeAudioSource(id: string, sourceId: string): Promise<Broadcast>;
+    /** Whether that source can be recorded right now; `fresh` skips the short cache. */
+    checkAudioSource(id: string, sourceId: string, opts?: {
+        fresh?: boolean;
+    }): Promise<AudioSourceCheck>;
+}
+export type CreateTranscriptionInput = CreateTranscription & {
+    /** The file to transcribe; omit it and set `url` to have the server fetch a link. */
+    file?: Upload;
+    /** The upload's file name, when `file` does not carry one. */
+    fileName?: string;
+};
+/** `vs.transcriptions`: a file, a link, a microphone or a stream, transcribed and stored. */
+export declare class Transcriptions extends ParentResource<Transcription, UpdateTranscription> {
+    protected readonly base: "/v1/transcriptions";
+    protected readonly key: "transcriptions";
+    /** One page of transcriptions, newest first: pass its `nextCursor` as
+     * `cursor` for the next; the last page has none. */
+    listPage(opts?: PageOptions & {
+        lifecycle?: LifecycleFilter;
+    }): Promise<TranscriptionPage>;
+    /** A file or link recording in this transcription: no live phase, transcribed at full speed.
+     * It has no job: open the grant's socket with `vs.recordings.publish(grant)` (with `url`
+     * the server fetches the link) and read it until the session is done. */
+    uploadRecording(id: string, req?: UploadRecording, call?: CallOptions): Promise<PublishGrant>;
+    /** From a file (`file`) or a public link (`url`).  The answer's
+     * `job.recordingId` is the job: `vs.jobs.wait(recordingId)`,
+     * then `vs.recordings.transcript(recordingId)`. */
+    create(req: CreateTranscriptionInput, call?: CallOptions): Promise<Transcription>;
+    /** `create({ url, ...opts })`. */
+    createFromUrl(url: string, opts?: Omit<CreateTranscription, 'url'>, call?: CallOptions): Promise<Transcription>;
+    /** A transcription captured as it is spoken: a microphone, or a stream
+     * the server pulls.  Created idle: `startRecording(id)` starts it. */
+    createLive(req: CreateLiveTranscription, call?: CallOptions): Promise<Transcription>;
+    /** Whether a link is live (a live transcription) or a file. */
+    probe(url: string): Promise<LinkProbe>;
+    /** Feed a broadcast from a live transcription.  Returns the transcription. */
+    attachBroadcast(id: string, broadcastId: string): Promise<Transcription>;
+    detachBroadcast(id: string, broadcastId: string): Promise<Transcription>;
+}
+/** What `batches.addFile` takes: a file (`file`) or a public link (`url`),
+ * and of the transcription options only these (the settings are the batch's). */
+export type AddBatchFileInput = Pick<CreateTranscription, 'url' | 'name' | 'startS' | 'endS' | 'durationS'> & {
+    /** The file to add; omit it and set `url` to have the server fetch a link. */
+    file?: Upload;
+    /** The upload's file name, when `file` does not carry one. */
+    fileName?: string;
+};
+/** `vs.batches`: several files transcribed together, for less than a
+ * transcription each (one create, one minimum charge).  Create a batch, add
+ * each file or link with `addFile`, then `start` it; `get` shows its files
+ * (each a transcription with its job) and their counts.  A batch's files get
+ * no summary, title, share link or spoken translations. */
+export declare class Batches {
+    #private;
+    constructor(t: Transport);
+    /** An open batch, ready for files (`name` defaults to "Batch of <date>"). */
+    create(req?: CreateBatch, call?: CallOptions): Promise<Batch>;
+    /** Every batch, newest first (every page of `listPage`); each with its counts, not its files. */
+    list(): Promise<Batch[]>;
+    /** One page of batches, newest first: pass its `nextCursor` as `cursor` for the next. */
+    listPage(opts?: PageOptions): Promise<BatchPage>;
+    /** A batch with its files (`files`, each a transcription with its job), in the order they were added. */
+    get(id: string): Promise<Batch>;
+    /** Discard a batch that was never started, with its files (nothing was charged). */
+    delete(id: string): Promise<void>;
+    /** Add one file (`file`) or link (`url`) to an open batch: a transcription
+     * of its own (`batchId`), waiting for the batch's `start`. */
+    addFile(id: string, req: AddBatchFileInput, call?: CallOptions): Promise<Transcription>;
+    /** `addFile(id, { url, ...opts })`. */
+    addUrl(id: string, url: string, opts?: Omit<AddBatchFileInput, 'url' | 'file' | 'fileName'>, call?: CallOptions): Promise<Transcription>;
+    /** Seal the batch and queue its files, longest first; `wait` follows it to the end. */
+    start(id: string, call?: CallOptions): Promise<Batch>;
+    /** Every finished file's transcript in one `format` (as `recordings.export`
+     * makes one), in one zip, as a `Response`: `.arrayBuffer()` it.  Files
+     * still running or failed are left out. */
+    export(id: string, format: ExportFormat): Promise<Response>;
+    /** Stop every file not finished yet: queued files never start, a running
+     * one is cancelled and billed for what it transcribed. */
+    stop(id: string): Promise<Batch>;
+    /** Poll a started batch until it is `done` (every file finished or
+     * failed) or `stopped`, and return it with its files.  It does not throw
+     * on a failed file: check `counts.failed` and each file's `job.state`.
+     * `onProgress` sees every read, the last one included. */
+    wait(id: string, opts?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+        onProgress?(batch: Batch): void;
+    }): Promise<Batch>;
+}
+/** `vs.recordings`: one take, live or uploaded. */
+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>;
+    /** Only from paused. */
+    stop(id: string, reason?: string): Promise<Recording>;
+    settings(id: string, patch: SettingsPatch): Promise<Recording>;
+    /** A new publisher grant for a recording that is already live. */
+    publishToken(id: string, opts?: {
+        takeover?: boolean;
+    }): Promise<PublishGrant>;
+    /** Open the publisher socket a grant names and wait until it is ready:
+     * send raw PCM (f32le, 16 kHz, mono) with `sendAudio`, end with `eof()`. */
+    publish(grant: PublishGrant, opts?: ConnectOptions): Promise<RealtimeSession>;
+    archive(id: string): Promise<Recording>;
+    restore(id: string): Promise<Recording>;
+    purge(id: string): Promise<void>;
+    /** The transcript: segments (with word timings), sentences and speakers,
+     * up to `lastSeq`; `after` continues from a cursor, `lang` reads it translated. */
+    transcript(id: string, opts?: {
+        after?: number;
+        lang?: string;
+        asListener?: boolean;
+    } & ReadAs): Promise<TranscriptSnapshot>;
+    /** Translate the given sentences (at most 40 ids per call); the answer
+     * carries only what this call translated. */
+    translation(id: string, lang: string, sentences?: number[], as?: ReadAs): Promise<{
+        lang: string;
+        translations: Record<string, string>;
+    }>;
+    /** Queue the AI title and summary of a finished recording. */
+    summarize(id: string, call?: CallOptions): Promise<SummaryStatus>;
+    /** The title and summary as they stand, in `lang` when given. */
+    summary(id: string, opts?: {
+        lang?: string;
+    } & ReadAs): Promise<SummaryStatus>;
+    /** An export file (JSON, SRT, XLSX, PDF) as a `Response`: `.text()` or
+     * `.arrayBuffer()` it.  `lang` makes it read in that language. */
+    export(id: string, format: ExportFormat, opts?: {
+        lang?: string;
+    } & ReadAs): Promise<Response>;
+    /** The export as a plain link, for a browser download with a browser
+     * access token (it rides in the query).  Never use it with an API key:
+     * the API refuses a key in a URL. */
+    exportUrl(id: string, format: ExportFormat, opts?: {
+        lang?: string;
+        shareCode?: string; /** A broadcast listener's, once the recording has ended. */
+        listenerToken?: string;
+    }): Promise<string>;
+    /** The signed media URL the server redirects to.  `kind`: `delivery`
+     * (default), `master`, or `source` (a transcription's original upload). */
+    audioUrl(id: string, opts?: {
+        kind?: 'delivery' | 'master' | 'source' | 'video';
+        lang?: string;
+        format?: string;
+    } & ReadAs): Promise<string>;
+    /** A stretch of the recording's audio, `startS` to `endS` seconds (at most 120 s). */
+    clip(id: string, startS: number, endS: number, as?: ReadAs): Promise<Response>;
+    /** The synthesized voice tracks of a recording (per language). */
+    voice(id: string, lang?: string, as?: ReadAs): Promise<VoiceTrack[]>;
+    /** Synthesize the voice track in these languages. */
+    renderVoice(id: string, langs: string[], call?: CallOptions): Promise<VoiceTrack[]>;
+    /** One sentence spoken in `lang`. */
+    voiceClip(id: string, sentence: number, lang: string, opts?: {
+        format?: 'ogg' | 'caf';
+    } & ReadAs): Promise<Response>;
+    /** A short-lived token for the recording's media URLs. */
+    mediaToken(id: string): Promise<{
+        token: string;
+        expiresAt: string;
+    }>;
+    /** Name a speaker (the diarizer's index); `null` clears the name. */
+    nameSpeaker(id: string, speaker: number, name: string | null): Promise<void>;
+    /** The durable event log with wall times (owner only): every event
+     * after `after` (a `seq`; the whole log without it), read `limit` a page. */
+    events(id: string, opts?: {
+        after?: number;
+        limit?: number;
+    }): Promise<RecordingEvent[]>;
+    /** One page of the event log (500 by default, 1000 at most): from `after`
+     * a `seq`, or the previous page's `nextCursor` as `cursor`. */
+    eventsPage(id: string, opts?: {
+        cursor?: string;
+        after?: number;
+        limit?: number;
+    }): Promise<RecordingEvents>;
+    /** Attach to the live fan-out; resolves once the backfill snapshot is in place. */
+    subscribe(id: string, opts?: SubscribeOptions): Promise<Subscription>;
+}
+/** `vs.jobs`: the transcription job of a file or link recording
+ * (`/v1/recordings/{id}/job`).  States: queued, fetching, transcribing,
+ * done, failed, and cropping (waiting for `start`). */
+export declare class Jobs {
+    #private;
+    constructor(t: Transport);
+    get(recordingId: string): Promise<TranscriptionJob>;
+    /** Release a job waiting in `cropping`: the window to transcribe, in seconds. */
+    start(recordingId: string, window?: StartJob): Promise<TranscriptionJob>;
+    /** Re-queue a failed job from its stored source. */
+    retry(recordingId: string): Promise<TranscriptionJob>;
+    /** The file the server fetched for a link job waiting in `cropping`. */
+    preview(recordingId: string): Promise<Response>;
+    /** Poll until the job is `done`, `failed` or `cropping`, and return it.
+     * It does not throw on `failed`: check `job.state` (and `job.error`).
+     * `onProgress` sees every job read, the last one included: its `state`
+     * and `progress` (`pct`, `processedS`, the fetch phase). */
+    wait(recordingId: string, opts?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+        onProgress?(job: TranscriptionJob): void;
+    }): Promise<TranscriptionJob>;
+}
+/** `vs.corrections`: edits to a finished transcript, each revertible. */
+export declare class Corrections {
+    #private;
+    constructor(t: Transport);
+    /** Every correction, newest first (every page of `listPage`). */
+    list(recordingId: string): Promise<Correction[]>;
+    /** One page of corrections, newest first: pass its `nextCursor` as `cursor` for the next. */
+    listPage(recordingId: string, opts?: PageOptions): Promise<CorrectionPage>;
+    /** Apply a staged batch atomically; every target must be settled. */
+    apply(recordingId: string, batch: CorrectionBatch): Promise<Correction[]>;
+    /** Read lines again with the language forced; lands as `line` corrections. */
+    retranscribe(recordingId: string, req: RetranscribeLine): Promise<Correction[]>;
+    revert(correctionId: string): Promise<Correction>;
+}
+/** `vs.shareLinks`: named public links to a transcription or broadcast
+ * (create and list them on their owner). */
+export declare class ShareLinks {
+    #private;
+    constructor(t: Transport);
+    update(id: string, req: UpdateShareLink): Promise<ShareLink>;
+    revoke(id: string): Promise<ShareLink>;
+}
+/** `vs.voices`: the account's cloned voices, and the catalogue a language offers. */
+export declare class Voices {
+    #private;
+    constructor(t: Transport);
+    list(): Promise<Voice[]>;
+    get(id: string): Promise<Voice>;
+    /** Build a voice from a sample (`sample`) or audio the server fetches
+     * (`sampleUrl`).  Calling it asserts you have the speaker's permission,
+     * unless `draft` (a draft is named and consented to later with `update`). */
+    create(req: {
+        name: string;
+        sample?: Upload;
+        sampleUrl?: string;
+        fileName?: string;
+        gender?: 'male' | 'female';
+        color?: string;
+        draft?: boolean;
+    }, call?: CallOptions): Promise<Voice>;
+    /** Build a voice from one speaker of a recording (asserts permission). */
+    createFromSpeaker(req: Omit<CreateVoiceFromSpeaker, 'consent'>, call?: CallOptions): Promise<Voice>;
+    /** Rename, recolour, switch off; `{ name, consent: true, draft: false }` finishes a draft. */
+    update(id: string, patch: PatchVoice): Promise<Voice>;
+    delete(id: string): Promise<void>;
+    /** The voices that can speak `lang`, best first (with a token, also the
+     * account's ready clones).  `recording` also offers the cloned voices that
+     * recording uses, to whoever may read it: its owner, or a listener with
+     * `listenerToken` or `shareCode`. */
+    available(lang: string, opts?: {
+        recording?: string;
+        asOwner?: boolean;
+    } & ReadAs): Promise<VoiceCatalogue>;
+    /** A catalogue voice speaking `lang` (Ogg/Opus; `caf` for Apple). 202 while it is prepared. */
+    preview(voice: string, lang: string, opts?: {
+        format?: 'ogg' | 'caf';
+    }): Promise<Response>;
+    /** A cloned voice speaking `lang`; 409 while it is not ready.  With
+     * `recording`, as it speaks in that recording, for whoever may read it
+     * (its owner, or a listener with `listenerToken` or `shareCode`). */
+    clonePreview(id: string, opts?: {
+        lang?: string;
+        format?: 'ogg' | 'caf';
+        recording?: string;
+        asOwner?: boolean;
+    } & ReadAs): Promise<Response>;
+    /** The audio a voice was made from. */
+    sample(id: string): Promise<Response>;
+}
+export interface SearchOptions {
+    /** Only these broadcasts, by link (`code`): what a listener joined. */
+    broadcasts?: string[];
+    /** Listener tokens for the private ones among `broadcasts`. */
+    listenerTokens?: string[];
+    /** Only this recording. */
+    recording?: string;
+    lang?: string;
+    limit?: number;
+}
+/** `vs.search`: full-text search over the caller's transcripts. */
+export declare class Search {
+    #private;
+    constructor(t: Transport);
+    /** `q` is 2 or more characters. */
+    query(q: string, opts?: SearchOptions): Promise<SearchResults>;
+}
+export interface Me {
+    userId?: string | null;
+    apiKeyId?: string | null;
+    displayName: string;
+    principalId: string;
+    principals: unknown[];
+    scopes: string[];
+}
+/** `vs.me`: who the credential is. */
+export declare class MeApi {
+    #private;
+    constructor(t: Transport);
+    get(): Promise<Me>;
+}
+/** `vs.connect.token()`'s parameters: what the callback received and the
+ * verifier the app made for the connect link. */
+export interface ConnectTokenInput {
+    /** The `code` the dashboard added to `redirect_uri` (single use, two minutes). */
+    code: string;
+    /** The PKCE verifier whose `BASE64URL(SHA256(verifier))` was the link's `code_challenge`. */
+    codeVerifier: string;
+    /** Exactly the `redirect_uri` of the connect link. */
+    redirectUri: string;
+}
+/** The key a connect code was redeemed for (the wire's own field names). */
+export interface ConnectToken {
+    /** The new API key (`vs_key_…`): shown once, here; keep it on the server. */
+    access_token: string;
+    token_type: 'api_key';
+    /** The key's id, as the API keys list and `GET /v1/me` (`apiKeyId`) show it. */
+    key_id: string;
+    /** The granted scopes, space-separated (`read write`). */
+    scope: string;
+    /** The account the key acts for. */
+    account: {
+        name: string;
+    };
+}
+/** `vs.connect`: one-click Connect, on the app's server. */
+export declare class Connect {
+    #private;
+    constructor(t: Transport);
+    /** Redeem the `code` the dashboard sent to the app's `redirect_uri` for
+     * an API key (OAuth 2.0 authorization code + PKCE).  No credential is
+     * sent, even when the client has one, and the call is never retried:
+     * the code works once.  A refusal is a `VocalStackError` whose `code` is
+     * OAuth's `error` (`invalid_grant`: unknown, spent or expired code, or a
+     * verifier or `redirect_uri` that does not match). */
+    token(input: ConnectTokenInput, opts?: CallOptions): Promise<ConnectToken>;
+}
+/** A page of a list. */
+export interface PageOptions {
+    /** The `nextCursor` of the previous page. */
+    cursor?: string;
+    /** 1 to 200: 50 by default for the billing lists, 100 for the others. */
+    limit?: number;
+}
+/** `vs.billing.usage()`'s range: inclusive days (`YYYY-MM-DD`) in `tz`. */
+export interface UsageOptions {
+    /** The first day (default: the first of this month); an earlier one than the account's is moved to it. */
+    startDate?: string;
+    /** The last day (default: today, the latest it may be). */
+    endDate?: string;
+    /** An IANA time zone (default `UTC`). */
+    tz?: string;
+}
+/** `vs.billing.usageCharges()`: the usage report's range, its filters and a page. */
+export interface UsageChargesOptions extends UsageOptions, PageOptions {
+    /** Only `file` or only `live` charges (realtime sessions are live). */
+    kind?: 'file' | 'live';
+    /** Only `dashboard`'s charges or one API key's (its id). */
+    source?: string;
+}
+/** `vs.billing`: the account's plan, credit balance and limits, the price
+ *  list, the ledger, the per-recording charges, the usage report, the
+ *  payments history, payment methods, invoice details and promo codes. */
+export declare class Billing {
+    #private;
+    constructor(t: Transport);
+    /** The account: plan, rates, balance, limits, subscription, top-up URL. */
+    get(): Promise<BillingView>;
+    /** The visible plans with their current rates and limits (no credential needed). */
+    plans(): Promise<PlanList>;
+    /** The ledger, newest first. */
+    ledger(opts?: PageOptions): Promise<LedgerPage>;
+    /** The per-recording charges, newest first. */
+    charges(opts?: PageOptions): Promise<ChargePage>;
+    /** Open a checkout at the payment provider (a top-up or a subscription); send the customer to `url`.
+     *  A signed-in person only, never an API key. */
+    createCheckout(req: CreateCheckout, opts?: CallOptions): Promise<CheckoutView>;
+    /** A checkout's status (by its id or the provider's). */
+    getCheckout(id: string): Promise<CheckoutView>;
+    /** Cancel the subscription at the end of its period. */
+    cancelSubscription(): Promise<SubscriptionView>;
+    /** Take back a scheduled cancellation. */
+    uncancelSubscription(): Promise<SubscriptionView>;
+    /** Turn auto top-up on (threshold and amount from `plans().autoTopUp`) or off. */
+    setAutoTopUp(req: AutoTopUpSettings): Promise<AutoTopUpView>;
+    /** A link to the provider's customer portal (payment methods, invoices, receipts). */
+    portal(): Promise<PortalLink>;
+    /** Charge the configured auto top-up amount now (under the day's cap). */
+    retryAutoTopUp(): Promise<AutoTopUpView>;
+    /** Turn the low-balance email on or off and set its line. */
+    setLowBalanceAlert(req: LowBalanceAlertSettings): Promise<LowBalanceAlertView>;
+    /** Renew `month`ly or `year`ly from the next period, at `subscription.switchPrices` (needs `acceptTerms` and `noNewWithdrawalPeriodShown`). */
+    setInterval(req: SetInterval): Promise<SubscriptionView>;
+    /** Keep the subscription by switching to yearly when monthly billing is withdrawn (`subscription.yearlyOptIn`). */
+    optInYearly(req: YearlyOptIn): Promise<SubscriptionView>;
+    /** Take back a scheduled interval switch. */
+    unsetInterval(): Promise<SubscriptionView>;
+    /** What the account spent per day, source (API key or Dashboard) and kind. */
+    usage(opts?: UsageOptions): Promise<UsageReport>;
+    /** The usage report's charges one by one, newest first, with how many match and their total. */
+    usageCharges(opts?: UsageChargesOptions): Promise<UsageChargePage>;
+    /** The payments history, newest first. */
+    payments(opts?: PageOptions): Promise<PaymentPage>;
+    /** A payment's invoice or receipt: `{url}`, or `{pending: true}` while the provider makes it. */
+    paymentDocument(id: string): Promise<PaymentDocument>;
+    /** The saved payment methods. */
+    paymentMethods(): Promise<PaymentMethodList>;
+    /** Remove a saved payment method. */
+    deletePaymentMethod(id: string): Promise<void>;
+    /** A link to the provider's portal to add a card or choose the default. */
+    managePaymentMethods(): Promise<PortalLink>;
+    /** The invoice details. */
+    details(): Promise<BillingDetails>;
+    /** Save the invoice details. */
+    setDetails(req: BillingDetails): Promise<BillingDetails>;
+    /** What a promo code gives for a top-up or a subscription. */
+    checkPromoCode(req: CheckPromoCode): Promise<PromoCodeView>;
+}
+/** `vs.languages`. */
+export declare class Languages {
+    #private;
+    constructor(t: Transport);
+    /** Spoken and translation languages. */
+    list(): Promise<LanguageLists>;
+}
+/** `vs.rtmp`. */
+export declare class Rtmp {
+    #private;
+    constructor(t: Transport);
+    /** The account's RTMP ingest: server URL (RTMPS where available), the stream key (in full only in the answer that made it, `maskedStreamKey` after), and whether an encoder is sending. */
+    status(): Promise<RtmpStatus>;
+    /** A stream key of the app's own, beside the account's: `streamKey` is in full in this answer only. It works while the API key that made it does. */
+    createKey(req: CreateAppStreamKey): Promise<CreatedAppStreamKey>;
+    /** The account's app stream keys, oldest first: masked, each with whether an encoder is sending on it (`live`, `audio`). */
+    listKeys(): Promise<AppStreamKey[]>;
+    /** Delete an app stream key: an encoder publishing on it is dropped within seconds. */
+    deleteKey(id: string): Promise<void>;
+}
+/** `vs.events`: the account socket. */
+export declare class Events {
+    #private;
+    constructor(t: Transport);
+    /** `events.ready`, then `lists.changed` whenever one of the owner's
+     * lists of broadcasts or transcriptions is out of date: re-read them. */
+    account(): Promise<WsLike>;
+}
+/** `vs.meta`. */
+export declare class Meta {
+    #private;
+    constructor(t: Transport);
+    health(): Promise<Health>;
+    /** The OpenAPI document this SDK is generated from. */
+    openapi(): Promise<Record<string, unknown>>;
+}
+export {};