@purpleschool/multisite 0.0.1 → 0.0.3

package/build/models/image-editor/image-editor-job.schema.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { JOB_STATUS, USER_REACTION } from '../../constants';
+export declare const ImageEditorJobSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    prompt: z.ZodString;
+    reaction: z.ZodNullable<z.ZodNativeEnum<typeof USER_REACTION>>;
+    dislikeReason: z.ZodNullable<z.ZodString>;
+    externalId: z.ZodNullable<z.ZodString>;
+    title: z.ZodString;
+    status: z.ZodNativeEnum<typeof JOB_STATUS>;
+    error: z.ZodNullable<z.ZodString>;
+    internalError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    modelId: z.ZodString;
+    price: z.ZodNumber;
+    params: z.ZodObject<{
+        attachedFiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            url: z.ZodString;
+            name: z.ZodString;
+            mimeType: z.ZodString;
+            type: z.ZodNativeEnum<typeof import("../../constants").FILE_TYPE>;
+            size: z.ZodNumber;
+            duration: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            type: import("../../constants").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            duration?: number | null | undefined;
+        }, {
+            uuid: string;
+            type: import("../../constants").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            duration?: number | null | undefined;
+        }>, "many">>;
+        imageUrls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        systemPromptId: z.ZodOptional<z.ZodString>;
+        aspectRatio: z.ZodOptional<z.ZodString>;
+        userHasActiveSubscriptionOrProduct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        aspectRatio?: string | undefined;
+        attachedFiles?: {
+            uuid: string;
+            type: import("../../constants").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            duration?: number | null | undefined;
+        }[] | undefined;
+        imageUrls?: string[] | undefined;
+        systemPromptId?: string | undefined;
+        userHasActiveSubscriptionOrProduct?: boolean | undefined;
+    }, {
+        aspectRatio?: string | undefined;
+        attachedFiles?: {
+            uuid: string;
+            type: import("../../constants").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            duration?: number | null | undefined;
+        }[] | undefined;
+        imageUrls?: string[] | undefined;
+        systemPromptId?: string | undefined;
+        userHasActiveSubscriptionOrProduct?: boolean | undefined;
+    }>;
+    imageUrls: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    attempts: z.ZodArray<z.ZodAny, "many">;
+    userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    postId: z.ZodNullable<z.ZodString>;
+    isDeleted: z.ZodBoolean;
+    tokenReservationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+    completedAt: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodDate]>>>;
+    updatedAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    price: number;
+    uuid: string;
+    status: JOB_STATUS;
+    params: {
+        aspectRatio?: string | undefined;
+        attachedFiles?: {
+            uuid: string;
+            type: import("../../constants").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            duration?: number | null | undefined;
+        }[] | undefined;
+        imageUrls?: string[] | undefined;
+        systemPromptId?: string | undefined;
+        userHasActiveSubscriptionOrProduct?: boolean | undefined;
+    };
+    title: string;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+    error: string | null;
+    modelId: string;
+    prompt: string;
+    reaction: USER_REACTION | null;
+    dislikeReason: string | null;
+    externalId: string | null;
+    attempts: any[];
+    isDeleted: boolean;
+    imageUrls: string[];
+    postId: string | null;
+    userId?: string | null | undefined;
+    unregisteredUserId?: string | null | undefined;
+    internalError?: string | null | undefined;
+    tokenReservationId?: string | null | undefined;
+    completedAt?: string | Date | null | undefined;
+}, {
+    price: number;
+    uuid: string;
+    status: JOB_STATUS;
+    params: {
+        aspectRatio?: string | undefined;
+        attachedFiles?: {
+            uuid: string;
+            type: import("../../constants").FILE_TYPE;
+            name: string;
+            url: string;
+            mimeType: string;
+            size: number;
+            duration?: number | null | undefined;
+        }[] | undefined;
+        imageUrls?: string[] | undefined;
+        systemPromptId?: string | undefined;
+        userHasActiveSubscriptionOrProduct?: boolean | undefined;
+    };
+    title: string;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+    error: string | null;
+    modelId: string;
+    prompt: string;
+    reaction: USER_REACTION | null;
+    dislikeReason: string | null;
+    externalId: string | null;
+    attempts: any[];
+    isDeleted: boolean;
+    postId: string | null;
+    userId?: string | null | undefined;
+    unregisteredUserId?: string | null | undefined;
+    internalError?: string | null | undefined;
+    tokenReservationId?: string | null | undefined;
+    completedAt?: string | Date | null | undefined;
+    imageUrls?: string[] | undefined;
+}>;
+export type ImageEditorJob = z.infer<typeof ImageEditorJobSchema>;
+//# sourceMappingURL=image-editor-job.schema.d.ts.map

