@purpleschool/gptbot 0.13.4 → 0.13.6

package/commands/agents/agent-template/find-agent-template-catalog.command.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { AgentTemplateCatalogSchema } from '../../../models/agents/agent-template-catalog.schema';
+
+export namespace FindAgentTemplateCatalogCommand {
+    export const ResponseSchema = z.object({
+        data: AgentTemplateCatalogSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/find-agent-template-categories.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { AgentTemplateCategorySchema } from '../../../models/agents/agent-template-category.schema';
+
+export namespace FindAgentTemplateCategoriesCommand {
+    export const RequestQuerySchema = z.object({
+        id: z.string().uuid().optional(),
+        slug: z.string().optional(),
+        name: z.string().optional(),
+        isActive: z.coerce.boolean().optional(),
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentTemplateCategorySchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/find-agent-template-instructions.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { AgentTemplateInstructionSchema } from '../../../models/agents/agent-template-instruction.schema';
+
+export namespace FindAgentTemplateInstructionsCommand {
+    export const RequestParamsSchema = z.object({
+        templateId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestQuerySchema = z.object({
+        title: z.string().optional(),
+        isActive: z.coerce.boolean().optional(),
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentTemplateInstructionSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/find-agent-templates.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { AgentTemplateSchema } from '../../../models/agents/agent-template.schema';
+
+export namespace FindAgentTemplatesCommand {
+    export const RequestQuerySchema = z.object({
+        id: z.string().uuid().optional(),
+        categoryId: z.string().uuid().optional(),
+        name: z.string().optional(),
+        isActive: z.coerce.boolean().optional(),
+        limit: z.coerce.number().optional(),
+        offset: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentTemplateSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,13 @@
+export * from './create-agent-template-category.command';
+export * from './create-agent-template-instruction.command';
+export * from './create-agent-template.command';
+export * from './delete-agent-template-category.command';
+export * from './delete-agent-template-instruction.command';
+export * from './delete-agent-template.command';
+export * from './find-agent-template-catalog.command';
+export * from './find-agent-template-categories.command';
+export * from './find-agent-template-instructions.command';
+export * from './find-agent-templates.command';
+export * from './update-agent-template-category.command';
+export * from './update-agent-template-instruction.command';
+export * from './update-agent-template.command';

package/commands/agents/agent-template/update-agent-template-category.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { AgentTemplateCategorySchema } from '../../../models/agents/agent-template-category.schema';
+
+export namespace UpdateAgentTemplateCategoryCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        slug: z.string().optional(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        order: z.number().optional(),
+        isActive: z.boolean().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentTemplateCategorySchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/update-agent-template-instruction.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { AgentTemplateInstructionSchema } from '../../../models/agents/agent-template-instruction.schema';
+
+export namespace UpdateAgentTemplateInstructionCommand {
+    export const RequestParamsSchema = z.object({
+        templateId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        title: z.string().optional(),
+        description: z.string().optional(),
+        prompt: z.string().optional(),
+        order: z.number().optional(),
+        isActive: z.boolean().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentTemplateInstructionSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-template/update-agent-template.command.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../../constants/agents/enums/agent-interaction-mode.enum';
+import { AgentTemplateSchema } from '../../../models/agents/agent-template.schema';
+
+export namespace UpdateAgentTemplateCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        categoryId: z.string().uuid().optional(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        iconUrl: z.string().nullable().optional(),
+        systemPrompt: z.string().nullable().optional(),
+        interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE).optional(),
+        order: z.number().optional(),
+        isActive: z.boolean().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentTemplateSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-tool/connect-agent-tool.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { AGENT_TOOL_TYPE } from '../../../constants/agents/enums';
+import { AgentToolCredentialsSchema } from '../../../models/agents/agent-tool-credentials.schema';
+import { AgentToolSchema } from '../../../models/agents/agent-tool.schema';
+
+export namespace ConnectAgentToolCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        toolType: z.nativeEnum(AGENT_TOOL_TYPE),
+        credentials: AgentToolCredentialsSchema.nullable().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentToolSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-tool/disconnect-agent-tool.command.ts

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

package/commands/agents/agent-tool/find-agent-tools-catalog.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { AGENT_TOOL_TYPE } from '../../../constants/agents/enums';
+import { AgentToolCatalogSchema } from '../../../models/agents/agent-tool-catalog.schema';
+
+export namespace FindAgentToolsCatalogCommand {
+    export const RequestQuerySchema = z.object({
+        type: z.nativeEnum(AGENT_TOOL_TYPE).optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentToolCatalogSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agent-tool/find-agent-tools.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentToolSchema } from '../../../models/agents/agent-tool.schema';
+
+export namespace FindAgentToolsCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentToolSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,5 @@
+export * from './find-agent-tools-catalog.command';
+export * from './find-agent-tools.command';
+export * from './connect-agent-tool.command';
+export * from './update-agent-tool.command';
+export * from './disconnect-agent-tool.command';

package/commands/agents/agent-tool/update-agent-tool.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { AGENT_TOOL_STATUS } from '../../../constants/agents/enums';
+import { AgentToolCredentialsSchema } from '../../../models/agents/agent-tool-credentials.schema';
+import { AgentToolSchema } from '../../../models/agents/agent-tool.schema';
+
+export namespace UpdateAgentToolCommand {
+    export const RequestParamsSchema = z.object({
+        agentId: z.string().uuid(),
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        credentials: AgentToolCredentialsSchema.nullable().optional(),
+        status: z.nativeEnum(AGENT_TOOL_STATUS).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentToolSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agents/create-agent.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../../constants/agents/enums/agent-interaction-mode.enum';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace CreateAgentCommand {
+    export const RequestBodySchema = z.object({
+        templateId: z.string().uuid().nullable().optional(),
+        name: z.string(),
+        icon: z.string().nullable().optional(),
+        avatar: z.string().nullable().optional(),
+        greetingPhrase: z.string().nullable().optional(),
+        instructions: z.string().nullable().optional(),
+        aiModelId: z.string().uuid(),
+        interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE).optional(),
+        isHumanHelp: z.boolean().optional(),
+        useDocuments: z.boolean().optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agents/delete-agent.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace DeleteAgentCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        success: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agents/find-agents.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace FindAgentsCommand {
+    export const RequestQuerySchema = z.object({
+        id: z.string().uuid().optional(),
+        name: z.string().optional(),
+        isHumanHelp: z.coerce.boolean().optional(),
+        page: z.coerce.number().optional(),
+        limit: z.coerce.number().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(AgentSchema),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace GetAgentByIdCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agents/get-agent-public-info.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+export const AgentPublicInfoSchema = z.object({
+    greetingPhrase: z.string().nullable(),
+    activity: z.boolean(),
+    icon: z.string().nullable(),
+    avatar: z.string().nullable(),
+});
+
+export type AgentPublicInfo = z.infer<typeof AgentPublicInfoSchema>;
+
+export namespace GetAgentPublicInfoCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentPublicInfoSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/agents/index.ts

@@ -0,0 +1,6 @@
+export * from './create-agent.command';
+export * from './delete-agent.command';
+export * from './find-agents.command';
+export * from './get-agent-by-id.command';
+export * from './get-agent-public-info.command';
+export * from './update-agent.command';

package/commands/agents/agents/update-agent.command.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { AGENT_INTERACTION_MODE } from '../../../constants/agents/enums/agent-interaction-mode.enum';
+import { AGENT_STATUS } from '../../../constants/agents/enums/agent-status.enum';
+import { AgentSchema } from '../../../models/agents/agent.schema';
+
+export namespace UpdateAgentCommand {
+    export const RequestParamsSchema = z.object({
+        id: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        templateId: z.string().uuid().nullable().optional(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        icon: z.string().nullable().optional(),
+        avatar: z.string().nullable().optional(),
+        greetingPhrase: z.string().nullable().optional(),
+        instructions: z.string().nullable().optional(),
+        aiModelId: z.string().uuid().optional(),
+        isHumanHelp: z.boolean().optional(),
+        useDocuments: z.boolean().optional(),
+        interactionMode: z.nativeEnum(AGENT_INTERACTION_MODE).optional(),
+        status: z.nativeEnum(AGENT_STATUS).optional(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: AgentSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/agents/index.ts

@@ -0,0 +1,9 @@
+export * from './agent-ai-model';
+export * from './agent-channel';
+export * from './agent-dialog';
+export * from './agent-lead-form';
+export * from './agent-lead';
+export * from './agent-tool';
+export * from './agent-document';
+export * from './agent-template';
+export * from './agents';

package/commands/index.ts

@@ -1,4 +1,5 @@
 export * from './account-merge';
+export * from './agents';
 export * from './ai-model';
 export * from './ai-vendor';
 export * from './auth';
@@ -24,6 +25,7 @@ export * from './product';
 export * from './question';
 export * from './referral';
 export * from './subscription';
+export * from './support-feedback';
 export * from './task';
 export * from './telegram';
 export * from './telegram-auth';

package/commands/support-feedback/check-support-feedback.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { SupportFeedbackSchema } from '../../models';
+
+export namespace CheckSupportFeedbackCommand {
+    export const RequestQuerySchema = z.object({
+        supportDialogId: z.string().min(1),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            hasFeedback: z.boolean(),
+            feedback: SupportFeedbackSchema.pick({
+                uuid: true,
+                supportDialogId: true,
+                rating: true,
+                comment: true,
+                createdAt: true,
+                updatedAt: true,
+            }).nullable(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/support-feedback/index.ts

@@ -0,0 +1,2 @@
+export * from './check-support-feedback.command';
+export * from './upsert-support-feedback.command';

package/commands/support-feedback/upsert-support-feedback.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { SupportFeedbackSchema } from '../../models';
+
+export namespace UpsertSupportFeedbackCommand {
+    export const RequestSchema = SupportFeedbackSchema.pick({
+        supportDialogId: true,
+        rating: true,
+        comment: true,
+    }).partial({
+        comment: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SupportFeedbackSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/agents/enums/agent-channel-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_CHANNEL_STATUS {
+    ACTIVE = 'active',
+    ERROR = 'error',
+    PENDING = 'pending',
+}

package/constants/agents/enums/agent-channel-type.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_CHANNEL_TYPE {
+    TELEGRAM = 'telegram',
+    WEB = 'web',
+    AVITO = 'avito',
+}

package/constants/agents/enums/agent-document-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_DOCUMENT_STATUS {
+    INDEXING = 'indexing',
+    UPLOADED = 'uploaded',
+    ERROR = 'error',
+}

package/constants/agents/enums/agent-interaction-mode.enum.ts

@@ -0,0 +1,4 @@
+export enum AGENT_INTERACTION_MODE {
+    EXTERNAL_ONLY = 'external_only',
+    INTERNAL_ONLY = 'internal_only',
+}

package/constants/agents/enums/agent-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_STATUS {
+    ACTIVE = 'active',
+    STOPPED = 'stopped',
+    DRAFT = 'draft',
+}

package/constants/agents/enums/agent-tool-status.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_TOOL_STATUS {
+    ACTIVE = 'active',
+    DISABLED = 'disabled',
+    ERROR = 'error',
+}

package/constants/agents/enums/agent-tool-type.enum.ts

@@ -0,0 +1,5 @@
+export enum AGENT_TOOL_TYPE {
+    BITRIX_LEAD = 'BITRIX_LEAD',
+    AMO_LEAD = 'AMO_LEAD',
+    EMAIL_LEAD = 'EMAIL_LEAD',
+}

package/constants/agents/enums/dialog-status.enum.ts

@@ -0,0 +1,7 @@
+export enum DIALOG_STATUS {
+    IN_PROGRESS = 'inProgress',
+    TRANSFERRED_TO_HUMAN = 'transferredToHuman',
+    GATHERED_LEAD = 'gatheredLead',
+    BANNED = 'banned',
+    CLOSED = 'closed',
+}

package/constants/agents/enums/index.ts

@@ -0,0 +1,8 @@
+export * from './agent-channel-status.enum';
+export * from './agent-channel-type.enum';
+export * from './agent-interaction-mode.enum';
+export * from './agent-status.enum';
+export * from './agent-tool-type.enum';
+export * from './agent-tool-status.enum';
+export * from './agent-document-status.enum';
+export * from './dialog-status.enum';

package/constants/agents/index.ts

@@ -0,0 +1 @@
+export * from './enums';

package/constants/index.ts

@@ -1,4 +1,5 @@
 export * from './ai-model';
+export * from './agents';
 export * from './blog';
 export * from './billing';
 export * from './category';

package/models/agents/agent-ai-model.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const AgentAiModelSchema = z.object({
+    id: z.string().uuid(),
+    model: z.string(),
+    name: z.string(),
+    icon: z.string().nullable(),
+    isActive: z.boolean(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentAiModel = z.infer<typeof AgentAiModelSchema>;

package/models/agents/agent-channel-credentials.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { AGENT_CHANNEL_TYPE } from '../../constants/agents/enums';
+
+export const TelegramChannelCredentialsSchema = z.object({
+    type: z.literal(AGENT_CHANNEL_TYPE.TELEGRAM),
+    token: z.string().min(1),
+});
+
+export type TelegramChannelCredentials = z.infer<typeof TelegramChannelCredentialsSchema>;
+
+export const WebChannelCredentialsSchema = z.object({
+    type: z.literal(AGENT_CHANNEL_TYPE.WEB),
+    domain: z.string().url().optional(),
+});
+
+export type WebChannelCredentials = z.infer<typeof WebChannelCredentialsSchema>;
+
+export const AvitoChannelCredentialsSchema = z.object({
+    type: z.literal(AGENT_CHANNEL_TYPE.AVITO),
+    clientId: z.string().min(1),
+    clientSecret: z.string().min(1),
+});
+
+export type AvitoChannelCredentials = z.infer<typeof AvitoChannelCredentialsSchema>;
+
+export const AgentChannelCredentialsSchema = z.discriminatedUnion('type', [
+    TelegramChannelCredentialsSchema,
+    WebChannelCredentialsSchema,
+    AvitoChannelCredentialsSchema,
+]);
+
+export type AgentChannelCredentials = z.infer<typeof AgentChannelCredentialsSchema>;

package/models/agents/agent-channel.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { AGENT_CHANNEL_STATUS, AGENT_CHANNEL_TYPE } from '../../constants/agents/enums';
+import { AgentChannelCredentialsSchema } from './agent-channel-credentials.schema';
+
+export const AgentChannelSchema = z.object({
+    id: z.string().uuid(),
+    agentId: z.string().uuid(),
+    channelType: z.nativeEnum(AGENT_CHANNEL_TYPE),
+    status: z.nativeEnum(AGENT_CHANNEL_STATUS),
+    credentials: AgentChannelCredentialsSchema,
+    lastCheckedAt: z.date().nullable(),
+    lastError: z.string().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentChannel = z.infer<typeof AgentChannelSchema>;

package/models/agents/agent-dialog-lead.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const AgentDialogLeadSchema = z.object({
+    id: z.string().uuid(),
+    dialogId: z.string().uuid(),
+    leadFormId: z.string().uuid(),
+    data: z.record(z.string(), z.string()),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type AgentDialogLead = z.infer<typeof AgentDialogLeadSchema>;