@calmlens/js-sdk 0.0.0

package/README.md

@@ -0,0 +1,37 @@
+# [api-def](https://github.com/Censkh/api-def/) · [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Censkh/api-def/blob/master/LICENSE) [![npm version](https://img.shields.io/npm/v/api-def.svg?style=flat)](https://www.npmjs.com/package/api-def) [![build status](https://img.shields.io/github/actions/workflow/status/censkh/api-def/workflow.yml)](https://github.com/Censkh/api-def/actions)
+
+Typed APIs with middleware support
+
+API def provides a unified way to type your endpoints allowing for compile time checking of query, body, response and even url parameters
+
+```bash
+npm i api-def
+```
+
+- [Documentation](https://censkh.github.io/api-def/)
+
+```typescript
+import { Api } from "api-def";
+
+const api = new Api({
+  baseUrl: "https://my-api/",
+  name: "My API",
+});
+
+const fetchData = api
+  .endpoint()
+  .queryOf<{ includeAwesome: boolean }>()
+  .responseOf<{ data: { awesome: boolean } }>()
+  .build({
+    id: "fetch_data",
+    method: "get",
+    path: "/data",
+  });
+
+// calls GET https://my-api/data?includeAwesome=true
+const res = await fetchData.submit({
+  query: { includeAwesome: true },
+});
+
+console.log(res.data); // { data: { awesome: true } }
+```

package/cjs/Asset.d.ts

@@ -0,0 +1,109 @@
+import * as zod from "zod/v4";
+export declare const ASSET_STATUS_SCHEMA: zod.ZodEnum<{
+    error: "error";
+    pending: "pending";
+    approved: "approved";
+    rejected: "rejected";
+}>;
+export type AssetStatus = zod.infer<typeof ASSET_STATUS_SCHEMA>;
+export declare const ASSET_TYPE_SCHEMA: zod.ZodEnum<{
+    image: "image";
+    video: "video";
+    audio: "audio";
+    document: "document";
+    website: "website";
+}>;
+export type AssetType = zod.infer<typeof ASSET_TYPE_SCHEMA>;
+export declare const ASSET_VISIBILITY_SCHEMA: zod.ZodEnum<{
+    public: "public";
+    private: "private";
+}>;
+export type AssetVisibility = zod.infer<typeof ASSET_VISIBILITY_SCHEMA>;
+export declare const ASSET_SCHEMA: zod.ZodObject<{
+    id: zod.ZodString;
+    projectId: zod.ZodString;
+    sizeInBytes: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+    userId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    parentId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    createdAt: zod.ZodNumber;
+    updatedAt: zod.ZodOptional<zod.ZodNumber>;
+    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>>>>;
+    description: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    externalId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    externalUrl: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    previewImageId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    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<{
+        image: "image";
+        video: "video";
+        audio: "audio";
+        document: "document";
+        website: "website";
+    }>;
+    previewHash: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    metadata: zod.ZodOptional<zod.ZodNullable<zod.ZodAny>>;
+    tags: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>>;
+    report: zod.ZodOptional<zod.ZodNullable<zod.ZodObject<{
+        processedAt: zod.ZodNumber;
+        categories: zod.ZodRecord<zod.ZodEnum<{
+            sexual: "sexual";
+            violence: "violence";
+            gore: "gore";
+            "self-harm": "self-harm";
+            harassment: "harassment";
+            hate: "hate";
+            illicit: "illicit";
+            "child-exploitation": "child-exploitation";
+        }> & zod.z.core.$partial, zod.ZodObject<{
+            category: zod.ZodEnum<{
+                sexual: "sexual";
+                violence: "violence";
+                gore: "gore";
+                "self-harm": "self-harm";
+                harassment: "harassment";
+                hate: "hate";
+                illicit: "illicit";
+                "child-exploitation": "child-exploitation";
+            }>;
+            likelihood: zod.ZodEnum<{
+                VERY_UNLIKELY: "VERY_UNLIKELY";
+                UNLIKELY: "UNLIKELY";
+                POSSIBLE: "POSSIBLE";
+                LIKELY: "LIKELY";
+                VERY_LIKELY: "VERY_LIKELY";
+            }>;
+            score: zod.ZodNumber;
+        }, zod.z.core.$strip>>;
+        flagged: zod.ZodBoolean;
+        score: zod.ZodNumber;
+        notes: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+        labels: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+            description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+            score: zod.ZodNumber;
+            topicalityScore: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+            likelihood: zod.ZodEnum<{
+                VERY_UNLIKELY: "VERY_UNLIKELY";
+                UNLIKELY: "UNLIKELY";
+                POSSIBLE: "POSSIBLE";
+                LIKELY: "LIKELY";
+                VERY_LIKELY: "VERY_LIKELY";
+            }>;
+            knowledgeBaseId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+        }, zod.z.core.$strip>>>>;
+    }, zod.z.core.$strip>>>;
+    status: zod.ZodEnum<{
+        error: "error";
+        pending: "pending";
+        approved: "approved";
+        rejected: "rejected";
+    }>;
+    keepAfterProcessing: zod.ZodOptional<zod.ZodNullable<zod.ZodBoolean>>;
+    visibility: zod.ZodOptional<zod.ZodNullable<zod.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>>;
+}, zod.z.core.$strip>;
+export type Asset = zod.infer<typeof ASSET_SCHEMA>;

