@calmlens/js-sdk 0.0.1 → 0.0.2

package/cjs/ZodUtils.js

@@ -0,0 +1,328 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodSchemaToTypeScript = exports.rsqlField = exports.urlField = exports.saneStringField = exports.updatedAtField = exports.createdAtField = exports.uuidField = exports.primaryUuidField = exports.nonNullable = exports.isZodTypeExtends = exports.getSchemaDisplayInfo = exports.getZodTypeChain = exports.isZodRequired = void 0;
+var zod = __importStar(require("zod/v4"));
+var zod_meta_1 = require("zod-meta");
+var zodbase_1 = require("zodbase");
+var DocMetaTypes_1 = require("./DocMetaTypes");
+var ValidationUtils_1 = require("./ValidationUtils");
+var isZodRequired = function (type) {
+    return !(0, exports.isZodTypeExtends)(type, zod.ZodOptional);
+};
+exports.isZodRequired = isZodRequired;
+var getZodTypeChain = function (type) {
+    var _a;
+    var chain = [];
+    var current = type;
+    while (current === null || current === void 0 ? void 0 : current.def) {
+        chain.push(current);
+        var innerType = (_a = current.def.innerType) !== null && _a !== void 0 ? _a : current.def.in;
+        current = innerType === current ? null : innerType;
+    }
+    return chain;
+};
+exports.getZodTypeChain = getZodTypeChain;
+var getSchemaDisplayInfo = function (type) {
+    var chain = (0, exports.getZodTypeChain)(type);
+    var metaItem = (0, zod_meta_1.getMetaItem)(type, DocMetaTypes_1.docPropertyInfo);
+    var description = (metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.description) || type.description;
+    var defaultValue = metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.defaultValue;
+    var placeholder = metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.placeholder;
+    var namedType = metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.namedType;
+    var mainType = type;
+    var qualifierTypes = new Set();
+    var enumValues;
+    for (var _i = 0, chain_1 = chain; _i < chain_1.length; _i++) {
+        var item = chain_1[_i];
+        if (item.def.innerType) {
+            if (item.def.type === "nullable" || item.def.type === "optional") {
+                qualifierTypes.add("optional");
+            }
+        }
+        else {
+            mainType = item;
+        }
+        // Check for enum values
+        if (item.def.type === "enum") {
+            // @ts-expect-error
+            enumValues = Object.values(item.def.entries);
+        }
+    }
+    var typeDisplay = mainType.def.type;
+    // If it's an enum, show the enum values
+    if (enumValues && enumValues.length > 0) {
+        typeDisplay = "enum";
+    }
+    return {
+        mainType: mainType.def.type,
+        description: description,
+        defaultValue: defaultValue,
+        placeholder: placeholder,
+        optional: !(0, exports.isZodRequired)(type),
+        enumValues: enumValues,
+        namedType: namedType,
+        type: "".concat(typeDisplay).concat(qualifierTypes.size > 0 ? " (".concat(Array.from(qualifierTypes).join(", "), ")") : ""),
+    };
+};
+exports.getSchemaDisplayInfo = getSchemaDisplayInfo;
+var isZodTypeExtends = function (type, zodType) {
+    if (type instanceof zodType) {
+        return type;
+    }
+    // @ts-expect-error
+    if (type.def.type === "union") {
+        // @ts-expect-error
+        for (var _i = 0, _a = type.def.options; _i < _a.length; _i++) {
+            var option = _a[_i];
+            if ((0, exports.isZodTypeExtends)(option, zodType)) {
+                return option;
+            }
+        }
+        return false;
+    }
+    // @ts-expect-error
+    var rootType = type.def.innerType;
+    if (rootType) {
+        return (0, exports.isZodTypeExtends)(rootType, zodType);
+    }
+    return false;
+};
+exports.isZodTypeExtends = isZodTypeExtends;
+var nonNullable = function (schema) {
+    return schema.refine(function (data) {
+        if (data === null || data === undefined) {
+            return false;
+        }
+        for (var key in data) {
+            if (data[key] === null || data[key] === undefined) {
+                return false;
+            }
+        }
+        return true;
+    }, {
+        message: "Value cannot contain null or undefined",
+    });
+};
+exports.nonNullable = nonNullable;
+var primaryUuidField = function () {
+    return zod
+        .string()
+        .uuid({
+        version: "v4",
+    })
+        .meta((0, zodbase_1.metaStore)([(0, zodbase_1.primaryKey)()]));
+};
+exports.primaryUuidField = primaryUuidField;
+var uuidField = function () {
+    return zod.string().uuid({
+        version: "v4",
+    });
+};
+exports.uuidField = uuidField;
+var createdAtField = function () { return zod.number().int(); };
+exports.createdAtField = createdAtField;
+var updatedAtField = function () {
+    return zod
+        .number()
+        .int()
+        .optional()
+        .meta((0, zodbase_1.metaStore)([(0, zodbase_1.updatedAt)()]));
+};
+exports.updatedAtField = updatedAtField;
+var SIZE_LIMITS = {
+    small: 64,
+    medium: 200,
+    large: 1500,
+};
+var saneStringField = function (options) {
+    return zod
+        .string()
+        .transform(function (value) { return value.trim(); })
+        .refine(function (value) {
+        if ((options === null || options === void 0 ? void 0 : options.minWidth) && value.length < options.minWidth) {
+            return false;
+        }
+        return true;
+    }, "Not long enough")
+        .refine(function (value) {
+        var _a;
+        var sizeLimit = SIZE_LIMITS[(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : "medium"];
+        return typeof value === "string" && value.length < sizeLimit;
+    }, "Too long");
+};
+exports.saneStringField = saneStringField;
+var urlField = function () {
+    return (0, exports.saneStringField)().refine(function (value) {
+        /*if (encodeURI(value) !== value) {
+          return false;
+        }*/
+        var parsedUrl = (0, ValidationUtils_1.validateUrl)(value);
+        return Boolean(parsedUrl);
+    }, "Invalid link");
+};
+exports.urlField = urlField;
+var rsqlField = function () {
+    return (0, exports.saneStringField)({
+        type: "large",
+    }).meta((0, zodbase_1.metaStore)([
+        (0, DocMetaTypes_1.docPropertyInfo)({
+            description: "RSQL filter string for filtering results. See [REST API Documentation](/docs/rest) for detailed syntax.\n\n**Examples:**\n- `status==rejected;parentId==null` (AND conditions)\n- `status==rejected,status==error` (OR conditions)\n- `price>100;price<500` (range filtering)\n- `tags=in=(react,typescript)` (array membership)\n\n**Supported operators:** `==`, `!=`, `>`, `>=`, `<`, `<=`, `=in=`, `=out=`, `=like=`\n\n**Logical operators:** `;` (AND), `,` (OR)",
+            placeholder: "status==approved;type==image",
+        }),
+    ]));
+};
+exports.rsqlField = rsqlField;
+/**
+ * Converts a Zod schema to a TypeScript type definition string
+ */
+var zodSchemaToTypeScript = function (schema, indent) {
+    if (indent === void 0) { indent = 0; }
+    var spaces = "  ".repeat(indent);
+    var chain = (0, exports.getZodTypeChain)(schema);
+    // Check for optional/nullable
+    var isOptional = chain.some(function (s) { return s.def.type === "optional"; });
+    var isNullable = chain.some(function (s) { return s.def.type === "nullable"; });
+    // Get the core type
+    var coreSchema = schema;
+    for (var _i = 0, chain_2 = chain; _i < chain_2.length; _i++) {
+        var s = chain_2[_i];
+        if (s.def.innerType) {
+            coreSchema = s.def.innerType;
+        }
+    }
+    var typeStr = "";
+    // Handle different types
+    if (coreSchema.def.type === "string") {
+        typeStr = "string";
+    }
+    else if (coreSchema.def.type === "number") {
+        typeStr = "number";
+    }
+    else if (coreSchema.def.type === "boolean") {
+        typeStr = "boolean";
+    }
+    else if (coreSchema.def.type === "bigint") {
+        typeStr = "bigint";
+    }
+    else if (coreSchema.def.type === "date") {
+        typeStr = "Date";
+    }
+    else if (coreSchema.def.type === "null") {
+        typeStr = "null";
+    }
+    else if (coreSchema.def.type === "undefined") {
+        typeStr = "undefined";
+    }
+    else if (coreSchema.def.type === "any") {
+        typeStr = "any";
+    }
+    else if (coreSchema.def.type === "unknown") {
+        typeStr = "unknown";
+    }
+    else if (coreSchema.def.type === "never") {
+        typeStr = "never";
+    }
+    else if (coreSchema.def.type === "void") {
+        typeStr = "void";
+    }
+    else if (coreSchema.def.type === "literal") {
+        var value = coreSchema.def.value;
+        typeStr = typeof value === "string" ? "\"".concat(value, "\"") : String(value);
+    }
+    else if (coreSchema.def.type === "enum") {
+        var entries = Object.values(coreSchema.def.entries);
+        typeStr = entries.map(function (e) { return "\"".concat(e, "\""); }).join(" | ");
+    }
+    else if (coreSchema.def.type === "array") {
+        var element = coreSchema.def.element;
+        var elementType = (0, exports.zodSchemaToTypeScript)(element, indent);
+        typeStr = "".concat(elementType, "[]");
+    }
+    else if (coreSchema.def.type === "object") {
+        var shape = coreSchema.def.shape || {};
+        var fields = Object.entries(shape).map(function (_a) {
+            var key = _a[0], fieldSchema = _a[1];
+            var fieldInfo = (0, exports.getSchemaDisplayInfo)(fieldSchema);
+            var fieldType = (0, exports.zodSchemaToTypeScript)(fieldSchema, indent + 1);
+            var optional = fieldInfo.optional ? "?" : "";
+            return "".concat(spaces, "  ").concat(key).concat(optional, ": ").concat(fieldType, ";");
+        });
+        if (fields.length === 0) {
+            typeStr = "{}";
+        }
+        else {
+            typeStr = "{\n".concat(fields.join("\n"), "\n").concat(spaces, "}");
+        }
+    }
+    else if (coreSchema.def.type === "union") {
+        var options = coreSchema.def.options || [];
+        var types = options.map(function (opt) { return (0, exports.zodSchemaToTypeScript)(opt, indent); });
+        typeStr = types.join(" | ");
+    }
+    else if (coreSchema.def.type === "intersection") {
+        var left = coreSchema.def.left;
+        var right = coreSchema.def.right;
+        var leftType = (0, exports.zodSchemaToTypeScript)(left, indent);
+        var rightType = (0, exports.zodSchemaToTypeScript)(right, indent);
+        typeStr = "".concat(leftType, " & ").concat(rightType);
+    }
+    else if (coreSchema.def.type === "record") {
+        var keyType = coreSchema.def.keyType
+            ? (0, exports.zodSchemaToTypeScript)(coreSchema.def.keyType, indent)
+            : "string";
+        var valueType = coreSchema.def.valueType
+            ? (0, exports.zodSchemaToTypeScript)(coreSchema.def.valueType, indent)
+            : "any";
+        typeStr = "Record<".concat(keyType, ", ").concat(valueType, ">");
+    }
+    else if (coreSchema.def.type === "tuple") {
+        var items = coreSchema.def.items || [];
+        var types = items.map(function (item) { return (0, exports.zodSchemaToTypeScript)(item, indent); });
+        typeStr = "[".concat(types.join(", "), "]");
+    }
+    else {
+        typeStr = "unknown";
+    }
+    // Add optional/nullable modifiers
+    if (isNullable && !typeStr.includes("null")) {
+        typeStr = "".concat(typeStr, " | null");
+    }
+    if (isOptional && indent === 0) {
+        typeStr = "".concat(typeStr, " | undefined");
+    }
+    return typeStr;
+};
+exports.zodSchemaToTypeScript = zodSchemaToTypeScript;

package/cjs/index.js

@@ -1,8 +1,11 @@
 "use strict";
 /// <reference types="typescript" />
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyWebhookSignature = exports.CalmLensClient = void 0;
 var CalmLensClient_1 = require("./CalmLensClient");
-Object.defineProperty(exports, "CalmLensClient", { enumerable: true, get: function () { return CalmLensClient_1.default; } });
+Object.defineProperty(exports, "CalmLensClient", { enumerable: true, get: function () { return __importDefault(CalmLensClient_1).default; } });
 var CalmLensUtils_1 = require("./CalmLensUtils");
 Object.defineProperty(exports, "verifyWebhookSignature", { enumerable: true, get: function () { return CalmLensUtils_1.verifyWebhookSignature; } });

package/esm/ApiKey.d.ts

@@ -0,0 +1,31 @@
+import * as zod from "zod/v4";
+export declare const API_KEY_STATUS_SCHEMA: zod.ZodEnum<{
+    active: "active";
+    revoked: "revoked";
+    expired: "expired";
+}>;
+export type ApiKeyStatus = zod.infer<typeof API_KEY_STATUS_SCHEMA>;
+export declare const API_KEY_SCHEMA: zod.ZodObject<{
+    id: zod.ZodString;
+    projectId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    userId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    createdAt: zod.ZodNumber;
+    updatedAt: zod.ZodOptional<zod.ZodNumber>;
+    name: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    description: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    keyHash: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    keyPrefix: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    roles: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodEnum<{
+        "system:super-admin": "system:super-admin";
+        "system:banned": "system:banned";
+        "assets:view-all": "assets:view-all";
+    }>>>>;
+    status: zod.ZodEnum<{
+        active: "active";
+        revoked: "revoked";
+        expired: "expired";
+    }>;
+    expiresAt: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+    lastUsedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+}, zod.z.core.$strip>;
+export type ApiKey = zod.infer<typeof API_KEY_SCHEMA>;

package/esm/ApiKey.js

@@ -0,0 +1,23 @@
+import * as zod from "zod/v4";
+import { ROLE_SCHEMA } from "./Roles";
+import { createdAtField, primaryUuidField, saneStringField, updatedAtField, uuidField, } from "./ZodUtils";
+export const API_KEY_STATUS_SCHEMA = zod.enum(["active", "revoked", "expired"]);
+export const API_KEY_SCHEMA = zod.object({
+    id: primaryUuidField(),
+    projectId: uuidField().nullish(),
+    userId: saneStringField().nullish(),
+    createdAt: createdAtField(),
+    updatedAt: updatedAtField(),
+    name: saneStringField({
+        type: "medium",
+    }),
+    description: saneStringField({
+        type: "large",
+    }).nullish(),
+    keyHash: saneStringField(), // Store hashed version of the key for security
+    keyPrefix: saneStringField(), // Store first few characters for identification
+    roles: zod.array(ROLE_SCHEMA).nullish(),
+    status: API_KEY_STATUS_SCHEMA,
+    expiresAt: zod.number().nullish(), // Unix timestamp
+    lastUsedAt: zod.number().nullish(), // Unix timestamp
+});

package/esm/Asset.d.ts

@@ -7,18 +7,56 @@ export declare const ASSET_STATUS_SCHEMA: zod.ZodEnum<{
 }>;
 export type AssetStatus = zod.infer<typeof ASSET_STATUS_SCHEMA>;
 export declare const ASSET_TYPE_SCHEMA: zod.ZodEnum<{
+    file: "file";
     image: "image";
     video: "video";
     audio: "audio";
-    document: "document";
+    "plaintext-document": "plaintext-document";
+    "multimedia-document": "multimedia-document";
     website: "website";
 }>;
 export type AssetType = zod.infer<typeof ASSET_TYPE_SCHEMA>;
+/**
+ * MIME types that are considered multimedia documents
+ * (documents that contain both text and embedded images/media)
+ */
+export declare const MULTIMEDIA_DOCUMENT_MIME_TYPES: readonly ["application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/msword", "application/rtf", "application/vnd.oasis.opendocument.text"];
+/**
+ * Checks if a MIME type is a multimedia document
+ */
+export declare const isMultimediaDocumentMimeType: (mimeType: string) => boolean;
 export declare const ASSET_VISIBILITY_SCHEMA: zod.ZodEnum<{
     public: "public";
     private: "private";
 }>;
 export type AssetVisibility = zod.infer<typeof ASSET_VISIBILITY_SCHEMA>;
+export interface CheckSums {
+    readonly md5?: string;
+    readonly sha1?: string;
+    readonly sha256?: string;
+    readonly sha384?: string;
+    readonly sha512?: string;
+}
+export declare const CHECKSUMS_SCHEMA: zod.ZodObject<{
+    md5: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    sha1: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    sha256: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    sha384: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    sha512: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+}, zod.z.core.$strip>;
+export declare const IMAGE_DATA_SCHEMA: zod.ZodObject<{
+    perceptualHash: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+}, zod.z.core.$strip>;
+export type ImageData = zod.infer<typeof IMAGE_DATA_SCHEMA>;
+export declare const DOCUMENT_DATA_SCHEMA: zod.ZodObject<{}, zod.z.core.$strip>;
+export type DocumentData = zod.infer<typeof DOCUMENT_DATA_SCHEMA>;
+export declare const PROCESSING_OPTIONS_SCHEMA: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+    keepAfterProcessing: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+    image: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+        ocrEnabled: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+    }, zod.z.core.$strip>>>;
+}, zod.z.core.$strip>>>;
+export type ProcessingOptions = zod.infer<typeof PROCESSING_OPTIONS_SCHEMA>;
 export declare const ASSET_SCHEMA: zod.ZodObject<{
     id: zod.ZodString;
     projectId: zod.ZodString;
@@ -27,6 +65,17 @@ export declare const ASSET_SCHEMA: zod.ZodObject<{
     parentId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
     createdAt: zod.ZodNumber;
     updatedAt: zod.ZodOptional<zod.ZodNumber>;
+    checksums: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+        md5: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        sha1: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        sha256: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        sha384: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        sha512: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    }, zod.z.core.$strip>>>;
+    imageData: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+        perceptualHash: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    }, zod.z.core.$strip>>>;
+    documentData: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{}, zod.z.core.$strip>>>;
     name: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
     fileFormat: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
     fileExtension: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
