@purpleschool/gptbot 0.13.23 → 0.14.2-stage-2

package/build/commands/b2b-compatible/openai-responses.command.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIResponsesCommand = exports.OpenAIResponseInputMessageSchema = exports.OpenAIResponseInputContentPartSchema = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common.schemas");
+const OpenAIInputTextContentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.enum(['input_text', 'text', 'output_text']),
+    text: zod_1.z.string(),
+})
+    .passthrough();
+const OpenAIInputImageContentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('input_image'),
+    image_url: zod_1.z.string().optional(),
+    file_id: zod_1.z.string().optional(),
+    detail: zod_1.z.enum(['auto', 'low', 'high']).optional(),
+})
+    .passthrough();
+const OpenAIInputFileContentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('input_file'),
+    file_id: zod_1.z.string().optional(),
+    file_data: zod_1.z.string().optional(),
+    file_url: zod_1.z.string().optional(),
+    filename: zod_1.z.string().optional(),
+    mime_type: zod_1.z.string().optional(),
+})
+    .passthrough();
+exports.OpenAIResponseInputContentPartSchema = zod_1.z.discriminatedUnion('type', [
+    OpenAIInputTextContentPartSchema,
+    OpenAIInputImageContentPartSchema,
+    OpenAIInputFileContentPartSchema,
+]);
+exports.OpenAIResponseInputMessageSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('message').optional(),
+    role: zod_1.z.enum(['system', 'developer', 'user', 'assistant']),
+    content: zod_1.z.union([zod_1.z.string(), zod_1.z.array(exports.OpenAIResponseInputContentPartSchema)]),
+})
+    .passthrough();
+const OpenAIAnyToolSchema = zod_1.z
+    .object({
+    type: zod_1.z.string(),
+})
+    .passthrough();
+const OpenAIResponseMetadataSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+const OpenAIResponseReasoningSchema = zod_1.z
+    .object({
+    effort: zod_1.z.string().optional(),
+    summary: zod_1.z.string().nullable().optional(),
+})
+    .passthrough();
+const OpenAIResponseTextOptionsSchema = zod_1.z
+    .object({
+    format: zod_1.z.unknown().optional(),
+    verbosity: zod_1.z.string().optional(),
+})
+    .passthrough();
+const OpenAIResponseUsageSchema = zod_1.z
+    .object({
+    input_tokens: zod_1.z.number().int().nonnegative(),
+    output_tokens: zod_1.z.number().int().nonnegative(),
+    total_tokens: zod_1.z.number().int().nonnegative(),
+    input_tokens_details: zod_1.z
+        .object({
+        cached_tokens: zod_1.z.number().int().nonnegative().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const OpenAIResponseOutputTextSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('output_text'),
+    text: zod_1.z.string(),
+    annotations: zod_1.z.array(zod_1.z.unknown()),
+})
+    .strict();
+const OpenAIResponseOutputMessageSchema = zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    type: zod_1.z.literal('message'),
+    status: zod_1.z.literal('completed'),
+    role: zod_1.z.literal('assistant'),
+    content: zod_1.z.array(OpenAIResponseOutputTextSchema),
+})
+    .strict();
+var OpenAIResponsesCommand;
+(function (OpenAIResponsesCommand) {
+    OpenAIResponsesCommand.HeadersSchema = common_schemas_1.OpenAIHeadersSchema;
+    OpenAIResponsesCommand.BodySchema = zod_1.z
+        .object({
+        model: zod_1.z.string(),
+        input: zod_1.z.union([zod_1.z.string(), zod_1.z.array(exports.OpenAIResponseInputMessageSchema).min(1)]),
+        instructions: zod_1.z.string().optional(),
+        stream: zod_1.z.boolean().optional(),
+        max_output_tokens: zod_1.z.number().int().positive().optional(),
+        tools: zod_1.z.array(OpenAIAnyToolSchema).optional(),
+        background: zod_1.z.boolean().optional(),
+        include: zod_1.z.array(zod_1.z.string()).optional(),
+        max_tool_calls: zod_1.z.number().int().positive().optional(),
+        metadata: OpenAIResponseMetadataSchema.nullable().optional(),
+        parallel_tool_calls: zod_1.z.boolean().optional(),
+        previous_response_id: zod_1.z.string().nullable().optional(),
+        prompt: zod_1.z.unknown().optional(),
+        reasoning: OpenAIResponseReasoningSchema.nullable().optional(),
+        safety_identifier: zod_1.z.string().optional(),
+        service_tier: zod_1.z.string().optional(),
+        store: zod_1.z.boolean().nullable().optional(),
+        stream_options: zod_1.z.unknown().optional(),
+        temperature: zod_1.z.number().optional(),
+        text: OpenAIResponseTextOptionsSchema.optional(),
+        tool_choice: zod_1.z.unknown().optional(),
+        top_p: zod_1.z.number().optional(),
+        truncation: zod_1.z.string().optional(),
+        user: zod_1.z.string().optional(),
+    })
+        .passthrough();
+    OpenAIResponsesCommand.UsageSchema = OpenAIResponseUsageSchema;
+    OpenAIResponsesCommand.ResponseSchema = zod_1.z
+        .object({
+        id: zod_1.z.string(),
+        object: zod_1.z.literal('response'),
+        created_at: zod_1.z.number().int(),
+        status: zod_1.z.literal('completed'),
+        model: zod_1.z.string(),
+        output: zod_1.z.array(OpenAIResponseOutputMessageSchema),
+        output_text: zod_1.z.string(),
+        usage: OpenAIResponsesCommand.UsageSchema,
+    })
+        .strict();
+    OpenAIResponsesCommand.StreamEventSchema = zod_1.z.union([
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.created'),
+            response: OpenAIResponsesCommand.ResponseSchema.omit({ status: true }).extend({
+                status: zod_1.z.literal('in_progress'),
+                output: zod_1.z.array(zod_1.z.never()),
+                output_text: zod_1.z.literal(''),
+            }),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.output_text.delta'),
+            response_id: zod_1.z.string(),
+            output_index: zod_1.z.number().int(),
+            content_index: zod_1.z.number().int(),
+            delta: zod_1.z.string(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.output_text.done'),
+            response_id: zod_1.z.string(),
+            output_index: zod_1.z.number().int(),
+            content_index: zod_1.z.number().int(),
+            text: zod_1.z.string(),
+        })
+            .strict(),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('response.completed'),
+            response: OpenAIResponsesCommand.ResponseSchema,
+        })
+            .strict(),
+        common_schemas_1.OpenAIErrorResponseSchema,
+    ]);
+    OpenAIResponsesCommand.ErrorResponseSchema = common_schemas_1.OpenAIErrorResponseSchema;
+})(OpenAIResponsesCommand || (exports.OpenAIResponsesCommand = OpenAIResponsesCommand = {}));