package/build/models/image-editor/image-editor-job.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-editor-job.schema.d.ts","sourceRoot":"","sources":["../../../models/image-editor/image-editor-job.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAG5D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/build/models/image-editor/image-editor-job.schema.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageEditorJobSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const image_editor_job_params_schema_1 = require("./image-editor-job-params.schema");
+exports.ImageEditorJobSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    prompt: zod_1.z.string(),
+    reaction: zod_1.z.nativeEnum(constants_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
+    externalId: zod_1.z.string().nullable(),
+    title: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(constants_1.JOB_STATUS),
+    error: zod_1.z.string().nullable(),
+    internalError: zod_1.z.string().nullable().optional(),
+    modelId: zod_1.z.string().uuid(),
+    price: zod_1.z.number().int().nonnegative(),
+    params: image_editor_job_params_schema_1.ImageEditorJobParamsSchema,
+    imageUrls: zod_1.z.array(zod_1.z.string()).default([]),
+    attempts: zod_1.z.array(zod_1.z.any()),
+    userId: zod_1.z.string().uuid().nullable().optional(),
+    unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    postId: zod_1.z.string().uuid().nullable(),
+    isDeleted: zod_1.z.boolean(),
+    tokenReservationId: zod_1.z.string().nullable().optional(),
+    createdAt: zod_1.z.string().datetime().or(zod_1.z.date()),
+    completedAt: zod_1.z.string().datetime().or(zod_1.z.date()).nullable().optional(),
+    updatedAt: zod_1.z.string().datetime().or(zod_1.z.date()),
+});

package/build/models/image-editor/image-editor-model-params.schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const ImageEditorModelParamsSchema: z.ZodObject<{
+    imageAttachment: z.ZodObject<{
+        supported: z.ZodBoolean;
+        maxImages: z.ZodNumber;
+        acceptedTypes: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        supported: boolean;
+        maxImages: number;
+        acceptedTypes: string[];
+    }, {
+        supported: boolean;
+        maxImages: number;
+        acceptedTypes: string[];
+    }>;
+    aspectRatio: z.ZodRecord<z.ZodString, z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        width: number;
+        height: number;
+    }, {
+        width: number;
+        height: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    aspectRatio: Record<string, {
+        width: number;
+        height: number;
+    }>;
+    imageAttachment: {
+        supported: boolean;
+        maxImages: number;
+        acceptedTypes: string[];
+    };
+}, {
+    aspectRatio: Record<string, {
+        width: number;
+        height: number;
+    }>;
+    imageAttachment: {
+        supported: boolean;
+        maxImages: number;
+        acceptedTypes: string[];
+    };
+}>;
+export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;
+//# sourceMappingURL=image-editor-model-params.schema.d.ts.map

package/build/models/image-editor/image-editor-model-params.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-editor-model-params.schema.d.ts","sourceRoot":"","sources":["../../../models/image-editor/image-editor-model-params.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAavC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/build/models/image-editor/image-editor-model-params.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageEditorModelParamsSchema = void 0;
+const zod_1 = require("zod");
+exports.ImageEditorModelParamsSchema = zod_1.z.object({
+    imageAttachment: zod_1.z.object({
+        supported: zod_1.z.boolean(),
+        maxImages: zod_1.z.number().int().nonnegative(),
+        acceptedTypes: zod_1.z.array(zod_1.z.string()),
+    }),
+    aspectRatio: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        width: zod_1.z.number().int().positive(),
+        height: zod_1.z.number().int().positive(),
+    })),
+});

