@purpleschool/gptbot-tools 0.2.76 → 0.2.78

package/build/paraphrase/commands/update-paraphrase-job-title.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateParaphraseJobTitleCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         title: z.ZodString;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
@@ -29,6 +29,26 @@ export declare namespace UpdateParaphraseJobTitleCommand {
             createdAt: Date;
             updatedAt: Date;
             completedAt: Date | null;
+            inputKind: import("..").PARAPHRASE_INPUT_KIND | null;
+            sourceDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            outputDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            uniquenessPercentage: number | null;
         }, unknown, z.core.$ZodTypeInternals<{
             uuid: string;
             userId: string | null;
@@ -49,6 +69,26 @@ export declare namespace UpdateParaphraseJobTitleCommand {
             createdAt: Date;
             updatedAt: Date;
             completedAt: Date | null;
+            inputKind: import("..").PARAPHRASE_INPUT_KIND | null;
+            sourceDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            outputDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            uniquenessPercentage: number | null;
         }, unknown>>>;
         code: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;

package/build/paraphrase/commands/update-paraphrase-job-title.command.js

@@ -7,9 +7,9 @@ const paraphrase_job_schema_1 = require("../models/paraphrase-job.schema");
 var UpdateParaphraseJobTitleCommand;
 (function (UpdateParaphraseJobTitleCommand) {
     UpdateParaphraseJobTitleCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         title: zod_1.z.string().min(1).max(40),
     });
     UpdateParaphraseJobTitleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(paraphrase_job_schema_1.ParaphraseJobSchema);

package/build/paraphrase/enums/index.d.ts

@@ -1 +1,2 @@
 export * from './paraphrasing-intesity.enum';
+export * from './paraphrase-input-kind.enum';

package/build/paraphrase/enums/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./paraphrasing-intesity.enum"), exports);
+__exportStar(require("./paraphrase-input-kind.enum"), exports);

package/build/paraphrase/enums/paraphrase-input-kind.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum PARAPHRASE_INPUT_KIND {
+    TEXT = "text",
+    DOCUMENT = "document"
+}

package/build/paraphrase/enums/paraphrase-input-kind.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARAPHRASE_INPUT_KIND = void 0;
+var PARAPHRASE_INPUT_KIND;
+(function (PARAPHRASE_INPUT_KIND) {
+    PARAPHRASE_INPUT_KIND["TEXT"] = "text";
+    PARAPHRASE_INPUT_KIND["DOCUMENT"] = "document";
+})(PARAPHRASE_INPUT_KIND || (exports.PARAPHRASE_INPUT_KIND = PARAPHRASE_INPUT_KIND = {}));

package/build/paraphrase/models/index.d.ts

@@ -2,3 +2,4 @@ export * from './paraphrase-type.schema';
 export * from './paraphrase-style.schema';
 export * from './paraphrase-job.schema';
 export * from './paraphrase-tool-config.schema';
+export * from './paraphrase-document.schema';

package/build/paraphrase/models/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./paraphrase-type.schema"), exports);
 __exportStar(require("./paraphrase-style.schema"), exports);
 __exportStar(require("./paraphrase-job.schema"), exports);
 __exportStar(require("./paraphrase-tool-config.schema"), exports);
+__exportStar(require("./paraphrase-document.schema"), exports);

package/build/paraphrase/models/paraphrase-document.schema.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const ParaphraseDocumentMetadataSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    url: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    type: z.ZodString;
+    size: z.ZodNumber;
+    extension: z.ZodString;
+}, z.core.$strip>;
+export declare const ParaphraseDocumentInputSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    url: z.ZodString;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    type: z.ZodString;
+    size: z.ZodNumber;
+    extension: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type ParaphraseDocumentInput = z.infer<typeof ParaphraseDocumentInputSchema>;
+export type ParaphraseDocumentMetadata = z.infer<typeof ParaphraseDocumentMetadataSchema>;

package/build/paraphrase/models/paraphrase-document.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaphraseDocumentInputSchema = exports.ParaphraseDocumentMetadataSchema = void 0;
+const zod_1 = require("zod");
+exports.ParaphraseDocumentMetadataSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    url: zod_1.z.string(),
+    name: zod_1.z.string(),
+    mimeType: zod_1.z.string(),
+    type: zod_1.z.string(),
+    size: zod_1.z.number(),
+    extension: zod_1.z.string(),
+});
+exports.ParaphraseDocumentInputSchema = exports.ParaphraseDocumentMetadataSchema.extend({
+    content: zod_1.z.string(),
+});