package/build/commands/b2b-usage-log/get-b2b-usage-statistics.command.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetB2bUsageStatisticsCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const b2b_1 = require("../../models/b2b");
+const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+const DateOnlySchema = zod_1.z
+    .string()
+    .regex(DATE_ONLY_PATTERN)
+    .refine((value) => {
+    const [year, month, day] = value.split('-').map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}, { message: 'Invalid calendar date' });
+const formatLocalDate = (date) => {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+};
+const toUtcCalendarTimestamp = (value) => {
+    const [year, month, day] = value.split('-').map(Number);
+    return Date.UTC(year, month - 1, day);
+};
+var GetB2bUsageStatisticsCommand;
+(function (GetB2bUsageStatisticsCommand) {
+    GetB2bUsageStatisticsCommand.RequestQuerySchema = zod_1.z
+        .object({
+        period: zod_1.z.nativeEnum(constants_1.B2B_STATISTICS_PERIOD).default(constants_1.B2B_STATISTICS_PERIOD.THIRTY_DAYS),
+        dateFrom: DateOnlySchema.optional(),
+        dateTo: DateOnlySchema.optional(),
+        apiKeyId: zod_1.z.string().uuid().optional(),
+    })
+        .superRefine((query, context) => {
+        const isCustom = query.period === constants_1.B2B_STATISTICS_PERIOD.CUSTOM;
+        if (!isCustom) {
+            if (query.dateFrom !== undefined) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    path: ['dateFrom'],
+                    message: 'dateFrom is only allowed for custom period',
+                });
+            }
+            if (query.dateTo !== undefined) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    path: ['dateTo'],
+                    message: 'dateTo is only allowed for custom period',
+                });
+            }
+            return;
+        }
+        if (query.dateFrom === undefined) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateFrom'],
+                message: 'dateFrom is required for custom period',
+            });
+        }
+        if (query.dateTo === undefined) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'dateTo is required for custom period',
+            });
+        }
+        if (query.dateFrom === undefined || query.dateTo === undefined) {
+            return;
+        }
+        const today = formatLocalDate(new Date());
+        if (query.dateFrom > today) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateFrom'],
+                message: 'dateFrom cannot be in the future',
+            });
+        }
+        if (query.dateTo > today) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'dateTo cannot be in the future',
+            });
+        }
+        if (query.dateFrom > query.dateTo) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'dateTo must be on or after dateFrom',
+            });
+            return;
+        }
+        const inclusiveDays = (toUtcCalendarTimestamp(query.dateTo) - toUtcCalendarTimestamp(query.dateFrom)) /
+            MILLISECONDS_PER_DAY +
+            1;
+        if (inclusiveDays > 90) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['dateTo'],
+                message: 'Custom period cannot exceed 90 calendar days',
+            });
+        }
+    });
+    GetB2bUsageStatisticsCommand.ResponseSchema = zod_1.z.object({
+        data: b2b_1.B2bUsageStatisticsSchema,
+    });
+})(GetB2bUsageStatisticsCommand || (exports.GetB2bUsageStatisticsCommand = GetB2bUsageStatisticsCommand = {}));

