@kl1/contracts 1.3.33 → 1.3.35

package/dist/index.mjs

@@ -193,6 +193,10 @@ var ChannelMetadataSchema = z6.object({
     apiKey: z6.string(),
     apiSecret: z6.string()
   }).optional(),
+  line: z6.object({
+    channelId: z6.string(),
+    channelSecret: z6.string()
+  }).optional(),
   lineRichMenuId: z6.string().optional().nullable(),
   messengerIntegrationType: z6.union([z6.literal("own"), z6.literal("business")]).optional(),
   facebookFeedIntegrationType: z6.union([z6.literal("own"), z6.literal("business")]).optional(),
@@ -609,56 +613,57 @@ var WorkflowRuleSchema = DefaultEntitySchema.extend({
 });
 
 // src/chat/schema.ts
-var MessageDirectionTypeSchema = z18.enum([
-  "incoming",
-  "outgoing",
-  "system"
+var MessageDirectionTypeSchema = z18.union([
+  z18.literal("incoming"),
+  z18.literal("outgoing"),
+  z18.literal("system")
 ]);
 var WorkflowAutoReplyMessageTypeSchema = z18.enum(["text", "image"]).default("text");
-var MessageTypeSchema = z18.enum([
-  "text",
-  "image",
-  "video",
-  "audio",
-  "file",
-  "imagemap",
-  "group",
-  "fallback",
-  "location",
-  "sticker",
+var messageTypes = [
+  z18.literal("text"),
+  z18.literal("image"),
+  z18.literal("video"),
+  z18.literal("audio"),
+  z18.literal("file"),
+  z18.literal("imagemap"),
+  z18.literal("group"),
+  z18.literal("fallback"),
+  z18.literal("location"),
+  z18.literal("sticker"),
   // botpress specific
-  "carousel",
-  "card",
-  "choice",
-  "dropdown",
-  "text_with_image",
-  "reaction",
-  "contacts",
-  // botpress specific
-  "carousel",
-  "card",
-  "choice",
-  "dropdown",
-  // messenger referral
-  "referral",
+  z18.literal("carousel"),
+  z18.literal("card"),
+  z18.literal("choice"),
+  z18.literal("dropdown"),
+  z18.literal("text_with_image"),
+  z18.literal("reaction"),
+  z18.literal("contacts"),
   // system
-  "csat",
-  "assign",
-  "solve",
-  "resolved",
-  "reopen",
-  "open",
-  "closed",
-  "handed_over",
-  "updated",
-  "started",
-  "hold",
-  "unhold",
-  "auto_unhold",
-  "edited",
-  "deleted",
-  "unsupported"
-]);
+  z18.literal("csat"),
+  z18.literal("assign"),
+  z18.literal("solve"),
+  z18.literal("resolved"),
+  z18.literal("reopen"),
+  z18.literal("open"),
+  z18.literal("closed"),
+  z18.literal("handed_over"),
+  z18.literal("updated"),
+  z18.literal("started"),
+  z18.literal("hold"),
+  z18.literal("unhold"),
+  z18.literal("auto_unhold"),
+  z18.literal("edited"),
+  z18.literal("deleted"),
+  z18.literal("unsupported"),
+  // lazada specific
+  z18.literal("lazada_item"),
+  z18.literal("lazada_sys_msg"),
+  z18.literal("lazada_order"),
+  z18.literal("lazada_order_invite"),
+  z18.literal("lazada_shop_invite"),
+  z18.literal("lazada_voucher")
+];
+var MessageTypeSchema = z18.union(messageTypes);
 var FeedPostTypeSchema = z18.enum([
   "text",
   "added_photos",
@@ -1186,7 +1191,8 @@ var CxLogSchemaWithRelations = DefaultEntitySchema.extend({
     summary: z25.string(),
     usage: z25.number(),
     usageUnit: z25.string()
-  })
+  }),
+  uid: z25.string()
 });
 
 // src/chat/validation.ts
