@kl1/contracts 1.3.33 → 1.3.35

package/dist/index.js

@@ -57,6 +57,7 @@ __export(index_exports, {
   cxLogContract: () => cxLogContract,
   dashboardContract: () => dashboardContract,
   evaluateFormContract: () => evaluateFormContract,
+  exportContract: () => exportContract,
   extensionContract: () => extensionContract2,
   facebookFeedContract: () => facebookFeedContract2,
   feedPostContract: () => feedPostContract,
@@ -99,6 +100,7 @@ __export(index_exports, {
   userContract: () => userContract,
   userNotificationContract: () => userNotificationContract,
   userPresenceStatusLogContract: () => userPresenceStatusLogContract,
+  widgetContract: () => widgetContract,
   widgetSettingContract: () => widgetSettingContract,
   workflowContract: () => workflowContract,
   wrapUpFormContract: () => wrapUpFormContract
@@ -300,6 +302,10 @@ var ChannelMetadataSchema = import_zod6.default.object({
     apiKey: import_zod6.default.string(),
     apiSecret: import_zod6.default.string()
   }).optional(),
+  line: import_zod6.default.object({
+    channelId: import_zod6.default.string(),
+    channelSecret: import_zod6.default.string()
+  }).optional(),
   lineRichMenuId: import_zod6.default.string().optional().nullable(),
   messengerIntegrationType: import_zod6.default.union([import_zod6.default.literal("own"), import_zod6.default.literal("business")]).optional(),
   facebookFeedIntegrationType: import_zod6.default.union([import_zod6.default.literal("own"), import_zod6.default.literal("business")]).optional(),
@@ -716,56 +722,57 @@ var WorkflowRuleSchema = DefaultEntitySchema.extend({
 });
 
 // src/chat/schema.ts
-var MessageDirectionTypeSchema = import_zod18.default.enum([
-  "incoming",
-  "outgoing",
-  "system"
+var MessageDirectionTypeSchema = import_zod18.default.union([
+  import_zod18.default.literal("incoming"),
+  import_zod18.default.literal("outgoing"),
+  import_zod18.default.literal("system")
 ]);
 var WorkflowAutoReplyMessageTypeSchema = import_zod18.default.enum(["text", "image"]).default("text");
-var MessageTypeSchema = import_zod18.default.enum([
-  "text",
-  "image",
-  "video",
-  "audio",
-  "file",
-  "imagemap",
-  "group",
-  "fallback",
-  "location",
-  "sticker",
+var messageTypes = [
+  import_zod18.default.literal("text"),
+  import_zod18.default.literal("image"),
+  import_zod18.default.literal("video"),
+  import_zod18.default.literal("audio"),
+  import_zod18.default.literal("file"),
+  import_zod18.default.literal("imagemap"),
+  import_zod18.default.literal("group"),
+  import_zod18.default.literal("fallback"),
+  import_zod18.default.literal("location"),
+  import_zod18.default.literal("sticker"),
   // botpress specific
-  "carousel",
-  "card",
-  "choice",
-  "dropdown",
-  "text_with_image",
-  "reaction",
-  "contacts",
-  // botpress specific
-  "carousel",
-  "card",
-  "choice",
-  "dropdown",
-  // messenger referral
-  "referral",
+  import_zod18.default.literal("carousel"),
+  import_zod18.default.literal("card"),
+  import_zod18.default.literal("choice"),
+  import_zod18.default.literal("dropdown"),
+  import_zod18.default.literal("text_with_image"),
+  import_zod18.default.literal("reaction"),
+  import_zod18.default.literal("contacts"),
   // system
-  "csat",
-  "assign",
-  "solve",
-  "resolved",
-  "reopen",
-  "open",
-  "closed",
-  "handed_over",
-  "updated",
-  "started",
-  "hold",
-  "unhold",
-  "auto_unhold",
-  "edited",
-  "deleted",
-  "unsupported"
-]);
+  import_zod18.default.literal("csat"),
+  import_zod18.default.literal("assign"),
+  import_zod18.default.literal("solve"),
+  import_zod18.default.literal("resolved"),
+  import_zod18.default.literal("reopen"),
+  import_zod18.default.literal("open"),
+  import_zod18.default.literal("closed"),
+  import_zod18.default.literal("handed_over"),
+  import_zod18.default.literal("updated"),
+  import_zod18.default.literal("started"),
+  import_zod18.default.literal("hold"),
+  import_zod18.default.literal("unhold"),
+  import_zod18.default.literal("auto_unhold"),
+  import_zod18.default.literal("edited"),
+  import_zod18.default.literal("deleted"),
+  import_zod18.default.literal("unsupported"),
+  // lazada specific
+  import_zod18.default.literal("lazada_item"),
+  import_zod18.default.literal("lazada_sys_msg"),
+  import_zod18.default.literal("lazada_order"),
+  import_zod18.default.literal("lazada_order_invite"),
+  import_zod18.default.literal("lazada_shop_invite"),
+  import_zod18.default.literal("lazada_voucher")
+];
+var MessageTypeSchema = import_zod18.default.union(messageTypes);
 var FeedPostTypeSchema = import_zod18.default.enum([
   "text",
   "added_photos",
@@ -1293,7 +1300,8 @@ var CxLogSchemaWithRelations = DefaultEntitySchema.extend({
     summary: import_zod25.default.string(),
     usage: import_zod25.default.number(),
     usageUnit: import_zod25.default.string()
-  })
+  }),
+  uid: import_zod25.default.string()
 });
 
 // src/chat/validation.ts
@@ -1338,7 +1346,9 @@ var MessageAttachmentSchema = import_zod26.default.object({
   fileSize: import_zod26.default.number(),
   url: import_zod26.default.string().nullable(),
   fileType: import_zod26.default.string(),
-  thumbnailUrl: import_zod26.default.string().optional()
+  thumbnailUrl: import_zod26.default.string().optional(),
+  width: import_zod26.default.string().optional(),
+  height: import_zod26.default.string().optional()
 });
 var StickerSchema = import_zod26.default.object({
   packageId: import_zod26.default.number(),
@@ -2274,7 +2284,8 @@ var ConnectWebChatSchema = import_zod37.default.object({
   })
 });
 var GetChannelSchema = import_zod37.default.object({
-  withDeleted: import_zod37.default.coerce.boolean().default(false)
+  withDeleted: import_zod37.default.coerce.boolean().default(false),
+  withRelations: import_zod37.default.coerce.boolean().default(true).optional()
 });
 var ConnectBotSchema = import_zod37.default.object({
   botId: import_zod37.default.string().uuid()
@@ -2297,6 +2308,10 @@ var ConnectWhatsappSchema = import_zod37.default.object({
   metadata: ChannelMetadataSchema,
   platformId: import_zod37.default.string()
 });
+var ConnectLazadaSchema = import_zod37.default.object({
+  name: import_zod37.default.string(),
+  code: import_zod37.default.string()
+});
 
 // src/instagram/validation.ts
 var import_zod38 = __toESM(require("zod"));
@@ -2616,11 +2631,30 @@ var whatsapp = (0, import_core7.initContract)().router(
     pathPrefix: "whatsapp"
   }
 );
+var lazada = (0, import_core7.initContract)().router(
+  {
+    connect: {
+      method: "POST",
+      path: "/connect",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          channel: ChannelSchema
+        }),
+        408: DefaultErrorResponseSchema
+      },
+      body: ConnectLazadaSchema,
+      summary: "Connect message channel"
+    }
+  },
+  {
+    pathPrefix: "lazada"
+  }
+);
 var channelContract = (0, import_core7.initContract)().router(
   {
     getChannels: {
       method: "GET",
-      path: "/channel",
+      path: "channel",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           data: ChannelSchema.array()
@@ -2733,7 +2767,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     updateChannelCsatPreference: {
       method: "POST",
-      path: "/csat/:channelId",
+      path: "csat/:channelId",
       pathParams: import_zod41.default.object({
         channelId: import_zod41.default.string().uuid()
       }),
@@ -2754,7 +2788,8 @@ var channelContract = (0, import_core7.initContract)().router(
     viber,
     telegram,
     webchat,
-    whatsapp
+    whatsapp,
+    lazada
   },
   {
     baseHeaders: DefaultHeaderSchema
@@ -2790,28 +2825,33 @@ var channelFacebookFeedContract = (0, import_core7.initContract)().router(
     pathPrefix: "ms/facebook-feed"
   }
 );
-var channelBotContract = (0, import_core7.initContract)().router({
-  connectBot: {
-    method: "POST",
-    path: "/connect-bot/:channelId",
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({ channel: ChannelSchema }),
-      400: DefaultErrorResponseSchema,
-      500: DefaultErrorResponseSchema
+var channelBotContract = (0, import_core7.initContract)().router(
+  {
+    connectBot: {
+      method: "POST",
+      path: "/connect-bot/:channelId",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({ channel: ChannelSchema }),
+        400: DefaultErrorResponseSchema,
+        500: DefaultErrorResponseSchema
+      },
+      body: ConnectBotSchema
     },
-    body: ConnectBotSchema
+    disconnectBot: {
+      method: "POST",
+      path: "/disconnect-bot/:channelId",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({ channel: ChannelSchema }),
+        400: DefaultErrorResponseSchema,
+        500: DefaultErrorResponseSchema
+      },
+      body: import_zod41.default.object({})
+    }
   },
-  disconnectBot: {
-    method: "POST",
-    path: "/disconnect-bot/:channelId",
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({ channel: ChannelSchema }),
-      400: DefaultErrorResponseSchema,
-      500: DefaultErrorResponseSchema
-    },
-    body: import_zod41.default.object({})
+  {
+    pathPrefix: "ms"
   }
-});
+);
 var channelSMSContract = (0, import_core7.initContract)().router(
   {
     connect: {
@@ -4181,7 +4221,8 @@ var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
   // Custom fields
   customFields: import_zod51.default.array(CustomFieldQueryParamsSchema),
   // Date filter
-  selectedDate: import_zod51.default.string()
+  selectedDate: import_zod51.default.string(),
+  uid: import_zod51.default.string()
 }).partial().optional();
 
 // src/cx-log/index.ts
@@ -4255,19 +4296,23 @@ var import_core13 = require("@ts-rest/core");
 // src/dashboard/validation.ts
 var import_zod53 = __toESM(require("zod"));
 var GetDashboardQueryParamsSchema = import_zod53.default.object({
-  channelIds: import_zod53.default.array(import_zod53.default.string()).optional(),
-  selectedDate: import_zod53.default.string()
+  channelIds: import_zod53.default.array(import_zod53.default.string().uuid()).optional(),
+  selectedDate: import_zod53.default.string().min(1)
 });
 var GetMessageChannelQueryParamsSchema = GetDashboardQueryParamsSchema.extend({
   time: import_zod53.default.enum(["byDay", "byMonth", "byHour"]),
   channelIds: import_zod53.default.array(import_zod53.default.string()).optional()
 });
-var DashboardQueryparamsSchema = GetDashboardQueryParamsSchema.merge(
-  import_zod53.default.object({
-    channelIds: import_zod53.default.array(import_zod53.default.string()).optional(),
-    agentIds: import_zod53.default.array(import_zod53.default.string()).optional()
-  })
-);
+var DashboardGlobalFiltersSchema = import_zod53.default.object({
+  automationQueueId: import_zod53.default.string().uuid().optional(),
+  selectedDate: import_zod53.default.string().min(1),
+  channelIds: import_zod53.default.array(import_zod53.default.string().uuid()).optional()
+});
+var DashboardQueryParamsSchema = GetDashboardQueryParamsSchema.extend({
+  automationQueueId: import_zod53.default.string().uuid().optional(),
+  channelIds: import_zod53.default.array(import_zod53.default.string().uuid()).optional(),
+  agentIds: import_zod53.default.array(import_zod53.default.string().uuid()).optional()
+});
 var GetDashboardQueryDetailParamsSchema = GetDashboardQueryParamsSchema.merge(
   import_zod53.default.object({
     agentId: import_zod53.default.string().uuid().optional()
@@ -4284,9 +4329,14 @@ var CallCountsQuerySchema = import_zod53.default.object({
   types: import_zod53.default.array(import_zod53.default.string()).optional(),
   selectedDate: import_zod53.default.string().optional()
 });
+var MessageDashboardDetailsQuerySchema = import_zod53.default.object({
+  automationQueueId: import_zod53.default.string().uuid().optional(),
+  selectedDate: import_zod53.default.string().min(1),
+  channelIds: import_zod53.default.array(import_zod53.default.string().uuid()).optional()
+});
 
 // src/dashboard/index.ts
-var import_zod55 = __toESM(require("zod"));
+var import_zod56 = __toESM(require("zod"));
 
 // src/dashboard/schema.ts
 var import_zod54 = __toESM(require("zod"));
@@ -4441,29 +4491,32 @@ var MessageStatusSchema = import_zod54.default.object({
   total: import_zod54.default.number().nullable(),
   closed: import_zod54.default.number().nullable(),
   unassignedOpen: import_zod54.default.number().nullable(),
-  assignedOpen: import_zod54.default.number().nullable()
+  assignedOpen: import_zod54.default.number().nullable(),
+  hold: import_zod54.default.number()
 });
 var MessageAverageSchema = import_zod54.default.object({
   selectedWeekAvgByDay: import_zod54.default.array(
     import_zod54.default.object({
       day: import_zod54.default.string().nullable(),
       avgResolutionTime: import_zod54.default.string().nullable(),
-      avgResponseTime: import_zod54.default.string().nullable()
+      avgResponseTime: import_zod54.default.string().nullable(),
+      resolutionRate: import_zod54.default.string()
     })
   ).optional().nullable(),
   previousWeekAvg: import_zod54.default.object({
     avgResolutionTime: import_zod54.default.string().nullable(),
-    avgResponseTime: import_zod54.default.string().nullable()
+    avgResponseTime: import_zod54.default.string().nullable(),
+    resolutionRate: import_zod54.default.string()
   }).nullable().optional(),
   selectedWeekAvg: import_zod54.default.object({
     avgResolutionTime: import_zod54.default.string().nullable(),
-    avgResponseTime: import_zod54.default.string().nullable()
+    avgResponseTime: import_zod54.default.string().nullable(),
+    resolutionRate: import_zod54.default.string()
   }).nullable().optional()
 });
 var ChannelIncomingMessageSchema = import_zod54.default.object({
-  channelName: import_zod54.default.string().nullable(),
-  channelType: import_zod54.default.string().nullable(),
-  count: import_zod54.default.string().nullable()
+  channelType: import_zod54.default.string(),
+  count: import_zod54.default.number()
 });
 var MessageDispositionSchema = import_zod54.default.object({
   name: import_zod54.default.string().optional().nullable(),
@@ -4486,6 +4539,49 @@ var CallCountsSchema = import_zod54.default.object({
   failedCallCount: import_zod54.default.number().gte(0),
   totalCallCount: import_zod54.default.number().gte(0)
 });
+var MessageQueueDataSchema = import_zod54.default.object({
+  id: import_zod54.default.string().uuid().nullable(),
+  name: import_zod54.default.string(),
+  sla: import_zod54.default.number(),
+  newContactCount: import_zod54.default.number(),
+  existingContactCount: import_zod54.default.number(),
+  totalRoomCount: import_zod54.default.number(),
+  closedRoomCount: import_zod54.default.number(),
+  unassignedRoomCount: import_zod54.default.number(),
+  assignedRoomCount: import_zod54.default.number(),
+  holdRoomCount: import_zod54.default.number()
+});
+var AgentMessageStatisticsSchema = import_zod54.default.object({
+  id: import_zod54.default.string().uuid(),
+  name: import_zod54.default.string(),
+  assignedRoomCount: import_zod54.default.number(),
+  holdRoomCount: import_zod54.default.number(),
+  closedRoomCount: import_zod54.default.number(),
+  averageFirstResponseTime: import_zod54.default.string(),
+  averageResolutionTime: import_zod54.default.string(),
+  totalHandledTime: import_zod54.default.string()
+});
+var UserCheckInLogSchema = import_zod54.default.object({
+  userId: import_zod54.default.string().uuid(),
+  firstLoginTime: import_zod54.default.string(),
+  lastLogoutTime: import_zod54.default.string().nullable(),
+  totalLoginDuration: import_zod54.default.string().nullable(),
+  averageFirstResponseTime: import_zod54.default.string().nullable(),
+  averageResolutionTime: import_zod54.default.string().nullable(),
+  totalHandledTime: import_zod54.default.string().nullable()
+});
+var UserCheckInLogsWithDaySchema = import_zod54.default.object({
+  date: import_zod54.default.date(),
+  formattedDate: import_zod54.default.string(),
+  userCheckInLogs: import_zod54.default.array(UserCheckInLogSchema)
+});
+
+// src/export/validation.ts
+var import_zod55 = __toESM(require("zod"));
+var ExportFileExtensionSchema = import_zod55.default.union([
+  import_zod55.default.literal("csv"),
+  import_zod55.default.literal("xlsx")
+]);
 
 // src/dashboard/index.ts
 var dashboardContract = (0, import_core13.initContract)().router(
@@ -4500,8 +4596,8 @@ var dashboardContract = (0, import_core13.initContract)().router(
         200: DefaultSuccessResponseSchema.extend({
           dashboard: DashboardDataSchema
         }),
-        400: import_zod55.default.object({
-          message: import_zod55.default.string()
+        400: import_zod56.default.object({
+          message: import_zod56.default.string()
         }),
         401: DefaultUnauthorizedSchema
       }
@@ -4516,8 +4612,8 @@ var dashboardContract = (0, import_core13.initContract)().router(
         200: DefaultSuccessResponseSchema.extend({
           queuecallDashboard: queueCallDashboardDataSchema
         }),
-        400: import_zod55.default.object({
-          message: import_zod55.default.string()
+        400: import_zod56.default.object({
+          message: import_zod56.default.string()
         }),
         401: DefaultUnauthorizedSchema
       }
@@ -4607,7 +4703,11 @@ var dashboardContract = (0, import_core13.initContract)().router(
     getMessageTagData: {
       method: "GET",
       path: "/message/tag",
-      query: DashboardQueryparamsSchema,
+      query: import_zod56.default.object({
+        automationQueueId: import_zod56.default.string().uuid().optional(),
+        selectedDate: import_zod56.default.string().min(1),
+        channelIds: import_zod56.default.array(import_zod56.default.string().uuid()).optional()
+      }),
       headers: DefaultHeaderSchema,
       summary: "Get message tag data",
       responses: {
@@ -4617,6 +4717,16 @@ var dashboardContract = (0, import_core13.initContract)().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportRoomTagCounts: {
+      method: "GET",
+      path: "/export-room-tag-counts",
+      query: DashboardGlobalFiltersSchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getCallTagData: {
       method: "GET",
       path: "/call/tag",
@@ -4648,7 +4758,7 @@ var dashboardContract = (0, import_core13.initContract)().router(
       path: "/message/conversation-activities",
       // conversation activity
       summary: "Get message contact data",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4661,7 +4771,7 @@ var dashboardContract = (0, import_core13.initContract)().router(
       method: "GET",
       path: "/message/status",
       summary: "Get room status count by status",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4674,7 +4784,7 @@ var dashboardContract = (0, import_core13.initContract)().router(
       method: "GET",
       path: "/message/average",
       summary: "Get room status average",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4683,37 +4793,74 @@ var dashboardContract = (0, import_core13.initContract)().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportMessageAverageData: {
+      method: "GET",
+      path: "/export-message-average-data",
+      query: import_zod56.default.object({
+        selectedDate: import_zod56.default.string().min(1),
+        automationQueueId: import_zod56.default.string().uuid().optional(),
+        channelIds: import_zod56.default.array(import_zod56.default.string().uuid()).optional(),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getChannelIncomingMessageCounts: {
       method: "GET",
       path: "/message/platform",
       summary: "Get message platform data",
-      query: DashboardQueryparamsSchema,
+      query: DashboardGlobalFiltersSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          incomingMessageCounts: import_zod55.default.array(ChannelIncomingMessageSchema)
+          incomingMessageCounts: import_zod56.default.array(ChannelIncomingMessageSchema)
         }),
         401: DefaultUnauthorizedSchema
       }
     },
+    exportRoomChannelCounts: {
+      method: "GET",
+      path: "/export-room-channel-counts",
+      query: DashboardGlobalFiltersSchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getMessageRoomStatusDispositionData: {
       method: "GET",
       path: "/message/disposition",
       summary: "Get message room status disposition data",
-      query: DashboardQueryparamsSchema,
+      query: import_zod56.default.object({
+        automationQueueId: import_zod56.default.string().uuid().optional(),
+        selectedDate: import_zod56.default.string().min(1),
+        channelIds: import_zod56.default.array(import_zod56.default.string().uuid()).optional()
+      }),
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          messageRoomStatusDispositionData: import_zod55.default.array(MessageDispositionSchema).optional()
+          messageRoomStatusDispositionData: import_zod56.default.array(MessageDispositionSchema).optional()
         }),
         401: DefaultUnauthorizedSchema
       }
     },
+    exportRoomDispositionCounts: {
+      method: "GET",
+      path: "/export-room-disposition-counts",
+      query: DashboardGlobalFiltersSchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getIncomingMessageByPlatform: {
       method: "GET",
       path: "/message/incoming",
       summary: "Get incoming message by platform",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4726,7 +4873,7 @@ var dashboardContract = (0, import_core13.initContract)().router(
       method: "GET",
       path: "/message/total-incoming",
       summary: "Get total incoming message data",
-      query: DashboardQueryparamsSchema,
+      query: DashboardGlobalFiltersSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4735,6 +4882,16 @@ var dashboardContract = (0, import_core13.initContract)().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportIncomingMessageCounts: {
+      method: "GET",
+      path: "/export-incoming-message-counts",
+      query: DashboardGlobalFiltersSchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getCallCounts: {
       method: "GET",
       path: "/call-counts",
@@ -4744,6 +4901,185 @@ var dashboardContract = (0, import_core13.initContract)().router(
           callCounts: CallCountsSchema
         })
       }
+    },
+    getAllQueueSLA: {
+      method: "GET",
+      path: "/all-queue-sla",
+      query: import_zod56.default.object({ selectedDate: import_zod56.default.string().min(1) }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          allQueueSLA: import_zod56.default.number()
+        })
+      }
+    },
+    getAllMessageQueueData: {
+      method: "GET",
+      path: "/all-message-queue-data",
+      query: import_zod56.default.object({
+        selectedDate: import_zod56.default.string().min(1),
+        page: import_zod56.default.coerce.number().positive(),
+        pageSize: import_zod56.default.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          allMessageQueueData: import_zod56.default.array(MessageQueueDataSchema),
+          page: import_zod56.default.coerce.number().positive(),
+          pageSize: import_zod56.default.coerce.number().positive(),
+          total: import_zod56.default.coerce.number().positive()
+        })
+      }
+    },
+    getMessageQueueData: {
+      method: "GET",
+      path: "/message-queue-data",
+      query: MessageDashboardDetailsQuerySchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          messageQueueData: MessageQueueDataSchema
+        })
+      }
+    },
+    getAgentMessageStatistics: {
+      method: "GET",
+      path: "/agent-message-statistics",
+      query: MessageDashboardDetailsQuerySchema.extend({
+        page: import_zod56.default.coerce.number().positive(),
+        pageSize: import_zod56.default.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          page: import_zod56.default.coerce.number().positive(),
+          pageSize: import_zod56.default.coerce.number().positive(),
+          lastPage: import_zod56.default.coerce.number().positive(),
+          total: import_zod56.default.coerce.number().positive(),
+          agentMessageStatistics: import_zod56.default.array(AgentMessageStatisticsSchema).nullable()
+        })
+      }
+    },
+    exportAgentMessageStatistics: {
+      method: "GET",
+      path: "/export-agent-message-statistics",
+      query: MessageDashboardDetailsQuerySchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
+    getUserCheckInLogsWithDays: {
+      method: "GET",
+      path: "/user-check-in-logs-with-days",
+      query: import_zod56.default.object({
+        automationQueueId: import_zod56.default.string().uuid().optional(),
+        selectedDate: import_zod56.default.string().min(1),
+        keyword: import_zod56.default.string().optional(),
+        page: import_zod56.default.coerce.number().positive(),
+        pageSize: import_zod56.default.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          page: import_zod56.default.coerce.number().positive(),
+          pageSize: import_zod56.default.coerce.number().positive(),
+          total: import_zod56.default.coerce.number().positive(),
+          userCheckInLogsWithDays: import_zod56.default.array(UserCheckInLogsWithDaySchema)
+        })
+      }
+    },
+    exportUserCheckInLogs: {
+      method: "GET",
+      path: "/export-user-check-in-logs",
+      query: import_zod56.default.object({
+        automationQueueId: import_zod56.default.string().uuid().optional(),
+        selectedDate: import_zod56.default.string().min(1),
+        keyword: import_zod56.default.string().optional(),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
+    getRoomStatusCountsByUserId: {
+      method: "GET",
+      path: "/room-status-counts-by-user-id",
+      query: import_zod56.default.object({
+        automationQueueId: import_zod56.default.string().optional(),
+        userId: import_zod56.default.string().uuid(),
+        selectedDate: import_zod56.default.string().min(1)
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          assignedRoomCount: import_zod56.default.number(),
+          holdRoomCount: import_zod56.default.number(),
+          closedRoomCount: import_zod56.default.number()
+        })
+      }
+    },
+    getPresenceStatusDurations: {
+      method: "GET",
+      path: "/presence-status-durations",
+      query: import_zod56.default.object({
+        userId: import_zod56.default.string().uuid(),
+        selectedDate: import_zod56.default.string().min(1),
+        page: import_zod56.default.coerce.number().positive(),
+        pageSize: import_zod56.default.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          presenceStatusDurations: import_zod56.default.array(
+            import_zod56.default.object({
+              formattedDate: import_zod56.default.string(),
+              date: import_zod56.default.date(),
+              presenceStatusDurationLogs: import_zod56.default.array(
+                import_zod56.default.object({
+                  presenceStatusId: import_zod56.default.string().uuid(),
+                  presenceStatusName: import_zod56.default.string(),
+                  durationSeconds: import_zod56.default.number().positive()
+                })
+              )
+            })
+          ),
+          page: import_zod56.default.coerce.number().positive(),
+          pageSize: import_zod56.default.coerce.number().positive(),
+          total: import_zod56.default.coerce.number().positive()
+        })
+      }
+    },
+    getUserCheckInLogsByUserId: {
+      method: "GET",
+      path: "/user-check-in-logs-by-user-id",
+      query: import_zod56.default.object({
+        automationQueueId: import_zod56.default.string().uuid().optional(),
+        userId: import_zod56.default.string().uuid(),
+        selectedDate: import_zod56.default.string().min(1),
+        page: import_zod56.default.coerce.number().positive(),
+        pageSize: import_zod56.default.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          userCheckInLogs: import_zod56.default.array(
+            import_zod56.default.object({
+              formattedDate: import_zod56.default.string(),
+              day: import_zod56.default.date(),
+              userCheckInLog: UserCheckInLogSchema
+            })
+          ),
+          page: import_zod56.default.coerce.number().positive(),
+          pageSize: import_zod56.default.coerce.number().positive(),
+          total: import_zod56.default.coerce.number().positive()
+        })
+      }
+    },
+    exportUserCheckInLogsByUserId: {
+      method: "GET",
+      path: "/export-user-check-in-logs-by-user-id",
+      query: import_zod56.default.object({
+        userId: import_zod56.default.string().uuid(),
+        selectedDate: import_zod56.default.string().min(1),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
     }
   },
   {
@@ -4752,14 +5088,14 @@ var dashboardContract = (0, import_core13.initContract)().router(
 );
 
 // src/evaluate-form/index.ts
-var import_zod57 = __toESM(require("zod"));
+var import_zod58 = __toESM(require("zod"));
 
 // src/evaluate-form/validation.ts
-var import_zod56 = __toESM(require("zod"));
-var CreateEvaluateFormSchema = import_zod56.default.object({
-  cxLogId: import_zod56.default.string().uuid(),
-  sentimentScore: import_zod56.default.string().nullable().optional(),
-  csatScore: import_zod56.default.string().nullable().optional()
+var import_zod57 = __toESM(require("zod"));
+var CreateEvaluateFormSchema = import_zod57.default.object({
+  cxLogId: import_zod57.default.string().uuid(),
+  sentimentScore: import_zod57.default.string().nullable().optional(),
+  csatScore: import_zod57.default.string().nullable().optional()
 });
 var UpdateEvaluateFormSchema = CreateEvaluateFormSchema.partial();
 
@@ -4773,7 +5109,7 @@ var evaluateFormContract = (0, import_core14.initContract)().router(
       body: CreateEvaluateFormSchema,
       responses: {
         201: DefaultSuccessResponseSchema.extend({
-          message: import_zod57.default.string()
+          message: import_zod58.default.string()
         }),
         401: DefaultUnauthorizedSchema
       },
@@ -4785,18 +5121,18 @@ var evaluateFormContract = (0, import_core14.initContract)().router(
 
 // src/extension/index.ts
 var import_core15 = require("@ts-rest/core");
-var import_zod59 = __toESM(require("zod"));
+var import_zod60 = __toESM(require("zod"));
 
 // src/extension/validation.ts
-var import_zod58 = require("zod");
-var CreateExtensionSchema = import_zod58.z.object({
-  userId: import_zod58.z.string().nullable(),
-  sipUserName: import_zod58.z.string(),
-  sipServerUrl: import_zod58.z.string().optional(),
-  webphoneLoginUser: import_zod58.z.string(),
-  extensionId: import_zod58.z.string().nullable(),
-  extensionName: import_zod58.z.string().nullable(),
-  telephonySignature: import_zod58.z.string().nullable().optional()
+var import_zod59 = require("zod");
+var CreateExtensionSchema = import_zod59.z.object({
+  userId: import_zod59.z.string().nullable(),
+  sipUserName: import_zod59.z.string(),
+  sipServerUrl: import_zod59.z.string().optional(),
+  webphoneLoginUser: import_zod59.z.string(),
+  extensionId: import_zod59.z.string().nullable(),
+  extensionName: import_zod59.z.string().nullable(),
+  telephonySignature: import_zod59.z.string().nullable().optional()
 });
 var UpdateExtensionSchema = CreateExtensionSchema;
 
@@ -4812,8 +5148,8 @@ var extensionContract = (0, import_core15.initContract)().router(
         201: DefaultSuccessResponseSchema.extend({
           extension: ExtensionSchema
         }),
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4825,33 +5161,33 @@ var extensionContract = (0, import_core15.initContract)().router(
     getExtensions: {
       method: "GET",
       path: "",
-      query: import_zod59.default.object({
-        page: import_zod59.default.coerce.number().default(1),
-        pageSize: import_zod59.default.coerce.number().default(10),
-        keyword: import_zod59.default.string().optional()
+      query: import_zod60.default.object({
+        page: import_zod60.default.coerce.number().default(1),
+        pageSize: import_zod60.default.coerce.number().default(10),
+        keyword: import_zod60.default.string().optional()
       }).optional(),
       headers: DefaultHeaderSchema,
       responses: {
         200: WithPagination(
           // The response data should contain the user relation.
           ExtensionSchema.extend({
-            user: import_zod59.default.object({
-              id: import_zod59.default.string().uuid(),
-              createdAt: import_zod59.default.date(),
-              updatedAt: import_zod59.default.date(),
-              deletedAt: import_zod59.default.date().nullable(),
-              name: import_zod59.default.string(),
-              email: import_zod59.default.string().email(),
-              emailVerifiedAt: import_zod59.default.date().nullable(),
-              password: import_zod59.default.string(),
-              address: import_zod59.default.string().nullable(),
-              phone: import_zod59.default.string().nullable(),
-              notificationCount: import_zod59.default.number().nullable()
+            user: import_zod60.default.object({
+              id: import_zod60.default.string().uuid(),
+              createdAt: import_zod60.default.date(),
+              updatedAt: import_zod60.default.date(),
+              deletedAt: import_zod60.default.date().nullable(),
+              name: import_zod60.default.string(),
+              email: import_zod60.default.string().email(),
+              emailVerifiedAt: import_zod60.default.date().nullable(),
+              password: import_zod60.default.string(),
+              address: import_zod60.default.string().nullable(),
+              phone: import_zod60.default.string().nullable(),
+              notificationCount: import_zod60.default.number().nullable()
             })
           })
         ),
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4863,12 +5199,12 @@ var extensionContract = (0, import_core15.initContract)().router(
     getExtensionByUserId: {
       method: "GET",
       path: "/user/:userId",
-      pathParams: import_zod59.default.object({ userId: import_zod59.default.string() }),
+      pathParams: import_zod60.default.object({ userId: import_zod60.default.string() }),
       headers: DefaultHeaderSchema,
       responses: {
         200: ExtensionSchema,
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4880,16 +5216,16 @@ var extensionContract = (0, import_core15.initContract)().router(
     getExtensionByDialpad: {
       method: "GET",
       path: "/dialpad",
-      query: import_zod59.default.object({
-        page: import_zod59.default.coerce.number().default(1),
-        pageSize: import_zod59.default.coerce.number().default(10),
-        keyword: import_zod59.default.string().optional()
+      query: import_zod60.default.object({
+        page: import_zod60.default.coerce.number().default(1),
+        pageSize: import_zod60.default.coerce.number().default(10),
+        keyword: import_zod60.default.string().optional()
       }).optional(),
       headers: DefaultHeaderSchema,
       responses: {
         200: WithPagination(ExtensionSchema),
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4901,15 +5237,15 @@ var extensionContract = (0, import_core15.initContract)().router(
     updateExtension: {
       method: "PATCH",
       path: "/:id",
-      pathParams: import_zod59.default.object({ id: import_zod59.default.string() }),
+      pathParams: import_zod60.default.object({ id: import_zod60.default.string() }),
       headers: DefaultHeaderSchema,
       body: UpdateExtensionSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           extension: ExtensionSchema
         }),
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4921,13 +5257,13 @@ var extensionContract = (0, import_core15.initContract)().router(
     deleteExtension: {
       method: "DELETE",
       path: "/:id",
-      pathParams: import_zod59.default.object({ id: import_zod59.default.string() }),
+      pathParams: import_zod60.default.object({ id: import_zod60.default.string() }),
       headers: DefaultHeaderSchema,
       body: null,
       responses: {
-        200: DefaultSuccessResponseSchema.extend({ message: import_zod59.default.string() }),
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        200: DefaultSuccessResponseSchema.extend({ message: import_zod60.default.string() }),
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4943,10 +5279,10 @@ var extensionContract = (0, import_core15.initContract)().router(
       body: null,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          message: import_zod59.default.string()
+          message: import_zod60.default.string()
         }),
-        400: import_zod59.default.object({
-          message: import_zod59.default.string()
+        400: import_zod60.default.object({
+          message: import_zod60.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4961,7 +5297,7 @@ var extensionContract = (0, import_core15.initContract)().router(
 
 // src/instagram/index.ts
 var import_core16 = require("@ts-rest/core");
-var import_zod60 = __toESM(require("zod"));
+var import_zod61 = __toESM(require("zod"));
 var instagramContract = (0, import_core16.initContract)().router({
   sendMessage: {
     method: "POST",
@@ -4995,8 +5331,8 @@ var instagramContract = (0, import_core16.initContract)().router({
   reconnect: {
     method: "POST",
     path: "/reconnect/:channelId",
-    pathParams: import_zod60.default.object({
-      channelId: import_zod60.default.string().uuid()
+    pathParams: import_zod61.default.object({
+      channelId: import_zod61.default.string().uuid()
     }),
     body: null,
     responses: {
@@ -5008,8 +5344,8 @@ var instagramContract = (0, import_core16.initContract)().router({
   delete: {
     method: "DELETE",
     path: "/delete/:channelId",
-    pathParams: import_zod60.default.object({
-      channelId: import_zod60.default.string().uuid()
+    pathParams: import_zod61.default.object({
+      channelId: import_zod61.default.string().uuid()
     }),
     body: null,
     responses: {
@@ -5050,84 +5386,84 @@ var instagramContract = (0, import_core16.initContract)().router({
 
 // src/line/index.ts
 var import_core17 = require("@ts-rest/core");
-var import_zod63 = __toESM(require("zod"));
+var import_zod64 = __toESM(require("zod"));
 
 // src/line/schema.ts
-var import_zod61 = __toESM(require("zod"));
+var import_zod62 = __toESM(require("zod"));
 var ConnectLineService = ConnectLineChannelSchema.extend({
-  actor: import_zod61.default.object({
-    id: import_zod61.default.string().uuid(),
-    name: import_zod61.default.string(),
-    email: import_zod61.default.string().email(),
-    address: import_zod61.default.string().nullable(),
-    phone: import_zod61.default.string().nullable()
+  actor: import_zod62.default.object({
+    id: import_zod62.default.string().uuid(),
+    name: import_zod62.default.string(),
+    email: import_zod62.default.string().email(),
+    address: import_zod62.default.string().nullable(),
+    phone: import_zod62.default.string().nullable()
   }).optional()
 });
 
 // src/line/validation.ts
-var import_zod62 = __toESM(require("zod"));
-var SendLineStickerSchema = import_zod62.default.object({
-  packageId: import_zod62.default.number(),
-  stickerId: import_zod62.default.number(),
-  room: import_zod62.default.object({
-    id: import_zod62.default.string().uuid(),
-    lastMessage: import_zod62.default.string().optional(),
-    handleTime: import_zod62.default.number().optional(),
-    isLatest: import_zod62.default.boolean(),
+var import_zod63 = __toESM(require("zod"));
+var SendLineStickerSchema = import_zod63.default.object({
+  packageId: import_zod63.default.number(),
+  stickerId: import_zod63.default.number(),
+  room: import_zod63.default.object({
+    id: import_zod63.default.string().uuid(),
+    lastMessage: import_zod63.default.string().optional(),
+    handleTime: import_zod63.default.number().optional(),
+    isLatest: import_zod63.default.boolean(),
     direction: MessageDirectionTypeSchema,
-    platformContact: import_zod62.default.object({
-      channelId: import_zod62.default.string().uuid(),
-      socialPlatformId: import_zod62.default.string().nullable(),
+    platformContact: import_zod63.default.object({
+      channelId: import_zod63.default.string().uuid(),
+      socialPlatformId: import_zod63.default.string().nullable(),
       type: ChannelTypeSchema,
       metadata: PlatformContactMetadataSchema,
-      contact: import_zod62.default.object({
-        name: import_zod62.default.string(),
-        address: import_zod62.default.string().nullable(),
-        channel: import_zod62.default.string().nullable(),
-        notes: import_zod62.default.string().nullable(),
-        contactProfile: import_zod62.default.string().nullable(),
-        socialProfileUrl: import_zod62.default.string().nullable()
+      contact: import_zod63.default.object({
+        name: import_zod63.default.string(),
+        address: import_zod63.default.string().nullable(),
+        channel: import_zod63.default.string().nullable(),
+        notes: import_zod63.default.string().nullable(),
+        contactProfile: import_zod63.default.string().nullable(),
+        socialProfileUrl: import_zod63.default.string().nullable()
       })
     }),
-    actor: import_zod62.default.object({
-      name: import_zod62.default.string(),
-      email: import_zod62.default.string().email(),
-      address: import_zod62.default.string().nullable(),
-      phone: import_zod62.default.string().nullable()
+    actor: import_zod63.default.object({
+      name: import_zod63.default.string(),
+      email: import_zod63.default.string().email(),
+      address: import_zod63.default.string().nullable(),
+      phone: import_zod63.default.string().nullable()
     }).nullable(),
     channel: ChannelSchema2
   }),
-  message: import_zod62.default.object({
-    message: import_zod62.default.string().optional(),
+  message: import_zod63.default.object({
+    message: import_zod63.default.string().optional(),
     direction: MessageDirectionTypeSchema,
     type: MessageTypeSchema,
-    readAt: import_zod62.default.date().optional(),
-    metadata: import_zod62.default.any().optional(),
-    platformId: import_zod62.default.string().optional(),
-    platformMessageId: import_zod62.default.string().optional(),
-    replyPlatformMessageId: import_zod62.default.string().optional(),
-    template: import_zod62.default.any().optional(),
+    readAt: import_zod63.default.date().optional(),
+    metadata: import_zod63.default.any().optional(),
+    platformId: import_zod63.default.string().optional(),
+    platformMessageId: import_zod63.default.string().optional(),
+    replyPlatformMessageId: import_zod63.default.string().optional(),
+    template: import_zod63.default.any().optional(),
     locale: MessageLocaleTypeSchema.optional(),
-    url: import_zod62.default.string().optional(),
-    previewUrl: import_zod62.default.string().optional(),
-    imageSetId: import_zod62.default.string().optional(),
-    upload: import_zod62.default.object({
-      bucketName: import_zod62.default.string(),
-      fileName: import_zod62.default.string(),
-      fileSize: import_zod62.default.number(),
-      fileKey: import_zod62.default.string()
+    url: import_zod63.default.string().optional(),
+    previewUrl: import_zod63.default.string().optional(),
+    imageSetId: import_zod63.default.string().optional(),
+    upload: import_zod63.default.object({
+      bucketName: import_zod63.default.string(),
+      fileName: import_zod63.default.string(),
+      fileSize: import_zod63.default.number(),
+      fileKey: import_zod63.default.string()
     }).optional(),
-    sender: import_zod62.default.object({
-      name: import_zod62.default.string(),
-      email: import_zod62.default.string().email(),
-      address: import_zod62.default.string().nullable(),
-      phone: import_zod62.default.string().nullable()
+    sender: import_zod63.default.object({
+      name: import_zod63.default.string(),
+      email: import_zod63.default.string().email(),
+      address: import_zod63.default.string().nullable(),
+      phone: import_zod63.default.string().nullable()
     })
   })
 });
-var createUserLevelRichMenuSchema = import_zod62.default.object({
-  linePlatformUserId: import_zod62.default.string(),
-  channelId: import_zod62.default.string()
+var createUserLevelRichMenuSchema = import_zod63.default.object({
+  linePlatformUserId: import_zod63.default.string(),
+  channelId: import_zod63.default.string()
 });
 
 // src/line/index.ts
@@ -5137,7 +5473,7 @@ var lineContract = (0, import_core17.initContract)().router({
     path: "sticker",
     responses: {
       200: DefaultSuccessResponseSchema.extend({
-        data: import_zod63.default.any()
+        data: import_zod64.default.any()
       }),
       500: DefaultErrorResponseSchema
     },
@@ -5160,7 +5496,7 @@ var lineContract = (0, import_core17.initContract)().router({
     path: "/message",
     body: SendMessageToPlatformSchema,
     responses: {
-      200: import_zod63.default.union([SendMessageResponseSchema, import_zod63.default.literal("TALK TO AGENT")]),
+      200: import_zod64.default.union([SendMessageResponseSchema, import_zod64.default.literal("TALK TO AGENT")]),
       500: DefaultErrorResponseSchema
     }
   },
@@ -5177,8 +5513,8 @@ var lineContract = (0, import_core17.initContract)().router({
   reconnect: {
     method: "POST",
     path: "/reconnect/:channelId",
-    pathParams: import_zod63.default.object({
-      channelId: import_zod63.default.string().uuid()
+    pathParams: import_zod64.default.object({
+      channelId: import_zod64.default.string().uuid()
     }),
     body: null,
     responses: {
@@ -5190,8 +5526,8 @@ var lineContract = (0, import_core17.initContract)().router({
   delete: {
     method: "DELETE",
     path: "/delete/:channelId",
-    pathParams: import_zod63.default.object({
-      channelId: import_zod63.default.string().uuid()
+    pathParams: import_zod64.default.object({
+      channelId: import_zod64.default.string().uuid()
     }),
     body: null,
     responses: {
@@ -5213,7 +5549,7 @@ var lineContract = (0, import_core17.initContract)().router({
 
 // src/mail/email-engine-webhooks-events.contract.ts
 var import_core18 = require("@ts-rest/core");
-var import_zod64 = __toESM(require("zod"));
+var import_zod65 = __toESM(require("zod"));
 var emailEngineWebhooksEventsContract = (0, import_core18.initContract)().router(
   {
     handleWebhooksEvents: {
@@ -5222,7 +5558,7 @@ var emailEngineWebhooksEventsContract = (0, import_core18.initContract)().router
       // we don't need to respone anything but added responses just for solving type error
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          message: import_zod64.default.string()
+          message: import_zod65.default.string()
         })
       },
       body: null,
@@ -5234,7 +5570,7 @@ var emailEngineWebhooksEventsContract = (0, import_core18.initContract)().router
 
 // src/messenger/index.ts
 var import_core19 = require("@ts-rest/core");
-var import_zod65 = __toESM(require("zod"));
+var import_zod66 = __toESM(require("zod"));
 var messengerContract = (0, import_core19.initContract)().router({
   sendMessage: {
     method: "POST",
@@ -5269,8 +5605,8 @@ var messengerContract = (0, import_core19.initContract)().router({
   reconnect: {
     method: "POST",
     path: "/reconnect/:channelId",
-    pathParams: import_zod65.default.object({
-      channelId: import_zod65.default.string().uuid()
+    pathParams: import_zod66.default.object({
+      channelId: import_zod66.default.string().uuid()
     }),
     body: null,
     responses: {
@@ -5282,8 +5618,8 @@ var messengerContract = (0, import_core19.initContract)().router({
   delete: {
     method: "DELETE",
     path: "/delete/:channelId",
-    pathParams: import_zod65.default.object({
-      channelId: import_zod65.default.string().uuid()
+    pathParams: import_zod66.default.object({
+      channelId: import_zod66.default.string().uuid()
     }),
     body: null,
     responses: {
@@ -5314,9 +5650,9 @@ var messengerContract = (0, import_core19.initContract)().router({
   getFacebookBusinesses: {
     method: "GET",
     path: "/facebook-businesses",
-    query: import_zod65.default.object({
-      userId: import_zod65.default.string(),
-      userAccessToken: import_zod65.default.string()
+    query: import_zod66.default.object({
+      userId: import_zod66.default.string(),
+      userAccessToken: import_zod66.default.string()
     }),
     responses: {
       200: DefaultSuccessResponseSchema,
@@ -5326,9 +5662,9 @@ var messengerContract = (0, import_core19.initContract)().router({
   getFacebookBusinessPages: {
     method: "GET",
     path: "/facebook-business-pages",
-    query: import_zod65.default.object({
-      businessId: import_zod65.default.string(),
-      userAccessToken: import_zod65.default.string()
+    query: import_zod66.default.object({
+      businessId: import_zod66.default.string(),
+      userAccessToken: import_zod66.default.string()
     }),
     responses: {
       200: DefaultSuccessResponseSchema,
@@ -5348,7 +5684,7 @@ var messengerContract = (0, import_core19.initContract)().router({
 
 // src/permission/index.ts
 var import_core20 = require("@ts-rest/core");
-var import_zod66 = __toESM(require("zod"));
+var import_zod67 = __toESM(require("zod"));
 var permissionContract = (0, import_core20.initContract)().router(
   {
     getPermissions: {
@@ -5356,9 +5692,9 @@ var permissionContract = (0, import_core20.initContract)().router(
       path: "",
       headers: DefaultHeaderSchema,
       responses: {
-        200: import_zod66.default.object({ permissions: PermissionSchema.array() }),
-        400: import_zod66.default.object({
-          message: import_zod66.default.string()
+        200: import_zod67.default.object({ permissions: PermissionSchema.array() }),
+        400: import_zod67.default.object({
+          message: import_zod67.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5371,15 +5707,15 @@ var permissionContract = (0, import_core20.initContract)().router(
 
 // src/role/index.ts
 var import_core21 = require("@ts-rest/core");
-var import_zod68 = __toESM(require("zod"));
+var import_zod69 = __toESM(require("zod"));
 
 // src/role/validation.ts
-var import_zod67 = require("zod");
-var CreateRoleSchema = import_zod67.z.object({
-  systemName: import_zod67.z.string(),
-  displayName: import_zod67.z.string(),
-  description: import_zod67.z.string().nullable(),
-  permissions: import_zod67.z.array(import_zod67.z.string())
+var import_zod68 = require("zod");
+var CreateRoleSchema = import_zod68.z.object({
+  systemName: import_zod68.z.string(),
+  displayName: import_zod68.z.string(),
+  description: import_zod68.z.string().nullable(),
+  permissions: import_zod68.z.array(import_zod68.z.string())
 });
 var UpdateRoleSchema = CreateRoleSchema;
 
@@ -5395,8 +5731,8 @@ var roleContract = (0, import_core21.initContract)().router(
         201: DefaultSuccessResponseSchema.extend({
           role: RoleSchema
         }),
-        400: import_zod68.default.object({
-          message: import_zod68.default.string()
+        400: import_zod69.default.object({
+          message: import_zod69.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5406,17 +5742,17 @@ var roleContract = (0, import_core21.initContract)().router(
     getRoles: {
       method: "GET",
       path: "",
-      query: import_zod68.default.object({
-        page: import_zod68.default.coerce.number().default(1),
-        pageSize: import_zod68.default.coerce.number().default(10)
+      query: import_zod69.default.object({
+        page: import_zod69.default.coerce.number().default(1),
+        pageSize: import_zod69.default.coerce.number().default(10)
       }).optional(),
       headers: DefaultHeaderSchema,
       responses: {
         200: WithPagination(RoleSchema).extend({
           roleUserCount: RoleUserCountSchema
         }),
-        400: import_zod68.default.object({
-          message: import_zod68.default.string()
+        400: import_zod69.default.object({
+          message: import_zod69.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5426,15 +5762,15 @@ var roleContract = (0, import_core21.initContract)().router(
     updateRole: {
       method: "PATCH",
       path: "/:id",
-      pathParams: import_zod68.default.object({ id: import_zod68.default.string() }),
+      pathParams: import_zod69.default.object({ id: import_zod69.default.string() }),
       headers: DefaultHeaderSchema,
       body: UpdateRoleSchema,
       responses: {
         201: DefaultSuccessResponseSchema.extend({
           role: RoleSchema
         }),
-        400: import_zod68.default.object({
-          message: import_zod68.default.string()
+        400: import_zod69.default.object({
+          message: import_zod69.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5444,11 +5780,11 @@ var roleContract = (0, import_core21.initContract)().router(
     deleteRole: {
       method: "DELETE",
       path: "/:id",
-      pathParams: import_zod68.default.object({ id: import_zod68.default.string() }),
+      pathParams: import_zod69.default.object({ id: import_zod69.default.string() }),
       headers: DefaultHeaderSchema,
       body: null,
       responses: {
-        200: DefaultSuccessResponseSchema.extend({ message: import_zod68.default.string() }),
+        200: DefaultSuccessResponseSchema.extend({ message: import_zod69.default.string() }),
         500: DefaultErrorResponseSchema
       },
       summary: "Delete a role."
@@ -5456,12 +5792,12 @@ var roleContract = (0, import_core21.initContract)().router(
     getRoleById: {
       method: "GET",
       path: "/:id",
-      pathParams: import_zod68.default.object({ id: import_zod68.default.string() }),
+      pathParams: import_zod69.default.object({ id: import_zod69.default.string() }),
       headers: DefaultHeaderSchema,
       responses: {
         200: RoleSchema,
-        400: import_zod68.default.object({
-          message: import_zod68.default.string()
+        400: import_zod69.default.object({
+          message: import_zod69.default.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5474,19 +5810,19 @@ var roleContract = (0, import_core21.initContract)().router(
 
 // src/tag/index.ts
 var import_core22 = require("@ts-rest/core");
-var import_zod70 = __toESM(require("zod"));
+var import_zod71 = __toESM(require("zod"));
 
 // src/tag/validation.ts
-var import_zod69 = require("zod");
-var CreateTagSchema = import_zod69.z.object({
-  name: import_zod69.z.string(),
+var import_zod70 = require("zod");
+var CreateTagSchema = import_zod70.z.object({
+  name: import_zod70.z.string(),
   group: TagGroupSchema
 });
-var GetTagsSchema = import_zod69.z.object({
+var GetTagsSchema = import_zod70.z.object({
   group: TagGroupSchema.default("general"),
-  keyword: import_zod69.z.string()
+  keyword: import_zod70.z.string()
 }).partial().optional();
-var UpdateTagSchema = import_zod69.z.object({ name: import_zod69.z.string() });
+var UpdateTagSchema = import_zod70.z.object({ name: import_zod70.z.string() });
 
 // src/tag/index.ts
 var tagContract = (0, import_core22.initContract)().router(
@@ -5509,7 +5845,7 @@ var tagContract = (0, import_core22.initContract)().router(
       query: GetTagsSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          tags: import_zod70.default.array(TagSchema)
+          tags: import_zod71.default.array(TagSchema)
         }),
         500: DefaultErrorResponseSchema
       },
@@ -5518,7 +5854,7 @@ var tagContract = (0, import_core22.initContract)().router(
     updateTag: {
       method: "PATCH",
       path: "/:id",
-      pathParams: import_zod70.default.object({ id: import_zod70.default.string() }),
+      pathParams: import_zod71.default.object({ id: import_zod71.default.string() }),
       body: UpdateTagSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -5531,11 +5867,11 @@ var tagContract = (0, import_core22.initContract)().router(
     deleteTag: {
       method: "DELETE",
       path: "/:id",
-      pathParams: import_zod70.default.object({ id: import_zod70.default.string() }),
-      body: import_zod70.default.any().optional(),
+      pathParams: import_zod71.default.object({ id: import_zod71.default.string() }),
+      body: import_zod71.default.any().optional(),
       // We don't need the body.
       responses: {
-        200: DefaultSuccessResponseSchema.extend({ message: import_zod70.default.string() }),
+        200: DefaultSuccessResponseSchema.extend({ message: import_zod71.default.string() }),
         500: DefaultErrorResponseSchema
       },
       headers: DefaultHeaderSchema
@@ -5550,31 +5886,31 @@ var tagContract = (0, import_core22.initContract)().router(
 var import_core23 = require("@ts-rest/core");
 var import_zod74 = __toESM(require("zod"));
 
-// src/telephony-agent-presence-status/schema.ts
-var import_zod72 = __toESM(require("zod"));
-
 // src/presence-status/schema.ts
-var import_zod71 = __toESM(require("zod"));
-var PresenceStatusDesEnum = import_zod71.default.enum([
-  "Can do everything.",
-  "Mute all notifications.",
-  `You won't receive call, but can still do other.`
+var import_zod72 = __toESM(require("zod"));
+var TPresenceStatusOption = import_zod72.default.union([
+  import_zod72.default.literal("receive_call"),
+  import_zod72.default.literal("do_not_receive_call"),
+  import_zod72.default.literal("receive_chat_message"),
+  import_zod72.default.literal("do_not_receive_chat_message")
 ]);
-var PresenceStatusSchema = import_zod71.default.object({
-  id: import_zod71.default.string().uuid(),
-  createdAt: import_zod71.default.date(),
-  updatedAt: import_zod71.default.date(),
-  deletedAt: import_zod71.default.date().nullable(),
-  status: import_zod71.default.string(),
-  description: PresenceStatusDesEnum,
-  position: import_zod71.default.number()
+var PresenceStatusSchema = import_zod72.default.object({
+  id: import_zod72.default.string().uuid(),
+  createdAt: import_zod72.default.date(),
+  updatedAt: import_zod72.default.date(),
+  deletedAt: import_zod72.default.date().nullable(),
+  systemName: import_zod72.default.string(),
+  displayName: import_zod72.default.string(),
+  description: import_zod72.default.string().nullable(),
+  position: import_zod72.default.number(),
+  emoji: import_zod72.default.string().nullable(),
+  presenceStatusOption: import_zod72.default.array(TPresenceStatusOption)
 });
 
 // src/telephony-agent-presence-status/schema.ts
 var UserPresenceStatusSchema = DefaultEntitySchema.extend({
   user: UserSchema,
-  presenceStatus: PresenceStatusSchema,
-  customPresenceStatus: import_zod72.default.string().nullable().optional()
+  presenceStatus: PresenceStatusSchema
 });
 
 // src/telephony-agent-presence-status/validation.ts
@@ -5582,27 +5918,12 @@ var import_zod73 = require("zod");
 var UpdateUserStatusSchema = import_zod73.z.object({
   userId: import_zod73.z.string(),
   presenceStatusId: import_zod73.z.string().nullable().optional(),
-  customPreseneStatus: import_zod73.z.string().nullable().optional(),
   reason: import_zod73.z.string()
 });
 
 // src/telephony-agent-presence-status/index.ts
 var telephonyAgentPresenceStatusContract = (0, import_core23.initContract)().router(
   {
-    getAllAgentStatus: {
-      method: "GET",
-      path: "/agents/presence_status",
-      headers: DefaultHeaderSchema,
-      responses: {
-        200: import_zod74.default.array(UserPresenceStatusSchema),
-        400: import_zod74.default.object({
-          message: import_zod74.default.string()
-        }),
-        401: DefaultUnauthorizedSchema,
-        500: DefaultErrorResponseSchema
-      },
-      summary: "Get all user presence status list."
-    },
     getAgentStatus: {
       method: "GET",
       path: "/presence_status/check_update/:userId",
@@ -8464,7 +8785,7 @@ var botpressContract = (0, import_core40.initContract)().router(
       body: SendBotpressMessageSchema
     }
   },
-  { pathPrefix: "/bots" }
+  { pathPrefix: "bots" }
 );
 var botContract = (0, import_core40.initContract)().router(
   {
@@ -8493,7 +8814,7 @@ var botContract = (0, import_core40.initContract)().router(
     }
   },
   {
-    pathPrefix: "bots"
+    pathPrefix: "ms/bots"
   }
 );
 
@@ -8504,9 +8825,12 @@ var import_zod113 = __toESM(require("zod"));
 // src/presence-status/validation.ts
 var import_zod112 = require("zod");
 var CreatePresenceStatusSchema = import_zod112.z.object({
-  status: import_zod112.z.string(),
-  description: PresenceStatusDesEnum,
-  position: import_zod112.z.number()
+  systemName: import_zod112.z.string(),
+  displayName: import_zod112.z.string(),
+  description: import_zod112.z.string().optional(),
+  position: import_zod112.z.number(),
+  emoji: import_zod112.z.string(),
+  presenceStatusOption: import_zod112.z.array(TPresenceStatusOption)
 });
 var UpdatePresenceStatusSchema = CreatePresenceStatusSchema;
 
@@ -9026,7 +9350,8 @@ var automationQueueContract = (0, import_core45.initContract)().router(
       method: "GET",
       path: "",
       query: import_zod118.z.object({
-        userId: import_zod118.z.string().uuid().optional()
+        userId: import_zod118.z.string().uuid().optional(),
+        withRelations: import_zod118.z.coerce.boolean().default(true).optional()
       }).optional(),
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -10515,6 +10840,32 @@ var settingCxIntelligenceContract = (0, import_core54.initContract)().router(
   },
   { pathPrefix: "settings/cx-intelligence" }
 );
+
+// src/export/index.ts
+var import_core55 = require("@ts-rest/core");
+var import_zod139 = __toESM(require("zod"));
+var exportContract = (0, import_core55.initContract)().router(
+  {
+    notifyExport: {
+      method: "POST",
+      path: "notify",
+      body: import_zod139.default.object({
+        userId: import_zod139.default.string().uuid(),
+        module: import_zod139.default.string(),
+        fileUrl: import_zod139.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          success: import_zod139.default.boolean()
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    }
+  },
+  {
+    pathPrefix: "export/"
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   activityLogContract,
@@ -10544,6 +10895,7 @@ var settingCxIntelligenceContract = (0, import_core54.initContract)().router(
   cxLogContract,
   dashboardContract,
   evaluateFormContract,
+  exportContract,
   extensionContract,
   facebookFeedContract,
   feedPostContract,
@@ -10586,6 +10938,7 @@ var settingCxIntelligenceContract = (0, import_core54.initContract)().router(
   userContract,
   userNotificationContract,
   userPresenceStatusLogContract,
+  widgetContract,
   widgetSettingContract,
   workflowContract,
   wrapUpFormContract