@purpleschool/gptbot 0.13.15 → 0.13.18

package/build/models/file.schema.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSchema = void 0;
+exports.FileSchema = exports.FileResolutionSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
+exports.FileResolutionSchema = zod_1.z.object({
+    width: zod_1.z.number().int().positive(),
+    height: zod_1.z.number().int().positive(),
+});
 exports.FileSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     name: zod_1.z.string(),
     size: zod_1.z.number(),
+    originalName: zod_1.z.string().nullable().optional(),
+    resolution: exports.FileResolutionSchema.nullable().optional(),
     mimeType: zod_1.z.string(),
     url: zod_1.z.string(),
     key: zod_1.z.string(),

package/build/models/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./file.schema"), exports);
 __exportStar(require("./key-value.schema"), exports);
 __exportStar(require("./form-submission.schema"), exports);
 __exportStar(require("./icon-variants.schema"), exports);
+__exportStar(require("./photo-studio"), exports);
 __exportStar(require("./lesson.schema"), exports);
 __exportStar(require("./lesson-translation.schema"), exports);
 __exportStar(require("./message.schema"), exports);

package/build/models/photo-studio/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("./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);

package/build/models/photo-studio/photo-studio-action.schema.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhotoStudioActionSchema = exports.PhotoStudioImageSettingsSchema = void 0;
+const zod_1 = require("zod");
+exports.PhotoStudioImageSettingsSchema = zod_1.z.object({
+    minImages: zod_1.z.number().int().min(0),
+    maxImages: zod_1.z.number().int().min(1),
+});
+exports.PhotoStudioActionSchema = zod_1.z.object({
+    alias: zod_1.z.string().min(1),
+    title: zod_1.z.string().min(1),
+    icon: zod_1.z.string().min(1),
+    allowUserPrompt: zod_1.z.boolean(),
+    systemPrompt: zod_1.z.string().nullable(),
+    imageSettings: exports.PhotoStudioImageSettingsSchema,
+    params: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).default({}),
+});

package/build/models/photo-studio/photo-studio-checkpoint.schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhotoStudioCheckpointSchema = exports.PhotoStudioCheckpointActionSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const photo_studio_image_node_schema_1 = require("./photo-studio-image-node.schema");
+exports.PhotoStudioCheckpointActionSchema = zod_1.z.object({
+    type: zod_1.z.nativeEnum(constants_1.PHOTO_STUDIO_CHECKPOINT_ACTION_TYPE),
+    actionAlias: zod_1.z.string().nullable().optional(),
+    title: zod_1.z.string().nullable().optional(),
+    params: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable().optional(),
+});
+exports.PhotoStudioCheckpointSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    canvasId: zod_1.z.string().uuid(),
+    sequence: zod_1.z.number().int().positive(),
+    action: exports.PhotoStudioCheckpointActionSchema,
+    images: zod_1.z.array(photo_studio_image_node_schema_1.PhotoStudioImageNodeSchema),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/models/photo-studio/photo-studio-image-node.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhotoStudioImageInputSchema = exports.PhotoStudioImageNodeSchema = exports.PhotoStudioImageResolutionSchema = void 0;
+const zod_1 = require("zod");
+const canvas_node_schema_1 = require("../canvas-node.schema");
+const file_schema_1 = require("../file.schema");
+exports.PhotoStudioImageResolutionSchema = file_schema_1.FileResolutionSchema;
+exports.PhotoStudioImageNodeSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    fileId: zod_1.z.string().uuid(),
+    url: zod_1.z.string().url(),
+    originalName: zod_1.z.string().nullable().optional(),
+    resolution: exports.PhotoStudioImageResolutionSchema.nullable().optional(),
+    position: canvas_node_schema_1.CanvasNodePositionSchema,
+});
+exports.PhotoStudioImageInputSchema = zod_1.z.object({
+    fileId: zod_1.z.string().uuid(),
+    position: canvas_node_schema_1.CanvasNodePositionSchema,
+});

