@veruna/api-contracts 1.0.18 → 1.0.19

package/build/v1/file/schemas/delete-file-response.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteFileByKeyResponseSchema = exports.DeleteFileResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Delete file by ID response schema
+ */
+exports.DeleteFileResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    message: zod_1.z.string(),
+});
+/**
+ * Delete file by key response schema (legacy)
+ */
+exports.DeleteFileByKeyResponseSchema = zod_1.z.object({
+    message: zod_1.z.string(),
+    key: zod_1.z.string(),
+});

package/build/v1/file/schemas/file-category.enum.d.ts

@@ -0,0 +1,9 @@
+/**
+ * File category based on content type
+ */
+export declare enum FileCategory {
+    IMAGE = "image",
+    DOCUMENT = "document",
+    VIDEO = "video",
+    OTHER = "other"
+}

package/build/v1/file/schemas/file-category.enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCategory = void 0;
+/**
+ * File category based on content type
+ */
+var FileCategory;
+(function (FileCategory) {
+    FileCategory["IMAGE"] = "image";
+    FileCategory["DOCUMENT"] = "document";
+    FileCategory["VIDEO"] = "video";
+    FileCategory["OTHER"] = "other";
+})(FileCategory || (exports.FileCategory = FileCategory = {}));

package/build/v1/file/schemas/file-response.schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { FileStatus } from './file-status.enum';
+import { FileCategory } from './file-category.enum';
+/**
+ * File item schema (for list responses)
+ */
+export declare const FileItemResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    folder: z.ZodString;
+    filename: z.ZodString;
+    size: z.ZodNumber;
+    contentType: z.ZodString;
+    category: z.ZodEnum<typeof FileCategory>;
+    status: z.ZodEnum<typeof FileStatus>;
+    url: z.ZodOptional<z.ZodString>;
+    uploadedBy: z.ZodString;
+    uploadedAt: z.ZodString;
+}, z.core.$strip>;

package/build/v1/file/schemas/file-response.schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileItemResponseSchema = void 0;
+const zod_1 = require("zod");
+const file_status_enum_1 = require("./file-status.enum");
+const file_category_enum_1 = require("./file-category.enum");
+/**
+ * File item schema (for list responses)
+ */
+exports.FileItemResponseSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    folder: zod_1.z.string(),
+    filename: zod_1.z.string(),
+    size: zod_1.z.number().int().nonnegative(),
+    contentType: zod_1.z.string(),
+    category: zod_1.z.enum(file_category_enum_1.FileCategory),
+    status: zod_1.z.enum(file_status_enum_1.FileStatus),
+    url: zod_1.z.string().optional(),
+    uploadedBy: zod_1.z.string(),
+    uploadedAt: zod_1.z.string().datetime(),
+});

package/build/v1/file/schemas/file-status.enum.d.ts

@@ -0,0 +1,10 @@
+/**
+ * File processing status
+ */
+export declare enum FileStatus {
+    UPLOADING = "UPLOADING",
+    PROCESSING = "PROCESSING",
+    READY = "READY",
+    FAILED = "FAILED",
+    DELETED = "DELETED"
+}

package/build/v1/file/schemas/file-status.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStatus = void 0;
+/**
+ * File processing status
+ */
+var FileStatus;
+(function (FileStatus) {
+    FileStatus["UPLOADING"] = "UPLOADING";
+    FileStatus["PROCESSING"] = "PROCESSING";
+    FileStatus["READY"] = "READY";
+    FileStatus["FAILED"] = "FAILED";
+    FileStatus["DELETED"] = "DELETED";
+})(FileStatus || (exports.FileStatus = FileStatus = {}));