package/build/paraphrase/models/paraphrase-job.schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { JOB_STATUS } from '../../tools';
 import { USER_REACTION } from '../../common';
-import { PARAPHRASING_INTENSITY } from '../enums';
+import { PARAPHRASE_INPUT_KIND, PARAPHRASING_INTENSITY } from '../enums';
 export declare const ParaphraseJobSchema: z.ZodObject<{
     uuid: z.ZodString;
     userId: z.ZodNullable<z.ZodString>;
@@ -22,5 +22,25 @@ export declare const ParaphraseJobSchema: z.ZodObject<{
     createdAt: z.ZodDate;
     updatedAt: z.ZodDate;
     completedAt: z.ZodNullable<z.ZodDate>;
+    inputKind: z.ZodDefault<z.ZodNullable<z.ZodEnum<typeof PARAPHRASE_INPUT_KIND>>>;
+    sourceDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        uuid: z.ZodString;
+        url: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        type: z.ZodString;
+        size: z.ZodNumber;
+        extension: z.ZodString;
+    }, z.core.$strip>>>;
+    outputDocument: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        uuid: z.ZodString;
+        url: z.ZodString;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        type: z.ZodString;
+        size: z.ZodNumber;
+        extension: z.ZodString;
+    }, z.core.$strip>>>;
+    uniquenessPercentage: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 export type ParaphraseJob = z.infer<typeof ParaphraseJobSchema>;

package/build/paraphrase/models/paraphrase-job.schema.js

@@ -5,6 +5,7 @@ const zod_1 = require("zod");
 const tools_1 = require("../../tools");
 const common_1 = require("../../common");
 const enums_1 = require("../enums");
+const paraphrase_document_schema_1 = require("./paraphrase-document.schema");
 exports.ParaphraseJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     userId: zod_1.z.string().nullable(),
@@ -13,16 +14,20 @@ exports.ParaphraseJobSchema = zod_1.z.object({
     aiOutput: zod_1.z.string().nullable(),
     aiTokenUsage: zod_1.z.number().nullable(),
     price: zod_1.z.number(),
-    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    status: zod_1.z.enum(tools_1.JOB_STATUS),
     title: zod_1.z.string(),
     error: zod_1.z.string().nullable(),
-    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    reaction: zod_1.z.enum(common_1.USER_REACTION).nullable(),
     dislikeReason: zod_1.z.string().nullable(),
     typeId: zod_1.z.string(),
     styleId: zod_1.z.string(),
-    intensity: zod_1.z.nativeEnum(enums_1.PARAPHRASING_INTENSITY),
+    intensity: zod_1.z.enum(enums_1.PARAPHRASING_INTENSITY),
     tokenReservationId: zod_1.z.string().nullable().optional(),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
     completedAt: zod_1.z.date().nullable(),
+    inputKind: zod_1.z.nativeEnum(enums_1.PARAPHRASE_INPUT_KIND).nullable().default(null),
+    sourceDocument: paraphrase_document_schema_1.ParaphraseDocumentMetadataSchema.nullable().default(null),
+    outputDocument: paraphrase_document_schema_1.ParaphraseDocumentMetadataSchema.nullable().default(null),
+    uniquenessPercentage: zod_1.z.number().int().min(0).max(100).nullable().default(null),
 });

package/build/paraphrase/models/paraphrase-tool-config.schema.d.ts

@@ -14,6 +14,10 @@ export declare const ParaphraseToolConfigSchema: z.ZodObject<{
         title: z.ZodString;
         icon: z.ZodString;
         price: z.ZodNumber;
+        inputPrice: z.ZodNullable<z.ZodNumber>;
+        outputPrice: z.ZodNullable<z.ZodNumber>;
+        freeMaxPromptLength: z.ZodNumber;
+        maxPromptLength: z.ZodNumber;
         aiModel: z.ZodString;
         status: z.ZodEnum<typeof import("../..").TOOL_MODEL_STATUS>;
         reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("../..").REASONING_EFFORT>>>;
@@ -21,6 +25,5 @@ export declare const ParaphraseToolConfigSchema: z.ZodObject<{
         createdAt: z.ZodDate;
         updatedAt: z.ZodDate;
     }, z.core.$strip>>;
-    maxSymbols: z.ZodNumber;
 }, z.core.$strip>;
 export type ParaphraseTool = z.infer<typeof ParaphraseToolConfigSchema>;

package/build/paraphrase/models/paraphrase-tool-config.schema.js