package/cjs/Asset.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSET_SCHEMA = exports.ASSET_VISIBILITY_SCHEMA = exports.ASSET_TYPE_SCHEMA = exports.ASSET_STATUS_SCHEMA = void 0;
+var zod = require("zod/v4");
+var Classification_1 = require("./Classification");
+var SchemaUtils_1 = require("./SchemaUtils");
+exports.ASSET_STATUS_SCHEMA = zod.enum(["pending", "approved", "rejected", "error"]);
+exports.ASSET_TYPE_SCHEMA = zod.enum(["image", "video", "audio", "document", "website"]);
+exports.ASSET_VISIBILITY_SCHEMA = zod.enum(["public", "private"]);
+exports.ASSET_SCHEMA = zod.object({
+    id: (0, SchemaUtils_1.primaryUuidField)(),
+    projectId: (0, SchemaUtils_1.uuidField)(),
+    sizeInBytes: zod.number().nullish(),
+    userId: (0, SchemaUtils_1.saneStringField)().nullish(),
+    parentId: (0, SchemaUtils_1.uuidField)().nullish(),
+    createdAt: (0, SchemaUtils_1.createdAtField)(),
+    updatedAt: (0, SchemaUtils_1.updatedAtField)(),
+    name: (0, SchemaUtils_1.saneStringField)({
+        type: "large",
+    }),
+    fileFormat: (0, SchemaUtils_1.saneStringField)().nullish(),
+    fileExtension: (0, SchemaUtils_1.saneStringField)().nullish(),
+    description: (0, SchemaUtils_1.saneStringField)({
+        type: "large",
+    }).nullish(),
+    externalId: (0, SchemaUtils_1.saneStringField)().nullish(),
+    externalUrl: zod.string().url().nullish(),
+    previewImageId: (0, SchemaUtils_1.saneStringField)().nullish(),
+    storageId: (0, SchemaUtils_1.saneStringField)().nullish(),
+    averageColor: (0, SchemaUtils_1.saneStringField)().nullish(),
+    type: exports.ASSET_TYPE_SCHEMA,
+    previewHash: (0, SchemaUtils_1.saneStringField)().nullish(),
+    metadata: zod.any().nullish(),
+    tags: zod.array((0, SchemaUtils_1.saneStringField)()).nullish(),
+    report: Classification_1.CLASSIFICATION_REPORT_SCHEMA.nullish(),
+    status: exports.ASSET_STATUS_SCHEMA,
+    keepAfterProcessing: zod.boolean().nullish(),
+    visibility: exports.ASSET_VISIBILITY_SCHEMA.nullish(),
+});

package/cjs/CalmLensClient.d.ts