package/build/models/image-editor/image-editor-model.schema.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+import { IMAGE_EDITING_STRATEGY, TOOL_MODEL_STATUS } from '../../constants';
+export declare const ImageEditorModelSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    aiModel: z.ZodString;
+    isNew: z.ZodBoolean;
+    tierLabel: z.ZodString;
+    pricePerImage: z.ZodNumber;
+    order: z.ZodNumber;
+    status: z.ZodNativeEnum<typeof TOOL_MODEL_STATUS>;
+    icons: z.ZodObject<{
+        light: z.ZodObject<{
+            png: z.ZodOptional<z.ZodString>;
+            svg: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            png?: string | undefined;
+            svg?: string | undefined;
+        }, {
+            png?: string | undefined;
+            svg?: string | undefined;
+        }>;
+        dark: z.ZodObject<{
+            png: z.ZodOptional<z.ZodString>;
+            svg: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            png?: string | undefined;
+            svg?: string | undefined;
+        }, {
+            png?: string | undefined;
+            svg?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        light: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+        dark: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+    }, {
+        light: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+        dark: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+    }>;
+    strategy: z.ZodNativeEnum<typeof IMAGE_EDITING_STRATEGY>;
+    maxInputLength: z.ZodNumber;
+    params: z.ZodObject<{
+        imageAttachment: z.ZodObject<{
+            supported: z.ZodBoolean;
+            maxImages: z.ZodNumber;
+            acceptedTypes: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            supported: boolean;
+            maxImages: number;
+            acceptedTypes: string[];
+        }, {
+            supported: boolean;
+            maxImages: number;
+            acceptedTypes: string[];
+        }>;
+        aspectRatio: z.ZodRecord<z.ZodString, z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            width: number;
+            height: number;
+        }, {
+            width: number;
+            height: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        aspectRatio: Record<string, {
+            width: number;
+            height: number;
+        }>;
+        imageAttachment: {
+            supported: boolean;
+            maxImages: number;
+            acceptedTypes: string[];
+        };
+    }, {
+        aspectRatio: Record<string, {
+            width: number;
+            height: number;
+        }>;
+        imageAttachment: {
+            supported: boolean;
+            maxImages: number;
+            acceptedTypes: string[];
+        };
+    }>;
+    pricingRules: z.ZodArray<z.ZodObject<{
+        condition: z.ZodObject<{
+            withoutSub: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            withoutSub?: boolean | undefined;
+        }, {
+            withoutSub?: boolean | undefined;
+        }>;
+        value: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        condition: {
+            withoutSub?: boolean | undefined;
+        };
+    }, {
+        value: number;
+        condition: {
+            withoutSub?: boolean | undefined;
+        };
+    }>, "many">;
+    canUse: z.ZodBoolean;
+    statusCheckEndpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+    updatedAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    status: TOOL_MODEL_STATUS;
+    params: {
+        aspectRatio: Record<string, {
+            width: number;
+            height: number;
+        }>;
+        imageAttachment: {
+            supported: boolean;
+            maxImages: number;
+            acceptedTypes: string[];
+        };
+    };
+    description: string;
+    title: string;
+    canUse: boolean;
+    pricingRules: {
+        value: number;
+        condition: {
+            withoutSub?: boolean | undefined;
+        };
+    }[];
+    strategy: IMAGE_EDITING_STRATEGY;
+    order: number;
+    aiModel: string;
+    isNew: boolean;
+    tierLabel: string;
+    pricePerImage: number;
+    icons: {
+        light: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+        dark: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+    };
+    maxInputLength: number;
+    statusCheckEndpoint?: string | null | undefined;
+    createdAt?: string | Date | undefined;
+    updatedAt?: string | Date | undefined;
+}, {
+    uuid: string;
+    status: TOOL_MODEL_STATUS;
+    params: {
+        aspectRatio: Record<string, {
+            width: number;
+            height: number;
+        }>;
+        imageAttachment: {
+            supported: boolean;
+            maxImages: number;
+            acceptedTypes: string[];
+        };
+    };
+    description: string;
+    title: string;
+    canUse: boolean;
+    pricingRules: {
+        value: number;
+        condition: {
+            withoutSub?: boolean | undefined;
+        };
+    }[];
+    strategy: IMAGE_EDITING_STRATEGY;
+    order: number;
+    aiModel: string;
+    isNew: boolean;
+    tierLabel: string;
+    pricePerImage: number;
+    icons: {
+        light: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+        dark: {
+            png?: string | undefined;
+            svg?: string | undefined;
+        };
+    };
+    maxInputLength: number;
+    statusCheckEndpoint?: string | null | undefined;
+    createdAt?: string | Date | undefined;
+    updatedAt?: string | Date | undefined;
+}>;
+export type ImageEditorModel = z.infer<typeof ImageEditorModelSchema>;
+//# sourceMappingURL=image-editor-model.schema.d.ts.map