@@ -7,5 +7,4 @@ const paraphrase_type_schema_1 = require("./paraphrase-type.schema");
 exports.ParaphraseToolConfigSchema = zod_1.z.object({
     styles: zod_1.z.array(paraphrase_style_schema_1.ParaphraseStyleSchema),
     types: zod_1.z.array(paraphrase_type_schema_1.ParaphraseTypeSchema),
-    maxSymbols: zod_1.z.number(),
 });

package/build/paraphrase/models/paraphrase-type.schema.d.ts

@@ -5,6 +5,10 @@ export declare const ParaphraseTypeSchema: z.ZodObject<{
     title: z.ZodString;
     icon: z.ZodString;
     price: z.ZodNumber;
+    inputPrice: z.ZodNullable<z.ZodNumber>;
+    outputPrice: z.ZodNullable<z.ZodNumber>;
+    freeMaxPromptLength: z.ZodNumber;
+    maxPromptLength: z.ZodNumber;
     aiModel: z.ZodString;
     status: z.ZodEnum<typeof TOOL_MODEL_STATUS>;
     reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof REASONING_EFFORT>>>;

package/build/paraphrase/models/paraphrase-type.schema.js

@@ -8,9 +8,13 @@ exports.ParaphraseTypeSchema = zod_1.z.object({
     title: zod_1.z.string(),
     icon: zod_1.z.string(),
     price: zod_1.z.number(),
+    inputPrice: zod_1.z.number().nullable(),
+    outputPrice: zod_1.z.number().nullable(),
+    freeMaxPromptLength: zod_1.z.number(),
+    maxPromptLength: zod_1.z.number(),
     aiModel: zod_1.z.string(),
-    status: zod_1.z.nativeEnum(common_1.TOOL_MODEL_STATUS),
-    reasoningEffort: zod_1.z.nativeEnum(common_1.REASONING_EFFORT).nullable().optional(),
+    status: zod_1.z.enum(common_1.TOOL_MODEL_STATUS),
+    reasoningEffort: zod_1.z.enum(common_1.REASONING_EFFORT).nullable().optional(),
     order: zod_1.z.number(),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),

package/build/paraphrase/queries/find-paraphrase-job-by-uuid.query.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace FindParaphraseJobByUuidQuery {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
@@ -28,6 +28,26 @@ export declare namespace FindParaphraseJobByUuidQuery {
             createdAt: Date;
             updatedAt: Date;
             completedAt: Date | null;
+            inputKind: import("..").PARAPHRASE_INPUT_KIND | null;
+            sourceDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            outputDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            uniquenessPercentage: number | null;
         }, unknown, z.core.$ZodTypeInternals<{
             uuid: string;
             userId: string | null;
@@ -48,6 +68,26 @@ export declare namespace FindParaphraseJobByUuidQuery {
             createdAt: Date;
             updatedAt: Date;
             completedAt: Date | null;
+            inputKind: import("..").PARAPHRASE_INPUT_KIND | null;
+            sourceDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            outputDocument: {
+                uuid: string;
+                url: string;
+                name: string;
+                mimeType: string;
+                type: string;
+                size: number;
+                extension: string;
+            } | null;
+            uniquenessPercentage: number | null;
         }, unknown>>>;
         code: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;

package/build/paraphrase/queries/find-paraphrase-job-by-uuid.query.js

@@ -7,9 +7,9 @@ const models_1 = require("../models");
 var FindParaphraseJobByUuidQuery;
 (function (FindParaphraseJobByUuidQuery) {
     FindParaphraseJobByUuidQuery.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
     });
     FindParaphraseJobByUuidQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.ParaphraseJobSchema);
 })(FindParaphraseJobByUuidQuery || (exports.FindParaphraseJobByUuidQuery = FindParaphraseJobByUuidQuery = {}));

package/build/paraphrase/queries/find-paraphrase-jobs.query.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { JOB_SORT, JOB_STATUS } from '../../tools';
 export declare namespace FindParaphraseJobsQuery {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodString>;
-        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodUUID>;
+        unregisteredUserId: z.ZodOptional<z.ZodUUID>;
         title: z.ZodOptional<z.ZodString>;
         isFavorite: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
         createdAtSortOrder: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SORT>>>;
@@ -35,6 +35,26 @@ export declare namespace FindParaphraseJobsQuery {
                 createdAt: Date;
                 updatedAt: Date;
                 completedAt: Date | null;
+                inputKind: import("..").PARAPHRASE_INPUT_KIND | null;
+                sourceDocument: {
+                    uuid: string;
+                    url: string;
+                    name: string;
+                    mimeType: string;
+                    type: string;
+                    size: number;
+                    extension: string;
+                } | null;
+                outputDocument: {
+                    uuid: string;
+                    url: string;
+                    name: string;
+                    mimeType: string;
+                    type: string;
+                    size: number;
+                    extension: string;
+                } | null;
+                uniquenessPercentage: number | null;
             }[];
             page: number;
             totalPages: number;
@@ -60,6 +80,26 @@ export declare namespace FindParaphraseJobsQuery {
                 createdAt: Date;
                 updatedAt: Date;
                 completedAt: Date | null;
+                inputKind: import("..").PARAPHRASE_INPUT_KIND | null;
+                sourceDocument: {
+                    uuid: string;
+                    url: string;
+                    name: string;
+                    mimeType: string;
+                    type: string;
+                    size: number;
+                    extension: string;
+                } | null;
+                outputDocument: {
+                    uuid: string;
+                    url: string;
+                    name: string;
+                    mimeType: string;
+                    type: string;
+                    size: number;
+                    extension: string;
+                } | null;
+                uniquenessPercentage: number | null;
             }[];
             page: number;
             totalPages: number;

package/build/paraphrase/queries/find-paraphrase-jobs.query.js

@@ -9,12 +9,12 @@ var FindParaphraseJobsQuery;
 (function (FindParaphraseJobsQuery) {
     FindParaphraseJobsQuery.RequestSchema = zod_1.z
         .object({
-        userId: zod_1.z.string().uuid().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        userId: zod_1.z.uuid().optional(),
+        unregisteredUserId: zod_1.z.uuid().optional(),
         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(),
+        createdAtSortOrder: zod_1.z.enum(tools_1.JOB_SORT).optional().default(tools_1.JOB_SORT.DESC),
+        status: zod_1.z.enum(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(),
     })

package/build/paraphrase/queries/get-paraphrase-tool-config.query.d.ts

@@ -21,6 +21,10 @@ export declare namespace GetParaphraseToolConfigQuery {
                 title: string;
                 icon: string;
                 price: number;
+                inputPrice: number | null;
+                outputPrice: number | null;
+                freeMaxPromptLength: number;
+                maxPromptLength: number;
                 aiModel: string;
                 status: import("../..").TOOL_MODEL_STATUS;
                 reasoningEffort?: import("../..").REASONING_EFFORT | null | undefined;
@@ -28,7 +32,6 @@ export declare namespace GetParaphraseToolConfigQuery {
                 createdAt: Date;
                 updatedAt: Date;
             }[];
-            maxSymbols: number;
         }, unknown, z.core.$ZodTypeInternals<{
             styles: {
                 uuid: string;
@@ -44,6 +47,10 @@ export declare namespace GetParaphraseToolConfigQuery {
                 title: string;
                 icon: string;
                 price: number;
+                inputPrice: number | null;
+                outputPrice: number | null;
+                freeMaxPromptLength: number;
+                maxPromptLength: number;
                 aiModel: string;
                 status: import("../..").TOOL_MODEL_STATUS;
                 reasoningEffort?: import("../..").REASONING_EFFORT | null | undefined;
@@ -51,7 +58,6 @@ export declare namespace GetParaphraseToolConfigQuery {
                 createdAt: Date;
                 updatedAt: Date;
             }[];
-            maxSymbols: number;
         }, unknown>>>;
         code: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare namespace DeletePhotoSessionStyleCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
+        uuid: z.ZodUUID;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

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

@@ -6,7 +6,7 @@ const command_response_schema_1 = require("../../../common/models/command-respon
 var DeletePhotoSessionStyleCommand;
 (function (DeletePhotoSessionStyleCommand) {
     DeletePhotoSessionStyleCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+        uuid: zod_1.z.uuid(),
     });
     DeletePhotoSessionStyleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
 })(DeletePhotoSessionStyleCommand || (exports.DeletePhotoSessionStyleCommand = DeletePhotoSessionStyleCommand = {}));

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare namespace UpdatePhotoSessionStyleCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
+        uuid: z.ZodUUID;
         locale: z.ZodEnum<typeof import("@purpleschool/rugpt-lib-common").LOCALE>;
         code: z.ZodOptional<z.ZodString>;
         title: z.ZodOptional<z.ZodString>;

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

@@ -7,7 +7,7 @@ const locale_schema_1 = require("../../../common/models/locale.schema");
 const models_1 = require("../../models");
 const create_photo_session_style_command_1 = require("./create-photo-session-style.command");
 const UpdatePhotoSessionStyleRequestSchema = zod_1.z.object({
-    uuid: zod_1.z.string().uuid(),
+    uuid: zod_1.z.uuid(),
     locale: locale_schema_1.LocaleSchema,
     code: zod_1.z.string().optional(),
     title: zod_1.z.string().optional(),

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

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { JOB_SCOPE } from '../../common';
 export declare namespace DeleteAllPhotoSessionsJobsCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         scope: z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/photo-sessions/commands/delete-all-photo-sessions-jobs.command.js

@@ -8,9 +8,9 @@ var DeleteAllPhotoSessionsJobsCommand;
 (function (DeleteAllPhotoSessionsJobsCommand) {
     DeleteAllPhotoSessionsJobsCommand.RequestSchema = zod_1.z
         .object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        scope: zod_1.z.nativeEnum(common_1.JOB_SCOPE).optional(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        scope: zod_1.z.enum(common_1.JOB_SCOPE).optional(),
     })
         .refine((data) => Boolean(data.userId) !== Boolean(data.unregisteredUserId), {
         message: 'Exactly one owner identity is required',

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

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace DeletePhotoSessionsJobByUuidCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         uuid: z.ZodString;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

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

@@ -6,8 +6,8 @@ const command_response_schema_1 = require("../../common/models/command-response.
 var DeletePhotoSessionsJobByUuidCommand;
 (function (DeletePhotoSessionsJobByUuidCommand) {
     DeletePhotoSessionsJobByUuidCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         uuid: zod_1.z.string(),
     });
     DeletePhotoSessionsJobByUuidCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace GetPhotoSessionsPriceCommand {
     const RequestSchema: z.ZodObject<{
-        modelId: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        modelId: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         prompt: z.ZodOptional<z.ZodString>;
         params: z.ZodObject<{
             attachedFiles: z.ZodArray<z.ZodObject<{
@@ -17,7 +17,7 @@ export declare namespace GetPhotoSessionsPriceCommand {
                 content: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                 contentLength: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             }, z.core.$strip>>;
-            styleId: z.ZodNullable<z.ZodString>;
+            styleId: z.ZodNullable<z.ZodUUID>;
             photosCount: z.ZodNumber;
             clothingPhotos: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 uuid: z.ZodString;

package/build/photo-sessions/commands/get-photo-sessions-price.command.js

@@ -7,13 +7,13 @@ const common_1 = require("../../common");
 var GetPhotoSessionsPriceCommand;
 (function (GetPhotoSessionsPriceCommand) {
     GetPhotoSessionsPriceCommand.RequestSchema = zod_1.z.object({
-        modelId: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        modelId: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         prompt: zod_1.z.string().optional(),
         params: zod_1.z.object({
             attachedFiles: zod_1.z.array(common_1.AttachedFileSchema).min(1).max(3),
-            styleId: zod_1.z.string().uuid().nullable(),
+            styleId: zod_1.z.uuid().nullable(),
             photosCount: zod_1.z.number().int().min(1).max(6),
             clothingPhotos: zod_1.z.array(common_1.AttachedFileSchema).max(2).optional(),
             hairstylePhotos: zod_1.z.array(common_1.AttachedFileSchema).max(2).optional(),

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

@@ -3,8 +3,8 @@ import { JOB_SCOPE } from '../../common';
 export declare namespace PhotoSessionsCommand {
     const RequestSchema: z.ZodObject<{
         locale: z.ZodEnum<typeof import("@purpleschool/rugpt-lib-common").LOCALE>;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         scope: z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>;
         prompt: z.ZodOptional<z.ZodString>;
         modelId: z.ZodString;
@@ -20,7 +20,7 @@ export declare namespace PhotoSessionsCommand {
                 content: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                 contentLength: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
             }, z.core.$strip>>;
-            styleId: z.ZodNullable<z.ZodString>;
+            styleId: z.ZodNullable<z.ZodUUID>;
             photosCount: z.ZodNumber;
             clothingPhotos: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 uuid: z.ZodString;
@@ -58,7 +58,7 @@ export declare namespace PhotoSessionsCommand {
             aspectRatio: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
         userHasActiveSubscriptionOrProduct: z.ZodBoolean;
-        tokenReservationId: z.ZodString;
+        tokenReservationId: z.ZodUUID;
         precalculatedPrice: z.ZodNumber;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;