@leaflow/sdk 0.0.0-dev.519.g9e3ae08 → 0.0.0-dev.523.gcaeef48

package/dist/canopy/v1/generated/functions.d.ts

@@ -38,13 +38,85 @@
  * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates Billing holds for each model's `billing`.
  * OpenAPI spec version: 1.0.0
  */
-import type { APIKeyResource, APIKeyUsageListResponseBody, ChatCompletion, ChatCompletionRequest, ConflictResponse, CreateAPIKeyRequestBody, CreateServiceRequestBody, CreateServiceResponseBody, CursorPageRequestResource, EmbeddingRequest, EmbeddingResponse, Error, GetUsageSummaryParams, GetUsageTimelineParams, InferenceError, IssuedAPIKeyResource, LengthAwarePageAPIKeyResource, ListApiKeysParams, ListRequestsParams, ListUsageByApiKeyParams, ListUsageByModelParams, Model, ModelList, ModelListResponseBody, ModelResource, ModelUsageListResponseBody, NativeRequest, NativeResponse, RequestResource, ResponseCreate, ResponseDeleted, ResponseResource, ServiceResource, StreamGenerateContentParams, TotalsResource, UpdateAPIKeyRequestBody, UsageTimelineResponseBody } from "./models.js";
+import type { APIKeyResource, APIKeyUsageListResponseBody, ChatCompletion, ChatCompletionRequest, ConflictResponse, CreateAPIKeyRequestBody, CreateServiceRequestBody, CreateServiceResponseBody, CursorPageRequestResource, EmbeddingRequest, EmbeddingResponse, Error, GetUsageSummaryParams, GetUsageTimelineParams, GetVideoContentHeaders, InferenceError, IssuedAPIKeyResource, LengthAwarePageAPIKeyResource, ListApiKeysParams, ListRequestsParams, ListUsageByApiKeyParams, ListUsageByModelParams, Model, ModelList, ModelListResponseBody, ModelResource, ModelUsageListResponseBody, NativeRequest, NativeResponse, RequestResource, ResponseCreate, ResponseDeleted, ResponseResource, ServiceResource, StreamGenerateContentParams, TotalsResource, UpdateAPIKeyRequestBody, UsageTimelineResponseBody, VideoCreateRequest, VideoTask } from "./models.js";
 export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
 export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
 export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
 export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
 export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
 export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type createVideoResponse200 = {
+    data: VideoTask;
+    status: 200;
+};
+export type createVideoResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createVideoResponseSuccess = createVideoResponse200 & {
+    headers: Headers;
+};
+export type createVideoResponseError = createVideoResponseDefault & {
+    headers: Headers;
+};
+export type createVideoResponse = createVideoResponseSuccess | createVideoResponseError;
+export declare const getCreateVideoUrl: () => string;
+/**
+ * Create an asynchronous video task in the verified project. Model and upstream support
+ * determine the accepted duration, resolution and references. Poll the returned task id.
+ * `reference_media` is a Canopy extension for ordered, typed image, video and audio URLs.
+ * Existing `input_reference` remains a first frame.
+ * The runtime also accepts OpenAI multipart uploads; send reference_media as a JSON text field.
+ * No remote reference is downloaded or retained by Canopy during request preparation.
+ * @summary Create a video
+ */
+export declare const createVideo: (videoCreateRequest: VideoCreateRequest, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createVideoResponse>;
+export type getVideoResponse200 = {
+    data: VideoTask;
+    status: 200;
+};
+export type getVideoResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getVideoResponseSuccess = getVideoResponse200 & {
+    headers: Headers;
+};
+export type getVideoResponseError = getVideoResponseDefault & {
+    headers: Headers;
+};
+export type getVideoResponse = getVideoResponseSuccess | getVideoResponseError;
+export declare const getGetVideoUrl: (video: string) => string;
+/**
+ * Read an existing task owned by the verified project; does not create another video.
+ * @summary Get a video task
+ */
+export declare const getVideo: (video: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getVideoResponse>;
+export type getVideoContentResponse200 = {
+    data: Blob;
+    status: 200;
+};
+export type getVideoContentResponse206 = {
+    data: Blob;
+    status: 206;
+};
+export type getVideoContentResponseDefault = {
+    data: InferenceError;
+    status: Exclude<HTTPStatusCodes, 200 | 206>;
+};
+export type getVideoContentResponseSuccess = (getVideoContentResponse200 | getVideoContentResponse206) & {
+    headers: Headers;
+};
+export type getVideoContentResponseError = getVideoContentResponseDefault & {
+    headers: Headers;
+};
+export type getVideoContentResponse = getVideoContentResponseSuccess | getVideoContentResponseError;
+export declare const getGetVideoContentUrl: (video: string) => string;
+/**
+ * Stream a completed video owned by the verified project. Supports HTTP Range.
+ * @summary Get generated video content
+ */
+export declare const getVideoContent: (video: string, headers?: GetVideoContentHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getVideoContentResponse>;
 export type createResponseResponse200ApplicationJson = {
     data: ResponseResource;
     status: 200;

package/dist/canopy/v1/generated/functions.js

@@ -1,3 +1,93 @@
+export const getCreateVideoUrl = () => {
+    return `https://canopy.leaflow.cloud/v1/videos`;
+};
+/**
+ * Create an asynchronous video task in the verified project. Model and upstream support
+ * determine the accepted duration, resolution and references. Poll the returned task id.
+ * `reference_media` is a Canopy extension for ordered, typed image, video and audio URLs.
+ * Existing `input_reference` remains a first frame.
+ * The runtime also accepts OpenAI multipart uploads; send reference_media as a JSON text field.
+ * No remote reference is downloaded or retained by Canopy during request preparation.
+ * @summary Create a video
+ */
+export const createVideo = async (videoCreateRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateVideoUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(videoCreateRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetVideoUrl = (video) => {
+    return `https://canopy.leaflow.cloud/v1/videos/${encodeURIComponent(String(video))}`;
+};
+/**
+ * Read an existing task owned by the verified project; does not create another video.
+ * @summary Get a video task
+ */
+export const getVideo = async (video, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetVideoUrl(video), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetVideoContentUrl = (video) => {
+    return `https://canopy.leaflow.cloud/v1/videos/${encodeURIComponent(String(video))}/content`;
+};
+/**
+ * Stream a completed video owned by the verified project. Supports HTTP Range.
+ * @summary Get generated video content
+ */
+export const getVideoContent = async (video, headers, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getGetVideoContentUrl(video), {
+        ...options,
+        method: "GET",
+        headers: { ...headers, ...getHeaders(options?.headers) },
+    });
+    const body = [204, 205, 304].includes(res.status)
+        ? null
+        : res.headers.get("content-type")?.includes("application/json")
+            ? JSON.parse(await res.text())
+            : await res.blob();
+    const data = body;
+    return { data, status: res.status, headers: res.headers };
+};
 export const getCreateResponseUrl = () => {
     return `https://canopy.leaflow.cloud/v1/responses`;
 };
@@ -27,11 +117,7 @@ export const createResponse = async (responseCreate, options, fetchFn) => {
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
         body: JSON.stringify(responseCreate),
     });
-    const body = [204, 205, 304].includes(res.status)
-        ? null
-        : res.headers.get("content-type")?.includes("application/json")
-            ? JSON.parse(await res.text())
-            : await res.blob();
+    const body = [204, 205, 304].includes(res.status) ? null : res.headers.get("content-type")?.includes("application/json") ? JSON.parse(await res.text()) : await res.blob();
     const data = body;
     return { data, status: res.status, headers: res.headers };
 };
@@ -94,7 +180,7 @@ export const createChatCompletion = async (chatCompletionRequest, options, fetch
         headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
         body: JSON.stringify(chatCompletionRequest),
     });
-    const body = [204, 205, 304].includes(res.status) ? null : res.headers.get("content-type")?.includes("application/json") ? JSON.parse(await res.text()) : await res.blob();
+    const body = [204, 205, 304].includes(res.status) ? null : await res.blob();
     const data = body;
     return { data, status: res.status, headers: res.headers };
 };

package/dist/canopy/v1/generated/models.d.ts

@@ -637,6 +637,36 @@ export interface MediaUsage {
 export interface ModelListResponseBody {
     items: ModelResource[];
 }
+export type MediaUsageDetailsReferenceCounts = {
+    [key: string]: number;
+};
+/**
+ * Per-request media measurements. Omitted values are unknown, not zero.
+ * Reference counts are audit data, not an additional billable quantity.
+ * video_quantity is the exact decimal quantity for the existing video_seconds
+ * meter; video_seconds in the summary remains a rounded compatibility counter.
+ * No monetary price or refund is calculated by Canopy.
+ */
+export interface MediaUsageDetails {
+    /** @minimum 0 */
+    input_video_seconds?: number;
+    /** @minimum 0 */
+    output_video_seconds?: number;
+    /** @minimum 0 */
+    input_audio_seconds?: number;
+    /**
+     * Recorded input quantity for the input_images meter, independent of its Billing price. Absent when unmeasured or not separately metered.
+     * @pattern ^[0-9]+$
+     */
+    input_image_quantity?: string;
+    /** @minimum 0 */
+    input_images?: number;
+    /** @minimum 0 */
+    output_images?: number;
+    /** @pattern ^[0-9]+([.][0-9]+)?$ */
+    video_quantity?: string;
+    reference_counts?: MediaUsageDetailsReferenceCounts;
+}
 export type RequestResourceStatus = (typeof RequestResourceStatus)[keyof typeof RequestResourceStatus];
 export declare const RequestResourceStatus: {
     readonly in_flight: "in_flight";
@@ -716,6 +746,7 @@ export interface RequestResource {
     reasoning: ReasoningDiagnostics | null;
     /** Media quantities and their rate dimensions. Null for a token-only request. */
     media?: MediaUsage | null;
+    media_details?: MediaUsageDetails;
 }
 export interface CursorPageRequestResource {
     /** The items in this page */
@@ -987,6 +1018,120 @@ export interface CreateServiceResponseBody {
      */
     order_id: string | null;
 }
+export type VideoReferenceMediaType = (typeof VideoReferenceMediaType)[keyof typeof VideoReferenceMediaType];
+export declare const VideoReferenceMediaType: {
+    readonly first_frame: "first_frame";
+    readonly last_frame: "last_frame";
+    readonly reference_image: "reference_image";
+    readonly reference_video: "reference_video";
+    readonly reference_audio: "reference_audio";
+};
+/**
+ * A typed reference asset. Order is preserved, including order within each media type.
+ * Wan 3.0 accepts at most one first frame, one last frame, ten reference images,
+ * five reference videos and five reference audio clips. A last frame needs a first frame.
+ * First/last frames cannot be combined with reference_image, reference_video or reference_audio.
+ * Reference images, videos and audio may be combined. Other models can accept fewer roles.
+ * Images accept public HTTP(S) or base64 image data URLs. Video and audio accept public
+ * HTTP(S) URLs only. Wan 3.0 limits reference videos and audio to 1-15 seconds each and
+ * 15 seconds total per media type; input video plus output duration must not exceed 30 seconds.
+ * The upstream validates remote asset size, format and duration. Canopy does not fetch them.
+ */
+export interface VideoReferenceMedia {
+    type: VideoReferenceMediaType;
+    /** @minLength 1 */
+    url: string;
+}
+/**
+ * Provide a prompt, reference media, or both. Extra fields depend on the selected model and adapter.
+ */
+export interface VideoCreateRequest {
+    /** @minLength 1 */
+    model: string;
+    prompt?: string;
+    /** @minimum 1 */
+    seconds?: number;
+    size?: string;
+    resolution?: string;
+    /**
+     * Backward-compatible first-frame image URL. May be combined with a last_frame, not another first_frame.
+     * @minLength 1
+     */
+    input_reference?: string;
+    /**
+     * @minItems 1
+     * @maxItems 20
+     */
+    reference_media?: VideoReferenceMedia[];
+    /** Whether the output has audio; separate from a reference_audio input. */
+    audio?: boolean;
+    prompt_extend?: boolean;
+    watermark?: boolean;
+    seed?: number;
+    negative_prompt?: string;
+    [key: string]: unknown;
+}
+/**
+ * Provider measurements on a task; only completed tasks are settled.
+ */
+export interface VideoUsage {
+    /**
+     * Output duration, kept for compatibility.
+     * @minimum 0
+     */
+    seconds?: number;
+    resolution?: string;
+    /** @minimum 0 */
+    input_seconds?: number;
+    /** @minimum 0 */
+    output_seconds?: number;
+    /**
+     * Total measured input and output video duration, not a monetary quote.
+     * @minimum 0
+     */
+    billable_seconds?: number;
+    [key: string]: unknown;
+}
+export type VideoTaskStatus = (typeof VideoTaskStatus)[keyof typeof VideoTaskStatus];
+export declare const VideoTaskStatus: {
+    readonly queued: "queued";
+    readonly in_progress: "in_progress";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+export type VideoTaskError = {
+    code?: string;
+    message?: string;
+    [key: string]: unknown;
+};
+export interface VideoTask {
+    id: string;
+    object: string;
+    status: VideoTaskStatus;
+    model?: string;
+    usage?: VideoUsage;
+    /** Output duration, not the duration of input references. */
+    seconds?: string;
+    size?: string;
+    created_at?: number;
+    completed_at?: number;
+    expires_at?: number;
+    progress?: number;
+    error?: VideoTaskError;
+    [key: string]: unknown;
+}
+/**
+ * A request body in the endpoint's own protocol. Canopy reads only the model name and forwards the rest unchanged.
+ */
+export interface NativeRequest {
+    [key: string]: unknown;
+}
+/**
+ * A response body in the endpoint's own protocol, as the upstream returned it.
+ */
+export interface NativeResponse {
+    [key: string]: unknown;
+}
 export type ResponseCreateReasoning = {
     [key: string]: unknown;
 };
@@ -1019,18 +1164,6 @@ export interface ResponseDeleted {
     object: string;
     deleted: boolean;
 }
-/**
- * A request body in the endpoint's own protocol. Canopy reads only the model name and forwards the rest unchanged.
- */
-export interface NativeRequest {
-    [key: string]: unknown;
-}
-/**
- * A response body in the endpoint's own protocol, as the upstream returned it.
- */
-export interface NativeResponse {
-    [key: string]: unknown;
-}
 /**
  * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
  */
@@ -1055,6 +1188,9 @@ export interface CursorPagination {
  * The request conflicts with the current state of the service. The codes are described where they apply.
  */
 export type ConflictResponse = Error;
+export type GetVideoContentHeaders = {
+    Range?: string;
+};
 export type StreamGenerateContentParams = {
     alt?: StreamGenerateContentAlt;
 };

package/dist/canopy/v1/generated/models.js

@@ -99,6 +99,19 @@ export const CheckoutMode = {
     automatic: "automatic",
     deferred: "deferred",
 };
+export const VideoReferenceMediaType = {
+    first_frame: "first_frame",
+    last_frame: "last_frame",
+    reference_image: "reference_image",
+    reference_video: "reference_video",
+    reference_audio: "reference_audio",
+};
+export const VideoTaskStatus = {
+    queued: "queued",
+    in_progress: "in_progress",
+    completed: "completed",
+    failed: "failed",
+};
 export const StreamGenerateContentAlt = {
     sse: "sse",
 };

package/dist/canopy/v1/generated/schemas.zod.d.ts

@@ -39,6 +39,55 @@
  * OpenAPI spec version: 1.0.0
  */
 import * as zod from "zod";
+/**
+ * Create an asynchronous video task in the verified project. Model and upstream support
+ * determine the accepted duration, resolution and references. Poll the returned task id.
+ * `reference_media` is a Canopy extension for ordered, typed image, video and audio URLs.
+ * Existing `input_reference` remains a first frame.
+ * The runtime also accepts OpenAI multipart uploads; send reference_media as a JSON text field.
+ * No remote reference is downloaded or retained by Canopy during request preparation.
+ * @summary Create a video
+ */
+export declare const CreateVideoBody: zod.ZodObject<{
+    model: zod.ZodString;
+    prompt: zod.ZodOptional<zod.ZodString>;
+    seconds: zod.ZodOptional<zod.ZodInt>;
+    size: zod.ZodOptional<zod.ZodString>;
+    resolution: zod.ZodOptional<zod.ZodString>;
+    input_reference: zod.ZodOptional<zod.ZodString>;
+    reference_media: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        type: zod.ZodEnum<{
+            first_frame: "first_frame";
+            last_frame: "last_frame";
+            reference_image: "reference_image";
+            reference_video: "reference_video";
+            reference_audio: "reference_audio";
+        }>;
+        url: zod.ZodString;
+    }, zod.z.core.$strict>>>;
+    audio: zod.ZodOptional<zod.ZodBoolean>;
+    prompt_extend: zod.ZodOptional<zod.ZodBoolean>;
+    watermark: zod.ZodOptional<zod.ZodBoolean>;
+    seed: zod.ZodOptional<zod.ZodInt>;
+    negative_prompt: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+/**
+ * Read an existing task owned by the verified project; does not create another video.
+ * @summary Get a video task
+ */
+export declare const GetVideoParams: zod.ZodObject<{
+    video: zod.ZodString;
+}, zod.z.core.$strict>;
+/**
+ * Stream a completed video owned by the verified project. Supports HTTP Range.
+ * @summary Get generated video content
+ */
+export declare const GetVideoContentParams: zod.ZodObject<{
+    video: zod.ZodString;
+}, zod.z.core.$strict>;
+export declare const GetVideoContentHeader: zod.ZodObject<{
+    Range: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
 /**
  * Supports JSON, SSE and native upstream response storage. Stored continuation is restricted to the current project and original provider credential. WebSocket clients connect with GET /v1/responses and send response.create events; one response may be active on a connection at a time. The connection stays on its initial model and provider credential.
  * @summary Create a model response

package/dist/canopy/v1/generated/schemas.zod.js

@@ -46,6 +46,34 @@ import { EmbeddingRequest } from "./validators/embeddingRequest.zod.js";
 import { NativeRequest } from "./validators/nativeRequest.zod.js";
 import { ResponseCreate } from "./validators/responseCreate.zod.js";
 import { UpdateAPIKeyRequestBody } from "./validators/updateAPIKeyRequestBody.zod.js";
+import { VideoCreateRequest } from "./validators/videoCreateRequest.zod.js";
+/**
+ * Create an asynchronous video task in the verified project. Model and upstream support
+ * determine the accepted duration, resolution and references. Poll the returned task id.
+ * `reference_media` is a Canopy extension for ordered, typed image, video and audio URLs.
+ * Existing `input_reference` remains a first frame.
+ * The runtime also accepts OpenAI multipart uploads; send reference_media as a JSON text field.
+ * No remote reference is downloaded or retained by Canopy during request preparation.
+ * @summary Create a video
+ */
+export const CreateVideoBody = VideoCreateRequest;
+/**
+ * Read an existing task owned by the verified project; does not create another video.
+ * @summary Get a video task
+ */
+export const GetVideoParams = zod.strictObject({
+    video: zod.string().min(1),
+});
+/**
+ * Stream a completed video owned by the verified project. Supports HTTP Range.
+ * @summary Get generated video content
+ */
+export const GetVideoContentParams = zod.strictObject({
+    video: zod.string().min(1),
+});
+export const GetVideoContentHeader = zod.strictObject({
+    Range: zod.string().optional(),
+});
 /**
  * Supports JSON, SSE and native upstream response storage. Stored continuation is restricted to the current project and original provider credential. WebSocket clients connect with GET /v1/responses and send response.create events; one response may be active on a connection at a time. The connection stays on its initial model and provider credential.
  * @summary Create a model response

package/dist/canopy/v1/generated/validators/cursorPageRequestResource.zod.d.ts

@@ -83,6 +83,16 @@ export declare const CursorPageRequestResource: zod.ZodObject<{
             quality: zod.ZodNullable<zod.ZodString>;
             resolution: zod.ZodNullable<zod.ZodString>;
         }, zod.z.core.$strict>, zod.ZodNull]>>;
+        media_details: zod.ZodOptional<zod.ZodObject<{
+            input_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+            output_video_seconds: zod.ZodOptional<zod.ZodNumber>;
+            input_audio_seconds: zod.ZodOptional<zod.ZodNumber>;
+            input_image_quantity: zod.ZodOptional<zod.ZodString>;
+            input_images: zod.ZodOptional<zod.ZodInt>;
+            output_images: zod.ZodOptional<zod.ZodInt>;
+            video_quantity: zod.ZodOptional<zod.ZodString>;
+            reference_counts: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodInt>>;
+        }, zod.z.core.$strict>>;
     }, zod.z.core.$strict>>;
     next_cursor: zod.ZodString;
 }, zod.z.core.$strict>;

package/dist/canopy/v1/generated/validators/getVideoContentHeaders.zod.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and serves the same endpoints.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days, or 400 days for the usage timeline. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export declare const GetVideoContentHeaders: zod.ZodObject<{
+    Range: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type GetVideoContentHeaders = zod.input<typeof GetVideoContentHeaders>;
+export type GetVideoContentHeadersOutput = zod.output<typeof GetVideoContentHeaders>;

package/dist/canopy/v1/generated/validators/getVideoContentHeaders.zod.js

@@ -0,0 +1,44 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Canopy API
+ * Canopy model inference, API keys, model catalogue, service enablement and recorded usage.
+ *
+ * Project inference is served on this host in each provider's own protocol:
+ *
+ * - OpenAI: `/v1/chat/completions`, `/v1/responses` and `/v1/embeddings`; use
+ *   `https://canopy.leaflow.cloud/v1` as the OpenAI SDK base URL.
+ * - Anthropic: `/v1/messages`; use `https://canopy.leaflow.cloud` as the Anthropic SDK base URL.
+ * - Gemini: `/v1beta/models/{model}:generateContent` and `:streamGenerateContent`.
+ *
+ * Canopy does not convert between protocols. A request is accepted only for a model whose
+ * `supported_endpoints` lists the endpoint it was sent to, and it is forwarded unchanged except for
+ * the model name and the credentials. Reasoning settings such as `reasoning_effort` are passed
+ * through as written; a model's `capabilities` lists the values its upstream accepts.
+ *
+ * Management operations use `/api/v1`. The management model catalogue names how each model is billed in Billing;
+ * `/v1/models` returns the OpenAI model format with Canopy capabilities and parameter limits.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * Management and project inference accept the same verified IAM scoped token. The token is the
+ * sole billing project authority; `OpenAI-Project` and historical identity headers cannot
+ * override it. These endpoints do not accept a Canopy API key. The separate API-key gateway
+ * accepts Canopy API keys and serves the same endpoints.
+ *
+ * ## Conventions
+ *
+ * - **The plaintext of an API key is returned once.** The `secret` appears in the response that issues it and is returned by no other endpoint. A key that has been lost has to be revoked and reissued.
+ * - **Disabling and revoking are distinct.** A disabled key may be enabled again at any time, while a revocation is irreversible and is intended for a key that has been exposed. Neither removes the record, and the usage the key accrued remains readable.
+ * - **A usage query must carry a time range**, spanning no more than 31 days, or 400 days for the usage timeline. `from` and `to` carry a timezone offset, which the server does not infer.
+ * - **The request and response bodies do not appear in the ledger.** They are not recorded. Quote the `upstream_request_id` from the response when reporting a problem.
+ * - **Usage may be estimated.** The upstream provider does not report usage on every request. Where it does not, `usage_source` is `estimated` and the figures are derived from the character classes of the payload, to within roughly fifteen per cent.
+ * - **The service is enabled before use.** A project enables the model platform once, through `create-service`; the forwarding endpoints refuse its requests until the service is `active`. Requests are then billed under the service's subscription by the tokens they use, at the rates Billing holds for each model's `billing`.
+ * OpenAPI spec version: 1.0.0
+ */
+import * as zod from "zod";
+export const GetVideoContentHeaders = zod.strictObject({
+    Range: zod.string().optional(),
+});