@@ -37,10 +86,12 @@ export declare const ASSET_SCHEMA: zod.ZodObject<{
     storageId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
     averageColor: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
     type: zod.ZodEnum<{
+        file: "file";
         image: "image";
         video: "video";
         audio: "audio";
-        document: "document";
+        "plaintext-document": "plaintext-document";
+        "multimedia-document": "multimedia-document";
         website: "website";
     }>;
     previewHash: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
@@ -100,10 +151,39 @@ export declare const ASSET_SCHEMA: zod.ZodObject<{
         approved: "approved";
         rejected: "rejected";
     }>;
-    keepAfterProcessing: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+    extractedTextId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    processingOptions: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+        keepAfterProcessing: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+        image: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+            ocrEnabled: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+        }, zod.z.core.$strip>>>;
+    }, zod.z.core.$strip>>>;
     visibility: zod.ZodOptional<zod.ZodNullable<zod.ZodEnum<{
         public: "public";
         private: "private";
     }>>>;
+    storageDeletedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+    classificationWorkflow: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+        id: zod.ZodString;
+        name: zod.ZodString;
+        steps: zod.ZodArray<zod.ZodObject<{
+            id: zod.ZodString;
+            label: zod.ZodString;
+            status: zod.ZodEnum<{
+                error: "error";
+                pending: "pending";
+                in_progress: "in_progress";
+                completed: "completed";
+                skipped: "skipped";
+            }>;
+            optional: zod.ZodOptional<zod.ZodBoolean>;
+            startedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            completedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            error: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        }, zod.z.core.$strip>>;
+        createdAt: zod.ZodString;
+        updatedAt: zod.ZodString;
+    }, zod.z.core.$strip>>>;
 }, zod.z.core.$strip>;
 export type Asset = zod.infer<typeof ASSET_SCHEMA>;
+export type AssetInput = Omit<zod.input<typeof ASSET_SCHEMA>, "createdAt" | "status">;