package/build/{constants/photo-studio/enums → commands/b2b-usage-log}/index.js

@@ -14,4 +14,4 @@ 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 });
-__exportStar(require("./photo-studio-checkpoint-action-type.enum"), exports);
+__exportStar(require("./get-b2b-usage-statistics.command"), exports);

package/build/commands/index.js

@@ -34,10 +34,10 @@ __exportStar(require("./form-submission"), exports);
 __exportStar(require("./key-value"), exports);
 __exportStar(require("./message"), exports);
 __exportStar(require("./midjourney"), exports);
+__exportStar(require("./model-page"), exports);
 __exportStar(require("./page"), exports);
 __exportStar(require("./order"), exports);
 __exportStar(require("./payment"), exports);
-__exportStar(require("./photo-studio"), exports);
 __exportStar(require("./product"), exports);
 __exportStar(require("./question"), exports);
 __exportStar(require("./referral"), exports);
@@ -66,6 +66,8 @@ __exportStar(require("./cabinet"), exports);
 __exportStar(require("./webmaster"), exports);
 __exportStar(require("./webmaster-click"), exports);
 __exportStar(require("./b2b"), exports);
+__exportStar(require("./b2b-usage-log"), exports);
+__exportStar(require("./b2b-compatible"), exports);
 __exportStar(require("./community"), exports);
 __exportStar(require("./user-profile"), exports);
 __exportStar(require("./team-account"), exports);

package/build/commands/model-page/base/create-model-page.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateModelPageCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const common_schemas_1 = require("../common.schemas");
+var CreateModelPageCommand;
+(function (CreateModelPageCommand) {
+    CreateModelPageCommand.RequestSchema = common_schemas_1.ModelPageSourceCreateSchema;
+    CreateModelPageCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.ModelPageSchema,
+    });
+})(CreateModelPageCommand || (exports.CreateModelPageCommand = CreateModelPageCommand = {}));

