@purpleschool/gptbot-tools 0.2.50 → 0.2.51

package/build/photo-sessions/queries/find-photo-sessions-jobs.query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindPhotoSessionsJobsQuery = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+const tools_1 = require("../../tools");
+var FindPhotoSessionsJobsQuery;
+(function (FindPhotoSessionsJobsQuery) {
+    FindPhotoSessionsJobsQuery.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        scope: zod_1.z.nativeEnum(common_1.JOB_SCOPE).optional().default(common_1.JOB_SCOPE.TOOL),
+        title: zod_1.z.string().optional(),
+        isFavorite: zod_1.z.coerce.boolean().optional(),
+        createdAtSortOrder: zod_1.z.nativeEnum(tools_1.JOB_SORT).optional().default(tools_1.JOB_SORT.DESC),
+        status: zod_1.z.nativeEnum(tools_1.JOB_STATUS).optional(),
+        limit: zod_1.z.coerce.number().min(1).optional(),
+        offset: zod_1.z.coerce.number().min(0).default(0).optional(),
+    });
+    FindPhotoSessionsJobsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        data: zod_1.z.array(models_1.PhotoSessionJobSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+        total: zod_1.z.number(),
+    }));
+})(FindPhotoSessionsJobsQuery || (exports.FindPhotoSessionsJobsQuery = FindPhotoSessionsJobsQuery = {}));

package/build/photo-sessions/queries/get-photo-sessions-config.query.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPhotoSessionsConfigQuery = void 0;
+const common_1 = require("../../common");
+const models_1 = require("../models");
+var GetPhotoSessionsConfigQuery;
+(function (GetPhotoSessionsConfigQuery) {
+    GetPhotoSessionsConfigQuery.RequestSchema = common_1.LocaleRequestSchema;
+    GetPhotoSessionsConfigQuery.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.PhotoSessionConfigSchema);
+})(GetPhotoSessionsConfigQuery || (exports.GetPhotoSessionsConfigQuery = GetPhotoSessionsConfigQuery = {}));

package/build/photo-sessions/queries/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("./find-photo-sessions-job-by-id.query"), exports);
+__exportStar(require("./find-photo-sessions-jobs.query"), exports);
+__exportStar(require("./get-photo-sessions-config.query"), exports);
+__exportStar(require("./find-photo-session-styles.query"), exports);
+__exportStar(require("./find-photo-session-style-by-id.query"), exports);

package/build/photo-sessions/routes/index.js

@@ -0,0 +1,18 @@
+"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-sessions.amqp.routes"), exports);
+__exportStar(require("./photo-sessions.http.routes"), exports);

package/build/photo-sessions/routes/photo-sessions.amqp.routes.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHOTO_SESSIONS_AMQP_ROUTES = void 0;
+exports.PHOTO_SESSIONS_AMQP_ROUTES = {
+    EXECUTE: 'tools.photo-sessions.execute.rpc',
+    GET_PRICE: 'tools.photo-sessions.get-price.rpc',
+    CONFIG: 'tools.photo-sessions.config.rpc',
+    GET_JOB: 'tools.photo-sessions.jobs.get.rpc',
+    LIST_JOBS: 'tools.photo-sessions.jobs.list.rpc',
+    SET_REACTION: 'tools.photo-sessions.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.photo-sessions.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.photo-sessions.jobs.update-favorite.rpc',
+    SOFT_DELETE: 'tools.photo-sessions.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.photo-sessions.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.photo-sessions.jobs.retry.rpc',
+    UPDATE_JOB: 'tools.photo-sessions.jobs.update.rpc',
+    LIST_STYLES: 'tools.photo-sessions.styles.list.rpc',
+    GET_STYLE: 'tools.photo-sessions.styles.get.rpc',
+    CREATE_STYLE: 'tools.photo-sessions.styles.create.rpc',
+    UPDATE_STYLE: 'tools.photo-sessions.styles.update.rpc',
+    DELETE_STYLE: 'tools.photo-sessions.styles.delete.rpc',
+};