package/build/v1/file/schemas/file-variant-response.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/**
+ * File variant schema (for images with different sizes/formats)
+ */
+export declare const FileVariantResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    sizeName: z.ZodString;
+    format: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/build/v1/file/schemas/file-variant-response.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileVariantResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * File variant schema (for images with different sizes/formats)
+ */
+exports.FileVariantResponseSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    sizeName: zod_1.z.string(),
+    format: zod_1.z.string(),
+    sizeBytes: zod_1.z.number().int().nonnegative(),
+    width: zod_1.z.number().int().positive().optional(),
+    height: zod_1.z.number().int().positive().optional(),
+    url: zod_1.z.string().optional(),
+});

package/build/v1/file/schemas/file-with-variants-response.schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/**
+ * File with variants schema (for single file response)
+ */
+export declare const FileWithVariantsResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    folder: z.ZodString;
+    filename: z.ZodString;
+    size: z.ZodNumber;
+    contentType: z.ZodString;
+    category: z.ZodEnum<typeof import("./file-category.enum").FileCategory>;
+    status: z.ZodEnum<typeof import("./file-status.enum").FileStatus>;
+    url: z.ZodOptional<z.ZodString>;
+    uploadedBy: z.ZodString;
+    uploadedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    variants: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sizeName: z.ZodString;
+        format: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/build/v1/file/schemas/file-with-variants-response.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWithVariantsResponseSchema = void 0;
+const zod_1 = require("zod");
+const file_response_schema_1 = require("./file-response.schema");
+const file_variant_response_schema_1 = require("./file-variant-response.schema");
+/**
+ * File with variants schema (for single file response)
+ */
+exports.FileWithVariantsResponseSchema = file_response_schema_1.FileItemResponseSchema.extend({
+    updatedAt: zod_1.z.string().datetime(),
+    variants: zod_1.z.array(file_variant_response_schema_1.FileVariantResponseSchema),
+});