package/build/commands/model-page/base/delete-model-page.command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteModelPageCommand = void 0;
+const common_schemas_1 = require("../common.schemas");
+var DeleteModelPageCommand;
+(function (DeleteModelPageCommand) {
+    DeleteModelPageCommand.RequestParamSchema = common_schemas_1.ModelPageUuidParamSchema;
+    DeleteModelPageCommand.ResponseSchema = common_schemas_1.ModelPageDeleteResponseSchema;
+})(DeleteModelPageCommand || (exports.DeleteModelPageCommand = DeleteModelPageCommand = {}));

package/build/commands/model-page/base/find-model-page-admin.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindModelPageAdminCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const common_schemas_1 = require("../common.schemas");
+var FindModelPageAdminCommand;
+(function (FindModelPageAdminCommand) {
+    FindModelPageAdminCommand.RequestParamSchema = common_schemas_1.ModelPageUuidParamSchema;
+    FindModelPageAdminCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.ModelPageSchema,
+    });
+})(FindModelPageAdminCommand || (exports.FindModelPageAdminCommand = FindModelPageAdminCommand = {}));

package/build/commands/model-page/base/find-model-pages-admin.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindModelPagesAdminCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+const common_schemas_1 = require("../common.schemas");
+var FindModelPagesAdminCommand;
+(function (FindModelPagesAdminCommand) {
+    FindModelPagesAdminCommand.RequestQuerySchema = zod_1.z.object({
+        vendorIds: (0, common_schemas_1.OptionalQueryArraySchema)(zod_1.z.string().uuid()),
+        types: (0, common_schemas_1.OptionalQueryArraySchema)(zod_1.z.nativeEnum(constants_1.MODEL_PAGE_TYPE)),
+        slug: zod_1.z.string().optional(),
+        limit: zod_1.z.coerce.number().int().min(1).max(100).optional().default(20),
+        offset: zod_1.z.coerce.number().int().min(0).optional().default(0),
+    });
+    FindModelPagesAdminCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.array(models_1.ModelPageSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+    });
+})(FindModelPagesAdminCommand || (exports.FindModelPagesAdminCommand = FindModelPagesAdminCommand = {}));

package/build/commands/model-page/base/index.js

@@ -0,0 +1,21 @@
+"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 });
+__exportStar(require("./create-model-page.command"), exports);
+__exportStar(require("./delete-model-page.command"), exports);
+__exportStar(require("./find-model-page-admin.command"), exports);
+__exportStar(require("./find-model-pages-admin.command"), exports);
+__exportStar(require("./update-model-page.command"), exports);

package/build/commands/model-page/base/update-model-page.command.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateModelPageCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+const common_schemas_1 = require("../common.schemas");
+var UpdateModelPageCommand;
+(function (UpdateModelPageCommand) {
+    UpdateModelPageCommand.RequestParamSchema = common_schemas_1.ModelPageUuidParamSchema;
+    UpdateModelPageCommand.RequestSchema = zod_1.z
+        .object({
+        slug: zod_1.z.string().min(1).optional(),
+        type: zod_1.z.nativeEnum(constants_1.MODEL_PAGE_TYPE).optional(),
+        vendorId: zod_1.z.string().uuid().optional(),
+        aiModelId: zod_1.z.string().uuid().nullable().optional(),
+        toolModelId: zod_1.z.string().uuid().nullable().optional(),
+    })
+        .superRefine((value, context) => {
+        if (value.aiModelId && value.toolModelId) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: 'aiModelId and toolModelId cannot both be set',
+                path: ['toolModelId'],
+            });
+        }
+        if (value.type === constants_1.MODEL_PAGE_TYPE.TEXT) {
+            if (value.aiModelId === null) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: 'aiModelId cannot be null for TEXT',
+                    path: ['aiModelId'],
+                });
+            }
+            if (value.toolModelId) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: 'toolModelId cannot be set for TEXT',
+                    path: ['toolModelId'],
+                });
+            }
+        }
+        if (value.type && value.type !== constants_1.MODEL_PAGE_TYPE.TEXT) {
+            if (value.aiModelId) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: 'aiModelId cannot be set for a non-text model page',
+                    path: ['aiModelId'],
+                });
+            }
+            if (value.toolModelId === null) {
+                context.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: 'toolModelId cannot be null for a non-text model page',
+                    path: ['toolModelId'],
+                });
+            }
+        }
+    });
+    UpdateModelPageCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.ModelPageSchema,
+    });
+})(UpdateModelPageCommand || (exports.UpdateModelPageCommand = UpdateModelPageCommand = {}));