@@ -0,0 +1,41 @@
+import type { Asset } from "./Asset";
+import type { SubmitAssetOptions } from "./SharedTypes";
+import type { CalmLensClientOptions } from "./CalmLensTypes";
+export default class CalmLensClient {
+    private options;
+    private readonly api;
+    private readonly endpoints;
+    /**
+     * Validates a webhook signature to ensure the webhook payload is authentic.
+     *
+     * @param payload - The webhook payload (string or object)
+     * @param signatureHex - The signature from the 'x-calmlens-signature' header
+     * @param secret - The webhook secret used to sign the payload
+     * @returns Promise<boolean> - True if the signature is valid, false otherwise
+     *
+     * @example
+     * ```javascript
+     * // In your webhook handler
+     * const signature = req.headers['x-calmlens-signature'];
+     * const payload = req.body;
+     * const isValid = await CalmLensClient.verifyWebhookSignature(payload, signature, WEBHOOK_SECRET);
+     *
+     * if (!isValid) {
+     *   return res.status(401).send('Unauthorized');
+     * }
+     * ```
+     */
+    static verifyWebhookSignature(payload: string | object, signatureHex: string, secret: string): Promise<boolean>;
+    constructor(options: CalmLensClientOptions);
+    submitAsset(options: SubmitAssetOptions): Promise<Asset>;
+    getAsset(assetId: string): Promise<Asset>;
+    listAssets(options?: {
+        pageIndex?: number;
+        pageSize?: number;
+    }): Promise<{
+        items: Asset[];
+        total: number;
+        pageIndex: number;
+        pageSize: number;
+    }>;
+}

package/cjs/CalmLensClient.js

@@ -0,0 +1,199 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var api_def_1 = require("api-def");
+var CalmLensUtils_1 = require("./CalmLensUtils");
+var createApi = function (options) {
+    var api = new api_def_1.Api({
+        name: "Calm Lens",
+        baseUrl: options.baseUrl,
+        middleware: [
+            {
+                beforeSend: function (context) {
+                    context.updateHeaders({
+                        "X-Api-Key": options.apiKey,
+                    });
+                },
+            },
+        ],
+    });
+    return api;
+};
+// API endpoint definitions
+var createEndpoints = function (api) {
+    var postUploadAsset = api
+        .endpoint()
+        .bodyOf()
+        .paramsOf()
+        .responseOf()
+        .build({
+        id: "postUploadAsset",
+        method: "post",
+        path: "/projects/:projectId/assets",
+    });
+    var getAsset = api.endpoint().paramsOf().responseOf().build({
+        id: "getAsset",
+        method: "get",
+        path: "/projects/:projectId/assets/:assetId",
+    });
+    var getAssetsPage = api
+        .endpoint()
+        .queryOf()
+        .paramsOf()
+        .responseOf()
+        .build({
+        id: "getAssetsPage",
+        method: "get",
+        path: "/projects/:projectId/assets/page",
+    });
+    return {
+        postUploadAsset: postUploadAsset,
+        getAsset: getAsset,
+        getAssetsPage: getAssetsPage,
+    };
+};
+var CalmLensClient = /** @class */ (function () {
+    function CalmLensClient(options) {
+        var _a;
+        this.options = options;
+        if (!options.apiKey) {
+            throw new Error("API key is required");
+        }
+        if (!options.projectId) {
+            throw new Error("Project ID is required");
+        }
+        this.options.baseUrl = (_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : "https://api.calmlens.com";
+        this.api = createApi(this.options);
+        this.endpoints = createEndpoints(this.api);
+    }
+    /**
+     * Validates a webhook signature to ensure the webhook payload is authentic.
+     *
+     * @param payload - The webhook payload (string or object)
+     * @param signatureHex - The signature from the 'x-calmlens-signature' header
+     * @param secret - The webhook secret used to sign the payload
+     * @returns Promise<boolean> - True if the signature is valid, false otherwise
+     *
+     * @example
+     * ```javascript
+     * // In your webhook handler
+     * const signature = req.headers['x-calmlens-signature'];
+     * const payload = req.body;
+     * const isValid = await CalmLensClient.verifyWebhookSignature(payload, signature, WEBHOOK_SECRET);
+     *
+     * if (!isValid) {
+     *   return res.status(401).send('Unauthorized');
+     * }
+     * ```
+     */
+    CalmLensClient.verifyWebhookSignature = function (payload, signatureHex, secret) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, CalmLensUtils_1.verifyWebhookSignature)(payload, signatureHex, secret)];
+            });
+        });
+    };
+    CalmLensClient.prototype.submitAsset = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!("file" in options) && !("url" in options)) {
+                            throw new Error("Either file content or URL is required");
+                        }
+                        if (!options.name) {
+                            throw new Error("Asset name is required");
+                        }
+                        return [4 /*yield*/, this.endpoints.postUploadAsset.submit({
+                                body: options,
+                                params: {
+                                    projectId: this.options.projectId,
+                                },
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.data];
+                }
+            });
+        });
+    };
+    CalmLensClient.prototype.getAsset = function (assetId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!assetId) {
+                            throw new Error("Asset ID is required");
+                        }
+                        return [4 /*yield*/, this.endpoints.getAsset.submit({
+                                params: {
+                                    projectId: this.options.projectId,
+                                    assetId: assetId,
+                                },
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.data];
+                }
+            });
+        });
+    };
+    CalmLensClient.prototype.listAssets = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var result;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.endpoints.getAssetsPage.submit({
+                            params: {
+                                projectId: this.options.projectId,
+                            },
+                            query: options,
+                        })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.data];
+                }
+            });
+        });
+    };
+    return CalmLensClient;
+}());
+exports.default = CalmLensClient;

