@audialize/sdk 0.1.0 → 1.0.0

package/dist/index.d.cts

@@ -3,6 +3,7 @@ interface HttpClientOptions {
     baseUrl?: string;
     timeout?: number;
     maxRetries?: number;
+    defaultHeaders?: Record<string, string>;
     fetch?: typeof fetch;
 }
 declare class HttpClient {
@@ -10,16 +11,199 @@ declare class HttpClient {
     private readonly baseUrl;
     private readonly timeout;
     private readonly maxRetries;
+    private readonly defaultHeaders;
     private readonly fetchImpl;
     constructor(options: HttpClientOptions);
     request<T>(path: string, options?: RequestInit): Promise<T>;
+    requestRaw(path: string, options?: RequestInit): Promise<Response>;
+    private execute;
     private handleErrorResponse;
     private delay;
     private getBackoffDelay;
 }
 
-type JobStatus = 'pending' | 'processing' | 'completed' | 'failed';
-type JobStep = 'initializing' | 'extracting_audio' | 'transcribing' | 'translating' | 'generating_subtitles' | 'finalizing';
+declare const DOMAIN_ENTITY_KINDS: readonly ["job", "live_session", "highlight_run", "dubbing_run", "clip_artifact", "commentary_run", "artifact", "export_package"];
+type DomainEntityKind = (typeof DOMAIN_ENTITY_KINDS)[number];
+declare const CAPABILITY_READINESS_STATES: readonly ["unavailable", "queued", "processing", "partial", "review_required", "ready", "failed"];
+type CapabilityReadinessState = (typeof CAPABILITY_READINESS_STATES)[number];
+declare const CANONICAL_JOB_STATUSES: readonly ["created", "queued", "processing", "completed", "failed", "cancelled"];
+type CanonicalJobStatus = (typeof CANONICAL_JOB_STATUSES)[number];
+declare const LEGACY_JOB_STATUSES: readonly ["pending", "processing", "completed", "failed", "created", "uploaded", "initializing", "transcribing", "translating", "paused"];
+type LegacyJobStatus = (typeof LEGACY_JOB_STATUSES)[number];
+type CompatibleJobStatus = CanonicalJobStatus | LegacyJobStatus;
+declare const LEGACY_TO_CANONICAL_JOB_STATUS: Record<LegacyJobStatus, CanonicalJobStatus>;
+declare const CANONICAL_JOB_CURRENT_STEPS: readonly ["awaiting_upload", "initializing", "extracting_audio", "transcribing", "translating", "generating_subtitles", "generating_summary", "generating_dubbing", "packaging_exports", "finalizing"];
+type CanonicalJobCurrentStep = (typeof CANONICAL_JOB_CURRENT_STEPS)[number];
+declare const LEGACY_JOB_CURRENT_STEPS: readonly ["initializing", "extracting_audio", "transcribing", "translating", "cleaning_subtitles", "generating_summary", "completing"];
+type LegacyJobCurrentStep = (typeof LEGACY_JOB_CURRENT_STEPS)[number];
+type CompatibleJobCurrentStep = CanonicalJobCurrentStep | LegacyJobCurrentStep;
+declare const LEGACY_TO_CANONICAL_JOB_CURRENT_STEP: Record<LegacyJobCurrentStep, CanonicalJobCurrentStep>;
+declare const LIVE_SESSION_STATUSES: readonly ["scheduled", "starting", "live", "finalizing", "completed", "failed", "cancelled"];
+type LiveSessionStatus = (typeof LIVE_SESSION_STATUSES)[number];
+declare const LIVE_SESSION_CURRENT_STEPS: readonly ["provisioning_stream", "connecting_inputs", "capturing_audio", "transcribing_live", "translating_live", "publishing_live_subtitles", "finalizing_session", "archiving_outputs"];
+type LiveSessionCurrentStep = (typeof LIVE_SESSION_CURRENT_STEPS)[number];
+declare const HIGHLIGHT_RUN_STATUSES: readonly ["queued", "processing", "completed", "failed", "cancelled"];
+type HighlightRunStatus = (typeof HIGHLIGHT_RUN_STATUSES)[number];
+declare const HIGHLIGHT_RUN_CURRENT_STEPS: readonly ["loading_source_context", "detecting_candidates", "scoring_candidates", "selecting_moments", "rendering_clips", "indexing_results"];
+type HighlightRunCurrentStep = (typeof HIGHLIGHT_RUN_CURRENT_STEPS)[number];
+declare const DUBBING_RUN_STATUSES: readonly ["queued", "processing", "partial", "completed", "failed", "cancelled"];
+type DubbingRunStatus = (typeof DUBBING_RUN_STATUSES)[number];
+declare const DUBBING_RUN_CURRENT_STEPS: readonly ["loading_source_media", "requesting_dubbing", "dubbing_languages", "storing_dubbed_artifacts", "finalizing_outputs"];
+type DubbingRunCurrentStep = (typeof DUBBING_RUN_CURRENT_STEPS)[number];
+declare const CLIP_ARTIFACT_STATUSES: readonly ["queued", "processing", "review_required", "ready", "failed", "cancelled"];
+type ClipArtifactStatus = (typeof CLIP_ARTIFACT_STATUSES)[number];
+declare const CLIP_ARTIFACT_CURRENT_STEPS: readonly ["queued_for_render", "extracting_media_window", "rendering_clip", "burning_subtitles", "rendering_variant", "generating_thumbnail", "awaiting_review", "publishing_clip"];
+type ClipArtifactCurrentStep = (typeof CLIP_ARTIFACT_CURRENT_STEPS)[number];
+declare const COMMENTARY_RUN_STATUSES: readonly ["queued", "processing", "review_required", "completed", "failed", "cancelled"];
+type CommentaryRunStatus = (typeof COMMENTARY_RUN_STATUSES)[number];
+declare const COMMENTARY_RUN_CURRENT_STEPS: readonly ["loading_context", "assembling_prompt", "generating_outputs", "normalizing_outputs", "awaiting_review", "publishing_outputs"];
+type CommentaryRunCurrentStep = (typeof COMMENTARY_RUN_CURRENT_STEPS)[number];
+declare const ARTIFACT_STATUSES: readonly ["unavailable", "queued", "processing", "partial", "review_required", "ready", "failed", "cancelled"];
+type ArtifactStatus = (typeof ARTIFACT_STATUSES)[number];
+declare const ARTIFACT_TYPES: readonly ["source_media", "extracted_audio", "transcript_json", "subtitle_json", "subtitle_srt", "subtitle_vtt", "subtitle_ttml", "subtitle_stl", "summary_text", "summary_json", "dubbed_audio", "highlight_clip", "highlight_clip_subtitled", "social_variant", "thumbnail_image", "commentary_text", "commentary_json", "export_bundle", "live_segment", "quality_report"];
+type ArtifactType = (typeof ARTIFACT_TYPES)[number];
+declare const ARTIFACT_FORMATS: readonly ["json", "txt", "md", "srt", "vtt", "ttml", "xml", "stl", "wav", "mp3", "mp4", "jpg", "png", "zip"];
+type ArtifactFormat = (typeof ARTIFACT_FORMATS)[number];
+declare const ARTIFACT_REVIEW_STATUSES: readonly ["not_required", "pending", "approved", "rejected"];
+type ArtifactReviewStatus = (typeof ARTIFACT_REVIEW_STATUSES)[number];
+declare const ARTIFACT_CURRENT_STEPS: readonly ["awaiting_source", "generating", "validating", "awaiting_review", "publishing", "indexed"];
+type ArtifactCurrentStep = (typeof ARTIFACT_CURRENT_STEPS)[number];
+declare const EXPORT_PACKAGE_STATUSES: readonly ["queued", "processing", "partial", "ready", "failed", "cancelled"];
+type ExportPackageStatus = (typeof EXPORT_PACKAGE_STATUSES)[number];
+declare const EXPORT_PACKAGE_FORMATS: readonly ["zip", "manifest", "deliverable_bundle"];
+type ExportPackageFormat = (typeof EXPORT_PACKAGE_FORMATS)[number];
+declare const EXPORT_PACKAGE_CURRENT_STEPS: readonly ["collecting_artifacts", "validating_contents", "packaging_bundle", "publishing_package", "indexed"];
+type ExportPackageCurrentStep = (typeof EXPORT_PACKAGE_CURRENT_STEPS)[number];
+interface EntityReference<TKind extends DomainEntityKind = DomainEntityKind> {
+    id: string;
+    kind: TKind;
+}
+type SourceEntityKind = 'job' | 'live_session';
+type CommentarySourceKind = SourceEntityKind | 'highlight_run' | 'clip_artifact';
+type ArtifactOwnerKind = CommentarySourceKind | 'commentary_run' | 'dubbing_run' | 'export_package';
+type SourceEntityReference<TKind extends SourceEntityKind = SourceEntityKind> = EntityReference<TKind>;
+type CommentarySourceReference<TKind extends CommentarySourceKind = CommentarySourceKind> = EntityReference<TKind>;
+type ArtifactOwnerReference<TKind extends ArtifactOwnerKind = ArtifactOwnerKind> = EntityReference<TKind>;
+interface BaseDomainEntity<TKind extends DomainEntityKind, TStatus extends string, TStep extends string> {
+    id: string;
+    kind: TKind;
+    status: TStatus;
+    currentStep: TStep | null;
+    progress: number | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    failedAt?: string | null;
+    cancelledAt?: string | null;
+    retryCount?: number;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+}
+interface JobCapabilityReadiness {
+    subtitles: CapabilityReadinessState;
+    summary: CapabilityReadinessState;
+    dubbing: CapabilityReadinessState;
+    highlights: CapabilityReadinessState;
+    commentary: CapabilityReadinessState;
+    exports: CapabilityReadinessState;
+}
+interface CanonicalJob extends BaseDomainEntity<'job', CanonicalJobStatus, CanonicalJobCurrentStep> {
+    jobId: string;
+    fileName: string;
+    sourceLanguage: string | null;
+    targetLanguages: string[];
+    sourceMediaArtifactId?: string | null;
+    readiness: JobCapabilityReadiness;
+    highlightRunIds?: string[];
+    commentaryRunIds?: string[];
+    artifactIds?: string[];
+    exportPackageIds?: string[];
+    rerunOfJobId?: string | null;
+}
+interface LiveSession extends BaseDomainEntity<'live_session', LiveSessionStatus, LiveSessionCurrentStep> {
+    sessionId: string;
+    title: string;
+    sourceLanguage: string | null;
+    targetLanguages: string[];
+    derivedJobId?: string | null;
+    artifactIds?: string[];
+    readiness: CapabilityReadinessState;
+}
+interface HighlightRun extends BaseDomainEntity<'highlight_run', HighlightRunStatus, HighlightRunCurrentStep> {
+    runId: string;
+    source: SourceEntityReference;
+    clipArtifactIds: string[];
+    candidateCount?: number;
+    selectedCount?: number;
+    profile?: 'default' | 'sport' | 'interview' | 'documentary' | 'social' | null;
+    readiness: CapabilityReadinessState;
+}
+interface DubbingRun extends BaseDomainEntity<'dubbing_run', DubbingRunStatus, DubbingRunCurrentStep> {
+    runId: string;
+    source: SourceEntityReference<'job'>;
+    targetLanguages: string[];
+    completedLanguages?: string[];
+    failedLanguages?: string[];
+    artifactIds?: string[];
+    error?: string;
+    readiness: CapabilityReadinessState;
+}
+interface ClipArtifact extends BaseDomainEntity<'clip_artifact', ClipArtifactStatus, ClipArtifactCurrentStep> {
+    clipId: string;
+    highlightRunId: string;
+    source: SourceEntityReference;
+    startMs: number;
+    endMs: number;
+    artifactIds?: string[];
+    renderStatus?: 'completed' | 'failed' | 'processing' | null;
+    thumbnailPath?: string | null;
+    readiness: CapabilityReadinessState;
+}
+interface CommentaryRun extends BaseDomainEntity<'commentary_run', CommentaryRunStatus, CommentaryRunCurrentStep> {
+    runId: string;
+    source: CommentarySourceReference;
+    outputKinds: string[];
+    artifactIds?: string[];
+    readiness: CapabilityReadinessState;
+}
+interface Artifact extends BaseDomainEntity<'artifact', ArtifactStatus, ArtifactCurrentStep> {
+    artifactId: string;
+    owner: ArtifactOwnerReference;
+    artifactType: ArtifactType;
+    language?: string | null;
+    format?: ArtifactFormat | null;
+    storageKey?: string | null;
+    storagePath?: string | null;
+    bucketName?: string | null;
+    mimeType?: string | null;
+    sizeBytes?: number | null;
+    checksum?: string | null;
+    reviewStatus?: ArtifactReviewStatus | null;
+    variantLabel?: string | null;
+    readiness: CapabilityReadinessState;
+}
+interface ExportPackage extends BaseDomainEntity<'export_package', ExportPackageStatus, ExportPackageCurrentStep> {
+    exportPackageId: string;
+    owner: SourceEntityReference;
+    artifactIds: string[];
+    packageFormat: ExportPackageFormat;
+    readiness: CapabilityReadinessState;
+}
+declare const JOB_STATUS_TRANSITIONS: Record<CanonicalJobStatus, readonly CanonicalJobStatus[]>;
+declare const LIVE_SESSION_STATUS_TRANSITIONS: Record<LiveSessionStatus, readonly LiveSessionStatus[]>;
+declare const HIGHLIGHT_RUN_STATUS_TRANSITIONS: Record<HighlightRunStatus, readonly HighlightRunStatus[]>;
+declare const DUBBING_RUN_STATUS_TRANSITIONS: Record<DubbingRunStatus, readonly DubbingRunStatus[]>;
+declare const CLIP_ARTIFACT_STATUS_TRANSITIONS: Record<ClipArtifactStatus, readonly ClipArtifactStatus[]>;
+declare const COMMENTARY_RUN_STATUS_TRANSITIONS: Record<CommentaryRunStatus, readonly CommentaryRunStatus[]>;
+declare const ARTIFACT_STATUS_TRANSITIONS: Record<ArtifactStatus, readonly ArtifactStatus[]>;
+declare const EXPORT_PACKAGE_STATUS_TRANSITIONS: Record<ExportPackageStatus, readonly ExportPackageStatus[]>;
+declare function normalizeJobStatus(status: CompatibleJobStatus): CanonicalJobStatus;
+declare function normalizeJobCurrentStep(step: CompatibleJobCurrentStep): CanonicalJobCurrentStep;
+declare function isValidTransition<TStatus extends string>(transitionMap: Record<TStatus, readonly TStatus[]>, from: TStatus, to: TStatus): boolean;
+
+type JobStatus = CompatibleJobStatus;
+type JobStep = CompatibleJobCurrentStep;
 interface Job {
     jobId: string;
     fileName: string;
@@ -31,6 +215,44 @@ interface Job {
     updatedAt: string;
     error?: string;
 }
+interface CreateJobOptions {
+    fileName: string;
+    languages: string[];
+    sourceLanguage?: string;
+}
+interface CreateJobResponse {
+    jobId: string;
+    success?: boolean;
+    message?: string;
+}
+interface DeleteJobResponse {
+    success?: boolean;
+    message?: string;
+    [key: string]: unknown;
+}
+type JobControlAction = 'pause' | 'resume' | 'stop' | 'restart';
+interface PauseResumeJobRequest {
+    action: JobControlAction;
+}
+interface SubmitJobFeedbackRequest {
+    language: string;
+    segmentIndex: number;
+    rating: number;
+    reason?: string;
+}
+interface GenerateJobQualityInsightsRequest {
+    language?: string;
+    metrics: Record<string, unknown>;
+}
+interface JobOperationResponse {
+    [key: string]: unknown;
+}
+interface StartJobRequest {
+    [key: string]: unknown;
+}
+interface StartJobResponse {
+    [key: string]: unknown;
+}
 
 interface ListOptions {
     limit?: number;
@@ -41,6 +263,180 @@ interface PagedResponse<T> {
     nextPageToken?: string;
 }
 
+type ReleaseStage = 'ga' | 'beta' | 'internal';
+type CapabilityKey = 'highlights' | 'commentary' | 'exports' | 'dubbing';
+interface CapabilityReadinessEntry {
+    capability: CapabilityKey;
+    readiness: CapabilityReadinessState;
+    releaseStage: ReleaseStage;
+    latestRunId?: string;
+    latestUpdatedAt?: string;
+}
+interface JobCapabilityReadinessResponse {
+    jobId: string;
+    capabilities: CapabilityReadinessEntry[];
+}
+interface StartJobCapabilityRunRequest {
+    config?: Record<string, unknown>;
+}
+interface StartJobCapabilityRunResponse {
+    jobId: string;
+    capability: CapabilityKey;
+    runId: string;
+    releaseStage: ReleaseStage;
+}
+interface ListJobArtifactsOptions {
+    type?: string;
+    language?: string;
+    status?: string;
+}
+interface ListJobExportPackagesOptions {
+    status?: ExportPackage['status'];
+    packageFormat?: ExportPackageFormat;
+}
+interface ListArtifactsOptions {
+    limit?: number;
+    pageToken?: string;
+    ownerKind?: ArtifactOwnerKind;
+    ownerId?: string;
+    type?: string;
+    language?: string;
+    status?: string;
+    releaseStage?: ReleaseStage;
+}
+interface ListCommentaryRunsOptions extends ListOptions {
+    sourceKind?: CommentarySourceKind;
+    sourceId?: string;
+    status?: CommentaryRun['status'];
+}
+interface ListLiveSessionsOptions extends ListOptions {
+    status?: LiveSession['status'];
+}
+interface ListExportPackagesOptions extends ListOptions {
+    ownerKind?: 'job' | 'live_session';
+    ownerId?: string;
+    status?: ExportPackage['status'];
+    packageFormat?: ExportPackageFormat;
+}
+type ArtifactListResponse = PagedResponse<Artifact>;
+interface CreateHighlightRunRequest {
+    source: {
+        kind: 'job' | 'live_session';
+        id: string;
+    };
+    profile?: string;
+    requestedClipCount?: number;
+}
+interface ListHighlightRunsOptions {
+    sourceKind?: 'job' | 'live_session';
+    sourceId?: string;
+    status?: string;
+}
+type HighlightRunListResponse = PagedResponse<HighlightRun>;
+type ClipArtifactListResponse = PagedResponse<ClipArtifact>;
+interface CreateClipVariantRequest {
+    variantId: string;
+    profile?: string;
+}
+interface ClipApprovalRequest {
+    decision: 'approve' | 'reject';
+    note?: string;
+}
+interface ClipApprovalResponse {
+    clipId: string;
+    status: ClipArtifact['status'];
+}
+interface ClipSocialExportResponse {
+    clipId: string;
+    triggered: number;
+    languages: string[];
+}
+interface CreateLiveSessionRequest {
+    title: string;
+    sourceLanguage?: string;
+    targetLanguages: string[];
+    sourceUrl?: string;
+}
+type LiveSessionListResponse = PagedResponse<LiveSession>;
+interface RollingSubtitleSegment {
+    segmentId: string;
+    language: string;
+    startMs: number;
+    endMs: number;
+    text: string;
+    publishedAt: string;
+    artifactId?: string;
+    storagePath?: string;
+}
+type RollingSubtitleSegmentListResponse = PagedResponse<RollingSubtitleSegment>;
+interface PublishRollingSubtitleSegmentInput {
+    language?: string;
+    startMs: number;
+    endMs: number;
+    text: string;
+}
+interface PublishRollingSubtitlesRequest {
+    segments: PublishRollingSubtitleSegmentInput[];
+}
+interface PublishRollingSubtitlesResponse {
+    session: LiveSession;
+    items: RollingSubtitleSegment[];
+}
+interface StopLiveSessionRequest {
+    finalize?: boolean;
+}
+interface CreateCommentaryRunRequest {
+    source: {
+        kind: CommentarySourceKind;
+        id: string;
+    };
+    outputKinds: string[];
+    templateId?: string;
+}
+type CommentaryRunListResponse = PagedResponse<CommentaryRun>;
+interface CommentaryOutputItem {
+    outputId: string;
+    kind: string;
+    title?: string;
+    artifactId?: string;
+    textPreview?: string;
+    createdAt: string;
+}
+type CommentaryOutputListResponse = PagedResponse<CommentaryOutputItem>;
+interface SignedArtifactUrlResponse {
+    artifactId: string;
+    url: string;
+    expiresAt: string;
+}
+interface SignedExportPackageUrlResponse {
+    exportPackageId: string;
+    url: string;
+    expiresAt: string;
+}
+interface CreateJobWithCapabilitiesRequest {
+    job: {
+        fileName: string;
+        languages: string[];
+        sourceLanguage?: string;
+    };
+    requestedCapabilities?: CapabilityKey[];
+}
+interface CreateJobWithCapabilitiesResponse {
+    job: Job;
+    capabilities: CapabilityReadinessEntry[];
+    releaseStage: ReleaseStage;
+}
+type ListJobArtifactsResponse = PagedResponse<Artifact>;
+type ListJobHighlightRunsResponse = PagedResponse<HighlightRun>;
+type ListJobCommentaryRunsResponse = PagedResponse<CommentaryRun>;
+type ListJobExportPackagesResponse = PagedResponse<ExportPackage>;
+type ExportPackageListResponse = PagedResponse<ExportPackage>;
+interface ListDubbingRunsOptions extends ListOptions {
+    sourceId?: string;
+    status?: DubbingRun['status'];
+}
+type DubbingRunListResponse = PagedResponse<DubbingRun>;
+
 interface PollOptions {
     interval?: number;
     maxInterval?: number;
@@ -77,7 +473,33 @@ interface WaitForCompletionOptions extends PollOptions {
 declare class JobsResource {
     private readonly client;
     constructor(client: HttpClient);
+    start(request: StartJobRequest): Promise<StartJobResponse>;
+    create(options: CreateJobOptions): Promise<CreateJobResponse>;
+    updateSubtitles(jobId: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    updateSubtitlesForLanguage(jobId: string, language: string, body: string, contentType: string): Promise<{
+        body: string;
+        contentType: string;
+        statusCode: number;
+    }>;
+    getSubtitles(jobId: string, language: string): Promise<Record<string, unknown>>;
+    getSummary(jobId: string, language?: string): Promise<Record<string, unknown>>;
+    generateSummary(jobId: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    cleanSubtitles(jobId: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getThumbnail(jobId: string): Promise<Record<string, unknown>>;
+    getVideo(jobId: string): Promise<Record<string, unknown>>;
+    getAudio(jobId: string, language: string): Promise<Response>;
+    updateSpeakerNames(payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    pauseResume(jobId: string, payload: PauseResumeJobRequest): Promise<JobOperationResponse>;
+    submitFeedback(jobId: string, payload: SubmitJobFeedbackRequest): Promise<JobOperationResponse>;
+    generateQualityAiInsights(jobId: string, payload: GenerateJobQualityInsightsRequest): Promise<JobOperationResponse>;
     get(jobId: string): Promise<Job>;
+    delete(jobId: string): Promise<DeleteJobResponse>;
+    getCapabilityReadiness(jobId: string): Promise<JobCapabilityReadinessResponse>;
+    listArtifacts(jobId: string, options?: ListJobArtifactsOptions): Promise<ListJobArtifactsResponse>;
+    startCapabilityRun(jobId: string, capability: CapabilityKey, request?: StartJobCapabilityRunRequest): Promise<StartJobCapabilityRunResponse>;
+    listHighlights(jobId: string): Promise<ListJobHighlightRunsResponse>;
+    listCommentary(jobId: string): Promise<ListJobCommentaryRunsResponse>;
+    listExports(jobId: string, options?: ListJobExportPackagesOptions): Promise<ListJobExportPackagesResponse>;
     list(options?: ListOptions): Promise<PagedResponse<Job>>;
     /**
      * Polls until the job reaches `completed` or `failed`, then returns the final job.
@@ -91,6 +513,63 @@ declare class JobsResource {
     poll(jobId: string, options?: PollOptions): JobPoller;
 }
 
+declare class HighlightsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    create(request: CreateHighlightRunRequest): Promise<HighlightRun>;
+    list(options?: ListHighlightRunsOptions): Promise<HighlightRunListResponse>;
+    get(runId: string): Promise<HighlightRun>;
+    listClips(runId: string): Promise<ClipArtifactListResponse>;
+    getClip(clipId: string): Promise<ClipArtifact>;
+    createVariant(clipId: string, request: CreateClipVariantRequest): Promise<ClipArtifact>;
+    approve(clipId: string, request: ClipApprovalRequest): Promise<ClipApprovalResponse>;
+    socialExport(clipId: string): Promise<ClipSocialExportResponse>;
+}
+
+declare class LiveSessionsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    create(request: CreateLiveSessionRequest): Promise<LiveSession>;
+    list(options?: ListLiveSessionsOptions): Promise<LiveSessionListResponse>;
+    get(sessionId: string): Promise<LiveSession>;
+    getRollingSubtitles(sessionId: string): Promise<RollingSubtitleSegmentListResponse>;
+    publishRollingSubtitles(sessionId: string, request: PublishRollingSubtitlesRequest): Promise<PublishRollingSubtitlesResponse>;
+    stop(sessionId: string, request?: StopLiveSessionRequest): Promise<LiveSession>;
+}
+
+declare class CommentaryResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    create(request: CreateCommentaryRunRequest): Promise<CommentaryRun>;
+    list(options?: ListCommentaryRunsOptions): Promise<CommentaryRunListResponse>;
+    get(runId: string): Promise<CommentaryRun>;
+    listOutputs(runId: string): Promise<CommentaryOutputListResponse>;
+}
+
+declare class DubbingResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(options?: ListDubbingRunsOptions): Promise<DubbingRunListResponse>;
+    get(runId: string): Promise<DubbingRun>;
+    getForJob(jobId: string): Promise<DubbingRun>;
+}
+
+declare class ArtifactsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(options?: ListArtifactsOptions): Promise<ArtifactListResponse>;
+    get(artifactId: string): Promise<Artifact>;
+    createSignedUrl(artifactId: string): Promise<SignedArtifactUrlResponse>;
+}
+
+declare class ExportPackagesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(options?: ListExportPackagesOptions): Promise<ExportPackageListResponse>;
+    get(exportPackageId: string): Promise<ExportPackage>;
+    createSignedUrl(exportPackageId: string): Promise<SignedExportPackageUrlResponse>;
+}
+
 interface Language {
     code: string;
     name: string;
@@ -163,6 +642,22 @@ interface CompleteMultipartUploadResponse {
     success: boolean;
     jobId: string;
 }
+type PresignedUrlRequestType = 'upload' | 'download' | 'thumbnail' | 'complete-multipart';
+interface PresignedUrlRequest {
+    type: PresignedUrlRequestType;
+    [key: string]: unknown;
+}
+interface PresignedUrlResponse {
+    url?: string;
+    uploadUrl?: string;
+    presignedUrl?: string;
+    downloadUrl?: string;
+    key?: string;
+    filename?: string;
+    jobId?: string;
+    success?: boolean;
+    [key: string]: unknown;
+}
 
 type FileInput = string | Buffer | Blob | File | ReadableStream;
 /** Default file size above which multipart upload is used (100 MB). */
@@ -178,6 +673,7 @@ interface MultipartUploadOptions extends UploadOptions {
 declare class FilesResource {
     private readonly client;
     constructor(client: HttpClient);
+    createPresignedUrl(request: PresignedUrlRequest): Promise<PresignedUrlResponse>;
     upload(file: FileInput, options: SingleUploadOptions): Promise<{
         jobId: string;
     }>;
@@ -205,10 +701,17 @@ interface AudiolizeClientOptions {
     baseUrl?: string;
     timeout?: number;
     maxRetries?: number;
+    defaultHeaders?: Record<string, string>;
 }
 declare class AudiolizeClient {
     private readonly http;
     readonly jobs: JobsResource;
+    readonly highlights: HighlightsResource;
+    readonly liveSessions: LiveSessionsResource;
+    readonly commentary: CommentaryResource;
+    readonly dubbing: DubbingResource;
+    readonly artifacts: ArtifactsResource;
+    readonly exportPackages: ExportPackagesResource;
     readonly languages: LanguagesResource;
     readonly subtitles: SubtitlesResource;
     readonly files: FilesResource;
@@ -275,4 +778,4 @@ interface RetryOptions {
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 
-export { AudiolizeApiError, AudiolizeClient, type AudiolizeClientOptions, AudiolizeError, AudiolizeTimeoutError, AudiolizeUploadError, AudiolizeValidationError, AuthenticationError, AuthorizationError, type CompleteMultipartUploadResponse, DEFAULT_MULTIPART_THRESHOLD, type FileInput, FilesResource, type Job, type JobContext, JobPoller, type JobStatus, type JobStep, JobsResource, type Language, LanguagesResource, type ListOptions, type LocalizeOptions, type LocalizeResult, type MultipartUploadOptions, NotFoundError, type PagedResponse, PaywallError, type PollOptions, type PresignedMultipartUploadResponse, type PresignedUploadResponse, RateLimitError, type RetryOptions, ServerError, type SingleUploadOptions, type SubtitleCue, type SubtitleFormat, type SubtitleResult, SubtitlesResource, type TranscriptionOptions, type UploadOptions, type WaitForCompletionOptions, getBackoffDelay, localize, withRetry };
+export { ARTIFACT_CURRENT_STEPS, ARTIFACT_FORMATS, ARTIFACT_REVIEW_STATUSES, ARTIFACT_STATUSES, ARTIFACT_STATUS_TRANSITIONS, ARTIFACT_TYPES, type Artifact, type ArtifactCurrentStep, type ArtifactFormat, type ArtifactListResponse, type ArtifactOwnerKind, type ArtifactOwnerReference, type ArtifactReviewStatus, type ArtifactStatus, type ArtifactType, ArtifactsResource, AudiolizeApiError, AudiolizeClient, type AudiolizeClientOptions, AudiolizeError, AudiolizeTimeoutError, AudiolizeUploadError, AudiolizeValidationError, AuthenticationError, AuthorizationError, type BaseDomainEntity, CANONICAL_JOB_CURRENT_STEPS, CANONICAL_JOB_STATUSES, CAPABILITY_READINESS_STATES, CLIP_ARTIFACT_CURRENT_STEPS, CLIP_ARTIFACT_STATUSES, CLIP_ARTIFACT_STATUS_TRANSITIONS, COMMENTARY_RUN_CURRENT_STEPS, COMMENTARY_RUN_STATUSES, COMMENTARY_RUN_STATUS_TRANSITIONS, type CanonicalJob, type CanonicalJobCurrentStep, type CanonicalJobStatus, type CapabilityKey, type CapabilityReadinessEntry, type CapabilityReadinessState, type ClipApprovalRequest, type ClipApprovalResponse, type ClipArtifact, type ClipArtifactCurrentStep, type ClipArtifactListResponse, type ClipArtifactStatus, type ClipSocialExportResponse, type CommentaryOutputItem, type CommentaryOutputListResponse, CommentaryResource, type CommentaryRun, type CommentaryRunCurrentStep, type CommentaryRunListResponse, type CommentaryRunStatus, type CommentarySourceKind, type CommentarySourceReference, type CompatibleJobCurrentStep, type CompatibleJobStatus, type CompleteMultipartUploadResponse, type CreateClipVariantRequest, type CreateCommentaryRunRequest, type CreateHighlightRunRequest, type CreateJobOptions, type CreateJobResponse, type CreateJobWithCapabilitiesRequest, type CreateJobWithCapabilitiesResponse, type CreateLiveSessionRequest, DEFAULT_MULTIPART_THRESHOLD, DOMAIN_ENTITY_KINDS, DUBBING_RUN_CURRENT_STEPS, DUBBING_RUN_STATUSES, DUBBING_RUN_STATUS_TRANSITIONS, type DeleteJobResponse, type DomainEntityKind, DubbingResource, type DubbingRun, type DubbingRunCurrentStep, type DubbingRunListResponse, type DubbingRunStatus, EXPORT_PACKAGE_CURRENT_STEPS, EXPORT_PACKAGE_FORMATS, EXPORT_PACKAGE_STATUSES, EXPORT_PACKAGE_STATUS_TRANSITIONS, type EntityReference, type ExportPackage, type ExportPackageCurrentStep, type ExportPackageFormat, type ExportPackageListResponse, type ExportPackageStatus, ExportPackagesResource, type FileInput, FilesResource, type GenerateJobQualityInsightsRequest, HIGHLIGHT_RUN_CURRENT_STEPS, HIGHLIGHT_RUN_STATUSES, HIGHLIGHT_RUN_STATUS_TRANSITIONS, type HighlightRun, type HighlightRunCurrentStep, type HighlightRunListResponse, type HighlightRunStatus, HighlightsResource, JOB_STATUS_TRANSITIONS, type Job, type JobCapabilityReadiness, type JobCapabilityReadinessResponse, type JobContext, type JobControlAction, type JobOperationResponse, JobPoller, type JobStatus, type JobStep, JobsResource, LEGACY_JOB_CURRENT_STEPS, LEGACY_JOB_STATUSES, LEGACY_TO_CANONICAL_JOB_CURRENT_STEP, LEGACY_TO_CANONICAL_JOB_STATUS, LIVE_SESSION_CURRENT_STEPS, LIVE_SESSION_STATUSES, LIVE_SESSION_STATUS_TRANSITIONS, type Language, LanguagesResource, type LegacyJobCurrentStep, type LegacyJobStatus, type ListArtifactsOptions, type ListCommentaryRunsOptions, type ListDubbingRunsOptions, type ListExportPackagesOptions, type ListHighlightRunsOptions, type ListJobArtifactsOptions, type ListJobArtifactsResponse, type ListJobCommentaryRunsResponse, type ListJobExportPackagesOptions, type ListJobExportPackagesResponse, type ListJobHighlightRunsResponse, type ListLiveSessionsOptions, type ListOptions, type LiveSession, type LiveSessionCurrentStep, type LiveSessionListResponse, type LiveSessionStatus, LiveSessionsResource, type LocalizeOptions, type LocalizeResult, type MultipartUploadOptions, NotFoundError, type PagedResponse, type PauseResumeJobRequest, PaywallError, type PollOptions, type PresignedMultipartUploadResponse, type PresignedUploadResponse, type PresignedUrlRequest, type PresignedUrlRequestType, type PresignedUrlResponse, type PublishRollingSubtitleSegmentInput, type PublishRollingSubtitlesRequest, type PublishRollingSubtitlesResponse, RateLimitError, type ReleaseStage, type RetryOptions, type RollingSubtitleSegment, type RollingSubtitleSegmentListResponse, ServerError, type SignedArtifactUrlResponse, type SignedExportPackageUrlResponse, type SingleUploadOptions, type SourceEntityKind, type SourceEntityReference, type StartJobCapabilityRunRequest, type StartJobCapabilityRunResponse, type StartJobRequest, type StartJobResponse, type StopLiveSessionRequest, type SubmitJobFeedbackRequest, type SubtitleCue, type SubtitleFormat, type SubtitleResult, SubtitlesResource, type TranscriptionOptions, type UploadOptions, type WaitForCompletionOptions, getBackoffDelay, isValidTransition, localize, normalizeJobCurrentStep, normalizeJobStatus, withRetry };