package/build/commands/model-page/common.schemas.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelPageSourceCreateSchema = exports.OptionalQueryArraySchema = exports.ModelPageDeleteResponseSchema = exports.ModelPageTranslationParamSchema = exports.ModelPageUuidParamSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+exports.ModelPageUuidParamSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+});
+exports.ModelPageTranslationParamSchema = exports.ModelPageUuidParamSchema.extend({
+    translationUuid: zod_1.z.string().uuid(),
+});
+exports.ModelPageDeleteResponseSchema = zod_1.z.object({
+    isDeleted: zod_1.z.boolean(),
+});
+const OptionalQueryArraySchema = (schema) => zod_1.z
+    .preprocess((value) => {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    return Array.isArray(value) ? value : [value];
+}, zod_1.z.array(schema))
+    .optional();
+exports.OptionalQueryArraySchema = OptionalQueryArraySchema;
+exports.ModelPageSourceCreateSchema = zod_1.z
+    .object({
+    slug: zod_1.z.string().min(1),
+    type: zod_1.z.nativeEnum(constants_1.MODEL_PAGE_TYPE),
+    vendorId: zod_1.z.string().uuid(),
+    aiModelId: zod_1.z.string().uuid().nullable().optional(),
+    toolModelId: zod_1.z.string().uuid().nullable().optional(),
+})
+    .superRefine((value, context) => {
+    const isText = value.type === constants_1.MODEL_PAGE_TYPE.TEXT;
+    if (isText && !value.aiModelId) {
+        context.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'aiModelId is required for TEXT',
+            path: ['aiModelId'],
+        });
+    }
+    if (isText && value.toolModelId) {
+        context.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'toolModelId cannot be set for TEXT',
+            path: ['toolModelId'],
+        });
+    }
+    if (!isText && value.aiModelId) {
+        context.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'aiModelId cannot be set for a non-text model page',
+            path: ['aiModelId'],
+        });
+    }
+    if (!isText && !value.toolModelId) {
+        context.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'toolModelId is required for a non-text model page',
+            path: ['toolModelId'],
+        });
+    }
+});

package/build/{models/photo-studio → commands/model-page}/index.js