package/cjs/CalmLensTypes.d.ts

@@ -0,0 +1,5 @@
+export interface CalmLensClientOptions {
+    apiKey: string;
+    projectId: string;
+    baseUrl?: string;
+}

package/cjs/CalmLensTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/CalmLensUtils.d.ts

@@ -0,0 +1 @@
+export declare function verifyWebhookSignature(payload: string | object, signatureHex: string, secret: string): Promise<boolean>;

package/cjs/CalmLensUtils.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWebhookSignature = verifyWebhookSignature;
+function verifyWebhookSignature(payload, signatureHex, secret) {
+    return __awaiter(this, void 0, void 0, function () {
+        var encoder, normalizePayload, key, sig, hex, diff, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    encoder = new TextEncoder();
+                    normalizePayload = typeof payload === "string" ? payload : JSON.stringify(payload);
+                    return [4 /*yield*/, crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"])];
+                case 1:
+                    key = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.sign("HMAC", key, encoder.encode(normalizePayload))];
+                case 2:
+                    sig = _a.sent();
+                    hex = Array.from(new Uint8Array(sig))
+                        .map(function (b) { return b.toString(16).padStart(2, "0"); })
+                        .join("");
+                    // Timing-safe equality not available in Node <20 cross-platform via subtle; compare length and constant-time loop
+                    if (hex.length !== signatureHex.length)
+                        return [2 /*return*/, false];
+                    diff = 0;
+                    for (i = 0; i < hex.length; i++) {
+                        diff |= hex.charCodeAt(i) ^ signatureHex.charCodeAt(i);
+                    }
+                    return [2 /*return*/, diff === 0];
+            }
+        });
+    });
+}

package/cjs/Classification.d.ts

