@stapel/cdn-react 0.1.0

package/dist/api/generated/schema.d.ts

@@ -0,0 +1,1050 @@
+export interface paths {
+    "/cdn/api/v1/file/exists/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Check if file exists (GET)
+         * @description Check if a file with the given hash already exists in the CDN.
+         *
+         *     Use this before uploading to avoid duplicate uploads.
+         *
+         *     **How to calculate hash:**
+         *     ```python
+         *     import hashlib
+         *
+         *     def calculate_file_hash(file_content: bytes) -> str:
+         *         return hashlib.sha256(file_content).hexdigest()
+         *     ```
+         *
+         *     **Response:**
+         *     - `exists: true` - file found, returns file details
+         *     - `exists: false` - file not found, `type` and `file` are null
+         *
+         *
+         *     **Permissions:** `OperandHolder`
+         */
+        get: operations["check_file_exists_get"];
+        put?: never;
+        /**
+         * Check if file exists (POST)
+         * @description Check if a file with the given hash already exists in the CDN.
+         *
+         *     Same as GET method but accepts hash in request body.
+         *     Useful when hash is very long or contains special characters.
+         *
+         *
+         *     **Permissions:** `OperandHolder`
+         */
+        post: operations["check_file_exists_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/images/{image_type}/random/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get random image by type
+         * @description Get a random image of the specified type.
+         *
+         *     **Available types:** product, avatar
+         *
+         *     **Requires:** Staff user or API key authentication.
+         *
+         *     **Use case:** Admin UI for quickly selecting test images.
+         *
+         *
+         *     **Permissions:** `IsStaffUser`
+         */
+        get: operations["random_image"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/images/{image_type}/upload/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload an image with specific type
+         * @description Upload an image file with a specific type (product, avatar).
+         *
+         *     **Supported formats:** JPEG, PNG, GIF, WebP, BMP, HEIC, HEIF
+         *
+         *     **Available types:** product, avatar
+         *
+         *     **Maximum file size:** `STAPEL_CDN["MAX_IMAGE_SIZE"]`, 20MB by default.
+         *     Enforced before the body is hashed; over it the answer is 413.
+         *
+         *
+         *     **Permissions:** `IsNotAnonymousUser`
+         */
+        post: operations["upload_typed_image"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/refs/sync/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Sync media references
+         * @description Add/remove reference tracking for media files. Used by other services to track which entities reference which media.
+         *
+         *     **Permissions:** `IsServiceRequest`
+         */
+        post: operations["sync_refs"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/upload/avatar/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload an avatar image
+         * @description Upload an avatar image file for processing.
+         *
+         *     **Same as image upload but sets type to 'avatar'.**
+         *
+         *     **Supported formats:** JPEG, PNG, GIF, WebP, BMP, HEIC, HEIF
+         *
+         *     **Maximum file size:** `STAPEL_CDN["MAX_IMAGE_SIZE"]`, 20MB by default.
+         *     Enforced before the body is hashed; over it the answer is 413.
+         *
+         *
+         *     **Permissions:** `IsAuthenticated`
+         */
+        post: operations["upload_avatar"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/upload/file/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload a file
+         * @description Upload a generic file (document, archive, etc.).
+         *
+         *     **Permissions:** `IsNotAnonymousUser`
+         */
+        post: operations["upload_file"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/upload/image/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload an image
+         * @description Upload an image file for processing.
+         *
+         *     **Supported formats:** JPEG, PNG, GIF, WebP, BMP, HEIC, HEIF
+         *
+         *     **What happens on upload:**
+         *     1. File hash (SHA-256) is calculated for deduplication
+         *     2. If file already exists, returns existing image data (200 OK)
+         *     3. If new file, creates image record and generates variants via background task
+         *     4. Variants are generated in WebP format at multiple resolutions
+         *
+         *     **Generated variants (all WebP):**
+         *     - 16px, 32px, 64px, 120px - min-side thumbnails
+         *     - 160px, 240px, 480px, 560px, 720px, 1080px - w/h preview branches
+         *
+         *     **Request format:** `multipart/form-data` with `file` field
+         *
+         *     **Maximum file size:** `STAPEL_CDN["MAX_IMAGE_SIZE"]`, 20MB by default.
+         *     Enforced before the body is hashed; over it the answer is 413.
+         *
+         *
+         *     **Permissions:** `IsNotAnonymousUser`
+         */
+        post: operations["upload_image"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cdn/api/v1/upload/video/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload a video
+         * @description Upload a video file for processing.
+         *
+         *     **Supported formats:** MP4, WebM, MOV, AVI, MKV
+         *
+         *     **What happens on upload:**
+         *     1. File hash (SHA-256) is calculated for deduplication
+         *     2. If file already exists, returns existing video data (200 OK)
+         *     3. If new file, creates video record
+         *     4. Variant generation via FFmpeg (TODO: not yet implemented)
+         *
+         *     **Planned variants:**
+         *     - 16p, 32p - animated thumbnails
+         *     - 240p, 480p, 720p, 1080p, 2160p - video resolutions
+         *
+         *     **Request format:** `multipart/form-data` with `file` field
+         *
+         *     **Maximum file size:** `STAPEL_CDN["MAX_VIDEO_SIZE"]`, 100MB by default.
+         *     Enforced before the body is hashed; over it the answer is 413.
+         *
+         *
+         *     **Permissions:** `IsNotAnonymousUser`
+         */
+        post: operations["upload_video"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /** @description Serializer for file existence check by hash. */
+        FileExists: {
+            /** @description SHA-256 hash of the file content (64 hex characters) */
+            file_hash: string;
+        };
+        /** @description File existence check result. */
+        FileExistsResponse: {
+            /** @description File object if found, null otherwise */
+            file: (components["schemas"]["Image"] | components["schemas"]["Video"] | components["schemas"]["FileModel"]) | null;
+            /**
+             * @description Whether the file exists
+             * @example true
+             */
+            exists: boolean;
+            /**
+             * @description File type if found (image or video)
+             * @example image
+             */
+            type: string | null;
+        };
+        /** @description Serializer for File model. */
+        FileModel: {
+            readonly id: number;
+            /** @description SHA-256 hash of the original file */
+            readonly file_hash: string;
+            original_filename: string;
+            file_extension: string;
+            mime_type?: string;
+            /** @description File size in bytes */
+            readonly original_size: number;
+            /** @description URL prefix: file/<hash> */
+            readonly prefix: string;
+            /**
+             * Format: uri
+             * @description URL to original uploaded file
+             */
+            readonly original_url: string;
+            /** @description List of references: service/entity_type/entity_id */
+            refs?: string[];
+            /** Format: uuid */
+            readonly uploaded_by: string | null;
+            readonly uploaded_by_username: string;
+            /** Format: date-time */
+            readonly created_at: string;
+            /** Format: date-time */
+            readonly updated_at: string;
+        };
+        /**
+         * @description Serializer for file upload requests.
+         *
+         *     Upload a file using multipart/form-data with the 'file' field.
+         */
+        FileUpload: {
+            /**
+             * Format: uri
+             * @description The file to upload. Images: jpg, jpeg, png, gif, webp, bmp, heic, heif. Videos: mp4, webm, mov, avi, mkv.
+             */
+            file: string;
+        };
+        /** @description Successful file upload. */
+        FileUploadResponse: {
+            /** @description Uploaded file object */
+            file: components["schemas"]["FileModel"];
+            /**
+             * @description Confirmation message
+             * @example File uploaded successfully
+             */
+            message: string;
+        };
+        /**
+         * @description Serializer for Image model.
+         *
+         *     Returns complete image information including all generated variants.
+         *     Variants are auto-generated in WebP format for optimal compression.
+         */
+        Image: {
+            readonly id: number;
+            /** @description SHA-256 hash of the original file */
+            readonly file_hash: string;
+            original_filename: string;
+            file_extension: string;
+            /**
+             * @description Image type — validated against STAPEL_CDN['ASSET_TYPES'] (default ('avatar',); the historical 'product' default value here is only in scope for host projects that still add it).
+             *
+             *     * `avatar` - Avatar
+             * @default product
+             */
+            readonly type: components["schemas"]["TypeEnum"];
+            /** @description URL prefix: <type>/<hash> */
+            readonly prefix: string;
+            readonly original_width: number;
+            readonly original_height: number;
+            /** @description File size in bytes */
+            readonly original_size: number;
+            /**
+             * Format: uri
+             * @description URL to original uploaded image
+             */
+            readonly original_url: string;
+            /**
+             * Format: uri
+             * @description 16px micro thumbnail, min-side (WebP)
+             */
+            readonly variant_16_url: string;
+            /**
+             * Format: uri
+             * @description 32px thumbnail, min-side (WebP)
+             */
+            readonly variant_32_url: string;
+            /**
+             * Format: uri
+             * @description 64px thumbnail, min-side (WebP)
+             */
+            readonly variant_64_url: string;
+            /**
+             * Format: uri
+             * @description 120px thumbnail, min-side (WebP)
+             */
+            readonly variant_120_url: string;
+            /**
+             * Format: uri
+             * @description 160px preview, w-branch (WebP)
+             */
+            readonly variant_160_url: string;
+            /**
+             * Format: uri
+             * @description 240px preview, w-branch (WebP)
+             */
+            readonly variant_240_url: string;
+            /**
+             * Format: uri
+             * @description 480px preview, w-branch (WebP)
+             */
+            readonly variant_480_url: string;
+            /**
+             * Format: uri
+             * @description 560px preview, w-branch (WebP)
+             */
+            readonly variant_560_url: string;
+            /**
+             * Format: uri
+             * @description 720px preview, w-branch (WebP)
+             */
+            readonly variant_720_url: string;
+            /**
+             * Format: uri
+             * @description 1080px preview, w-branch (WebP)
+             */
+            readonly variant_1080_url: string;
+            /**
+             * Format: uri
+             * @description 1440px 2K (WebP)
+             */
+            readonly variant_1440_url: string;
+            /**
+             * Format: uri
+             * @description 2160px 4K (WebP)
+             */
+            readonly variant_2160_url: string;
+            /** @description Generated variants with geometry: [{tier, branch, url, width, height}] */
+            readonly variants_meta: {
+                tier: number;
+                /**
+                 * @description None for thumbnail-class (min-side) tiers.
+                 * @enum {string|null}
+                 */
+                branch?: "w" | "h" | null;
+                url: string;
+                width: number;
+                height: number;
+            }[];
+            /** @description Whether variants have been generated */
+            readonly is_processed: boolean;
+            /** Format: uuid */
+            readonly uploaded_by: string | null;
+            readonly uploaded_by_username: string;
+            /** Format: date-time */
+            readonly created_at: string;
+            /** Format: date-time */
+            readonly updated_at: string;
+        };
+        /** @description Successful image upload. */
+        ImageUploadResponse: {
+            /** @description Uploaded image object (serialized by ImageSerializer) */
+            image: components["schemas"]["Image"];
+            /**
+             * @description Confirmation message
+             * @example Image uploaded successfully
+             */
+            message: string;
+        };
+        /** @description CDN reference sync request. */
+        RefSyncRequest: {
+            /**
+             * @description Service name
+             * @example auth
+             */
+            service: string;
+            /**
+             * @description Entity type
+             * @example profile
+             */
+            entity_type: string;
+            /**
+             * @description Entity identifier
+             * @example 464
+             */
+            entity_id: string;
+            /**
+             * @description Previous media references
+             * @example [
+             *       "product/hash1",
+             *       "product/hash2"
+             *     ]
+             */
+            old_hashes: string[];
+            /**
+             * @description Current media references
+             * @example [
+             *       "product/hash2",
+             *       "product/hash3"
+             *     ]
+             */
+            new_hashes: string[];
+        };
+        /** @description CDN reference sync result. */
+        RefSyncResponse: {
+            /**
+             * @description Number of refs added
+             * @example 1
+             */
+            added: number;
+            /**
+             * @description Number of refs removed
+             * @example 1
+             */
+            removed: number;
+            /**
+             * @description List of unresolved media references
+             * @example [
+             *       "product/nonexistent"
+             *     ]
+             */
+            errors: string[];
+        };
+        /** @description Structured error returned by all Stapel API endpoints. */
+        StapelError: {
+            /**
+             * @description Translation key for client-side localization
+             * @example error.404.not_found
+             */
+            localizable_error: string;
+            /** @description Human-readable fallback/debug message — not reliably English, */
+            error: string;
+            /**
+             * @description Context values for template placeholders
+             * @example {
+             *       "retry_after": 30
+             *     }
+             */
+            params?: {
+                [key: string]: unknown;
+            };
+            /** @description Active Django locale `error` was rendered in (e.g */
+            error_language?: string;
+        };
+        /**
+         * @description * `avatar` - Avatar
+         * @enum {string}
+         */
+        TypeEnum: "avatar";
+        /** @description Serializer for Video model. */
+        Video: {
+            readonly id: number;
+            /** @description SHA-256 hash of the original file */
+            readonly file_hash: string;
+            original_filename: string;
+            file_extension: string;
+            readonly original_width: number | null;
+            readonly original_height: number | null;
+            /** @description File size in bytes */
+            readonly original_size: number;
+            /**
+             * Format: double
+             * @description Duration in seconds
+             */
+            readonly duration: number | null;
+            /** Format: uri */
+            readonly original_url: string;
+            /** Format: uri */
+            readonly variant_16p_url: string;
+            /** Format: uri */
+            readonly variant_32p_url: string;
+            /** Format: uri */
+            readonly variant_240p_url: string;
+            /** Format: uri */
+            readonly variant_480p_url: string;
+            /** Format: uri */
+            readonly variant_720p_url: string;
+            /** Format: uri */
+            readonly variant_1080p_url: string;
+            /** Format: uri */
+            readonly variant_2160p_url: string;
+            /** @description Whether variants have been generated */
+            readonly is_processed: boolean;
+            /** Format: uuid */
+            readonly uploaded_by: string | null;
+            readonly uploaded_by_username: string;
+            /** Format: date-time */
+            readonly created_at: string;
+            /** Format: date-time */
+            readonly updated_at: string;
+        };
+        /** @description Successful video upload. */
+        VideoUploadResponse: {
+            /** @description Uploaded video object (serialized by VideoSerializer) */
+            video: components["schemas"]["Video"];
+            /**
+             * @description Confirmation message
+             * @example Video uploaded successfully
+             */
+            message: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    check_file_exists_get: {
+        parameters: {
+            query: {
+                /** @description SHA-256 hash of the file (64 hex characters) */
+                file_hash: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileExistsResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    check_file_exists_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["FileExists"];
+                "application/x-www-form-urlencoded": components["schemas"]["FileExists"];
+                "multipart/form-data": components["schemas"]["FileExists"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileExistsResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    random_image: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                image_type: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Image"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    upload_typed_image: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                image_type: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "multipart/form-data": {
+                    /**
+                     * Format: binary
+                     * @description Image file to upload
+                     */
+                    file: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageUploadResponse"];
+                };
+            };
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageUploadResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    sync_refs: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RefSyncRequest"];
+                "application/x-www-form-urlencoded": components["schemas"]["RefSyncRequest"];
+                "multipart/form-data": components["schemas"]["RefSyncRequest"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RefSyncResponse"];
+                };
+            };
+        };
+    };
+    upload_avatar: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "multipart/form-data": {
+                    /**
+                     * Format: binary
+                     * @description Avatar image file to upload
+                     */
+                    file: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageUploadResponse"];
+                };
+            };
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageUploadResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    upload_file: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "multipart/form-data": {
+                    /**
+                     * Format: binary
+                     * @description File to upload
+                     */
+                    file: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileUploadResponse"];
+                };
+            };
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileUploadResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    upload_image: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": components["schemas"]["FileUpload"];
+                "application/x-www-form-urlencoded": components["schemas"]["FileUpload"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageUploadResponse"];
+                };
+            };
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImageUploadResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+    upload_video: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "multipart/form-data": {
+                    /**
+                     * Format: binary
+                     * @description Video file to upload (mp4, webm, mov, avi, mkv)
+                     */
+                    file: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VideoUploadResponse"];
+                };
+            };
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VideoUploadResponse"];
+                };
+            };
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StapelError"];
+                };
+            };
+        };
+    };
+}
+//# sourceMappingURL=schema.d.ts.map