@@ -14,7 +14,8 @@ 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 });
-__exportStar(require("./photo-studio-action.schema"), exports);
-__exportStar(require("./photo-studio-checkpoint.schema"), exports);
-__exportStar(require("./photo-studio-image-node.schema"), exports);
-__exportStar(require("./photo-studio.schema"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./public"), exports);
+__exportStar(require("./question"), exports);
+__exportStar(require("./question-translation"), exports);
+__exportStar(require("./translation"), exports);

package/build/commands/model-page/public/find-model-page-answer-detail.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindModelPageAnswerDetailCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+var FindModelPageAnswerDetailCommand;
+(function (FindModelPageAnswerDetailCommand) {
+    FindModelPageAnswerDetailCommand.RequestParamSchema = zod_1.z.object({
+        questionType: zod_1.z.nativeEnum(constants_1.MODEL_PAGE_QUESTION_TYPE),
+        slug: zod_1.z.string(),
+    });
+    FindModelPageAnswerDetailCommand.ResponseSchema = models_1.ModelPageAnswerDetailSchema;
+})(FindModelPageAnswerDetailCommand || (exports.FindModelPageAnswerDetailCommand = FindModelPageAnswerDetailCommand = {}));

package/build/commands/model-page/public/find-model-page-detail.command.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindModelPageDetailCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+var FindModelPageDetailCommand;
+(function (FindModelPageDetailCommand) {
+    FindModelPageDetailCommand.RequestParamSchema = zod_1.z.object({
+        slug: zod_1.z.string(),
+    });
+    FindModelPageDetailCommand.ResponseSchema = models_1.ModelPageDetailSchema;
+})(FindModelPageDetailCommand || (exports.FindModelPageDetailCommand = FindModelPageDetailCommand = {}));

package/build/commands/model-page/public/find-model-page-hub.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindModelPageHubCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+const common_schemas_1 = require("../common.schemas");
+var FindModelPageHubCommand;
+(function (FindModelPageHubCommand) {
+    FindModelPageHubCommand.RequestQuerySchema = zod_1.z.object({
+        vendorIds: (0, common_schemas_1.OptionalQueryArraySchema)(zod_1.z.string().uuid()),
+        types: (0, common_schemas_1.OptionalQueryArraySchema)(zod_1.z.nativeEnum(constants_1.MODEL_PAGE_TYPE)),
+        sortBy: zod_1.z.nativeEnum(constants_1.MODEL_PAGE_SORT_BY).optional().default(constants_1.MODEL_PAGE_SORT_BY.ORDER),
+        sortDir: zod_1.z.nativeEnum(constants_1.SORT_ORDER).optional().default(constants_1.SORT_ORDER.ASC),
+        page: zod_1.z.coerce.number().int().min(1).optional().default(1),
+        limit: zod_1.z.coerce.number().int().min(1).max(100).optional().default(20),
+    });
+    FindModelPageHubCommand.ResponseSchema = models_1.ModelPageHubSchema;
+})(FindModelPageHubCommand || (exports.FindModelPageHubCommand = FindModelPageHubCommand = {}));

package/build/commands/model-page/public/find-model-page-question-type.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindModelPageQuestionTypeCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+var FindModelPageQuestionTypeCommand;
+(function (FindModelPageQuestionTypeCommand) {
+    FindModelPageQuestionTypeCommand.RequestParamSchema = zod_1.z.object({
+        questionType: zod_1.z.nativeEnum(constants_1.MODEL_PAGE_QUESTION_TYPE),
+    });
+    FindModelPageQuestionTypeCommand.ResponseSchema = models_1.ModelPageQuestionTypeListSchema;
+})(FindModelPageQuestionTypeCommand || (exports.FindModelPageQuestionTypeCommand = FindModelPageQuestionTypeCommand = {}));

package/build/commands/model-page/public/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./find-model-page-answer-detail.command"), exports);
+__exportStar(require("./find-model-page-detail.command"), exports);
+__exportStar(require("./find-model-page-hub.command"), exports);
+__exportStar(require("./find-model-page-question-type.command"), exports);

package/build/commands/model-page/question/create-model-page-question.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateModelPageQuestionCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+var CreateModelPageQuestionCommand;
+(function (CreateModelPageQuestionCommand) {
+    CreateModelPageQuestionCommand.RequestSchema = models_1.ModelPageQuestionSchema.pick({
+        modelPageId: true,
+        questionType: true,
+        slug: true,
+    });
+    CreateModelPageQuestionCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.ModelPageQuestionSchema,
+    });
+})(CreateModelPageQuestionCommand || (exports.CreateModelPageQuestionCommand = CreateModelPageQuestionCommand = {}));

package/build/commands/model-page/question/delete-model-page-question.command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteModelPageQuestionCommand = void 0;
+const common_schemas_1 = require("../common.schemas");
+var DeleteModelPageQuestionCommand;
+(function (DeleteModelPageQuestionCommand) {
+    DeleteModelPageQuestionCommand.RequestParamSchema = common_schemas_1.ModelPageUuidParamSchema;
+    DeleteModelPageQuestionCommand.ResponseSchema = common_schemas_1.ModelPageDeleteResponseSchema;
+})(DeleteModelPageQuestionCommand || (exports.DeleteModelPageQuestionCommand = DeleteModelPageQuestionCommand = {}));