package/build/models/photo-studio/photo-studio.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhotoStudioCanvasWithImagesSchema = exports.PhotoStudioCanvasSchema = void 0;
+const zod_1 = require("zod");
+const photo_studio_image_node_schema_1 = require("./photo-studio-image-node.schema");
+exports.PhotoStudioCanvasSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    name: zod_1.z.string(),
+    userId: zod_1.z.string().uuid(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.PhotoStudioCanvasWithImagesSchema = exports.PhotoStudioCanvasSchema.extend({
+    images: zod_1.z.array(photo_studio_image_node_schema_1.PhotoStudioImageNodeSchema),
+});

package/build/models/tools/image-generation/image-generation-job.schema.js

@@ -4,6 +4,7 @@ exports.ImageGenerationJobSchema = exports.ImageGenerationJobParamsSchema = expo
 const zod_1 = require("zod");
 const tool_job_schema_1 = require("../../tool-job.schema");
 const constants_1 = require("../../../constants");
+const file_schema_1 = require("../../file.schema");
 exports.ImageGenerationFileAttachmentSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     url: zod_1.z.string(),
@@ -28,6 +29,8 @@ exports.ImageGenerationJobSchema = tool_job_schema_1.ToolJobSchema.extend({
         .array(zod_1.z.object({
         uuid: zod_1.z.string(),
         url: zod_1.z.string(),
+        originalName: zod_1.z.string().nullable().optional(),
+        resolution: file_schema_1.FileResolutionSchema.nullable().optional(),
     }))
         .nullable(),
     params: exports.ImageGenerationJobParamsSchema.optional(),

package/commands/agents/agent-dialog/get-cabinet-price-preview.command.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+
+export namespace GetCabinetPricePreviewCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        dialogId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        inputLength: z.number().int().min(0),
+        fileIds: z.array(z.string().uuid()).optional(),
+        useWebSearch: z.boolean().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            price: z.number().int().min(0),
+            breakdown: z.object({
+                textCost: z.number().int().min(0),
+                attachmentsCost: z.number().int().min(0),
+                webSearchCost: z.number().int().min(0),
+            }),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-dialog/get-dialog-context-length.command.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { MessageAttachmentTypeEnum } from '../../../models/agents/message-attachment.schema';
+
+export namespace GetDialogContextLengthCommand {
+    export const RequestSchema = z.object({
+        teamAccountId: z.string().uuid(),
+        dialogId: z.string().uuid(),
+        inputLength: z.number().int().min(0),
+        attachments: z
+            .array(
+                z.object({
+                    type: MessageAttachmentTypeEnum,
+                    contentLength: z.number().int().optional(),
+                }),
+            )
+            .default([]),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        isSuccess: z.literal(true),
+        data: z.object({
+            historyChars: z.number().int().min(0),
+            totalInputChars: z.number().int().min(0),
+            modelPricing: z.object({
+                inputPrice: z.number(),
+                outputPrice: z.number(),
+            }),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+    export type ResponseData = z.infer<typeof ResponseSchema>['data'];
+}

package/commands/agents/agent-dialog/index.ts

@@ -5,3 +5,6 @@ export * from './clear-agent-dialog-history.command';
 export * from './send-agent-dialog-admin-reply.command';
 export * from './start-cabinet-dialog.command';
 export * from './send-cabinet-message.command';
+export * from './get-dialog-context-length.command';
+export * from './get-cabinet-price-preview.command';
+export * from './stop-cabinet-stream.command';

package/commands/agents/agent-dialog/send-cabinet-message.command.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MessageAttachmentInputSchema } from '../../../models/agents/message-attachment.schema';
 
 export namespace SendCabinetMessageCommand {
     export const RequestParamsSchema = z.object({
@@ -10,17 +11,13 @@ export namespace SendCabinetMessageCommand {
     export const RequestBodySchema = z
         .object({
             text: z.string().optional(),
-            images: z.array(z.string()).optional(),
-            attachments: z.array(z.string()).optional(),
+            fileIds: z.array(z.string().uuid()).optional(),
+            useWebSearch: z.boolean().optional(),
         })
-        .refine(
-            (data) =>
-                data.text || (data.images?.length ?? 0) > 0 || (data.attachments?.length ?? 0) > 0,
-            {
-                message: 'Message must contain text, images, or attachments',
-                path: ['text'],
-            },
-        );
+        .refine((data) => data.text || (data.fileIds?.length ?? 0) > 0, {
+            message: 'Message must contain text or file attachments',
+            path: ['text'],
+        });
     export type RequestBody = z.infer<typeof RequestBodySchema>;
 
     export const ResponseSchema = z.object({
@@ -31,4 +28,15 @@ export namespace SendCabinetMessageCommand {
         }),
     });
     export type Response = z.infer<typeof ResponseSchema>;
+
+    // RMQ payload sent to rugpt-agents (new format with resolved attachments)
+    export type RmqRequest = {
+        teamAccountId: string;
+        userId: string;
+        teamMemberRole?: string;
+        dialogId: string;
+        text?: string;
+        attachments: z.infer<typeof MessageAttachmentInputSchema>[];
+        useWebSearch?: boolean;
+    };
 }

package/commands/agents/agent-dialog/stop-cabinet-stream.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export namespace StopCabinetStreamCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        dialogId: z.string().uuid(),
+        messageId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        stopped: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-lead/find-agent-leads.command.ts

@@ -1,16 +1,14 @@
 import { z } from 'zod';
-import { AgentLeadFindResultSchema } from '../../../models/agents/agent-lead-find-result.schema';
+import { AgentLeadSchema } from '../../../models/agents/agent-lead.schema';
 
 export namespace FindAgentLeadsCommand {
     export const RequestQuerySchema = z.object({
         dialogId: z.string().uuid().optional(),
-        limit: z.coerce.number().optional(),
-        offset: z.coerce.number().optional(),
     });
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;
 
     export const ResponseSchema = z.object({
-        data: AgentLeadFindResultSchema,
+        data: z.array(AgentLeadSchema),
     });
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/index.ts

@@ -21,6 +21,7 @@ export * from './midjourney';
 export * from './page';
 export * from './order';
 export * from './payment';
+export * from './photo-studio';
 export * from './product';
 export * from './question';
 export * from './referral';

package/commands/photo-studio/add-photo-studio-checkpoint.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import {
+    PhotoStudioCheckpointActionSchema,
+    PhotoStudioCheckpointSchema,
+    PhotoStudioImageInputSchema,
+} from '../../models';
+
+export namespace AddPhotoStudioCheckpointCommand {
+    export const RequestParamSchema = z.object({ canvasId: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        action: PhotoStudioCheckpointActionSchema,
+        images: z.array(PhotoStudioImageInputSchema).optional(),
+        baseCheckpointSequence: z.number().int().positive().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioCheckpointSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/clear-photo-studio-checkpoints.command.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { PhotoStudioCheckpointSchema } from '../../models';
+
+export namespace ClearPhotoStudioCheckpointsCommand {
+    export const RequestParamSchema = z.object({ canvasId: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PhotoStudioCheckpointSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/create-photo-studio-canvas.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { PhotoStudioCanvasWithImagesSchema, PhotoStudioImageInputSchema } from '../../models';
+
+export namespace CreatePhotoStudioCanvasCommand {
+    export const RequestSchema = z.object({
+        name: z.string().trim().min(1).optional(),
+        images: z.array(PhotoStudioImageInputSchema).default([]).optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioCanvasWithImagesSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/delete-photo-studio-canvas.command.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export namespace DeletePhotoStudioCanvasCommand {
+    export const RequestParamSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({ isDeleted: z.boolean() }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/delete-photo-studio-checkpoint.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export namespace DeletePhotoStudioCheckpointCommand {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+        checkpointId: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({ isDeleted: z.boolean() }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/execute-photo-studio-action.command.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { TOOL_CONTENT_TYPE } from '../../constants';
+import { IMAGE_GENERATION_RESOLUTION } from '../../constants/tool-image-generation/enums/image-generation-resolution.enum';
+import { CanvasNodePositionSchema, ToolJobSchema } from '../../models';
+
+export namespace ExecutePhotoStudioActionCommand {
+    export const RequestSchema = z.object({
+        actionAlias: z.string().min(1),
+        modelId: z.string().uuid(),
+        prompt: z.string().optional(),
+        params: z
+            .object({
+                imageUrls: z.array(z.string().uuid()).optional(),
+                enhancePrompt: z.boolean().optional(),
+                resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
+                aspectRatio: z.string().optional(),
+                effect: z.string().optional(),
+                size: z.enum(['2x', '4x', '8x']).optional(),
+                variationsCount: z.union([z.literal(2), z.literal(3), z.literal(4)]).optional(),
+                variationStrength: z.enum(['light', 'medium', 'high']).optional(),
+                fontStyle: z
+                    .enum([
+                        'calligraphy',
+                        'handwritten',
+                        'elegant',
+                        'decorative',
+                        'poster',
+                        'engraving',
+                    ])
+                    .optional(),
+                placement: z.enum(['top', 'center', 'bottom']).optional(),
+                color: z.string().optional(),
+            })
+            .default({}),
+        position: CanvasNodePositionSchema,
+        baseCheckpointSequence: z.number().int().positive().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const PhotoStudioExecuteJobSchema = ToolJobSchema.extend({
+        toolType: z.nativeEnum(TOOL_CONTENT_TYPE),
+    });
+    export type PhotoStudioExecuteJob = z.infer<typeof PhotoStudioExecuteJobSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PhotoStudioExecuteJobSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/find-photo-studio-canvas-by-uuid.query.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { PhotoStudioCanvasWithImagesSchema } from '../../models';
+
+export namespace FindPhotoStudioCanvasByUuidQuery {
+    export const RequestParamSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioCanvasWithImagesSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/find-photo-studio-canvases.query.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { PhotoStudioCanvasSchema } from '../../models';
+
+export namespace FindPhotoStudioCanvasesQuery {
+    export const RequestSchema = z.object({
+        limit: z.coerce.number().int().min(1).default(20).optional(),
+        offset: z.coerce.number().int().min(0).default(0).optional(),
+        name: z.string().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PhotoStudioCanvasSchema.extend({ countOfImages: z.number() })),
+        page: z.number(),
+        totalPages: z.number(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/find-photo-studio-checkpoints.query.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { PhotoStudioCheckpointSchema } from '../../models';
+
+export namespace FindPhotoStudioCheckpointsQuery {
+    export const RequestParamSchema = z.object({ canvasId: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PhotoStudioCheckpointSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/find-photo-studio-job-by-id.query.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { TOOL_CONTENT_TYPE, TOOL_JOB_STATUS } from '../../constants';
+import { CanvasNodePositionSchema, FileResolutionSchema } from '../../models';
+
+export namespace FindPhotoStudioJobByIdQuery {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+        jobId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamSchema>;
+
+    export const PhotoStudioJobImageSchema = z.object({
+        fileId: z.string().uuid(),
+        url: z.string(),
+        originalName: z.string().nullable().optional(),
+        resolution: FileResolutionSchema.nullable().optional(),
+    });
+    export type PhotoStudioJobImage = z.infer<typeof PhotoStudioJobImageSchema>;
+
+    export const PhotoStudioJobSchema = z.object({
+        jobId: z.string().uuid(),
+        toolType: z.nativeEnum(TOOL_CONTENT_TYPE),
+        status: z.nativeEnum(TOOL_JOB_STATUS),
+        position: CanvasNodePositionSchema,
+        images: z.array(PhotoStudioJobImageSchema),
+        error: z.string().nullable(),
+        createdAt: z.date(),
+        updatedAt: z.date(),
+    });
+    export type PhotoStudioJob = z.infer<typeof PhotoStudioJobSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/find-photo-studio-jobs.query.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { TOOL_JOB_STATUS } from '../../constants';
+import { FindPhotoStudioJobByIdQuery } from './find-photo-studio-job-by-id.query';
+
+export namespace FindPhotoStudioJobsQuery {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamSchema>;
+
+    export const RequestQuerySchema = z.object({
+        status: z.nativeEnum(TOOL_JOB_STATUS).optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(FindPhotoStudioJobByIdQuery.PhotoStudioJobSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/get-photo-studio-actions.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { PhotoStudioActionSchema } from '../../models';
+
+export namespace GetPhotoStudioActionsQuery {
+    export const ResponseSchema = z.object({
+        data: z.array(PhotoStudioActionSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/index.ts

@@ -0,0 +1,15 @@
+export * from './add-photo-studio-checkpoint.command';
+export * from './clear-photo-studio-checkpoints.command';
+export * from './create-photo-studio-canvas.command';
+export * from './delete-photo-studio-canvas.command';
+export * from './delete-photo-studio-checkpoint.command';
+export * from './execute-photo-studio-action.command';
+export * from './find-photo-studio-canvas-by-uuid.query';
+export * from './find-photo-studio-canvases.query';
+export * from './find-photo-studio-checkpoints.query';
+export * from './find-photo-studio-job-by-id.query';
+export * from './find-photo-studio-jobs.query';
+export * from './get-photo-studio-actions.query';
+export * from './save-photo-studio-canvas.command';
+export * from './update-photo-studio-canvas.command';
+export * from './update-photo-studio-checkpoint.command';

package/commands/photo-studio/save-photo-studio-canvas.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import {
+    PhotoStudioCanvasWithImagesSchema,
+    PhotoStudioCheckpointActionSchema,
+    PhotoStudioImageInputSchema,
+} from '../../models';
+
+export namespace SavePhotoStudioCanvasCommand {
+    export const RequestParamSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        updatedAt: z.coerce.date().optional(),
+        images: z.array(PhotoStudioImageInputSchema),
+        action: PhotoStudioCheckpointActionSchema.optional(),
+        baseCheckpointSequence: z.number().int().positive().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioCanvasWithImagesSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/update-photo-studio-canvas.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { PhotoStudioCanvasWithImagesSchema } from '../../models';
+
+export namespace UpdatePhotoStudioCanvasCommand {
+    export const RequestParamSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        name: z.string().trim().min(1),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioCanvasWithImagesSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/photo-studio/update-photo-studio-checkpoint.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import {
+    PhotoStudioCheckpointActionSchema,
+    PhotoStudioCheckpointSchema,
+    PhotoStudioImageInputSchema,
+} from '../../models';
+
+export namespace UpdatePhotoStudioCheckpointCommand {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+        checkpointId: z.string().uuid(),
+    });
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        action: PhotoStudioCheckpointActionSchema.optional(),
+        images: z.array(PhotoStudioImageInputSchema).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PhotoStudioCheckpointSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}