@@ -0,0 +1,154 @@
+import * as zod from "zod/v4";
+export declare const CLASSIFICATION_CATEGORIES: readonly ["sexual", "violence", "gore", "self-harm", "harassment", "hate", "illicit", "child-exploitation"];
+export declare const CLASSIFICATION_CATEGORY_SCHEMA: zod.ZodEnum<{
+    sexual: "sexual";
+    violence: "violence";
+    gore: "gore";
+    "self-harm": "self-harm";
+    harassment: "harassment";
+    hate: "hate";
+    illicit: "illicit";
+    "child-exploitation": "child-exploitation";
+}>;
+export type ClassificationCategory = zod.infer<typeof CLASSIFICATION_CATEGORY_SCHEMA>;
+export declare const CLASSIFICATION_CATEGORY_INFO_SCHEMA: zod.ZodObject<{
+    category: zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }>;
+    displayName: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    textOnly: zod.ZodBoolean;
+    supportsImages: zod.ZodBoolean;
+}, zod.z.core.$strip>;
+export type ClassificationCategoryInfo = zod.infer<typeof CLASSIFICATION_CATEGORY_INFO_SCHEMA>;
+export declare const CLASSIFICATION_CATEGORY_INFO: Record<ClassificationCategory, ClassificationCategoryInfo>;
+export declare const getCategoryInfo: (category: ClassificationCategory) => ClassificationCategoryInfo;
+export declare const LIKELIHOOD_SCHEMA: zod.ZodEnum<{
+    VERY_UNLIKELY: "VERY_UNLIKELY";
+    UNLIKELY: "UNLIKELY";
+    POSSIBLE: "POSSIBLE";
+    LIKELY: "LIKELY";
+    VERY_LIKELY: "VERY_LIKELY";
+}>;
+export type Likelihood = zod.infer<typeof LIKELIHOOD_SCHEMA>;
+export declare const CLASSIFICATION_CATEGORY_REPORT_SCHEMA: zod.ZodObject<{
+    category: zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }>;
+    likelihood: zod.ZodEnum<{
+        VERY_UNLIKELY: "VERY_UNLIKELY";
+        UNLIKELY: "UNLIKELY";
+        POSSIBLE: "POSSIBLE";
+        LIKELY: "LIKELY";
+        VERY_LIKELY: "VERY_LIKELY";
+    }>;
+    score: zod.ZodNumber;
+}, zod.z.core.$strip>;
+export type ClassificationCategoryReport = zod.infer<typeof CLASSIFICATION_CATEGORY_REPORT_SCHEMA>;
+export declare const CATEGORIES_SCHEMA: zod.ZodRecord<zod.ZodEnum<{
+    sexual: "sexual";
+    violence: "violence";
+    gore: "gore";
+    "self-harm": "self-harm";
+    harassment: "harassment";
+    hate: "hate";
+    illicit: "illicit";
+    "child-exploitation": "child-exploitation";
+}> & zod.z.core.$partial, zod.ZodObject<{
+    category: zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }>;
+    likelihood: zod.ZodEnum<{
+        VERY_UNLIKELY: "VERY_UNLIKELY";
+        UNLIKELY: "UNLIKELY";
+        POSSIBLE: "POSSIBLE";
+        LIKELY: "LIKELY";
+        VERY_LIKELY: "VERY_LIKELY";
+    }>;
+    score: zod.ZodNumber;
+}, zod.z.core.$strip>>;
+export type ClassificationCategories = zod.infer<typeof CATEGORIES_SCHEMA>;
+export declare const CLASSIFICATION_LABEL_SCHEMA: zod.ZodObject<{
+    description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    score: zod.ZodNumber;
+    topicalityScore: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+    likelihood: zod.ZodEnum<{
+        VERY_UNLIKELY: "VERY_UNLIKELY";
+        UNLIKELY: "UNLIKELY";
+        POSSIBLE: "POSSIBLE";
+        LIKELY: "LIKELY";
+        VERY_LIKELY: "VERY_LIKELY";
+    }>;
+    knowledgeBaseId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+}, zod.z.core.$strip>;
+export type ClassificationLabel = zod.infer<typeof CLASSIFICATION_LABEL_SCHEMA>;
+export declare const CLASSIFICATION_REPORT_SCHEMA: zod.ZodObject<{
+    processedAt: zod.ZodNumber;
+    categories: zod.ZodRecord<zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }> & zod.z.core.$partial, zod.ZodObject<{
+        category: zod.ZodEnum<{
+            sexual: "sexual";
+            violence: "violence";
+            gore: "gore";
+            "self-harm": "self-harm";
+            harassment: "harassment";
+            hate: "hate";
+            illicit: "illicit";
+            "child-exploitation": "child-exploitation";
+        }>;
+        likelihood: zod.ZodEnum<{
+            VERY_UNLIKELY: "VERY_UNLIKELY";
+            UNLIKELY: "UNLIKELY";
+            POSSIBLE: "POSSIBLE";
+            LIKELY: "LIKELY";
+            VERY_LIKELY: "VERY_LIKELY";
+        }>;
+        score: zod.ZodNumber;
+    }, zod.z.core.$strip>>;
+    flagged: zod.ZodBoolean;
+    score: zod.ZodNumber;
+    notes: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    labels: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+        description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+        score: zod.ZodNumber;
+        topicalityScore: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+        likelihood: zod.ZodEnum<{
+            VERY_UNLIKELY: "VERY_UNLIKELY";
+            UNLIKELY: "UNLIKELY";
+            POSSIBLE: "POSSIBLE";
+            LIKELY: "LIKELY";
+            VERY_LIKELY: "VERY_LIKELY";
+        }>;
+        knowledgeBaseId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    }, zod.z.core.$strip>>>>;
+}, zod.z.core.$strip>;
+export type ClassificationReport = zod.infer<typeof CLASSIFICATION_REPORT_SCHEMA>;