@purpleschool/gptbot 0.15.76 → 0.15.78-stage-2

package/build/commands/agents/agent-dialog/start-cabinet-dialog.command.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare namespace StartCabinetDialogCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
+        agentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const RequestBodySchema: z.ZodObject<{
@@ -10,7 +10,7 @@ export declare namespace StartCabinetDialogCommand {
     type RequestBody = z.infer<typeof RequestBodySchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            dialogId: z.ZodString;
+            dialogId: z.ZodUUID;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/agents/agent-dialog/start-cabinet-dialog.command.js

@@ -5,14 +5,14 @@ const zod_1 = require("zod");
 var StartCabinetDialogCommand;
 (function (StartCabinetDialogCommand) {
     StartCabinetDialogCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
     });
     StartCabinetDialogCommand.RequestBodySchema = zod_1.z.object({
         userMeta: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
     });
     StartCabinetDialogCommand.ResponseSchema = zod_1.z.object({
         data: zod_1.z.object({
-            dialogId: zod_1.z.string().uuid(),
+            dialogId: zod_1.z.uuid(),
         }),
     });
 })(StartCabinetDialogCommand || (exports.StartCabinetDialogCommand = StartCabinetDialogCommand = {}));

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace StopCabinetStreamCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
-        dialogId: z.ZodString;
-        messageId: z.ZodString;
+        agentId: z.ZodUUID;
+        dialogId: z.ZodUUID;
+        messageId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{

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

@@ -5,9 +5,9 @@ const zod_1 = require("zod");
 var StopCabinetStreamCommand;
 (function (StopCabinetStreamCommand) {
     StopCabinetStreamCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
-        dialogId: zod_1.z.string().uuid(),
-        messageId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
+        dialogId: zod_1.z.uuid(),
+        messageId: zod_1.z.uuid(),
     });
     StopCabinetStreamCommand.ResponseSchema = zod_1.z.object({
         stopped: zod_1.z.boolean(),

package/build/commands/agents/agent-dialog/update-agent-dialog-status.command.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { DIALOG_STATUS } from '../../../constants/agents/enums';
 export declare namespace UpdateAgentDialogStatusCommand {
     const RequestParamsSchema: z.ZodObject<{
-        dialogId: z.ZodString;
+        dialogId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const RequestQuerySchema: z.ZodObject<{}, z.core.$strip>;
@@ -13,9 +13,9 @@ export declare namespace UpdateAgentDialogStatusCommand {
     type RequestBody = z.infer<typeof RequestBodySchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            id: z.ZodString;
-            agentId: z.ZodString;
-            userId: z.ZodOptional<z.ZodString>;
+            id: z.ZodUUID;
+            agentId: z.ZodUUID;
+            userId: z.ZodOptional<z.ZodUUID>;
             userName: z.ZodString;
             source: z.ZodOptional<z.ZodString>;
             utm_campaign: z.ZodOptional<z.ZodString>;
@@ -37,9 +37,9 @@ export declare namespace UpdateAgentDialogStatusCommand {
             updatedAt: z.ZodDate;
             messageCount: z.ZodOptional<z.ZodNumber>;
             lead: z.ZodOptional<z.ZodObject<{
-                id: z.ZodString;
-                dialogId: z.ZodString;
-                leadFormId: z.ZodString;
+                id: z.ZodUUID;
+                dialogId: z.ZodUUID;
+                leadFormId: z.ZodUUID;
                 data: z.ZodRecord<z.ZodString, z.ZodString>;
                 isDeleted: z.ZodBoolean;
                 createdAt: z.ZodDate;

package/build/commands/agents/agent-dialog/update-agent-dialog-status.command.js

@@ -7,11 +7,11 @@ const dialog_schema_1 = require("../../../models/agents/dialog.schema");
 var UpdateAgentDialogStatusCommand;
 (function (UpdateAgentDialogStatusCommand) {
     UpdateAgentDialogStatusCommand.RequestParamsSchema = zod_1.z.object({
-        dialogId: zod_1.z.string().uuid(),
+        dialogId: zod_1.z.uuid(),
     });
     UpdateAgentDialogStatusCommand.RequestQuerySchema = zod_1.z.object({});
     UpdateAgentDialogStatusCommand.RequestBodySchema = zod_1.z.object({
-        status: zod_1.z.nativeEnum(enums_1.DIALOG_STATUS),
+        status: zod_1.z.enum(enums_1.DIALOG_STATUS),
     });
     UpdateAgentDialogStatusCommand.ResponseSchema = zod_1.z.object({
         data: dialog_schema_1.DialogSchema,

package/build/commands/agents/agent-document/add-document-from-url.command.d.ts

@@ -2,22 +2,22 @@ import { z } from 'zod';
 import { AGENT_DOCUMENT_STATUS } from '../../../constants/agents/enums';
 export declare namespace AddDocumentFromUrlCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
+        agentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const RequestBodySchema: z.ZodObject<{
-        url: z.ZodString;
+        url: z.ZodURL;
     }, z.core.$strip>;
     type RequestBody = z.infer<typeof RequestBodySchema>;
     const ResponseDataSchema: z.ZodObject<{
-        documentId: z.ZodString;
+        documentId: z.ZodUUID;
         filename: z.ZodString;
         status: z.ZodEnum<typeof AGENT_DOCUMENT_STATUS>;
     }, z.core.$strip>;
     type ResponseData = z.infer<typeof ResponseDataSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            documentId: z.ZodString;
+            documentId: z.ZodUUID;
             filename: z.ZodString;
             status: z.ZodEnum<typeof AGENT_DOCUMENT_STATUS>;
         }, z.core.$strip>;

package/build/commands/agents/agent-document/add-document-from-url.command.js

@@ -6,15 +6,15 @@ const enums_1 = require("../../../constants/agents/enums");
 var AddDocumentFromUrlCommand;
 (function (AddDocumentFromUrlCommand) {
     AddDocumentFromUrlCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
     });
     AddDocumentFromUrlCommand.RequestBodySchema = zod_1.z.object({
-        url: zod_1.z.string().url(),
+        url: zod_1.z.url(),
     });
     AddDocumentFromUrlCommand.ResponseDataSchema = zod_1.z.object({
-        documentId: zod_1.z.string().uuid(),
+        documentId: zod_1.z.uuid(),
         filename: zod_1.z.string(),
-        status: zod_1.z.nativeEnum(enums_1.AGENT_DOCUMENT_STATUS),
+        status: zod_1.z.enum(enums_1.AGENT_DOCUMENT_STATUS),
     });
     AddDocumentFromUrlCommand.ResponseSchema = zod_1.z.object({
         data: AddDocumentFromUrlCommand.ResponseDataSchema,

package/build/commands/agents/agent-document/delete-agent-document.command.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace DeleteAgentDocumentCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
-        documentId: z.ZodString;
+        agentId: z.ZodUUID;
+        documentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/commands/agents/agent-document/delete-agent-document.command.js

@@ -5,8 +5,8 @@ const zod_1 = require("zod");
 var DeleteAgentDocumentCommand;
 (function (DeleteAgentDocumentCommand) {
     DeleteAgentDocumentCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
-        documentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
+        documentId: zod_1.z.uuid(),
     });
     DeleteAgentDocumentCommand.ResponseSchema = zod_1.z.object({
         success: zod_1.z.boolean(),

package/build/commands/agents/agent-document/find-agent-documents.command.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare namespace FindAgentDocumentsCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
+        agentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const RequestQuerySchema: z.ZodObject<{
@@ -12,14 +12,14 @@ export declare namespace FindAgentDocumentsCommand {
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
             data: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                agentId: z.ZodString;
+                id: z.ZodUUID;
+                agentId: z.ZodUUID;
                 filename: z.ZodString;
                 originalUrl: z.ZodOptional<z.ZodString>;
                 fileSize: z.ZodOptional<z.ZodNumber>;
                 contentType: z.ZodString;
                 status: z.ZodEnum<typeof import("../../..").AGENT_DOCUMENT_STATUS>;
-                sourceId: z.ZodOptional<z.ZodString>;
+                sourceId: z.ZodOptional<z.ZodUUID>;
                 chunksCount: z.ZodOptional<z.ZodNumber>;
                 isDeleted: z.ZodBoolean;
                 createdAt: z.ZodDate;

package/build/commands/agents/agent-document/find-agent-documents.command.js

@@ -6,7 +6,7 @@ const agent_document_find_result_schema_1 = require("../../../models/agents/agen
 var FindAgentDocumentsCommand;
 (function (FindAgentDocumentsCommand) {
     FindAgentDocumentsCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
     });
     FindAgentDocumentsCommand.RequestQuerySchema = zod_1.z.object({
         limit: zod_1.z.coerce.number().optional(),

package/build/commands/agents/agent-document/get-agent-document-by-id.command.d.ts

@@ -1,20 +1,20 @@
 import { z } from 'zod';
 export declare namespace GetAgentDocumentByIdCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
-        documentId: z.ZodString;
+        agentId: z.ZodUUID;
+        documentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            id: z.ZodString;
-            agentId: z.ZodString;
+            id: z.ZodUUID;
+            agentId: z.ZodUUID;
             filename: z.ZodString;
             originalUrl: z.ZodOptional<z.ZodString>;
             fileSize: z.ZodOptional<z.ZodNumber>;
             contentType: z.ZodString;
             status: z.ZodEnum<typeof import("../../..").AGENT_DOCUMENT_STATUS>;
-            sourceId: z.ZodOptional<z.ZodString>;
+            sourceId: z.ZodOptional<z.ZodUUID>;
             chunksCount: z.ZodOptional<z.ZodNumber>;
             isDeleted: z.ZodBoolean;
             createdAt: z.ZodDate;

package/build/commands/agents/agent-document/get-agent-document-by-id.command.js

@@ -6,8 +6,8 @@ const agent_document_schema_1 = require("../../../models/agents/agent-document.s
 var GetAgentDocumentByIdCommand;
 (function (GetAgentDocumentByIdCommand) {
     GetAgentDocumentByIdCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
-        documentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
+        documentId: zod_1.z.uuid(),
     });
     GetAgentDocumentByIdCommand.ResponseSchema = zod_1.z.object({
         data: agent_document_schema_1.AgentDocumentSchema,

package/build/commands/agents/agent-document/upload-agent-document.command.d.ts

@@ -2,18 +2,18 @@ import { z } from 'zod';
 import { AGENT_DOCUMENT_STATUS } from '../../../constants/agents/enums';
 export declare namespace UploadAgentDocumentCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
+        agentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseDataSchema: z.ZodObject<{
-        documentId: z.ZodString;
+        documentId: z.ZodUUID;
         filename: z.ZodString;
         status: z.ZodEnum<typeof AGENT_DOCUMENT_STATUS>;
     }, z.core.$strip>;
     type ResponseData = z.infer<typeof ResponseDataSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            documentId: z.ZodString;
+            documentId: z.ZodUUID;
             filename: z.ZodString;
             status: z.ZodEnum<typeof AGENT_DOCUMENT_STATUS>;
         }, z.core.$strip>;

package/build/commands/agents/agent-document/upload-agent-document.command.js

@@ -6,12 +6,12 @@ const enums_1 = require("../../../constants/agents/enums");
 var UploadAgentDocumentCommand;
 (function (UploadAgentDocumentCommand) {
     UploadAgentDocumentCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
     });
     UploadAgentDocumentCommand.ResponseDataSchema = zod_1.z.object({
-        documentId: zod_1.z.string().uuid(),
+        documentId: zod_1.z.uuid(),
         filename: zod_1.z.string(),
-        status: zod_1.z.nativeEnum(enums_1.AGENT_DOCUMENT_STATUS),
+        status: zod_1.z.enum(enums_1.AGENT_DOCUMENT_STATUS),
     });
     UploadAgentDocumentCommand.ResponseSchema = zod_1.z.object({
         data: UploadAgentDocumentCommand.ResponseDataSchema,

package/build/commands/agents/agent-files/upload-agent-chat-file.command.d.ts

@@ -1,15 +1,15 @@
 import { z } from 'zod';
 export declare namespace UploadAgentChatFileCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
+        agentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const RequestBodySchema: z.ZodObject<{
-        dialogId: z.ZodOptional<z.ZodString>;
+        dialogId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     type RequestBody = z.infer<typeof RequestBodySchema>;
     const ResponseDataSchema: z.ZodObject<{
-        fileId: z.ZodString;
+        fileId: z.ZodUUID;
         url: z.ZodString;
         mimeType: z.ZodString;
         type: z.ZodEnum<{
@@ -26,7 +26,7 @@ export declare namespace UploadAgentChatFileCommand {
     type ResponseData = z.infer<typeof ResponseDataSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            fileId: z.ZodString;
+            fileId: z.ZodUUID;
             url: z.ZodString;
             mimeType: z.ZodString;
             type: z.ZodEnum<{

package/build/commands/agents/agent-files/upload-agent-chat-file.command.js

@@ -6,13 +6,13 @@ const message_attachment_schema_1 = require("../../../models/agents/message-atta
 var UploadAgentChatFileCommand;
 (function (UploadAgentChatFileCommand) {
     UploadAgentChatFileCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
     });
     UploadAgentChatFileCommand.RequestBodySchema = zod_1.z.object({
-        dialogId: zod_1.z.string().uuid().optional(),
+        dialogId: zod_1.z.uuid().optional(),
     });
     UploadAgentChatFileCommand.ResponseDataSchema = zod_1.z.object({
-        fileId: zod_1.z.string().uuid(),
+        fileId: zod_1.z.uuid(),
         url: zod_1.z.string(),
         mimeType: zod_1.z.string(),
         type: message_attachment_schema_1.MessageAttachmentTypeEnum,

package/build/commands/agents/agent-lead/create-agent-lead.command.d.ts

@@ -2,15 +2,15 @@ import { z } from 'zod';
 export declare namespace CreateAgentLeadCommand {
     const RequestBodySchema: z.ZodObject<{
         data: z.ZodRecord<z.ZodString, z.ZodString>;
-        dialogId: z.ZodString;
-        leadFormId: z.ZodString;
+        dialogId: z.ZodUUID;
+        leadFormId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestBody = z.infer<typeof RequestBodySchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            id: z.ZodString;
-            dialogId: z.ZodString;
-            leadFormId: z.ZodString;
+            id: z.ZodUUID;
+            dialogId: z.ZodUUID;
+            leadFormId: z.ZodUUID;
             data: z.ZodRecord<z.ZodString, z.ZodString>;
             isDeleted: z.ZodBoolean;
             createdAt: z.ZodDate;

package/build/commands/agents/agent-lead/create-agent-lead.command.js

@@ -7,8 +7,8 @@ var CreateAgentLeadCommand;
 (function (CreateAgentLeadCommand) {
     CreateAgentLeadCommand.RequestBodySchema = zod_1.z.object({
         data: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
-        dialogId: zod_1.z.string().uuid(),
-        leadFormId: zod_1.z.string().uuid(),
+        dialogId: zod_1.z.uuid(),
+        leadFormId: zod_1.z.uuid(),
     });
     CreateAgentLeadCommand.ResponseSchema = zod_1.z.object({
         data: agent_lead_schema_1.AgentLeadSchema,

package/build/commands/agents/agent-lead/delete-agent-lead.command.d.ts

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

package/build/commands/agents/agent-lead/delete-agent-lead.command.js

@@ -5,7 +5,7 @@ const zod_1 = require("zod");
 var DeleteAgentLeadCommand;
 (function (DeleteAgentLeadCommand) {
     DeleteAgentLeadCommand.RequestParamsSchema = zod_1.z.object({
-        id: zod_1.z.string().uuid(),
+        id: zod_1.z.uuid(),
     });
     DeleteAgentLeadCommand.ResponseSchema = zod_1.z.object({
         success: zod_1.z.boolean(),

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

@@ -1,14 +1,14 @@
 import { z } from 'zod';
 export declare namespace FindAgentLeadsCommand {
     const RequestQuerySchema: z.ZodObject<{
-        dialogId: z.ZodOptional<z.ZodString>;
+        dialogId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     type RequestQuery = z.infer<typeof RequestQuerySchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            dialogId: z.ZodString;
-            leadFormId: z.ZodString;
+            id: z.ZodUUID;
+            dialogId: z.ZodUUID;
+            leadFormId: z.ZodUUID;
             data: z.ZodRecord<z.ZodString, z.ZodString>;
             isDeleted: z.ZodBoolean;
             createdAt: z.ZodDate;

package/build/commands/agents/agent-lead/find-agent-leads.command.js

@@ -6,7 +6,7 @@ const agent_lead_schema_1 = require("../../../models/agents/agent-lead.schema");
 var FindAgentLeadsCommand;
 (function (FindAgentLeadsCommand) {
     FindAgentLeadsCommand.RequestQuerySchema = zod_1.z.object({
-        dialogId: zod_1.z.string().uuid().optional(),
+        dialogId: zod_1.z.uuid().optional(),
     });
     FindAgentLeadsCommand.ResponseSchema = zod_1.z.object({
         data: zod_1.z.array(agent_lead_schema_1.AgentLeadSchema),

package/build/commands/agents/agent-lead/get-agent-lead-by-id.command.d.ts

@@ -1,14 +1,14 @@
 import { z } from 'zod';
 export declare namespace GetAgentLeadByIdCommand {
     const RequestParamsSchema: z.ZodObject<{
-        id: z.ZodString;
+        id: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            id: z.ZodString;
-            dialogId: z.ZodString;
-            leadFormId: z.ZodString;
+            id: z.ZodUUID;
+            dialogId: z.ZodUUID;
+            leadFormId: z.ZodUUID;
             data: z.ZodRecord<z.ZodString, z.ZodString>;
             isDeleted: z.ZodBoolean;
             createdAt: z.ZodDate;

package/build/commands/agents/agent-lead/get-agent-lead-by-id.command.js

@@ -6,7 +6,7 @@ const agent_lead_schema_1 = require("../../../models/agents/agent-lead.schema");
 var GetAgentLeadByIdCommand;
 (function (GetAgentLeadByIdCommand) {
     GetAgentLeadByIdCommand.RequestParamsSchema = zod_1.z.object({
-        id: zod_1.z.string().uuid(),
+        id: zod_1.z.uuid(),
     });
     GetAgentLeadByIdCommand.ResponseSchema = zod_1.z.object({
         data: agent_lead_schema_1.AgentLeadSchema,

package/build/commands/agents/agent-lead/update-agent-lead.command.d.ts

@@ -1,20 +1,20 @@
 import { z } from 'zod';
 export declare namespace UpdateAgentLeadCommand {
     const RequestParamsSchema: z.ZodObject<{
-        id: z.ZodString;
+        id: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const RequestBodySchema: z.ZodObject<{
         data: z.ZodRecord<z.ZodString, z.ZodString>;
-        dialogId: z.ZodString;
-        leadFormId: z.ZodString;
+        dialogId: z.ZodUUID;
+        leadFormId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestBody = z.infer<typeof RequestBodySchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            id: z.ZodString;
-            dialogId: z.ZodString;
-            leadFormId: z.ZodString;
+            id: z.ZodUUID;
+            dialogId: z.ZodUUID;
+            leadFormId: z.ZodUUID;
             data: z.ZodRecord<z.ZodString, z.ZodString>;
             isDeleted: z.ZodBoolean;
             createdAt: z.ZodDate;

package/build/commands/agents/agent-lead/update-agent-lead.command.js

@@ -6,12 +6,12 @@ const agent_lead_schema_1 = require("../../../models/agents/agent-lead.schema");
 var UpdateAgentLeadCommand;
 (function (UpdateAgentLeadCommand) {
     UpdateAgentLeadCommand.RequestParamsSchema = zod_1.z.object({
-        id: zod_1.z.string().uuid(),
+        id: zod_1.z.uuid(),
     });
     UpdateAgentLeadCommand.RequestBodySchema = zod_1.z.object({
         data: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
-        dialogId: zod_1.z.string().uuid(),
-        leadFormId: zod_1.z.string().uuid(),
+        dialogId: zod_1.z.uuid(),
+        leadFormId: zod_1.z.uuid(),
     });
     UpdateAgentLeadCommand.ResponseSchema = zod_1.z.object({
         data: agent_lead_schema_1.AgentLeadSchema,

package/build/commands/agents/agent-lead-form/delete-agent-lead-form.command.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace DeleteAgentLeadFormCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
-        id: z.ZodString;
+        agentId: z.ZodUUID;
+        id: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/commands/agents/agent-lead-form/delete-agent-lead-form.command.js

@@ -5,8 +5,8 @@ const zod_1 = require("zod");
 var DeleteAgentLeadFormCommand;
 (function (DeleteAgentLeadFormCommand) {
     DeleteAgentLeadFormCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
-        id: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
+        id: zod_1.z.uuid(),
     });
     DeleteAgentLeadFormCommand.ResponseSchema = zod_1.z.object({
         success: zod_1.z.boolean(),

package/build/commands/agents/agent-lead-form/find-agent-lead-forms.command.d.ts

@@ -1,15 +1,15 @@
 import { z } from 'zod';
 export declare namespace FindAgentLeadFormsCommand {
     const RequestQuerySchema: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodUUID>;
         limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
         offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     }, z.core.$strip>;
     type RequestQuery = z.infer<typeof RequestQuerySchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            agentId: z.ZodString;
+            id: z.ZodUUID;
+            agentId: z.ZodUUID;
             fields: z.ZodArray<z.ZodObject<{
                 key: z.ZodString;
                 name: z.ZodString;

package/build/commands/agents/agent-lead-form/find-agent-lead-forms.command.js

@@ -6,7 +6,7 @@ const agent_lead_form_schema_1 = require("../../../models/agents/agent-lead-form
 var FindAgentLeadFormsCommand;
 (function (FindAgentLeadFormsCommand) {
     FindAgentLeadFormsCommand.RequestQuerySchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid().optional(),
+        agentId: zod_1.z.uuid().optional(),
         limit: zod_1.z.coerce.number().optional(),
         offset: zod_1.z.coerce.number().optional(),
     });

package/build/commands/agents/agent-lead-form/get-agent-lead-form-by-agent.command.d.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 export declare namespace GetAgentLeadFormByAgentCommand {
     const RequestParamsSchema: z.ZodObject<{
-        agentId: z.ZodString;
+        agentId: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            agentId: z.ZodString;
+            id: z.ZodUUID;
+            agentId: z.ZodUUID;
             fields: z.ZodArray<z.ZodObject<{
                 key: z.ZodString;
                 name: z.ZodString;

package/build/commands/agents/agent-lead-form/get-agent-lead-form-by-agent.command.js

@@ -6,7 +6,7 @@ const agent_lead_form_schema_1 = require("../../../models/agents/agent-lead-form
 var GetAgentLeadFormByAgentCommand;
 (function (GetAgentLeadFormByAgentCommand) {
     GetAgentLeadFormByAgentCommand.RequestParamsSchema = zod_1.z.object({
-        agentId: zod_1.z.string().uuid(),
+        agentId: zod_1.z.uuid(),
     });
     GetAgentLeadFormByAgentCommand.ResponseSchema = zod_1.z.object({
         data: agent_lead_form_schema_1.AgentLeadFormSchema.nullable(),

package/build/commands/agents/agent-lead-form/get-agent-lead-form-by-id.command.d.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 export declare namespace GetAgentLeadFormByIdCommand {
     const RequestParamsSchema: z.ZodObject<{
-        id: z.ZodString;
+        id: z.ZodUUID;
     }, z.core.$strip>;
     type RequestParams = z.infer<typeof RequestParamsSchema>;
     const ResponseSchema: z.ZodObject<{
         data: z.ZodObject<{
-            id: z.ZodString;
-            agentId: z.ZodString;
+            id: z.ZodUUID;
+            agentId: z.ZodUUID;
             fields: z.ZodArray<z.ZodObject<{
                 key: z.ZodString;
                 name: z.ZodString;

package/build/commands/agents/agent-lead-form/get-agent-lead-form-by-id.command.js

@@ -6,7 +6,7 @@ const agent_lead_form_schema_1 = require("../../../models/agents/agent-lead-form
 var GetAgentLeadFormByIdCommand;
 (function (GetAgentLeadFormByIdCommand) {
     GetAgentLeadFormByIdCommand.RequestParamsSchema = zod_1.z.object({
-        id: zod_1.z.string().uuid(),
+        id: zod_1.z.uuid(),
     });
     GetAgentLeadFormByIdCommand.ResponseSchema = zod_1.z.object({
         data: agent_lead_form_schema_1.AgentLeadFormSchema,