package/build/photo-sessions/routes/photo-sessions.http.routes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHOTO_SESSIONS_CONTROLLER = void 0;
+exports.PHOTO_SESSIONS_CONTROLLER = 'photo-sessions';

package/build/tools/enums/tool-content-type.enum.js

@@ -20,5 +20,6 @@ var TOOL_CONTENT_TYPE;
     TOOL_CONTENT_TYPE["SPELL_CORRECTOR"] = "SPELL_CORRECTOR";
     TOOL_CONTENT_TYPE["DIAGRAMS"] = "DIAGRAMS";
     TOOL_CONTENT_TYPE["HTML_PAGE_BUILDER"] = "HTML_PAGE_BUILDER";
+    TOOL_CONTENT_TYPE["PHOTO_SESSIONS"] = "PHOTO_SESSIONS";
     TOOL_CONTENT_TYPE["IMAGE_RECOGNITION"] = "IMAGE_RECOGNITION";
 })(TOOL_CONTENT_TYPE || (exports.TOOL_CONTENT_TYPE = TOOL_CONTENT_TYPE = {}));

package/build/tools/enums/tool-type.enum.js

@@ -22,5 +22,6 @@ var TOOL_TYPE;
     TOOL_TYPE["SOLVING_EDU_TASK"] = "SOLVING_EDU_TASK";
     TOOL_TYPE["DIAGRAMS"] = "DIAGRAMS";
     TOOL_TYPE["HTML_PAGE_BUILDER"] = "HTML_PAGE_BUILDER";
+    TOOL_TYPE["PHOTO_SESSION"] = "PHOTO_SESSION";
     TOOL_TYPE["IMAGE_RECOGNITION"] = "IMAGE_RECOGNITION";
 })(TOOL_TYPE || (exports.TOOL_TYPE = TOOL_TYPE = {}));

package/build/tools/models/global-tools-config.schema.js

@@ -19,6 +19,7 @@ const solving_edu_task_1 = require("../../solving-edu-task");
 const spell_corrector_1 = require("../../spell-corrector");
 const diagrams_1 = require("../../diagrams");
 const models_2 = require("../../html-page-builder/models");
+const photo_sessions_1 = require("../../photo-sessions");
 const image_recognition_1 = require("../../image-recognition");
 exports.GlobalToolsConfigSchema = zod_1.z.object({
     [enums_1.TOOL_CONTENT_TYPE.VIDEO]: video_1.VideoConfigSchema,
@@ -37,5 +38,6 @@ exports.GlobalToolsConfigSchema = zod_1.z.object({
     [enums_1.TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: spell_corrector_1.SpellCorrectorToolConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.DIAGRAMS]: diagrams_1.DiagramsConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER]: models_2.HtmlPageBuilderConfigSchema,
+    [enums_1.TOOL_CONTENT_TYPE.PHOTO_SESSIONS]: photo_sessions_1.PhotoSessionConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.IMAGE_RECOGNITION]: image_recognition_1.ImageRecognitionConfigSchema,
 });

package/index.ts

@@ -22,6 +22,7 @@ export * from './html-page-builder';
 export * from './tool-workspace';
 export * from './diagrams';
 export * from './image-recognition';
+export * from './photo-sessions';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -47,6 +48,7 @@ import * as accountMerge from './account-merge';
 import * as toolWorkspace from './tool-workspace';
 import * as diagrams from './diagrams';
 import * as imageRecognition from './image-recognition';