package/build/v1/file/schemas/folder-response.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * Folder item schema
+ */
+export declare const FolderItemSchema: z.ZodObject<{
+    path: z.ZodString;
+    fileCount: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * List folders response schema
+ */
+export declare const ListFoldersResponseSchema: z.ZodObject<{
+    folders: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        fileCount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/build/v1/file/schemas/folder-response.schema.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFoldersResponseSchema = exports.FolderItemSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Folder item schema
+ */
+exports.FolderItemSchema = zod_1.z.object({
+    path: zod_1.z.string(),
+    fileCount: zod_1.z.number().int().nonnegative(),
+});
+/**
+ * List folders response schema
+ */
+exports.ListFoldersResponseSchema = zod_1.z.object({
+    folders: zod_1.z.array(exports.FolderItemSchema),
+});

package/build/v1/file/schemas/image-format.enum.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Supported image formats for conversion
+ */
+export declare enum ImageFormat {
+    WEBP = "webp",
+    JPEG = "jpeg"
+}

package/build/v1/file/schemas/image-format.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageFormat = void 0;
+/**
+ * Supported image formats for conversion
+ */
+var ImageFormat;
+(function (ImageFormat) {
+    ImageFormat["WEBP"] = "webp";
+    ImageFormat["JPEG"] = "jpeg";
+})(ImageFormat || (exports.ImageFormat = ImageFormat = {}));

package/build/v1/file/schemas/index.d.ts

@@ -0,0 +1,16 @@
+export * from './file-status.enum';
+export * from './file-category.enum';
+export * from './image-format.enum';
+export * from './file-response.schema';
+export * from './file-variant-response.schema';
+export * from './file-with-variants-response.schema';
+export * from './folder-response.schema';
+export * from './upload-image-request.schema';
+export * from './upload-image-response.schema';
+export * from './upload-file-request.schema';
+export * from './upload-file-response.schema';
+export * from './list-files-request.schema';
+export * from './list-files-response.schema';
+export * from './list-folders-request.schema';
+export * from './delete-file-response.schema';
+export * from './delete-file-by-key-request.schema';

package/build/v1/file/schemas/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Enums
+__exportStar(require("./file-status.enum"), exports);
+__exportStar(require("./file-category.enum"), exports);
+__exportStar(require("./image-format.enum"), exports);
+// Response schemas
+__exportStar(require("./file-response.schema"), exports);
+__exportStar(require("./file-variant-response.schema"), exports);
+__exportStar(require("./file-with-variants-response.schema"), exports);
+__exportStar(require("./folder-response.schema"), exports);
+// Upload schemas
+__exportStar(require("./upload-image-request.schema"), exports);
+__exportStar(require("./upload-image-response.schema"), exports);
+__exportStar(require("./upload-file-request.schema"), exports);
+__exportStar(require("./upload-file-response.schema"), exports);
+// List schemas
+__exportStar(require("./list-files-request.schema"), exports);
+__exportStar(require("./list-files-response.schema"), exports);
+__exportStar(require("./list-folders-request.schema"), exports);
+// Delete schemas
+__exportStar(require("./delete-file-response.schema"), exports);
+__exportStar(require("./delete-file-by-key-request.schema"), exports);

package/build/v1/file/schemas/list-files-request.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { FileStatus } from './file-status.enum';
+import { FileCategory } from './file-category.enum';
+/**
+ * List files query parameters schema
+ */
+export declare const ListFilesQuerySchema: z.ZodObject<{
+    folder: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<typeof FileStatus>>;
+    category: z.ZodOptional<z.ZodEnum<typeof FileCategory>>;
+    uploadedBy: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;

package/build/v1/file/schemas/list-files-request.schema.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFilesQuerySchema = void 0;
+const zod_1 = require("zod");
+const file_status_enum_1 = require("./file-status.enum");
+const file_category_enum_1 = require("./file-category.enum");
+/**
+ * List files query parameters schema
+ */
+exports.ListFilesQuerySchema = zod_1.z.object({
+    folder: zod_1.z.string().optional(),
+    status: zod_1.z.enum(file_status_enum_1.FileStatus).optional(),
+    category: zod_1.z.enum(file_category_enum_1.FileCategory).optional(),
+    uploadedBy: zod_1.z.string().optional(),
+    page: zod_1.z.coerce.number().int().positive().default(1),
+    limit: zod_1.z.coerce.number().int().positive().max(100).default(20),
+});

package/build/v1/file/schemas/list-files-response.schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/**
+ * List files paginated response schema
+ */
+export declare const ListFilesResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        folder: z.ZodString;
+        filename: z.ZodString;
+        size: z.ZodNumber;
+        contentType: z.ZodString;
+        category: z.ZodEnum<typeof import("./file-category.enum").FileCategory>;
+        status: z.ZodEnum<typeof import("./file-status.enum").FileStatus>;
+        url: z.ZodOptional<z.ZodString>;
+        uploadedBy: z.ZodString;
+        uploadedAt: z.ZodString;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        page: z.ZodNumber;
+        limit: z.ZodNumber;
+        total: z.ZodNumber;
+        totalPages: z.ZodNumber;
+        hasNext: z.ZodBoolean;
+        hasPrev: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/build/v1/file/schemas/list-files-response.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFilesResponseSchema = void 0;
+const zod_1 = require("zod");
+const file_response_schema_1 = require("./file-response.schema");
+const shared_1 = require("../../../shared");
+/**
+ * List files paginated response schema
+ */
+exports.ListFilesResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(file_response_schema_1.FileItemResponseSchema),
+    meta: shared_1.PaginationMetaSchema,
+});

package/build/v1/file/schemas/list-folders-request.schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * List folders query parameters schema
+ */
+export declare const ListFoldersQuerySchema: z.ZodObject<{
+    prefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/build/v1/file/schemas/list-folders-request.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFoldersQuerySchema = void 0;
+const zod_1 = require("zod");
+/**
+ * List folders query parameters schema
+ */
+exports.ListFoldersQuerySchema = zod_1.z.object({
+    prefix: zod_1.z.string().optional(),
+});

package/build/v1/file/schemas/upload-file-request.schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * Upload file query parameters schema
+ */
+export declare const UploadFileQuerySchema: z.ZodObject<{
+    folder: z.ZodString;
+}, z.core.$strip>;

package/build/v1/file/schemas/upload-file-request.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFileQuerySchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Upload file query parameters schema
+ */
+exports.UploadFileQuerySchema = zod_1.z.object({
+    folder: zod_1.z.string().min(1),
+});

package/build/v1/file/schemas/upload-file-response.schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+/**
+ * Upload file response schema
+ */
+export declare const UploadFileResponseSchema: z.ZodObject<{
+    key: z.ZodString;
+    cdnUrl: z.ZodString;
+    s3Url: z.ZodString;
+}, z.core.$strip>;

package/build/v1/file/schemas/upload-file-response.schema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFileResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Upload file response schema
+ */
+exports.UploadFileResponseSchema = zod_1.z.object({
+    key: zod_1.z.string(),
+    cdnUrl: zod_1.z.string().url(),
+    s3Url: zod_1.z.string().url(),
+});

package/build/v1/file/schemas/upload-image-request.schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ImageFormat } from './image-format.enum';
+/**
+ * Upload image query parameters schema
+ */
+export declare const UploadImageQuerySchema: z.ZodObject<{
+    folder: z.ZodString;
+    formats: z.ZodString;
+    sizes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Helper to parse formats string to array
+ */
+export declare function parseFormats(formats: string): ImageFormat[];
+/**
+ * Helper to parse sizes string to array
+ */
+export declare function parseSizes(sizes: string | undefined): string[];

package/build/v1/file/schemas/upload-image-request.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadImageQuerySchema = void 0;
+exports.parseFormats = parseFormats;
+exports.parseSizes = parseSizes;
+const zod_1 = require("zod");
+/**
+ * Upload image query parameters schema
+ */
+exports.UploadImageQuerySchema = zod_1.z.object({
+    folder: zod_1.z.string().min(1),
+    formats: zod_1.z.string().min(1), // comma-separated: "webp" | "jpeg" | "webp,jpeg"
+    sizes: zod_1.z.string().optional(), // comma-separated: "1024x1024,512x512"
+});
+/**
+ * Helper to parse formats string to array
+ */
+function parseFormats(formats) {
+    return formats.split(',').map((f) => f.trim());
+}
+/**
+ * Helper to parse sizes string to array
+ */
+function parseSizes(sizes) {
+    if (!sizes)
+        return [];
+    return sizes.split(',').map((s) => s.trim());
+}

package/build/v1/file/schemas/upload-image-response.schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/**
+ * Upload image response schema
+ */
+export declare const UploadImageResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    variants: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+    cdnUrl: z.ZodString;
+    s3Url: z.ZodString;
+}, z.core.$strip>;

package/build/v1/file/schemas/upload-image-response.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadImageResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Variants map: size -> format -> path
+ * Example: { "1024x1024": { "webp": "path/to/file.webp", "jpeg": "path/to/file.jpg" } }
+ */
+const VariantsMapSchema = zod_1.z.record(zod_1.z.string(), // size name
+zod_1.z.record(zod_1.z.string(), zod_1.z.string()));
+/**
+ * Upload image response schema
+ */
+exports.UploadImageResponseSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    variants: VariantsMapSchema,
+    cdnUrl: zod_1.z.string().url(),
+    s3Url: zod_1.z.string().url(),
+});

package/build/v1/index.d.ts

@@ -5,3 +5,4 @@ export * from './users';
 export * from './email';
 export * from './notifications';
 export * from './seo-pages';
+export * from './ai-provider';

package/build/v1/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./users"), exports);
 __exportStar(require("./email"), exports);
 __exportStar(require("./notifications"), exports);
 __exportStar(require("./seo-pages"), exports);
+__exportStar(require("./ai-provider"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veruna/api-contracts",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "API contracts for Veruna project - Zod schemas, types, and paths",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",