package/build/models/image-editor/image-editor-model.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-editor-model.schema.d.ts","sourceRoot":"","sources":["../../../models/image-editor/image-editor-model.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAK5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/build/models/image-editor/image-editor-model.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageEditorModelSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const common_1 = require("../common");
+const image_editor_model_params_schema_1 = require("./image-editor-model-params.schema");
+const image_editor_pricing_rule_schema_1 = require("./image-editor-pricing-rule.schema");
+exports.ImageEditorModelSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    aiModel: zod_1.z.string(),
+    isNew: zod_1.z.boolean(),
+    tierLabel: zod_1.z.string(),
+    pricePerImage: zod_1.z.number().int().nonnegative(),
+    order: zod_1.z.number().int(),
+    status: zod_1.z.nativeEnum(constants_1.TOOL_MODEL_STATUS),
+    icons: common_1.IconVariantsSchema,
+    strategy: zod_1.z.nativeEnum(constants_1.IMAGE_EDITING_STRATEGY),
+    maxInputLength: zod_1.z.number().int().nonnegative(),
+    params: image_editor_model_params_schema_1.ImageEditorModelParamsSchema,
+    pricingRules: image_editor_pricing_rule_schema_1.ImageEditorPricingRulesSchema,
+    canUse: zod_1.z.boolean(),
+    statusCheckEndpoint: zod_1.z.string().nullable().optional(),
+    createdAt: zod_1.z.string().datetime().or(zod_1.z.date()).optional(),
+    updatedAt: zod_1.z.string().datetime().or(zod_1.z.date()).optional(),
+});

package/build/models/image-editor/image-editor-pricing-rule.schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const ImageEditorPricingRuleConditionSchema: z.ZodObject<{
+    withoutSub: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    withoutSub?: boolean | undefined;
+}, {
+    withoutSub?: boolean | undefined;
+}>;
+export declare const ImageEditorPricingRulesSchema: z.ZodArray<z.ZodObject<{
+    condition: z.ZodObject<{
+        withoutSub: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        withoutSub?: boolean | undefined;
+    }, {
+        withoutSub?: boolean | undefined;
+    }>;
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    condition: {
+        withoutSub?: boolean | undefined;
+    };
+}, {
+    value: number;
+    condition: {
+        withoutSub?: boolean | undefined;
+    };
+}>, "many">;
+export type ImageEditorPricingRules = z.infer<typeof ImageEditorPricingRulesSchema>;
+//# sourceMappingURL=image-editor-pricing-rule.schema.d.ts.map

package/build/models/image-editor/image-editor-pricing-rule.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-editor-pricing-rule.schema.d.ts","sourceRoot":"","sources":["../../../models/image-editor/image-editor-pricing-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qCAAqC;;;;;;EAEhD,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;WAKzC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/build/models/image-editor/image-editor-pricing-rule.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageEditorPricingRulesSchema = exports.ImageEditorPricingRuleConditionSchema = void 0;
+const zod_1 = require("zod");
+exports.ImageEditorPricingRuleConditionSchema = zod_1.z.object({
+    withoutSub: zod_1.z.boolean().optional(),
+});
+exports.ImageEditorPricingRulesSchema = zod_1.z.array(zod_1.z.object({
+    condition: exports.ImageEditorPricingRuleConditionSchema,
+    value: zod_1.z.number().int(),
+}));