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

package/dist/resources.d.ts

@@ -1,147 +1,82 @@
-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 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';
-/** 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`). */
+    archiveMany(ids: string[]): Promise<ManyResult>;
+    restoreMany(ids: string[]): Promise<ManyResult>;
+    purgeMany(ids: string[]): Promise<ManyResult>;
     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;
@@ -149,115 +84,108 @@ export declare class Batches {
         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. */
+    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>;
-    /** 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. */
+        shareCode?: string;
         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';
+        kind?: 'delivery' | 'background' | 'speech' | '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). */
+    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>;
-    /** 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`. */
+    renderVoice(id: string, req: RenderVoice & ReadAs, call?: CallOptions): Promise<VoiceTrack[]>;
     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 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>;
-    /** 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;
@@ -265,37 +193,43 @@ export declare class Jobs {
         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);
+    open(code: string): Promise<SharedTranscript>;
     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 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(): Promise<Voice[]>;
+    list(opts?: {
+        lifecycle?: 'active' | 'archived';
+    }): 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`). */
+    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;
@@ -305,50 +239,37 @@ export declare class Voices {
         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. */
+    setConsent(id: string, consent: 'granted' | 'refused', opts?: {
+        name?: string;
+    }): Promise<Voice>;
     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 {
@@ -359,163 +280,95 @@ export interface Me {
     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>>;
+    clientPolicy(client: ClientApp): Promise<ClientPolicy>;
 }
 export {};