@byte_fluffy/nexra-sdk 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/{catalog-mytCeh5t.d.ts → media-geometry-Ckr1-Mh3.d.ts}

@@ -10,28 +10,6 @@ interface CursorPage<T> {
 
 declare const BILLING_METRICS: readonly ["requests", "input_tokens", "cached_input_tokens", "cache_write_tokens", "cache_creation_5m_input_tokens", "cache_creation_1h_input_tokens", "cache_read_input_tokens", "output_tokens", "input_characters", "input_utf8_bytes", "input_images", "output_images", "input_audio_seconds", "output_audio_seconds", "input_video_seconds", "output_video_seconds", "provider_credits", "web_search_requests"];
 type BillingMetric = (typeof BILLING_METRICS)[number];
-declare const BILLING_EXPORT_DIMENSIONS: readonly ["resolution", "duration", "layer_decomposition", "with_audio", "has_input_video", "hd", "prompt_extend", "modality", "tier", "quality", "image_count", "input_token_tier", "input_modality", "service_tier", "inference_geo", "speed", "region_scope", "has_reference_image", "mode"];
-type UsageComponentEvidence = {
-    source: "provider_native" | "request_derived" | "response_derived" | "tariff_equivalent" | "unknown";
-    paths?: string[];
-    calculation?: string;
-};
-interface MeteredUsageComponent {
-    metric: BillingMetric;
-    quantity: number;
-    dimensions?: Record<string, JsonPrimitive>;
-    evidence?: UsageComponentEvidence;
-}
-/**
- * Provider evidence is normalized into independent metered components instead
- * of one canonical model response. This keeps protocol conversion separate
- * from billing and allows one request to carry differently-dimensioned usage.
- */
-interface NormalizedUsageV1 {
-    schemaVersion: 1;
-    components: MeteredUsageComponent[];
-    billingEvidenceComplete?: boolean;
-}
 interface MeteredPriceRate {
     metric: BillingMetric;
     unitSize: number;
@@ -46,42 +24,8 @@ interface MeteredPriceRuleV1 {
     rates: MeteredPriceRate[];
 }
 type PriceRule = MeteredPriceRuleV1;
-interface PriceEvaluationLine {
-    evidence?: UsageComponentEvidence;
-    metric: BillingMetric;
-    quantity: number;
-    unitSize: number;
-    unitPrice: string;
-    rounding: "proportional" | "ceil";
-    includedQuantity: number;
-    dimensions?: Record<string, JsonPrimitive>;
-    amount: string;
-    discountedAmount?: string;
-}
-/** Preserve frozen row order when distributing the eight-decimal remainder. */
-declare function allocateDiscountedPriceLines(lines: readonly PriceEvaluationLine[], saleAmount: string): PriceEvaluationLine[];
-interface PriceEvaluationIssue {
-    code: "dimension_mismatch" | "ambiguous_rate" | "missing_usage";
-    metric: BillingMetric;
-    componentIndex: number;
-}
-interface PriceEvaluation {
-    status: "rated" | "incomplete";
-    amount: string;
-    lines: PriceEvaluationLine[];
-    issues: PriceEvaluationIssue[];
-}
-declare function validateNormalizedUsage(value: unknown): asserts value is NormalizedUsageV1;
-/**
- * Deterministically rates normalized usage without mutating wallets or billing
- * records. Amounts are rounded half-up to the database's eight-decimal money
- * scale per line; ceil rates round usage units before multiplying the price.
- */
-declare function evaluatePriceRule(ruleValue: unknown, usageValue: unknown): PriceEvaluation;
-declare function validatePriceRule(value: unknown): asserts value is PriceRule;
 
 type MeteringKind = "token" | "non_token" | "mixed";
-type UsageEvidenceStatus = "complete" | "partial" | "missing" | "invalid" | "not_expected";
 interface MeteringContract {
     schemaVersion: 1;
     kind: MeteringKind;
@@ -91,17 +35,6 @@ interface MeteringContract {
         whenFeature?: string;
     }>;
 }
-interface UsageEvidenceAssessment {
-    kind: MeteringKind | "unknown";
-    evidenceStatus: UsageEvidenceStatus;
-    expectedMetrics: BillingMetric[];
-    observedMetrics: BillingMetric[];
-    missingMetrics: BillingMetric[];
-    issues: string[];
-}
-declare function validateMeteringContract(value: unknown): asserts value is MeteringContract;
-/** Evidence completeness is independent of sale/cost prices and delivery success. */
-declare function assessUsageEvidence(contract: unknown, usage: unknown, features?: Readonly<Record<string, boolean>>): UsageEvidenceAssessment;
 
 type ModelModality = "language" | "embedding" | "reranker" | "image" | "video" | "audio" | "world" | "multimodal" | "other";
 interface ModelEndpointSummary {
@@ -121,6 +54,10 @@ interface ModelCapabilitySummary {
     /** User-facing input patterns such as text-to-video or image-to-image. */
     inputModes: string[];
     features: string[];
+    /** Maximum combined input and output context supported by the model. */
+    contextWindowTokens?: number;
+    /** Maximum generated output tokens supported by the model. */
+    maxOutputTokens?: number;
 }
 interface ModelDateVersion {
     id: string;
@@ -228,6 +165,15 @@ interface NexraModelOperation {
     outputSchema: JsonObject;
     metering: MeteringContract;
 }
+/** Public native wire endpoint metadata. Provider routing and credentials stay private. */
+interface NexraModelEndpointSpec {
+    endpointKey: string;
+    operation: string;
+    protocol: string;
+    method: string;
+    path: string;
+    capabilities: readonly string[];
+}
 interface NexraModelSpec {
     id: string;
     contractVersion: number;
@@ -240,6 +186,7 @@ interface NexraModelSpec {
     aliases: readonly string[];
     capabilities: ModelCapabilitySummary;
     operations: readonly NexraModelOperation[];
+    endpoints: readonly NexraModelEndpointSpec[];
 }
 interface NexraModelSpecFilter {
     kind?: ModelModality;
@@ -253,11 +200,23 @@ interface NexraSalePrice {
     effectiveFrom: string;
     rule: PriceRule;
 }
+interface NexraSalePriceList {
+    currency: NexraBillingCurrency;
+    prices: readonly NexraSalePrice[];
+}
 interface CreateNexraQuoteRequest {
     modelId: string;
     operation: string;
     input: JsonObject;
 }
+interface CreateNexraDisplayQuoteBatchRequest {
+    modelId: string;
+    operation: string;
+    entries: readonly Readonly<{
+        key: string;
+        input: JsonObject;
+    }>[];
+}
 interface NexraQuote {
     quoteToken: string;
     modelId: string;
@@ -269,6 +228,32 @@ interface NexraQuote {
     accuracy: "exact" | "estimated";
     expiresAt: string;
 }
+type NexraDisplayQuoteBatchEntry = Readonly<{
+    key: string;
+    amount: string;
+    maximumAmount: string;
+    accuracy: "exact" | "estimated";
+}> | Readonly<{
+    key: string;
+    error: {
+        code: string;
+        message: string;
+    };
+}>;
+interface NexraDisplayQuoteBatch {
+    modelId: string;
+    contractVersion: number;
+    priceRevision: string;
+    pricingPolicyRevision: string;
+    quoteContextRevision: string;
+    currency: NexraBillingCurrency;
+    entries: readonly NexraDisplayQuoteBatchEntry[];
+    expiresAt: string;
+}
+interface NexraCatalogRevision {
+    revision: string;
+    changedAt: string;
+}
 interface NexraSettlement {
     amount: string;
     currency: NexraBillingCurrency;
@@ -298,16 +283,36 @@ declare class HttpTransport {
     json<T>(path: string, init?: RequestInit, options?: RequestOptions): Promise<T>;
     response(path: string, init?: RequestInit, options?: RequestOptions): Promise<Response>;
 }
-declare function jsonBody(value: unknown): Pick<RequestInit, "body" | "headers">;
-declare function queryString(values: Record<string, string | number | undefined>): string;
-declare function sleep(milliseconds: number, signal?: AbortSignal | null): Promise<void>;
 
-declare class CatalogClient {
-    private readonly transport;
-    constructor(transport: HttpTransport);
-    quote(request: CreateNexraQuoteRequest, signal?: AbortSignal): Promise<NexraQuote>;
-}
-declare function getModelSpec(modelId: string): NexraModelSpec | undefined;
-declare function listModelSpecs(filter?: NexraModelSpecFilter): readonly NexraModelSpec[];
+/** Unified canvas vocabulary: resolution 1K/2K/4K, ratio X:X. */
+type UnifiedMediaGeometry = {
+    resolution?: string;
+    ratio?: string;
+    quality?: string;
+};
+type MediaGeometryField = {
+    field: string;
+    nest?: string;
+    options: readonly string[];
+    default?: string;
+    optionLabels: Readonly<Record<string, string>>;
+};
+type MediaGeometryProjection = {
+    kind: "pixel-size" | "tier-size" | "resolution-ratio" | "ratio-only" | "none";
+    resolution?: MediaGeometryField;
+    ratio?: MediaGeometryField;
+    quality?: MediaGeometryField;
+};
+/** Schema → unified resolution/ratio/quality controls for app UIs. */
+declare function projectMediaGeometry(inputSchema: JsonObject): MediaGeometryProjection;
+/** Unified geometry → the model's native catalog fields (channel original params). */
+declare function encodeMediaGeometry(inputSchema: JsonObject, geometry: UnifiedMediaGeometry): JsonObject;
+/** Native catalog fields → unified resolution/ratio/quality. */
+declare function decodeMediaGeometry(inputSchema: JsonObject, nativeInput: JsonObject): UnifiedMediaGeometry;
+/**
+ * Rewrite a Task/quote body: unified keys become native catalog fields.
+ * Native size/ratio already present is left alone (existing callers keep working).
+ */
+declare function applyMediaGeometry(inputSchema: JsonObject, input: JsonObject): JsonObject;
 
-export { type NormalizedUsageV1 as A, type BillingMetric as B, type CursorPage as C, type PriceEvaluationIssue as D, type PriceEvaluationLine as E, type FetchLike as F, type PriceRule as G, HttpTransport as H, type UsageEvidenceAssessment as I, type JsonObject as J, type UsageEvidenceStatus as K, allocateDiscountedPriceLines as L, type ModelSearchParams as M, type NexraSettlement as N, assessUsageEvidence as O, type PriceEvaluation as P, evaluatePriceRule as Q, getModelSpec as R, jsonBody as S, type TaskModelSummary as T, type UsageComponentEvidence as U, listModelSpecs as V, queryString as W, sleep as X, validateMeteringContract as Y, validateNormalizedUsage as Z, validatePriceRule as _, type JsonValue as a, type TaskModel as b, type ModelSchema as c, CatalogClient as d, type NexraClientOptions as e, BILLING_EXPORT_DIMENSIONS as f, BILLING_METRICS as g, type CreateNexraQuoteRequest as h, type JsonPrimitive as i, type MeteredPriceRate as j, type MeteredPriceRuleV1 as k, type MeteredUsageComponent as l, type MeteringContract as m, type MeteringKind as n, type ModelCapabilitySummary as o, type ModelDateVersion as p, type ModelEndpointSummary as q, type ModelModality as r, type ModelResourceList as s, type ModelResourceOption as t, type NexraBillingCurrency as u, type NexraModelOperation as v, type NexraModelSpec as w, type NexraModelSpecFilter as x, type NexraQuote as y, type NexraSalePrice as z };
+export { type ModelModality as A, type ModelResourceList as B, type CreateNexraQuoteRequest as C, type ModelResourceOption as D, type NexraDisplayQuoteBatchEntry as E, type FetchLike as F, HttpTransport as H, type JsonValue as J, type MediaGeometryField as M, type NexraSalePriceList as N, type TaskModelSummary as T, type UnifiedMediaGeometry as U, type NexraQuote as a, type CreateNexraDisplayQuoteBatchRequest as b, type NexraDisplayQuoteBatch as c, type NexraCatalogRevision as d, type NexraModelSpec as e, type NexraModelSpecFilter as f, type MediaGeometryProjection as g, type NexraBillingCurrency as h, type NexraModelEndpointSpec as i, type NexraModelOperation as j, type NexraSalePrice as k, type NexraSettlement as l, applyMediaGeometry as m, decodeMediaGeometry as n, encodeMediaGeometry as o, projectMediaGeometry as p, type ModelSearchParams as q, type CursorPage as r, type TaskModel as s, type ModelSchema as t, type NexraClientOptions as u, type JsonObject as v, type JsonPrimitive as w, type ModelCapabilitySummary as x, type ModelDateVersion as y, type ModelEndpointSummary as z };

package/dist/types-CvKdgo7V.d.ts

@@ -0,0 +1,343 @@
+import { v as JsonObject, J as JsonValue, l as NexraSettlement, r as CursorPage, H as HttpTransport } from './media-geometry-Ckr1-Mh3.js';
+
+declare const MEDIA_KINDS: readonly ["image", "video", "audio", "document", "archive", "other"];
+type MediaKind = (typeof MEDIA_KINDS)[number];
+type MediaAssetStatus = "pending" | "ready" | "failed" | "deleted";
+interface MediaAsset {
+    id: string;
+    kind: MediaKind;
+    status: MediaAssetStatus;
+    source: "upload" | "generated" | "provider" | "imported";
+    name?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    width?: number;
+    height?: number;
+    durationMs?: number;
+    checksumSha256?: string;
+    url?: string;
+    downloadUrl?: string;
+    expiresAt?: string;
+    metadata?: JsonObject;
+    createdAt: string;
+}
+interface AssetReference {
+    assetId: string;
+}
+type AssetInput = AssetReference | Blob | File | MediaAsset | string | URL;
+interface AssetUploadOptions {
+    kind?: MediaKind;
+    name?: string;
+    signal?: AbortSignal;
+}
+interface AssetImportRequest {
+    url: string;
+    kind?: MediaKind;
+    name?: string;
+}
+type AssetCertificationProvider = "seedance";
+type AssetCertificationStatus = "processing" | "ready" | "failed";
+interface AssetCertification {
+    assetId: string;
+    provider: AssetCertificationProvider;
+    status: AssetCertificationStatus;
+    providerAssetId?: string;
+    assetUri?: string;
+    groupId?: string;
+    library: "general" | "liveness";
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AssetCertificationRequest {
+    library?: "general" | "liveness";
+}
+interface AssetCertificationWaitOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+
+interface ApiErrorPayload {
+    error: {
+        code: string;
+        message: string;
+        category?: string;
+        retryable?: boolean;
+        requestId?: string;
+        details?: JsonObject;
+    };
+}
+
+declare const TASK_STATUSES: readonly ["queued", "running", "succeeded", "failed", "cancelling", "cancelled"];
+type TaskStatus = (typeof TASK_STATUSES)[number];
+type TerminalTaskStatus = "succeeded" | "failed" | "cancelled";
+interface TaskProgress {
+    percent?: number;
+    stage?: string;
+    message?: string;
+}
+interface TaskError {
+    code: string;
+    message: string;
+    category?: string;
+    retryable?: boolean;
+    details?: JsonObject;
+}
+interface TaskUsage {
+    components: Array<{
+        name: string;
+        quantity: number;
+        unit: string;
+    }>;
+    metadata?: JsonObject;
+}
+interface TaskCost {
+    amount: string;
+    currency: string;
+}
+interface TaskTiming {
+    submittedAt: string;
+    providerSubmittedAt?: string;
+    providerCompletedAt?: string;
+    /** First public terminal response; background media may still be preparing. */
+    firstResponseAt?: string;
+    /** Background media ready response; absent while preparing or after persistence failure. */
+    secondResponseAt?: string;
+    storedAt?: string;
+    persistPolicy?: "terminal" | "background";
+    deliveryStatus?: "preparing" | "ready" | "failed";
+    preparationMs: number | null;
+    generationMs: number | null;
+    /** Background: elapsed persistence stage until assets are ready; terminal: measured transfer. Null when unfinished or unavailable. */
+    storageMs: number | null;
+    /** Start of in-progress background persistence, when a worker has claimed the output. */
+    storageStartedAt?: string;
+    /** Background persistence elapsed time from first response to durable asset readiness. */
+    persistMs?: number | null;
+    totalMs: number | null;
+    startSource: "client" | "server";
+    /** Server clock reading taken when this snapshot was built; lets clients anchor live timers to server time. */
+    observedAt?: string;
+}
+/** Repository/console read model. HTTP clients receive TaskReceipt or TaskResult. */
+interface Task<TOutput = JsonValue> {
+    id: string;
+    /** Original platform request ID, shared with request history. */
+    requestId?: string;
+    /** Public Run ID, when this Task belongs to a shared-input run. */
+    runId?: string;
+    model: string;
+    operation: string;
+    schemaVersion: number;
+    /** Model request parameters; native-managed tasks retain the upstream field structure. */
+    input?: JsonObject;
+    status: TaskStatus;
+    /** Persistence policy frozen when the Task is created. Background is limited to video Tasks. */
+    persistPolicy?: "terminal" | "background";
+    /**
+     * Regional media availability. "preparing" means the task result is delivered
+     * with provider media URLs while Nexra persists them to its own object storage
+     * in the background; "ready" means persisted URLs; "failed" means background
+     * persistence exhausted its retries and the provider URLs have expired.
+     * Execution/billing remain terminal regardless of this value.
+     */
+    deliveryStatus?: "preparing" | "ready" | "failed";
+    progress?: TaskProgress;
+    /** Native-managed tasks preserve the final response shape and media URLs; catalog models may normalize model identifiers. */
+    output?: TOutput;
+    assets: MediaAsset[];
+    error?: TaskError;
+    usage?: TaskUsage;
+    cost?: TaskCost;
+    /** Customer billing state; absent on older servers. */
+    billingStatus?: "pending" | "succeeded" | "failed" | "refunded" | "unavailable";
+    /** Final customer sale settlement. Provider procurement cost is never exposed here. */
+    settlement?: NexraSettlement;
+    /**
+     * Caller-supplied business data, returned unchanged; never sent to the provider.
+     * The platform extracts the reserved string keys `callerUrl` (caller origin,
+     * https URL) and `endUserId` (opaque end-user identifier) into dedicated
+     * attribution columns for support diagnostics; their values are not validated
+     * beyond format checks and remain unchanged inside `metadata`.
+     */
+    metadata?: JsonObject;
+    timing?: TaskTiming;
+    /** Server-side Task record creation time (ISO 8601 UTC). */
+    createdAt: string;
+    /** Latest Task record update, not the generation completion time (ISO 8601 UTC). */
+    updatedAt: string;
+    /** First worker execution start; absent while queued or cancelled before execution. */
+    startedAt?: string;
+    /**
+     * Terminal succeeded/failed/cancelled time. Synchronously persisted tasks
+     * (default) reach succeeded only after required asset storage; background-
+     * persisted tasks are declared succeeded at result delivery while storage
+     * continues, signalled by `deliveryStatus` and the task timing second response.
+     */
+    completedAt?: string;
+    /** @deprecated Reserved; no Task expiry policy is currently enforced. Not a media URL expiry. */
+    expiresAt?: string;
+}
+/** POST /tasks returns acceptance only, including for idempotent replays. */
+type TaskReceipt = Pick<Task, "id" | "status">;
+/** Public Task result; platform diagnostics and business tags live in RequestDetails. */
+type TaskResult<TOutput = JsonValue> = Pick<Task<TOutput>, "id" | "model" | "status"> & Partial<Pick<Task<TOutput>, "requestId" | "output" | "assets" | "error" | "persistPolicy" | "deliveryStatus" | "settlement">>;
+/** Platform request details, used by both managed Tasks and native proxy requests. */
+interface RequestDetails {
+    id: string;
+    requestId: string;
+    taskId: string | null;
+    method: string;
+    path: string;
+    protocol?: string;
+    accessMode?: string | null;
+    model: string | null;
+    operation: string | null;
+    status: string;
+    /** Linked Task lifecycle when this request accepted a Task; HTTP `status` stays accepted. */
+    taskStatus?: string | null;
+    persistPolicy?: "terminal" | "background";
+    deliveryStatus?: Task["deliveryStatus"];
+    httpStatus: number | null;
+    errorCode: string | null;
+    /** HTTP duration, never substituted with asynchronous task duration. */
+    durationMs: number | null;
+    timing?: TaskTiming;
+    cost?: TaskCost;
+    billingStatus?: Task["billingStatus"];
+    settlement?: NexraSettlement;
+    metadata?: JsonObject;
+    /** Caller-asserted origin extracted from metadata.callerUrl; diagnostics display only. */
+    callerUrl?: string | null;
+    /** Caller-asserted end-user identifier extracted from metadata.endUserId; diagnostics display only. */
+    endUserId?: string | null;
+    /** Name of the API key that authenticated this request; diagnostics display only. */
+    apiKeyName?: string | null;
+    /** Latest known execution update; omitted when not observed. */
+    updatedAt?: string;
+    runId?: string;
+    schemaVersion?: number;
+    createdAt?: string;
+    startedAt?: string;
+    completedAt?: string;
+    input: JsonObject | null;
+    /** Present only on single-request reads (`includeOutput`). */
+    output?: JsonValue | null;
+    /** Output media with durable TOS URLs; present only on `includeOutput`. */
+    assets?: MediaAsset[];
+    receivedAt: string;
+    finishedAt: string | null;
+}
+type TaskEventType = "state" | "progress" | "preview" | "log" | "usage" | "warning" | "result";
+interface TaskEvent {
+    id: string;
+    taskId: string;
+    sequence: number;
+    type: TaskEventType;
+    status?: TaskStatus;
+    progress?: TaskProgress;
+    asset?: MediaAsset;
+    message?: string;
+    payload?: JsonObject;
+    occurredAt: string;
+}
+/** @deprecated Use CreateTaskRequest.callback_url. Kept for existing callers. */
+interface TaskWebhookConfig {
+    url: string;
+    /** Shared HMAC secret used to verify Nexra callback signatures. */
+    secret: string;
+    events?: Array<"completed">;
+}
+interface CreateTaskRequest<TInput = Record<string, unknown>> {
+    /** @internal Console telemetry only: browser send time before uploads, not execution time. */
+    submittedAt?: string;
+    model: string;
+    input: TInput;
+    /** Signed Nexra quote used to lock this input to a sale-price revision. */
+    quoteToken?: string;
+    /** Optional business identifiers such as orderId, available in request details. Do not include secrets. */
+    metadata?: JsonObject;
+    /** Platform completion callback, independent of provider callback support. Never sent upstream. */
+    callback_url?: string;
+    /** @deprecated Use callback_url; do not supply both. */
+    webhook?: TaskWebhookConfig;
+    /** @deprecated Compatibility check only; the server resolves the current contract. */
+    schemaVersion?: number;
+}
+interface TaskListParams {
+    status?: TaskStatus;
+    model?: string;
+    limit?: number;
+    cursor?: string;
+}
+type TaskPage<TOutput = JsonValue> = CursorPage<Task<TOutput>>;
+interface RunResult<TOutput = JsonValue> {
+    taskId: string;
+    output: TOutput;
+    assets: MediaAsset[];
+    usage?: TaskUsage;
+    cost?: TaskCost;
+    task: TaskResult<TOutput>;
+}
+declare function isTerminalTaskStatus(status: TaskStatus): status is TerminalTaskStatus;
+
+declare class AssetsClient {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    upload(file: Blob, options?: AssetUploadOptions): Promise<MediaAsset>;
+    import(request: AssetImportRequest, signal?: AbortSignal): Promise<MediaAsset>;
+    get(assetId: string, signal?: AbortSignal): Promise<MediaAsset>;
+    certifyForSeedance(asset: MediaAsset | string, request?: AssetCertificationRequest, signal?: AbortSignal): Promise<AssetCertification>;
+    getSeedanceCertification(asset: MediaAsset | string, signal?: AbortSignal): Promise<AssetCertification>;
+    waitForSeedanceCertification(asset: MediaAsset | string, options?: AssetCertificationWaitOptions): Promise<AssetCertification>;
+    download(asset: MediaAsset | string, signal?: AbortSignal): Promise<Response>;
+    stream(asset: MediaAsset | string, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+}
+
+interface CreateTaskOptions<TInput = Record<string, unknown>> {
+    input: TInput;
+    quoteToken?: string;
+    submittedAt?: string;
+    metadata?: JsonObject;
+    callback_url?: string;
+    /** @deprecated Use callback_url; do not supply both. */
+    webhook?: TaskWebhookConfig;
+    schemaVersion?: number;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface WatchTaskOptions {
+    signal?: AbortSignal;
+    lastEventId?: string;
+    maxReconnects?: number;
+}
+interface WaitTaskOptions extends WatchTaskOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    onEvent?: (event: TaskEvent) => void | Promise<void>;
+}
+interface RunTaskOptions<TInput = Record<string, unknown>> extends CreateTaskOptions<TInput>, WaitTaskOptions {
+    cancelOnAbort?: boolean;
+}
+declare class TasksClient {
+    private readonly transport;
+    private readonly assets;
+    constructor(transport: HttpTransport, assets: AssetsClient);
+    create<TOutput = JsonValue, TInput = Record<string, unknown>>(model: string, options: CreateTaskOptions<TInput>): Promise<TaskReceipt>;
+    get<TOutput = JsonValue>(taskId: string, signal?: AbortSignal): Promise<TaskResult<TOutput>>;
+    list<TOutput = JsonValue>(params?: TaskListParams, signal?: AbortSignal): Promise<CursorPage<TaskResult<TOutput>>>;
+    cancel<TOutput = JsonValue>(taskId: string, signal?: AbortSignal): Promise<TaskReceipt>;
+    watch(taskId: string, options?: WatchTaskOptions): AsyncGenerator<TaskEvent>;
+    wait<TOutput = JsonValue>(taskId: string, options?: WaitTaskOptions): Promise<TaskResult<TOutput>>;
+    run<TOutput = JsonValue, TInput = Record<string, unknown>>(model: string, options: RunTaskOptions<TInput>): Promise<RunResult<TOutput>>;
+}
+
+interface VerifyWebhookOptions {
+    toleranceSeconds?: number;
+    now?: Date;
+}
+/** @deprecated Only verifies legacy signed webhooks, not callback_url notifications. */
+declare function verifyWebhook(request: Request, secret: string, options?: VerifyWebhookOptions): Promise<boolean>;
+
+export { AssetsClient as A, type TerminalTaskStatus as B, type CreateTaskOptions as C, type WatchTaskOptions as D, isTerminalTaskStatus as E, verifyWebhook as F, MEDIA_KINDS as M, type RunTaskOptions as R, TasksClient as T, type VerifyWebhookOptions as V, type WaitTaskOptions as W, type RunResult as a, type ApiErrorPayload as b, type TaskResult as c, type AssetImportRequest as d, type AssetInput as e, type AssetReference as f, type AssetUploadOptions as g, type CreateTaskRequest as h, type MediaAsset as i, type MediaAssetStatus as j, type MediaKind as k, type RequestDetails as l, TASK_STATUSES as m, type Task as n, type TaskCost as o, type TaskError as p, type TaskEvent as q, type TaskEventType as r, type TaskListParams as s, type TaskPage as t, type TaskProgress as u, type TaskReceipt as v, type TaskStatus as w, type TaskTiming as x, type TaskUsage as y, type TaskWebhookConfig as z };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export { b as ApiErrorPayload, d as AssetImportRequest, e as AssetInput, f as AssetReference, g as AssetUploadOptions, C as CreateTaskOptions, h as CreateTaskRequest, i as MediaAsset, j as MediaAssetStatus, k as MediaKind, l as RequestDetails, a as RunResult, R as RunTaskOptions, n as Task, o as TaskCost, p as TaskError, q as TaskEvent, r as TaskEventType, s as TaskListParams, t as TaskPage, u as TaskProgress, v as TaskReceipt, c as TaskResult, w as TaskStatus, x as TaskTiming, y as TaskUsage, z as TaskWebhookConfig, B as TerminalTaskStatus, V as VerifyWebhookOptions, W as WaitTaskOptions, D as WatchTaskOptions } from './types-CvKdgo7V.js';
+export { b as CreateNexraDisplayQuoteBatchRequest, C as CreateNexraQuoteRequest, r as CursorPage, F as FetchLike, v as JsonObject, w as JsonPrimitive, J as JsonValue, M as MediaGeometryField, g as MediaGeometryProjection, x as ModelCapabilitySummary, y as ModelDateVersion, z as ModelEndpointSummary, A as ModelModality, B as ModelResourceList, D as ModelResourceOption, t as ModelSchema, q as ModelSearchParams, h as NexraBillingCurrency, d as NexraCatalogRevision, u as NexraClientOptions, c as NexraDisplayQuoteBatch, E as NexraDisplayQuoteBatchEntry, j as NexraModelOperation, e as NexraModelSpec, f as NexraModelSpecFilter, a as NexraQuote, k as NexraSalePrice, N as NexraSalePriceList, l as NexraSettlement, s as TaskModel, T as TaskModelSummary, U as UnifiedMediaGeometry } from './media-geometry-Ckr1-Mh3.js';

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@byte_fluffy/nexra-sdk",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.20",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/starrank-soft/nexra-monorepo.git",
@@ -24,6 +28,10 @@
     "./decimal": {
       "types": "./dist/decimal.d.ts",
       "import": "./dist/decimal.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
     }
   },
   "publishConfig": {
@@ -32,12 +40,14 @@
   },
   "scripts": {
     "generate": "bun scripts/generate-public-catalog.ts",
-    "build": "bun run generate && tsup src/index.ts src/catalog.ts src/decimal.ts --format esm --dts --dts-resolve --clean --out-dir dist --target es2022 --platform browser",
+    "build": "bun run generate && tsup",
     "test": "vitest run --root ../.. packages/sdk/tests",
+    "verify:video-schema-drift": "bun scripts/verify-video-schema-drift.ts",
     "prepack": "bun run build"
   },
   "devDependencies": {
     "@nexra/contracts": "workspace:*",
+    "@nexra/models": "workspace:*",
     "tsup": "8.5.1",
     "typescript": "5.9.3"
   }