+import * as photoSessions from './photo-sessions';
 
 export namespace ToolService {
     export import Common = common;
@@ -73,4 +75,5 @@ export namespace ToolService {
     export import ToolWorkspace = toolWorkspace;
     export import Diagrams = diagrams;
     export import ImageRecognition = imageRecognition;
+    export import PhotoSessions = photoSessions;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.2.50",
+  "version": "0.2.51",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

package/photo-sessions/commands/admin/create-photo-session-style.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../../common/models/command-response.schema';
+import { PhotoSessionStyleSchema } from '../../models';
+
+export const CreatePhotoSessionStyleReferenceSchema = z.object({
+    photoUrl: z.string(),
+    description: z.string().optional(),
+    order: z.number().int().min(0).max(5),
+});
+
+export namespace CreatePhotoSessionStyleCommand {
+    export const RequestSchema = z.object({
+        code: z.string(),
+        title: z.string(),
+        description: z.string().optional(),
+        references: z.array(CreatePhotoSessionStyleReferenceSchema).max(6),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionStyleSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/admin/delete-photo-session-style.command.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../../common/models/command-response.schema';
+
+export namespace DeletePhotoSessionStyleCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/admin/index.ts

@@ -0,0 +1,3 @@
+export * from './create-photo-session-style.command';
+export * from './update-photo-session-style.command';
+export * from './delete-photo-session-style.command';

package/photo-sessions/commands/admin/update-photo-session-style.command.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../../common/models/command-response.schema';
+import { PhotoSessionStyleSchema } from '../../models';
+import { CreatePhotoSessionStyleReferenceSchema } from './create-photo-session-style.command';
+
+const UpdatePhotoSessionStyleReferenceSchema = CreatePhotoSessionStyleReferenceSchema.extend({
+    uuid: z.string().uuid().optional(),
+}).refine(
+    (ref) => {
+        if (
+            ref.photoUrl === undefined &&
+            ref.description === undefined &&
+            ref.order === undefined
+        ) {
+            return false;
+        }
+        return true;
+    },
+    { message: 'At least one field must be provided for reference update' },
+);
+
+export namespace UpdatePhotoSessionStyleCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        code: z.string().optional(),
+        title: z.string().optional(),
+        description: z.string().nullable().optional(),
+        references: z.array(UpdatePhotoSessionStyleReferenceSchema).max(6).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionStyleSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/delete-all-photo-sessions-jobs.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { JOB_SCOPE } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteAllPhotoSessionsJobsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/delete-photo-sessions-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeletePhotoSessionsJobByUuidCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/get-photo-sessions-price.command.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { AttachedFileSchema } from '../../common';
+
+export namespace GetPhotoSessionsPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string().optional().default(''),
+        params: z.object({
+            attachedFiles: z.array(AttachedFileSchema).min(1).max(3),
+            styleId: z.string().uuid().nullable().optional(),
+            referenceIds: z.array(z.string().uuid()).optional().default([]),
+            customStylePrompt: z.string().nullable().optional(),
+            customStylePhotos: z.array(z.string()).optional().default([]),
+            clothingPhotos: z.array(z.string()).optional().default([]),
+            hairstylePhotos: z.array(z.string()).optional().default([]),
+            accessoriesPhotos: z.array(z.string()).optional().default([]),
+        }),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+    export type ResponseData = z.infer<typeof ResponseDataSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/index.ts

@@ -0,0 +1,10 @@
+export * from './delete-photo-sessions-job-by-uuid.command';
+export * from './delete-all-photo-sessions-jobs.command';
+export * from './get-photo-sessions-price.command';
+export * from './retry-photo-sessions-job.command';
+export * from './set-reaction-to-photo-sessions-job.command';
+export * from './photo-sessions.command';
+export * from './update-photo-sessions-job-title.command';
+export * from './update-photo-sessions-job-favorite.command';
+export * from './update-published-status-photo-sessions-jobs.command';
+export * from './admin';

package/photo-sessions/commands/photo-sessions.command.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { AttachedFileSchema, JOB_SCOPE } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { LocaleSchema } from '../../common/models/locale.schema';
+import { PhotoSessionJobSchema } from '../models';
+import { TOOL_WORKSPACE_ITEM_SLOT } from '../../tool-workspace';
+import { TOOL_CONTENT_TYPE } from '../../tools';
+
+export namespace PhotoSessionsCommand {
+    export const RequestSchema = z.object({
+        locale: LocaleSchema,
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
+        workspaceId: z.string().uuid().nullable().optional(),
+        workspaceItemId: z.string().uuid().nullable().optional(),
+        workspaceToolType: z.nativeEnum(TOOL_CONTENT_TYPE).nullable().optional(),
+        workspaceSlot: z.nativeEnum(TOOL_WORKSPACE_ITEM_SLOT).optional(),
+        workspaceOrder: z.number().int().min(0).optional(),
+        prompt: z.string().optional().default(''),
+        modelId: z.string(),
+        params: z.object({
+            attachedFiles: z.array(AttachedFileSchema).min(1).max(3),
+            styleId: z.string().uuid().nullable().optional(),
+            referenceIds: z.array(z.string().uuid()).optional().default([]),
+            customStylePrompt: z.string().nullable().optional(),
+            customStylePhotos: z.array(z.string()).optional().default([]),
+            clothingPhotos: z.array(z.string()).max(6).optional().default([]),
+            hairstylePhotos: z.array(z.string()).max(6).optional().default([]),
+            accessoriesPhotos: z.array(z.string()).max(6).optional().default([]),
+            aspectRatio: z.string().optional(),
+        }),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.array(PhotoSessionJobSchema));
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/retry-photo-sessions-job.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobParamsSchema, PhotoSessionJobSchema } from '../models';
+import { LocaleSchema } from '../../common';
+
+export namespace RetryPhotoSessionsJobCommand {
+    export const RequestSchema = z.object({
+        locale: LocaleSchema,
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
+        tokenReservationId: z.string().uuid(),
+        precalculatedPrice: z.number(),
+        modelId: z.string().optional(),
+        prompt: z.string().optional(),
+        params: PhotoSessionJobParamsSchema.optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/set-reaction-to-photo-sessions-job.command.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobSchema } from '../models';
+import { USER_REACTION } from '../../common';
+
+export namespace SetReactionToPhotoSessionsJobCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/update-photo-sessions-job-favorite.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobSchema } from '../models';
+
+export namespace UpdatePhotoSessionsJobFavoriteCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        isFavorite: z.boolean(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/update-photo-sessions-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobSchema } from '../models';
+
+export namespace UpdatePhotoSessionsJobTitleCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        title: z.string().min(1).max(40),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/commands/update-published-status-photo-sessions-jobs.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PhotoSessionJobSchema } from '../models';
+
+export namespace UpdatePublishedStatusPhotoSessionsJobsCommand {
+    export const RequestSchema = z.object({
+        criteria: z.object({
+            uuid: z.string().uuid(),
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+        }),
+        data: z
+            .object({
+                isPublished: z.boolean(),
+                postId: z.string().nullable().optional(),
+            })
+            .refine((data) => (data.isPublished ? !!data.postId : true), {
+                message: 'Post ID is required when job is published',
+                path: ['postId'],
+            }),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PhotoSessionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/photo-sessions/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './photo-session-strategy.enum';
+export * from './photo-session-look-type.enum';

package/photo-sessions/enums/photo-session-look-type.enum.ts

@@ -0,0 +1,5 @@
+export enum PHOTO_SESSION_LOOK_TYPE {
+    CLOTHING = 'clothing',
+    HAIRSTYLE = 'hairstyle',
+    ACCESSORIES = 'accessories',
+}

package/photo-sessions/enums/photo-session-strategy.enum.ts

@@ -0,0 +1,4 @@
+export enum PHOTO_SESSION_STRATEGY {
+    NANO_BANANA_PRO_CALLBACK = 'NANO_BANANA_PRO_CALLBACK',
+    OPENAI_IMAGE_1_GENERATION = 'OPENAI_IMAGE_1_GENERATION',
+}

package/photo-sessions/index.ts

@@ -0,0 +1,5 @@
+export * from './commands';
+export * from './enums';
+export * from './models';
+export * from './queries';
+export * from './routes';

package/photo-sessions/models/index.ts

@@ -0,0 +1,4 @@
+export * from './photo-session-config.schema';
+export * from './photo-session-job.schema';
+export * from './photo-session-model.schema';
+export * from './photo-session-style.schema';

package/photo-sessions/models/photo-session-config.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { PhotoSessionModelSchema } from './photo-session-model.schema';
+import { PhotoSessionStyleSchema } from './photo-session-style.schema';
+import { PHOTO_SESSION_LOOK_TYPE } from '../enums';
+
+export const PhotoSessionLookCategorySchema = z.object({
+    type: z.nativeEnum(PHOTO_SESSION_LOOK_TYPE),
+    maxPhotos: z.number(),
+});
+
+export const PhotoSessionConfigSchema = z.object({
+    models: z.array(PhotoSessionModelSchema),
+    styles: z.array(PhotoSessionStyleSchema),
+    looks: z.array(PhotoSessionLookCategorySchema),
+});
+
+export type PhotoSessionConfig = z.infer<typeof PhotoSessionConfigSchema>;

package/photo-sessions/models/photo-session-job.schema.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { AttachedFileSchema, USER_REACTION } from '../../common';
+
+export const PhotoSessionJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedFileSchema).optional(),
+    imageUrls: z.array(z.string()).optional(),
+    styleId: z.string().uuid().nullable().optional(),
+    referenceId: z.string().uuid().nullable().optional(),
+    referenceIds: z.array(z.string().uuid()).optional(),
+    customStylePrompt: z.string().nullable().optional(),
+    customStylePhotos: z.array(z.string()).optional(),
+    clothingPhotos: z.array(z.string()).optional(),
+    hairstylePhotos: z.array(z.string()).optional(),
+    accessoriesPhotos: z.array(z.string()).optional(),
+    aspectRatio: z.string().optional(),
+    userHasActiveSubscriptionOrProduct: z.boolean().optional(),
+});
+
+export type PhotoSessionJobParams = z.infer<typeof PhotoSessionJobParamsSchema>;
+
+export const PhotoSessionJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    externalId: z.string().nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    modelId: z.string(),
+    price: z.number(),
+    previewUrl: z.string().nullable(),
+    params: PhotoSessionJobParamsSchema,
+    imageUrls: z.array(z.string()).nullable(),
+    attempts: z.array(z.any()),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    isPublished: z.boolean(),
+    postId: z.string().nullable(),
+    isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
+    tokenReservationId: z.string().nullable().optional(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable().optional(),
+    updatedAt: z.date(),
+});
+
+export type PhotoSessionJob = z.infer<typeof PhotoSessionJobSchema>;

package/photo-sessions/models/photo-session-model.schema.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS, IconVariantsSchema } from '../../common';
+import { PHOTO_SESSION_STRATEGY } from '../enums';
+
+export const PhotoSessionModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+    aspectRatio: z.record(
+        z.string(),
+        z.object({
+            width: z.number(),
+            height: z.number(),
+        }),
+    ),
+});
+
+export type PhotoSessionModelParams = z.infer<typeof PhotoSessionModelParamsSchema>;
+
+export const PhotoSessionModelPricingRuleConditionSchema = z.object({
+    withoutSub: z.boolean().optional(),
+});
+export type PhotoSessionModelPricingRuleCondition = z.infer<
+    typeof PhotoSessionModelPricingRuleConditionSchema
+>;
+
+export const PhotoSessionModelPricingRulesSchema = z.array(
+    z.object({
+        condition: PhotoSessionModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type PhotoSessionModelPricingRules = z.infer<typeof PhotoSessionModelPricingRulesSchema>;
+
+export const PhotoSessionModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    isNew: z.boolean(),
+    tierLabel: z.string(),
+    pricePerImage: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    strategy: z.nativeEnum(PHOTO_SESSION_STRATEGY),
+    maxInputLength: z.number(),
+    params: PhotoSessionModelParamsSchema,
+    pricingRules: PhotoSessionModelPricingRulesSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type PhotoSessionModel = z.infer<typeof PhotoSessionModelSchema>;