@@ -1231,7 +1237,9 @@ var MessageAttachmentSchema = z26.object({
   fileSize: z26.number(),
   url: z26.string().nullable(),
   fileType: z26.string(),
-  thumbnailUrl: z26.string().optional()
+  thumbnailUrl: z26.string().optional(),
+  width: z26.string().optional(),
+  height: z26.string().optional()
 });
 var StickerSchema = z26.object({
   packageId: z26.number(),
@@ -2167,7 +2175,8 @@ var ConnectWebChatSchema = z37.object({
   })
 });
 var GetChannelSchema = z37.object({
-  withDeleted: z37.coerce.boolean().default(false)
+  withDeleted: z37.coerce.boolean().default(false),
+  withRelations: z37.coerce.boolean().default(true).optional()
 });
 var ConnectBotSchema = z37.object({
   botId: z37.string().uuid()
@@ -2190,6 +2199,10 @@ var ConnectWhatsappSchema = z37.object({
   metadata: ChannelMetadataSchema,
   platformId: z37.string()
 });
+var ConnectLazadaSchema = z37.object({
+  name: z37.string(),
+  code: z37.string()
+});
 
 // src/instagram/validation.ts
 import z38 from "zod";
@@ -2509,11 +2522,30 @@ var whatsapp = initContract7().router(
     pathPrefix: "whatsapp"
   }
 );
+var lazada = initContract7().router(
+  {
+    connect: {
+      method: "POST",
+      path: "/connect",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          channel: ChannelSchema
+        }),
+        408: DefaultErrorResponseSchema
+      },
+      body: ConnectLazadaSchema,
+      summary: "Connect message channel"
+    }
+  },
+  {
+    pathPrefix: "lazada"
+  }
+);
 var channelContract = initContract7().router(
   {
     getChannels: {
       method: "GET",
-      path: "/channel",
+      path: "channel",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           data: ChannelSchema.array()
@@ -2626,7 +2658,7 @@ var channelContract = initContract7().router(
     },
     updateChannelCsatPreference: {
       method: "POST",
-      path: "/csat/:channelId",
+      path: "csat/:channelId",
       pathParams: z41.object({
         channelId: z41.string().uuid()
       }),
@@ -2647,7 +2679,8 @@ var channelContract = initContract7().router(
     viber,
     telegram,
     webchat,
-    whatsapp
+    whatsapp,
+    lazada
   },
   {
     baseHeaders: DefaultHeaderSchema
@@ -2683,28 +2716,33 @@ var channelFacebookFeedContract = initContract7().router(
     pathPrefix: "ms/facebook-feed"
   }
 );
-var channelBotContract = initContract7().router({
-  connectBot: {
-    method: "POST",
-    path: "/connect-bot/:channelId",
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({ channel: ChannelSchema }),
-      400: DefaultErrorResponseSchema,
-      500: DefaultErrorResponseSchema
+var channelBotContract = initContract7().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: z41.object({})
+    }
   },
-  disconnectBot: {
-    method: "POST",
-    path: "/disconnect-bot/:channelId",
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({ channel: ChannelSchema }),
-      400: DefaultErrorResponseSchema,
-      500: DefaultErrorResponseSchema
-    },
-    body: z41.object({})
+  {
+    pathPrefix: "ms"
   }
-});
+);
 var channelSMSContract = initContract7().router(
   {
     connect: {
@@ -4074,7 +4112,8 @@ var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
   // Custom fields
   customFields: z51.array(CustomFieldQueryParamsSchema),
   // Date filter
-  selectedDate: z51.string()
+  selectedDate: z51.string(),
+  uid: z51.string()
 }).partial().optional();
 
 // src/cx-log/index.ts
@@ -4148,19 +4187,23 @@ import { initContract as initContract13 } from "@ts-rest/core";
 // src/dashboard/validation.ts
 import z53 from "zod";
 var GetDashboardQueryParamsSchema = z53.object({
-  channelIds: z53.array(z53.string()).optional(),
-  selectedDate: z53.string()
+  channelIds: z53.array(z53.string().uuid()).optional(),
+  selectedDate: z53.string().min(1)
 });
 var GetMessageChannelQueryParamsSchema = GetDashboardQueryParamsSchema.extend({
   time: z53.enum(["byDay", "byMonth", "byHour"]),
   channelIds: z53.array(z53.string()).optional()
 });
-var DashboardQueryparamsSchema = GetDashboardQueryParamsSchema.merge(
-  z53.object({
-    channelIds: z53.array(z53.string()).optional(),
-    agentIds: z53.array(z53.string()).optional()
-  })
-);
+var DashboardGlobalFiltersSchema = z53.object({
+  automationQueueId: z53.string().uuid().optional(),
+  selectedDate: z53.string().min(1),
+  channelIds: z53.array(z53.string().uuid()).optional()
+});
+var DashboardQueryParamsSchema = GetDashboardQueryParamsSchema.extend({
+  automationQueueId: z53.string().uuid().optional(),
+  channelIds: z53.array(z53.string().uuid()).optional(),
+  agentIds: z53.array(z53.string().uuid()).optional()
+});
 var GetDashboardQueryDetailParamsSchema = GetDashboardQueryParamsSchema.merge(
   z53.object({
     agentId: z53.string().uuid().optional()
@@ -4177,9 +4220,14 @@ var CallCountsQuerySchema = z53.object({
   types: z53.array(z53.string()).optional(),
   selectedDate: z53.string().optional()
 });
+var MessageDashboardDetailsQuerySchema = z53.object({
+  automationQueueId: z53.string().uuid().optional(),
+  selectedDate: z53.string().min(1),
+  channelIds: z53.array(z53.string().uuid()).optional()
+});
 
 // src/dashboard/index.ts
-import z55 from "zod";
+import z56 from "zod";
 
 // src/dashboard/schema.ts
 import z54 from "zod";
@@ -4334,29 +4382,32 @@ var MessageStatusSchema = z54.object({
   total: z54.number().nullable(),
   closed: z54.number().nullable(),
   unassignedOpen: z54.number().nullable(),
-  assignedOpen: z54.number().nullable()
+  assignedOpen: z54.number().nullable(),
+  hold: z54.number()
 });
 var MessageAverageSchema = z54.object({
   selectedWeekAvgByDay: z54.array(
     z54.object({
       day: z54.string().nullable(),
       avgResolutionTime: z54.string().nullable(),
-      avgResponseTime: z54.string().nullable()
+      avgResponseTime: z54.string().nullable(),
+      resolutionRate: z54.string()
     })
   ).optional().nullable(),
   previousWeekAvg: z54.object({
     avgResolutionTime: z54.string().nullable(),
-    avgResponseTime: z54.string().nullable()
+    avgResponseTime: z54.string().nullable(),
+    resolutionRate: z54.string()
   }).nullable().optional(),
   selectedWeekAvg: z54.object({
     avgResolutionTime: z54.string().nullable(),
-    avgResponseTime: z54.string().nullable()
+    avgResponseTime: z54.string().nullable(),
+    resolutionRate: z54.string()
   }).nullable().optional()
 });
 var ChannelIncomingMessageSchema = z54.object({
-  channelName: z54.string().nullable(),
-  channelType: z54.string().nullable(),
-  count: z54.string().nullable()
+  channelType: z54.string(),
+  count: z54.number()
 });
 var MessageDispositionSchema = z54.object({
   name: z54.string().optional().nullable(),
@@ -4379,6 +4430,49 @@ var CallCountsSchema = z54.object({
   failedCallCount: z54.number().gte(0),
   totalCallCount: z54.number().gte(0)
 });
+var MessageQueueDataSchema = z54.object({
+  id: z54.string().uuid().nullable(),
+  name: z54.string(),
+  sla: z54.number(),
+  newContactCount: z54.number(),
+  existingContactCount: z54.number(),
+  totalRoomCount: z54.number(),
+  closedRoomCount: z54.number(),
+  unassignedRoomCount: z54.number(),
+  assignedRoomCount: z54.number(),
+  holdRoomCount: z54.number()
+});
+var AgentMessageStatisticsSchema = z54.object({
+  id: z54.string().uuid(),
+  name: z54.string(),
+  assignedRoomCount: z54.number(),
+  holdRoomCount: z54.number(),
+  closedRoomCount: z54.number(),
+  averageFirstResponseTime: z54.string(),
+  averageResolutionTime: z54.string(),
+  totalHandledTime: z54.string()
+});
+var UserCheckInLogSchema = z54.object({
+  userId: z54.string().uuid(),
+  firstLoginTime: z54.string(),
+  lastLogoutTime: z54.string().nullable(),
+  totalLoginDuration: z54.string().nullable(),
+  averageFirstResponseTime: z54.string().nullable(),
+  averageResolutionTime: z54.string().nullable(),
+  totalHandledTime: z54.string().nullable()
+});
+var UserCheckInLogsWithDaySchema = z54.object({
+  date: z54.date(),
+  formattedDate: z54.string(),
+  userCheckInLogs: z54.array(UserCheckInLogSchema)
+});
+
+// src/export/validation.ts
+import z55 from "zod";
+var ExportFileExtensionSchema = z55.union([
+  z55.literal("csv"),
+  z55.literal("xlsx")
+]);
 
 // src/dashboard/index.ts
 var dashboardContract = initContract13().router(
@@ -4393,8 +4487,8 @@ var dashboardContract = initContract13().router(
         200: DefaultSuccessResponseSchema.extend({
           dashboard: DashboardDataSchema
         }),
-        400: z55.object({
-          message: z55.string()
+        400: z56.object({
+          message: z56.string()
         }),
         401: DefaultUnauthorizedSchema
       }
@@ -4409,8 +4503,8 @@ var dashboardContract = initContract13().router(
         200: DefaultSuccessResponseSchema.extend({
           queuecallDashboard: queueCallDashboardDataSchema
         }),
-        400: z55.object({
-          message: z55.string()
+        400: z56.object({
+          message: z56.string()
         }),
         401: DefaultUnauthorizedSchema
       }
@@ -4500,7 +4594,11 @@ var dashboardContract = initContract13().router(
     getMessageTagData: {
       method: "GET",
       path: "/message/tag",
-      query: DashboardQueryparamsSchema,
+      query: z56.object({
+        automationQueueId: z56.string().uuid().optional(),
+        selectedDate: z56.string().min(1),
+        channelIds: z56.array(z56.string().uuid()).optional()
+      }),
       headers: DefaultHeaderSchema,
       summary: "Get message tag data",
       responses: {
@@ -4510,6 +4608,16 @@ var dashboardContract = initContract13().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",
@@ -4541,7 +4649,7 @@ var dashboardContract = initContract13().router(
       path: "/message/conversation-activities",
       // conversation activity
       summary: "Get message contact data",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4554,7 +4662,7 @@ var dashboardContract = initContract13().router(
       method: "GET",
       path: "/message/status",
       summary: "Get room status count by status",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4567,7 +4675,7 @@ var dashboardContract = initContract13().router(
       method: "GET",
       path: "/message/average",
       summary: "Get room status average",
-      query: DashboardQueryparamsSchema,
+      query: DashboardQueryParamsSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4576,37 +4684,74 @@ var dashboardContract = initContract13().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportMessageAverageData: {
+      method: "GET",
+      path: "/export-message-average-data",
+      query: z56.object({
+        selectedDate: z56.string().min(1),
+        automationQueueId: z56.string().uuid().optional(),
+        channelIds: z56.array(z56.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: z55.array(ChannelIncomingMessageSchema)
+          incomingMessageCounts: z56.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: z56.object({
+        automationQueueId: z56.string().uuid().optional(),
+        selectedDate: z56.string().min(1),
+        channelIds: z56.array(z56.string().uuid()).optional()
+      }),
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          messageRoomStatusDispositionData: z55.array(MessageDispositionSchema).optional()
+          messageRoomStatusDispositionData: z56.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({
@@ -4619,7 +4764,7 @@ var dashboardContract = initContract13().router(
       method: "GET",
       path: "/message/total-incoming",
       summary: "Get total incoming message data",
-      query: DashboardQueryparamsSchema,
+      query: DashboardGlobalFiltersSchema,
       headers: DefaultHeaderSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -4628,6 +4773,16 @@ var dashboardContract = initContract13().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",
@@ -4637,6 +4792,185 @@ var dashboardContract = initContract13().router(
           callCounts: CallCountsSchema
         })
       }
+    },
+    getAllQueueSLA: {
+      method: "GET",
+      path: "/all-queue-sla",
+      query: z56.object({ selectedDate: z56.string().min(1) }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          allQueueSLA: z56.number()
+        })
+      }
+    },
+    getAllMessageQueueData: {
+      method: "GET",
+      path: "/all-message-queue-data",
+      query: z56.object({
+        selectedDate: z56.string().min(1),
+        page: z56.coerce.number().positive(),
+        pageSize: z56.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          allMessageQueueData: z56.array(MessageQueueDataSchema),
+          page: z56.coerce.number().positive(),
+          pageSize: z56.coerce.number().positive(),
+          total: z56.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: z56.coerce.number().positive(),
+        pageSize: z56.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          page: z56.coerce.number().positive(),
+          pageSize: z56.coerce.number().positive(),
+          lastPage: z56.coerce.number().positive(),
+          total: z56.coerce.number().positive(),
+          agentMessageStatistics: z56.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: z56.object({
+        automationQueueId: z56.string().uuid().optional(),
+        selectedDate: z56.string().min(1),
+        keyword: z56.string().optional(),
+        page: z56.coerce.number().positive(),
+        pageSize: z56.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          page: z56.coerce.number().positive(),
+          pageSize: z56.coerce.number().positive(),
+          total: z56.coerce.number().positive(),
+          userCheckInLogsWithDays: z56.array(UserCheckInLogsWithDaySchema)
+        })
+      }
+    },
+    exportUserCheckInLogs: {
+      method: "GET",
+      path: "/export-user-check-in-logs",
+      query: z56.object({
+        automationQueueId: z56.string().uuid().optional(),
+        selectedDate: z56.string().min(1),
+        keyword: z56.string().optional(),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
+    getRoomStatusCountsByUserId: {
+      method: "GET",
+      path: "/room-status-counts-by-user-id",
+      query: z56.object({
+        automationQueueId: z56.string().optional(),
+        userId: z56.string().uuid(),
+        selectedDate: z56.string().min(1)
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          assignedRoomCount: z56.number(),
+          holdRoomCount: z56.number(),
+          closedRoomCount: z56.number()
+        })
+      }
+    },
+    getPresenceStatusDurations: {
+      method: "GET",
+      path: "/presence-status-durations",
+      query: z56.object({
+        userId: z56.string().uuid(),
+        selectedDate: z56.string().min(1),
+        page: z56.coerce.number().positive(),
+        pageSize: z56.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          presenceStatusDurations: z56.array(
+            z56.object({
+              formattedDate: z56.string(),
+              date: z56.date(),
+              presenceStatusDurationLogs: z56.array(
+                z56.object({
+                  presenceStatusId: z56.string().uuid(),
+                  presenceStatusName: z56.string(),
+                  durationSeconds: z56.number().positive()
+                })
+              )
+            })
+          ),
+          page: z56.coerce.number().positive(),
+          pageSize: z56.coerce.number().positive(),
+          total: z56.coerce.number().positive()
+        })
+      }
+    },
+    getUserCheckInLogsByUserId: {
+      method: "GET",
+      path: "/user-check-in-logs-by-user-id",
+      query: z56.object({
+        automationQueueId: z56.string().uuid().optional(),
+        userId: z56.string().uuid(),
+        selectedDate: z56.string().min(1),
+        page: z56.coerce.number().positive(),
+        pageSize: z56.coerce.number().positive()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          userCheckInLogs: z56.array(
+            z56.object({
+              formattedDate: z56.string(),
+              day: z56.date(),
+              userCheckInLog: UserCheckInLogSchema
+            })
+          ),
+          page: z56.coerce.number().positive(),
+          pageSize: z56.coerce.number().positive(),
+          total: z56.coerce.number().positive()
+        })
+      }
+    },
+    exportUserCheckInLogsByUserId: {
+      method: "GET",
+      path: "/export-user-check-in-logs-by-user-id",
+      query: z56.object({
+        userId: z56.string().uuid(),
+        selectedDate: z56.string().min(1),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
     }
   },
   {
@@ -4645,14 +4979,14 @@ var dashboardContract = initContract13().router(
 );
 
 // src/evaluate-form/index.ts
-import z57 from "zod";
+import z58 from "zod";
 
 // src/evaluate-form/validation.ts
-import z56 from "zod";
-var CreateEvaluateFormSchema = z56.object({
-  cxLogId: z56.string().uuid(),
-  sentimentScore: z56.string().nullable().optional(),
-  csatScore: z56.string().nullable().optional()
+import z57 from "zod";
+var CreateEvaluateFormSchema = z57.object({
+  cxLogId: z57.string().uuid(),
+  sentimentScore: z57.string().nullable().optional(),
+  csatScore: z57.string().nullable().optional()
 });
 var UpdateEvaluateFormSchema = CreateEvaluateFormSchema.partial();
 
@@ -4666,7 +5000,7 @@ var evaluateFormContract = initContract14().router(
       body: CreateEvaluateFormSchema,
       responses: {
         201: DefaultSuccessResponseSchema.extend({
-          message: z57.string()
+          message: z58.string()
         }),
         401: DefaultUnauthorizedSchema
       },
@@ -4678,18 +5012,18 @@ var evaluateFormContract = initContract14().router(
 
 // src/extension/index.ts
 import { initContract as initContract15 } from "@ts-rest/core";
-import z59 from "zod";
+import z60 from "zod";
 
 // src/extension/validation.ts
-import { z as z58 } from "zod";
-var CreateExtensionSchema = z58.object({
-  userId: z58.string().nullable(),
-  sipUserName: z58.string(),
-  sipServerUrl: z58.string().optional(),
-  webphoneLoginUser: z58.string(),
-  extensionId: z58.string().nullable(),
-  extensionName: z58.string().nullable(),
-  telephonySignature: z58.string().nullable().optional()
+import { z as z59 } from "zod";
+var CreateExtensionSchema = z59.object({
+  userId: z59.string().nullable(),
+  sipUserName: z59.string(),
+  sipServerUrl: z59.string().optional(),
+  webphoneLoginUser: z59.string(),
+  extensionId: z59.string().nullable(),
+  extensionName: z59.string().nullable(),
+  telephonySignature: z59.string().nullable().optional()
 });
 var UpdateExtensionSchema = CreateExtensionSchema;
 
@@ -4705,8 +5039,8 @@ var extensionContract = initContract15().router(
         201: DefaultSuccessResponseSchema.extend({
           extension: ExtensionSchema
         }),
-        400: z59.object({
-          message: z59.string()
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4718,33 +5052,33 @@ var extensionContract = initContract15().router(
     getExtensions: {
       method: "GET",
       path: "",
-      query: z59.object({
-        page: z59.coerce.number().default(1),
-        pageSize: z59.coerce.number().default(10),
-        keyword: z59.string().optional()
+      query: z60.object({
+        page: z60.coerce.number().default(1),
+        pageSize: z60.coerce.number().default(10),
+        keyword: z60.string().optional()
       }).optional(),
       headers: DefaultHeaderSchema,
       responses: {
         200: WithPagination(
           // The response data should contain the user relation.
           ExtensionSchema.extend({
-            user: z59.object({
-              id: z59.string().uuid(),
-              createdAt: z59.date(),
-              updatedAt: z59.date(),
-              deletedAt: z59.date().nullable(),
-              name: z59.string(),
-              email: z59.string().email(),
-              emailVerifiedAt: z59.date().nullable(),
-              password: z59.string(),
-              address: z59.string().nullable(),
-              phone: z59.string().nullable(),
-              notificationCount: z59.number().nullable()
+            user: z60.object({
+              id: z60.string().uuid(),
+              createdAt: z60.date(),
+              updatedAt: z60.date(),
+              deletedAt: z60.date().nullable(),
+              name: z60.string(),
+              email: z60.string().email(),
+              emailVerifiedAt: z60.date().nullable(),
+              password: z60.string(),
+              address: z60.string().nullable(),
+              phone: z60.string().nullable(),
+              notificationCount: z60.number().nullable()
             })
           })
         ),
-        400: z59.object({
-          message: z59.string()
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4756,12 +5090,12 @@ var extensionContract = initContract15().router(
     getExtensionByUserId: {
       method: "GET",
       path: "/user/:userId",
-      pathParams: z59.object({ userId: z59.string() }),
+      pathParams: z60.object({ userId: z60.string() }),
       headers: DefaultHeaderSchema,
       responses: {
         200: ExtensionSchema,
-        400: z59.object({
-          message: z59.string()
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4773,16 +5107,16 @@ var extensionContract = initContract15().router(
     getExtensionByDialpad: {
       method: "GET",
       path: "/dialpad",
-      query: z59.object({
-        page: z59.coerce.number().default(1),
-        pageSize: z59.coerce.number().default(10),
-        keyword: z59.string().optional()
+      query: z60.object({
+        page: z60.coerce.number().default(1),
+        pageSize: z60.coerce.number().default(10),
+        keyword: z60.string().optional()
       }).optional(),
       headers: DefaultHeaderSchema,
       responses: {
         200: WithPagination(ExtensionSchema),
-        400: z59.object({
-          message: z59.string()
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4794,15 +5128,15 @@ var extensionContract = initContract15().router(
     updateExtension: {
       method: "PATCH",
       path: "/:id",
-      pathParams: z59.object({ id: z59.string() }),
+      pathParams: z60.object({ id: z60.string() }),
       headers: DefaultHeaderSchema,
       body: UpdateExtensionSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           extension: ExtensionSchema
         }),
-        400: z59.object({
-          message: z59.string()
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4814,13 +5148,13 @@ var extensionContract = initContract15().router(
     deleteExtension: {
       method: "DELETE",
       path: "/:id",
-      pathParams: z59.object({ id: z59.string() }),
+      pathParams: z60.object({ id: z60.string() }),
       headers: DefaultHeaderSchema,
       body: null,
       responses: {
-        200: DefaultSuccessResponseSchema.extend({ message: z59.string() }),
-        400: z59.object({
-          message: z59.string()
+        200: DefaultSuccessResponseSchema.extend({ message: z60.string() }),
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4836,10 +5170,10 @@ var extensionContract = initContract15().router(
       body: null,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          message: z59.string()
+          message: z60.string()
         }),
-        400: z59.object({
-          message: z59.string()
+        400: z60.object({
+          message: z60.string()
         }),
         401: DefaultUnauthorizedSchema,
         404: DefaultNotFoundSchema,
@@ -4854,7 +5188,7 @@ var extensionContract = initContract15().router(
 
 // src/instagram/index.ts
 import { initContract as initContract16 } from "@ts-rest/core";
-import z60 from "zod";
+import z61 from "zod";
 var instagramContract = initContract16().router({
   sendMessage: {
     method: "POST",
@@ -4888,8 +5222,8 @@ var instagramContract = initContract16().router({
   reconnect: {
     method: "POST",
     path: "/reconnect/:channelId",
-    pathParams: z60.object({
-      channelId: z60.string().uuid()
+    pathParams: z61.object({
+      channelId: z61.string().uuid()
     }),
     body: null,
     responses: {
@@ -4901,8 +5235,8 @@ var instagramContract = initContract16().router({
   delete: {
     method: "DELETE",
     path: "/delete/:channelId",
-    pathParams: z60.object({
-      channelId: z60.string().uuid()
+    pathParams: z61.object({
+      channelId: z61.string().uuid()
     }),
     body: null,
     responses: {
@@ -4943,84 +5277,84 @@ var instagramContract = initContract16().router({
 
 // src/line/index.ts
 import { initContract as initContract17 } from "@ts-rest/core";
-import z63 from "zod";
+import z64 from "zod";
 
 // src/line/schema.ts
-import z61 from "zod";
+import z62 from "zod";
 var ConnectLineService = ConnectLineChannelSchema.extend({
-  actor: z61.object({
-    id: z61.string().uuid(),
-    name: z61.string(),
-    email: z61.string().email(),
-    address: z61.string().nullable(),
-    phone: z61.string().nullable()
+  actor: z62.object({
+    id: z62.string().uuid(),
+    name: z62.string(),
+    email: z62.string().email(),
+    address: z62.string().nullable(),
+    phone: z62.string().nullable()
   }).optional()
 });
 
 // src/line/validation.ts
-import z62 from "zod";
-var SendLineStickerSchema = z62.object({
-  packageId: z62.number(),
-  stickerId: z62.number(),
-  room: z62.object({
-    id: z62.string().uuid(),
-    lastMessage: z62.string().optional(),
-    handleTime: z62.number().optional(),
-    isLatest: z62.boolean(),
+import z63 from "zod";
+var SendLineStickerSchema = z63.object({
+  packageId: z63.number(),
+  stickerId: z63.number(),
+  room: z63.object({
+    id: z63.string().uuid(),
+    lastMessage: z63.string().optional(),
+    handleTime: z63.number().optional(),
+    isLatest: z63.boolean(),
     direction: MessageDirectionTypeSchema,
-    platformContact: z62.object({
-      channelId: z62.string().uuid(),
-      socialPlatformId: z62.string().nullable(),
+    platformContact: z63.object({
+      channelId: z63.string().uuid(),
+      socialPlatformId: z63.string().nullable(),
       type: ChannelTypeSchema,
       metadata: PlatformContactMetadataSchema,
-      contact: z62.object({
-        name: z62.string(),
-        address: z62.string().nullable(),
-        channel: z62.string().nullable(),
-        notes: z62.string().nullable(),
-        contactProfile: z62.string().nullable(),
-        socialProfileUrl: z62.string().nullable()
+      contact: z63.object({
+        name: z63.string(),
+        address: z63.string().nullable(),
+        channel: z63.string().nullable(),
+        notes: z63.string().nullable(),
+        contactProfile: z63.string().nullable(),
+        socialProfileUrl: z63.string().nullable()
       })
     }),
-    actor: z62.object({
-      name: z62.string(),
-      email: z62.string().email(),
-      address: z62.string().nullable(),
-      phone: z62.string().nullable()
+    actor: z63.object({
+      name: z63.string(),
+      email: z63.string().email(),
+      address: z63.string().nullable(),
+      phone: z63.string().nullable()
     }).nullable(),
     channel: ChannelSchema2
   }),
-  message: z62.object({
-    message: z62.string().optional(),
+  message: z63.object({
+    message: z63.string().optional(),
     direction: MessageDirectionTypeSchema,
     type: MessageTypeSchema,
-    readAt: z62.date().optional(),
-    metadata: z62.any().optional(),
-    platformId: z62.string().optional(),
-    platformMessageId: z62.string().optional(),
-    replyPlatformMessageId: z62.string().optional(),
-    template: z62.any().optional(),
+    readAt: z63.date().optional(),
+    metadata: z63.any().optional(),
+    platformId: z63.string().optional(),
+    platformMessageId: z63.string().optional(),
+    replyPlatformMessageId: z63.string().optional(),
+    template: z63.any().optional(),
     locale: MessageLocaleTypeSchema.optional(),
-    url: z62.string().optional(),
-    previewUrl: z62.string().optional(),
-    imageSetId: z62.string().optional(),
-    upload: z62.object({
-      bucketName: z62.string(),
-      fileName: z62.string(),
-      fileSize: z62.number(),
-      fileKey: z62.string()
+    url: z63.string().optional(),
+    previewUrl: z63.string().optional(),
+    imageSetId: z63.string().optional(),
+    upload: z63.object({
+      bucketName: z63.string(),
+      fileName: z63.string(),
+      fileSize: z63.number(),
+      fileKey: z63.string()
     }).optional(),
-    sender: z62.object({
-      name: z62.string(),
-      email: z62.string().email(),
-      address: z62.string().nullable(),
-      phone: z62.string().nullable()
+    sender: z63.object({
+      name: z63.string(),
+      email: z63.string().email(),
+      address: z63.string().nullable(),
+      phone: z63.string().nullable()
     })
   })
 });
-var createUserLevelRichMenuSchema = z62.object({
-  linePlatformUserId: z62.string(),
-  channelId: z62.string()
+var createUserLevelRichMenuSchema = z63.object({
+  linePlatformUserId: z63.string(),
+  channelId: z63.string()
 });
 
 // src/line/index.ts
@@ -5030,7 +5364,7 @@ var lineContract = initContract17().router({
     path: "sticker",
     responses: {
       200: DefaultSuccessResponseSchema.extend({
-        data: z63.any()
+        data: z64.any()
       }),
       500: DefaultErrorResponseSchema
     },
@@ -5053,7 +5387,7 @@ var lineContract = initContract17().router({
     path: "/message",
     body: SendMessageToPlatformSchema,
     responses: {
-      200: z63.union([SendMessageResponseSchema, z63.literal("TALK TO AGENT")]),
+      200: z64.union([SendMessageResponseSchema, z64.literal("TALK TO AGENT")]),
       500: DefaultErrorResponseSchema
     }
   },
@@ -5070,8 +5404,8 @@ var lineContract = initContract17().router({
   reconnect: {
     method: "POST",
     path: "/reconnect/:channelId",
-    pathParams: z63.object({
-      channelId: z63.string().uuid()
+    pathParams: z64.object({
+      channelId: z64.string().uuid()
     }),
     body: null,
     responses: {
@@ -5083,8 +5417,8 @@ var lineContract = initContract17().router({
   delete: {
     method: "DELETE",
     path: "/delete/:channelId",
-    pathParams: z63.object({
-      channelId: z63.string().uuid()
+    pathParams: z64.object({
+      channelId: z64.string().uuid()
     }),
     body: null,
     responses: {
@@ -5106,7 +5440,7 @@ var lineContract = initContract17().router({
 
 // src/mail/email-engine-webhooks-events.contract.ts
 import { initContract as initContract18 } from "@ts-rest/core";
-import z64 from "zod";
+import z65 from "zod";
 var emailEngineWebhooksEventsContract = initContract18().router(
   {
     handleWebhooksEvents: {
@@ -5115,7 +5449,7 @@ var emailEngineWebhooksEventsContract = initContract18().router(
       // we don't need to respone anything but added responses just for solving type error
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          message: z64.string()
+          message: z65.string()
         })
       },
       body: null,
@@ -5127,7 +5461,7 @@ var emailEngineWebhooksEventsContract = initContract18().router(
 
 // src/messenger/index.ts
 import { initContract as initContract19 } from "@ts-rest/core";
-import z65 from "zod";
+import z66 from "zod";
 var messengerContract = initContract19().router({
   sendMessage: {
     method: "POST",
@@ -5162,8 +5496,8 @@ var messengerContract = initContract19().router({
   reconnect: {
     method: "POST",
     path: "/reconnect/:channelId",
-    pathParams: z65.object({
-      channelId: z65.string().uuid()
+    pathParams: z66.object({
+      channelId: z66.string().uuid()
     }),
     body: null,
     responses: {
@@ -5175,8 +5509,8 @@ var messengerContract = initContract19().router({
   delete: {
     method: "DELETE",
     path: "/delete/:channelId",
-    pathParams: z65.object({
-      channelId: z65.string().uuid()
+    pathParams: z66.object({
+      channelId: z66.string().uuid()
     }),
     body: null,
     responses: {
@@ -5207,9 +5541,9 @@ var messengerContract = initContract19().router({
   getFacebookBusinesses: {
     method: "GET",
     path: "/facebook-businesses",
-    query: z65.object({
-      userId: z65.string(),
-      userAccessToken: z65.string()
+    query: z66.object({
+      userId: z66.string(),
+      userAccessToken: z66.string()
     }),
     responses: {
       200: DefaultSuccessResponseSchema,
@@ -5219,9 +5553,9 @@ var messengerContract = initContract19().router({
   getFacebookBusinessPages: {
     method: "GET",
     path: "/facebook-business-pages",
-    query: z65.object({
-      businessId: z65.string(),
-      userAccessToken: z65.string()
+    query: z66.object({
+      businessId: z66.string(),
+      userAccessToken: z66.string()
     }),
     responses: {
       200: DefaultSuccessResponseSchema,
@@ -5241,7 +5575,7 @@ var messengerContract = initContract19().router({
 
 // src/permission/index.ts
 import { initContract as initContract20 } from "@ts-rest/core";
-import z66 from "zod";
+import z67 from "zod";
 var permissionContract = initContract20().router(
   {
     getPermissions: {
@@ -5249,9 +5583,9 @@ var permissionContract = initContract20().router(
       path: "",
       headers: DefaultHeaderSchema,
       responses: {
-        200: z66.object({ permissions: PermissionSchema.array() }),
-        400: z66.object({
-          message: z66.string()
+        200: z67.object({ permissions: PermissionSchema.array() }),
+        400: z67.object({
+          message: z67.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5264,15 +5598,15 @@ var permissionContract = initContract20().router(
 
 // src/role/index.ts
 import { initContract as initContract21 } from "@ts-rest/core";
-import z68 from "zod";
+import z69 from "zod";
 
 // src/role/validation.ts
-import { z as z67 } from "zod";
-var CreateRoleSchema = z67.object({
-  systemName: z67.string(),
-  displayName: z67.string(),
-  description: z67.string().nullable(),
-  permissions: z67.array(z67.string())
+import { z as z68 } from "zod";
+var CreateRoleSchema = z68.object({
+  systemName: z68.string(),
+  displayName: z68.string(),
+  description: z68.string().nullable(),
+  permissions: z68.array(z68.string())
 });
 var UpdateRoleSchema = CreateRoleSchema;
 
@@ -5288,8 +5622,8 @@ var roleContract = initContract21().router(
         201: DefaultSuccessResponseSchema.extend({
           role: RoleSchema
         }),
-        400: z68.object({
-          message: z68.string()
+        400: z69.object({
+          message: z69.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5299,17 +5633,17 @@ var roleContract = initContract21().router(
     getRoles: {
       method: "GET",
       path: "",
-      query: z68.object({
-        page: z68.coerce.number().default(1),
-        pageSize: z68.coerce.number().default(10)
+      query: z69.object({
+        page: z69.coerce.number().default(1),
+        pageSize: z69.coerce.number().default(10)
       }).optional(),
       headers: DefaultHeaderSchema,
       responses: {
         200: WithPagination(RoleSchema).extend({
           roleUserCount: RoleUserCountSchema
         }),
-        400: z68.object({
-          message: z68.string()
+        400: z69.object({
+          message: z69.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5319,15 +5653,15 @@ var roleContract = initContract21().router(
     updateRole: {
       method: "PATCH",
       path: "/:id",
-      pathParams: z68.object({ id: z68.string() }),
+      pathParams: z69.object({ id: z69.string() }),
       headers: DefaultHeaderSchema,
       body: UpdateRoleSchema,
       responses: {
         201: DefaultSuccessResponseSchema.extend({
           role: RoleSchema
         }),
-        400: z68.object({
-          message: z68.string()
+        400: z69.object({
+          message: z69.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5337,11 +5671,11 @@ var roleContract = initContract21().router(
     deleteRole: {
       method: "DELETE",
       path: "/:id",
-      pathParams: z68.object({ id: z68.string() }),
+      pathParams: z69.object({ id: z69.string() }),
       headers: DefaultHeaderSchema,
       body: null,
       responses: {
-        200: DefaultSuccessResponseSchema.extend({ message: z68.string() }),
+        200: DefaultSuccessResponseSchema.extend({ message: z69.string() }),
         500: DefaultErrorResponseSchema
       },
       summary: "Delete a role."
@@ -5349,12 +5683,12 @@ var roleContract = initContract21().router(
     getRoleById: {
       method: "GET",
       path: "/:id",
-      pathParams: z68.object({ id: z68.string() }),
+      pathParams: z69.object({ id: z69.string() }),
       headers: DefaultHeaderSchema,
       responses: {
         200: RoleSchema,
-        400: z68.object({
-          message: z68.string()
+        400: z69.object({
+          message: z69.string()
         }),
         401: DefaultUnauthorizedSchema,
         500: DefaultErrorResponseSchema
@@ -5367,19 +5701,19 @@ var roleContract = initContract21().router(
 
 // src/tag/index.ts
 import { initContract as initContract22 } from "@ts-rest/core";
-import z70 from "zod";
+import z71 from "zod";
 
 // src/tag/validation.ts
-import { z as z69 } from "zod";
-var CreateTagSchema = z69.object({
-  name: z69.string(),
+import { z as z70 } from "zod";
+var CreateTagSchema = z70.object({
+  name: z70.string(),
   group: TagGroupSchema
 });
-var GetTagsSchema = z69.object({
+var GetTagsSchema = z70.object({
   group: TagGroupSchema.default("general"),
-  keyword: z69.string()
+  keyword: z70.string()
 }).partial().optional();
-var UpdateTagSchema = z69.object({ name: z69.string() });
+var UpdateTagSchema = z70.object({ name: z70.string() });
 
 // src/tag/index.ts
 var tagContract = initContract22().router(
@@ -5402,7 +5736,7 @@ var tagContract = initContract22().router(
       query: GetTagsSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          tags: z70.array(TagSchema)
+          tags: z71.array(TagSchema)
         }),
         500: DefaultErrorResponseSchema
       },
@@ -5411,7 +5745,7 @@ var tagContract = initContract22().router(
     updateTag: {
       method: "PATCH",
       path: "/:id",
-      pathParams: z70.object({ id: z70.string() }),
+      pathParams: z71.object({ id: z71.string() }),
       body: UpdateTagSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -5424,11 +5758,11 @@ var tagContract = initContract22().router(
     deleteTag: {
       method: "DELETE",
       path: "/:id",
-      pathParams: z70.object({ id: z70.string() }),
-      body: z70.any().optional(),
+      pathParams: z71.object({ id: z71.string() }),
+      body: z71.any().optional(),
       // We don't need the body.
       responses: {
-        200: DefaultSuccessResponseSchema.extend({ message: z70.string() }),
+        200: DefaultSuccessResponseSchema.extend({ message: z71.string() }),
         500: DefaultErrorResponseSchema
       },
       headers: DefaultHeaderSchema
@@ -5443,31 +5777,31 @@ var tagContract = initContract22().router(
 import { initContract as initContract23 } from "@ts-rest/core";
 import z74 from "zod";
 
-// src/telephony-agent-presence-status/schema.ts
-import z72 from "zod";
-
 // src/presence-status/schema.ts
-import z71 from "zod";
-var PresenceStatusDesEnum = z71.enum([
-  "Can do everything.",
-  "Mute all notifications.",
-  `You won't receive call, but can still do other.`
+import z72 from "zod";
+var TPresenceStatusOption = z72.union([
+  z72.literal("receive_call"),
+  z72.literal("do_not_receive_call"),
+  z72.literal("receive_chat_message"),
+  z72.literal("do_not_receive_chat_message")
 ]);
-var PresenceStatusSchema = z71.object({
-  id: z71.string().uuid(),
-  createdAt: z71.date(),
-  updatedAt: z71.date(),
-  deletedAt: z71.date().nullable(),
-  status: z71.string(),
-  description: PresenceStatusDesEnum,
-  position: z71.number()
+var PresenceStatusSchema = z72.object({
+  id: z72.string().uuid(),
+  createdAt: z72.date(),
+  updatedAt: z72.date(),
+  deletedAt: z72.date().nullable(),
+  systemName: z72.string(),
+  displayName: z72.string(),
+  description: z72.string().nullable(),
+  position: z72.number(),
+  emoji: z72.string().nullable(),
+  presenceStatusOption: z72.array(TPresenceStatusOption)
 });
 
 // src/telephony-agent-presence-status/schema.ts
 var UserPresenceStatusSchema = DefaultEntitySchema.extend({
   user: UserSchema,
-  presenceStatus: PresenceStatusSchema,
-  customPresenceStatus: z72.string().nullable().optional()
+  presenceStatus: PresenceStatusSchema
 });
 
 // src/telephony-agent-presence-status/validation.ts
@@ -5475,27 +5809,12 @@ import { z as z73 } from "zod";
 var UpdateUserStatusSchema = z73.object({
   userId: z73.string(),
   presenceStatusId: z73.string().nullable().optional(),
-  customPreseneStatus: z73.string().nullable().optional(),
   reason: z73.string()
 });
 
 // src/telephony-agent-presence-status/index.ts
 var telephonyAgentPresenceStatusContract = initContract23().router(
   {
-    getAllAgentStatus: {
-      method: "GET",
-      path: "/agents/presence_status",
-      headers: DefaultHeaderSchema,
-      responses: {
-        200: z74.array(UserPresenceStatusSchema),
-        400: z74.object({
-          message: z74.string()
-        }),
-        401: DefaultUnauthorizedSchema,
-        500: DefaultErrorResponseSchema
-      },
-      summary: "Get all user presence status list."
-    },
     getAgentStatus: {
       method: "GET",
       path: "/presence_status/check_update/:userId",
@@ -8357,7 +8676,7 @@ var botpressContract = initContract40().router(
       body: SendBotpressMessageSchema
     }
   },
-  { pathPrefix: "/bots" }
+  { pathPrefix: "bots" }
 );
 var botContract = initContract40().router(
   {
@@ -8386,7 +8705,7 @@ var botContract = initContract40().router(
     }
   },
   {
-    pathPrefix: "bots"
+    pathPrefix: "ms/bots"
   }
 );
 
@@ -8397,9 +8716,12 @@ import z113 from "zod";
 // src/presence-status/validation.ts
 import { z as z112 } from "zod";
 var CreatePresenceStatusSchema = z112.object({
-  status: z112.string(),
-  description: PresenceStatusDesEnum,
-  position: z112.number()
+  systemName: z112.string(),
+  displayName: z112.string(),
+  description: z112.string().optional(),
+  position: z112.number(),
+  emoji: z112.string(),
+  presenceStatusOption: z112.array(TPresenceStatusOption)
 });
 var UpdatePresenceStatusSchema = CreatePresenceStatusSchema;
 
@@ -8919,7 +9241,8 @@ var automationQueueContract = initContract45().router(
       method: "GET",
       path: "",
       query: z118.object({
-        userId: z118.string().uuid().optional()
+        userId: z118.string().uuid().optional(),
+        withRelations: z118.coerce.boolean().default(true).optional()
       }).optional(),
       responses: {
         200: DefaultSuccessResponseSchema.extend({
@@ -10408,6 +10731,32 @@ var settingCxIntelligenceContract = initContract54().router(
   },
   { pathPrefix: "settings/cx-intelligence" }
 );
+
+// src/export/index.ts
+import { initContract as initContract55 } from "@ts-rest/core";
+import z139 from "zod";
+var exportContract = initContract55().router(
+  {
+    notifyExport: {
+      method: "POST",
+      path: "notify",
+      body: z139.object({
+        userId: z139.string().uuid(),
+        module: z139.string(),
+        fileUrl: z139.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          success: z139.boolean()
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    }
+  },
+  {
+    pathPrefix: "export/"
+  }
+);
 export {
   activityLogContract,
   apiContract,
@@ -10436,6 +10785,7 @@ export {
   cxLogContract,
   dashboardContract,
   evaluateFormContract,
+  exportContract,
   extensionContract2 as extensionContract,
   facebookFeedContract2 as facebookFeedContract,
   feedPostContract,
@@ -10478,6 +10828,7 @@ export {
   userContract,
   userNotificationContract,
   userPresenceStatusLogContract,
+  widgetContract,
   widgetSettingContract,
   workflowContract,
   wrapUpFormContract