@kl1/contracts 1.3.20 → 1.3.23

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
@@ -302,8 +304,19 @@ var ChannelMetadataSchema = import_zod6.default.object({
   }).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()
-});
+  facebookFeedIntegrationType: import_zod6.default.union([import_zod6.default.literal("own"), import_zod6.default.literal("business")]).optional(),
+  isCSATEnabled: import_zod6.default.boolean().optional()
+});
+var CsatPreferencesSchema = import_zod6.default.object({
+  image: import_zod6.default.string().optional().nullable(),
+  headline: import_zod6.default.string(),
+  scaleOptions: import_zod6.default.array(
+    import_zod6.default.object({
+      value: import_zod6.default.string(),
+      label: import_zod6.default.string().optional().nullable()
+    })
+  )
+}).optional().nullable();
 var ChannelSchema = import_zod6.default.object({
   id: import_zod6.default.string().uuid(),
   createdAt: import_zod6.default.date(),
@@ -705,55 +718,58 @@ 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",
-  // botpress specific
-  "carousel",
-  "card",
-  "choice",
-  "dropdown",
-  "text_with_image",
-  "reaction",
-  "contacts",
+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",
+  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"),
   // messenger referral
-  "referral",
+  import_zod18.default.literal("referral"),
   // system
-  "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")
+];
+var MessageTypeSchema = import_zod18.default.union(messageTypes);
 var FeedPostTypeSchema = import_zod18.default.enum([
   "text",
   "added_photos",
@@ -793,6 +809,7 @@ var RoomSchema = DefaultEntitySchema.extend({
   isBotRoom: import_zod18.default.boolean(),
   direction: MessageDirectionTypeSchema,
   platformContact: PlatformContactSchema,
+  csatStatus: import_zod18.default.string().nullable(),
   actor: import_zod18.default.object({
     id: import_zod18.default.string().uuid(),
     createdAt: import_zod18.default.date(),
@@ -1325,7 +1342,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(),
@@ -1822,7 +1841,7 @@ var activityLogContract = (0, import_core2.initContract)().router(
       summary: "Get all activity logs"
     }
   },
-  { pathPrefix: "activity-log" }
+  { pathPrefix: "ms/activity-log" }
 );
 
 // src/attribute/index.ts
@@ -1947,7 +1966,7 @@ var attributeContract = (0, import_core3.initContract)().router(
     }
   },
   {
-    pathPrefix: "attributes"
+    pathPrefix: "ms/attributes"
   }
 );
 
@@ -1970,7 +1989,7 @@ var authContract = (0, import_core4.initContract)().router(
       summary: "Get current user"
     }
   },
-  { pathPrefix: "auth" }
+  { pathPrefix: "ms/auth" }
 );
 
 // src/aws/index.ts
@@ -2034,7 +2053,7 @@ var awsContract = (0, import_core5.initContract)().router(
     }
   },
   {
-    pathPrefix: "aws/s3"
+    pathPrefix: "ms/aws/s3"
   }
 );
 
@@ -2162,7 +2181,7 @@ var categoryContract = (0, import_core6.initContract)().router(
     }
   },
   {
-    pathPrefix: "categories"
+    pathPrefix: "ms/categories"
   }
 );
 
@@ -2261,7 +2280,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()
@@ -2284,6 +2304,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"));
@@ -2432,7 +2456,7 @@ var messenger = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/messenger"
+    pathPrefix: "messenger"
   }
 );
 var instagram = (0, import_core7.initContract)().router(
@@ -2462,7 +2486,7 @@ var instagram = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/instagram"
+    pathPrefix: "instagram"
   }
 );
 var line = (0, import_core7.initContract)().router(
@@ -2479,7 +2503,7 @@ var line = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/line"
+    pathPrefix: "line"
   }
 );
 var webchat = (0, import_core7.initContract)().router(
@@ -2499,7 +2523,7 @@ var webchat = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/webchat"
+    pathPrefix: "webchat"
   }
 );
 var viber = (0, import_core7.initContract)().router(
@@ -2519,7 +2543,7 @@ var viber = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/viber"
+    pathPrefix: "viber"
   }
 );
 var telegram = (0, import_core7.initContract)().router(
@@ -2539,7 +2563,7 @@ var telegram = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/telegram"
+    pathPrefix: "telegram"
   }
 );
 var whatsapp = (0, import_core7.initContract)().router(
@@ -2600,14 +2624,33 @@ var whatsapp = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/whatsapp"
+    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: "/",
+      path: "channel",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           data: ChannelSchema.array()
@@ -2618,7 +2661,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     disconnect: {
       method: "POST",
-      path: "/disconnect/:channelId",
+      path: "channel/disconnect/:channelId",
       pathParams: import_zod41.default.object({
         channelId: import_zod41.default.string().uuid()
       }),
@@ -2633,7 +2676,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     delete: {
       method: "DELETE",
-      path: "/delete/:channelId",
+      path: "channel/delete/:channelId",
       pathParams: import_zod41.default.object({
         channelId: import_zod41.default.string().uuid()
       }),
@@ -2648,7 +2691,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     rename: {
       method: "POST",
-      path: "/rename/:channelId",
+      path: "channel/rename/:channelId",
       pathParams: import_zod41.default.object({
         channelId: import_zod41.default.string().uuid()
       }),
@@ -2665,7 +2708,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     reconnect: {
       method: "POST",
-      path: "/reconnect/:channelId",
+      path: "channel/reconnect/:channelId",
       pathParams: import_zod41.default.object({
         channelId: import_zod41.default.string().uuid()
       }),
@@ -2682,7 +2725,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     relogin: {
       method: "POST",
-      path: "/relogin",
+      path: "channel/relogin",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           channel: ChannelSchema
@@ -2694,7 +2737,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     checknewTenant: {
       method: "GET",
-      path: "/check-new-tenant",
+      path: "channel/check-new-tenant",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           data: tenantCheckedSchema
@@ -2705,7 +2748,7 @@ var channelContract = (0, import_core7.initContract)().router(
     },
     updateNewTenant: {
       method: "PATCH",
-      path: "/update-new-tenant",
+      path: "channel/update-new-tenant",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           message: import_zod41.default.string()
@@ -2718,17 +2761,34 @@ var channelContract = (0, import_core7.initContract)().router(
       }),
       summary: "Update new tenant"
     },
+    updateChannelCsatPreference: {
+      method: "POST",
+      path: "csat/:channelId",
+      pathParams: import_zod41.default.object({
+        channelId: import_zod41.default.string().uuid()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          channel: ChannelSchema
+        }),
+        408: DefaultErrorResponseSchema
+      },
+      body: import_zod41.default.object({
+        isCSATEnabled: import_zod41.default.boolean()
+      }),
+      summary: "Enable or Disable CSAT for channel"
+    },
     messenger,
     line,
     instagram,
     viber,
     telegram,
     webchat,
-    whatsapp
+    whatsapp,
+    lazada
   },
   {
-    baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "channel"
+    baseHeaders: DefaultHeaderSchema
   }
 );
 var channelFacebookFeedContract = (0, import_core7.initContract)().router(
@@ -2758,7 +2818,7 @@ var channelFacebookFeedContract = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/facebook-feed"
+    pathPrefix: "ms/facebook-feed"
   }
 );
 var channelBotContract = (0, import_core7.initContract)().router({
@@ -2799,7 +2859,7 @@ var channelSMSContract = (0, import_core7.initContract)().router(
     }
   },
   {
-    pathPrefix: "/channel/sms"
+    pathPrefix: "channel/sms"
   }
 );
 
@@ -2824,14 +2884,14 @@ var receiveMessageContract = (0, import_core8.initContract)().router(
       "x-code": import_zod42.default.string().uuid(),
       "x-tenant": import_zod42.default.string().uuid()
     }),
-    pathPrefix: "message"
+    pathPrefix: "ms/message"
   }
 );
 var mainFeedContract = (0, import_core8.initContract)().router(
   {
     getFeedPostById: {
       method: "GET",
-      path: "/feed-post/:id",
+      path: "/:id",
       pathParams: import_zod42.default.object({
         id: import_zod42.default.string().uuid()
       }),
@@ -2844,7 +2904,7 @@ var mainFeedContract = (0, import_core8.initContract)().router(
     },
     getMessagesByParent: {
       method: "GET",
-      path: "/feed-post/message/:parentId/relevance",
+      path: "/message/:parentId/relevance",
       pathParams: import_zod42.default.object({
         parentId: import_zod42.default.string().uuid()
       }),
@@ -2861,7 +2921,8 @@ var mainFeedContract = (0, import_core8.initContract)().router(
     }
   },
   {
-    baseHeaders: DefaultHeaderSchema
+    baseHeaders: DefaultHeaderSchema,
+    pathPrefix: "ms/feed-post"
   }
 );
 var mainChatRoomContract = (0, import_core8.initContract)().router(
@@ -2996,7 +3057,7 @@ var mainChatRoomContract = (0, import_core8.initContract)().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 var mainChatContract = (0, import_core8.initContract)().router(
@@ -3107,7 +3168,7 @@ var mainChatContract = (0, import_core8.initContract)().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 var initiateMessageContract = (0, import_core8.initContract)().router(
@@ -3125,7 +3186,7 @@ var initiateMessageContract = (0, import_core8.initContract)().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 var mainChatMessageContract = (0, import_core8.initContract)().router(
@@ -3169,7 +3230,7 @@ var mainChatMessageContract = (0, import_core8.initContract)().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 
@@ -4145,66 +4206,69 @@ var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
 }).partial().optional();
 
 // src/cx-log/index.ts
-var cxLogContract = (0, import_core12.initContract)().router({
-  findAll: {
-    method: "GET",
-    path: "/cx-logs",
-    headers: DefaultHeaderSchema,
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({
-        total: import_zod52.default.number(),
-        page: import_zod52.default.number(),
-        pageSize: import_zod52.default.number(),
-        cxLogs: import_zod52.default.array(CxLogSchemaWithRelations)
-      }),
-      401: DefaultUnauthorizedSchema
+var cxLogContract = (0, import_core12.initContract)().router(
+  {
+    findAll: {
+      method: "GET",
+      path: "/cx-logs",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          total: import_zod52.default.number(),
+          page: import_zod52.default.number(),
+          pageSize: import_zod52.default.number(),
+          cxLogs: import_zod52.default.array(CxLogSchemaWithRelations)
+        }),
+        401: DefaultUnauthorizedSchema
+      },
+      query: GetAllCxLogQueryParamsSchema,
+      summary: "Get all cx-logs"
     },
-    query: GetAllCxLogQueryParamsSchema,
-    summary: "Get all cx-logs"
-  },
-  export: {
-    method: "GET",
-    path: "/cx-logs/export",
-    headers: DefaultHeaderSchema,
-    responses: {
-      200: null,
-      401: DefaultUnauthorizedSchema
+    export: {
+      method: "GET",
+      path: "/cx-logs/export",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: null,
+        401: DefaultUnauthorizedSchema
+      },
+      query: GetAllCxLogQueryParamsSchema,
+      summary: "Export  cx-logs"
     },
-    query: GetAllCxLogQueryParamsSchema,
-    summary: "Export  cx-logs"
-  },
-  syncSla: {
-    method: "POST",
-    path: "/cx-logs/sync-sla",
-    headers: DefaultHeaderSchema,
-    responses: {
-      200: null,
-      401: DefaultUnauthorizedSchema,
-      500: DefaultErrorResponseSchema
+    syncSla: {
+      method: "POST",
+      path: "/cx-logs/sync-sla",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: null,
+        401: DefaultUnauthorizedSchema,
+        500: DefaultErrorResponseSchema
+      },
+      body: null,
+      summary: "Export  cx-logs"
     },
-    body: null,
-    summary: "Export  cx-logs"
+    updateSla: {
+      method: "POST",
+      path: "/cx-logs",
+      headers: import_zod52.default.object({
+        // biome-ignore lint/style/useNamingConvention: <explanation>
+        "x-tenant": import_zod52.default.string({ required_error: "Tenant id is required" }),
+        "x-code": import_zod52.default.string().uuid().optional()
+      }),
+      responses: {
+        200: null,
+        403: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        500: DefaultErrorResponseSchema
+      },
+      body: import_zod52.default.object({
+        roomId: import_zod52.default.string().uuid(),
+        slaStatus: import_zod52.default.enum(["meet", "unmeet", "-"])
+      })
+    }
   },
-  updateSla: {
-    method: "POST",
-    path: "/cx-logs",
-    headers: import_zod52.default.object({
-      // biome-ignore lint/style/useNamingConvention: <explanation>
-      "x-tenant": import_zod52.default.string({ required_error: "Tenant id is required" }),
-      "x-code": import_zod52.default.string().uuid().optional()
-    }),
-    responses: {
-      200: null,
-      403: DefaultUnauthorizedSchema,
-      404: DefaultNotFoundSchema,
-      500: DefaultErrorResponseSchema
-    },
-    body: import_zod52.default.object({
-      roomId: import_zod52.default.string().uuid(),
-      slaStatus: import_zod52.default.enum(["meet", "unmeet", "-"])
-    })
-  }
-});
+  { pathPrefix: "ms" }
+);
 
 // src/dashboard/index.ts
 var import_core13 = require("@ts-rest/core");
@@ -4212,19 +4276,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()
@@ -4241,9 +4309,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"));
@@ -4398,29 +4471,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(),
@@ -4443,6 +4519,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(
@@ -4457,8 +4576,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
       }
@@ -4473,8 +4592,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
       }
@@ -4564,7 +4683,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: {
@@ -4574,6 +4697,16 @@ var dashboardContract = (0, import_core13.initContract)().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportRoomTagCounts: {
+      method: "POST",
+      path: "/export-room-tag-counts",
+      body: DashboardGlobalFiltersSchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getCallTagData: {
       method: "GET",
       path: "/call/tag",
@@ -4605,7 +4738,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({
@@ -4618,7 +4751,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({
@@ -4631,7 +4764,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({
@@ -4640,37 +4773,74 @@ var dashboardContract = (0, import_core13.initContract)().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportMessageAverageData: {
+      method: "POST",
+      path: "/export-message-average-data",
+      body: 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: "POST",
+      path: "/export-room-channel-counts",
+      body: 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: "POST",
+      path: "/export-room-disposition-counts",
+      body: 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({
@@ -4683,7 +4853,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({
@@ -4692,6 +4862,16 @@ var dashboardContract = (0, import_core13.initContract)().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportIncomingMessageCounts: {
+      method: "POST",
+      path: "/export-incoming-message-counts",
+      body: DashboardGlobalFiltersSchema.extend({
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
+    },
     getCallCounts: {
       method: "GET",
       path: "/call-counts",
@@ -4701,22 +4881,195 @@ 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)
+        })
+      }
+    },
+    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: "POST",
+      path: "/export-agent-message-statistics",
+      body: 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: "POST",
+      path: "/export-user-check-in-logs",
+      body: 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
+            })
+          )
+        })
+      }
+    },
+    exportUserCheckInLogsByUserId: {
+      method: "POST",
+      path: "/export-user-check-in-logs-by-user-id",
+      body: import_zod56.default.object({
+        userId: import_zod56.default.string().uuid(),
+        selectedDate: import_zod56.default.string().min(1),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
     }
   },
   {
-    pathPrefix: "dashboard"
+    pathPrefix: "ms/dashboard"
   }
 );
 
 // 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();
 
@@ -4730,30 +5083,30 @@ 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
       },
       summary: "Create evaluate form"
     }
   },
-  { pathPrefix: "evaluate-forms" }
+  { pathPrefix: "ms/evaluate-forms" }
 );
 
 // 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;
 
@@ -4769,8 +5122,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,
@@ -4782,33 +5135,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,
@@ -4820,12 +5173,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,
@@ -4837,16 +5190,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,
@@ -4858,15 +5211,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,
@@ -4878,13 +5231,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,
@@ -4900,10 +5253,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,
@@ -4913,12 +5266,12 @@ var extensionContract = (0, import_core15.initContract)().router(
       summary: "Request new extension."
     }
   },
-  { pathPrefix: "extension" }
+  { pathPrefix: "ms/extension" }
 );
 
 // 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",
@@ -4952,8 +5305,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: {
@@ -4965,8 +5318,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: {
@@ -5007,84 +5360,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
@@ -5094,7 +5447,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
     },
@@ -5117,7 +5470,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
     }
   },
@@ -5134,8 +5487,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: {
@@ -5147,8 +5500,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: {
@@ -5170,25 +5523,28 @@ 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 emailEngineWebhooksEventsContract = (0, import_core18.initContract)().router({
-  handleWebhooksEvents: {
-    method: "POST",
-    path: "/email_engine/webhooks",
-    // we don't need to respone anything but added responses just for solving type error
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({
-        message: import_zod64.default.string()
-      })
-    },
-    body: null,
-    summary: "Handle email engine webhooks events such as authenticationSuccess, messageNew"
-  }
-});
+var import_zod65 = __toESM(require("zod"));
+var emailEngineWebhooksEventsContract = (0, import_core18.initContract)().router(
+  {
+    handleWebhooksEvents: {
+      method: "POST",
+      path: "/email_engine/webhooks",
+      // we don't need to respone anything but added responses just for solving type error
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod65.default.string()
+        })
+      },
+      body: null,
+      summary: "Handle email engine webhooks events such as authenticationSuccess, messageNew"
+    }
+  },
+  { pathPrefix: "ms" }
+);
 
 // 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",
@@ -5223,8 +5579,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: {
@@ -5236,8 +5592,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: {
@@ -5268,9 +5624,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,
@@ -5280,9 +5636,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,
@@ -5302,7 +5658,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: {
@@ -5310,9 +5666,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
@@ -5320,20 +5676,20 @@ var permissionContract = (0, import_core20.initContract)().router(
       summary: "Get all permissions"
     }
   },
-  { pathPrefix: "permission" }
+  { pathPrefix: "ms/permission" }
 );
 
 // 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;
 
@@ -5349,8 +5705,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
@@ -5360,17 +5716,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
@@ -5380,15 +5736,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
@@ -5398,11 +5754,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."
@@ -5410,12 +5766,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
@@ -5423,24 +5779,24 @@ var roleContract = (0, import_core21.initContract)().router(
       summary: "Get role by Id"
     }
   },
-  { pathPrefix: "role" }
+  { pathPrefix: "ms/role" }
 );
 
 // 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(
@@ -5463,7 +5819,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
       },
@@ -5472,7 +5828,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({
@@ -5485,18 +5841,18 @@ 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
     }
   },
   {
-    pathPrefix: "tags"
+    pathPrefix: "ms/tags"
   }
 );
 
@@ -5504,31 +5860,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
@@ -5536,27 +5892,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",
@@ -5590,7 +5931,7 @@ var telephonyAgentPresenceStatusContract = (0, import_core23.initContract)().rou
       summary: "Update presence status"
     }
   },
-  { pathPrefix: "telephony" }
+  { pathPrefix: "ms/telephony" }
 );
 
 // src/telephony-cdr/index.ts
@@ -5912,7 +6253,7 @@ var telephonyCdrContract = (0, import_core24.initContract)().router(
       }
     }
   },
-  { pathPrefix: "telephony-cdr" }
+  { pathPrefix: "ms/telephony-cdr" }
 );
 
 // src/telephony-extension/index.ts
@@ -5969,7 +6310,7 @@ var telephonyExtensionContract = (0, import_core25.initContract)().router(
       summary: "Get all extension list by yeastar"
     }
   },
-  { pathPrefix: "telephony" }
+  { pathPrefix: "ms/telephony" }
 );
 
 // src/ticket/index.ts
@@ -6650,7 +6991,7 @@ var userContract = (0, import_core27.initContract)().router(
       summary: "Delete a user."
     }
   },
-  { pathPrefix: "user" }
+  { pathPrefix: "ms/user" }
 );
 
 // src/user-presence-status-log/index.ts
@@ -6710,7 +7051,7 @@ var userPresenceStatusLogContract = (0, import_core28.initContract)().router(
       }
     }
   },
-  { pathPrefix: "user-presence-status-log" }
+  { pathPrefix: "ms/user-presence-status-log" }
 );
 
 // src/widget/index.ts
@@ -6723,21 +7064,40 @@ var FieldsSchema = import_zod86.default.object({ data: import_zod86.default.arra
 var WidgetPositionSchema = import_zod86.default.union([
   import_zod86.default.literal("menu"),
   import_zod86.default.literal("ticket_detail"),
-  import_zod86.default.literal("contact_detail")
+  import_zod86.default.literal("contact_detail"),
+  import_zod86.default.literal("contact_profile"),
+  import_zod86.default.literal("inbox_detail")
+]);
+var WidgetTypeSchema = import_zod86.default.union([
+  import_zod86.default.literal("iframe"),
+  import_zod86.default.literal("custom")
+]);
+var WidgetHeaderSchema = import_zod86.default.object({
+  key: import_zod86.default.string(),
+  value: import_zod86.default.string()
+});
+var WidgetMethodSchema = import_zod86.default.union([
+  import_zod86.default.literal("get"),
+  import_zod86.default.literal("post")
 ]);
 var WidgetSchema = DefaultEntitySchema.extend({
   name: import_zod86.default.string(),
   description: import_zod86.default.string().nullable(),
-  position: WidgetPositionSchema.nullable(),
+  position: WidgetPositionSchema,
   fields: FieldsSchema,
-  url: import_zod86.default.string()
+  url: import_zod86.default.string(),
+  type: WidgetTypeSchema.nullable(),
+  headers: import_zod86.default.array(WidgetHeaderSchema).nullable(),
+  method: WidgetMethodSchema.nullable(),
+  fileKey: import_zod86.default.string().nullable(),
+  fileUrl: import_zod86.default.string().nullable()
 });
 
 // src/widget/validation.ts
 var import_zod87 = __toESM(require("zod"));
 var CreateWidgetSchema = import_zod87.default.object({
   name: import_zod87.default.string(),
-  description: import_zod87.default.string(),
+  description: import_zod87.default.string().optional(),
   url: import_zod87.default.string(),
   position: WidgetPositionSchema,
   fields: import_zod87.default.object({
@@ -6745,7 +7105,11 @@ var CreateWidgetSchema = import_zod87.default.object({
       // Array of attribute system names
       import_zod87.default.array(import_zod87.default.string())
     )
-  }).optional()
+  }).optional(),
+  type: WidgetTypeSchema,
+  headers: import_zod87.default.array(WidgetHeaderSchema).optional(),
+  method: WidgetMethodSchema.optional(),
+  fileKey: import_zod87.default.string().nullable()
 });
 var UpdateWidgetSchema = CreateWidgetSchema;
 var GetWidgetUrlPathQuerySchema = import_zod87.default.object({
@@ -6897,7 +7261,7 @@ var widgetContract = (0, import_core29.initContract)().router(
       summary: "Delete a widget."
     }
   },
-  { pathPrefix: "widget" }
+  { pathPrefix: "ms/widget" }
 );
 
 // src/wrap-up-form/index.ts
@@ -7047,7 +7411,7 @@ var wrapUpFormContract = (0, import_core30.initContract)().router(
       summary: "Update a wrap up form."
     }
   },
-  { pathPrefix: "wrap-up-form" }
+  { pathPrefix: "ms/wrap-up-form" }
 );
 
 // src/upload/index.ts
@@ -7111,7 +7475,7 @@ var uploadContract = (0, import_core31.initContract)().router(
     }
   },
   {
-    pathPrefix: "/upload"
+    pathPrefix: "ms/upload"
   }
 );
 
@@ -7441,7 +7805,7 @@ var userNotificationContract = (0, import_core34.initContract)().router(
     }
   },
   {
-    pathPrefix: "notification"
+    pathPrefix: "ms/notification"
   }
 );
 
@@ -7598,7 +7962,7 @@ var snippetContract = (0, import_core35.initContract)().router(
     }
   },
   {
-    pathPrefix: "snippets"
+    pathPrefix: "ms/snippets"
   }
 );
 
@@ -7677,51 +8041,56 @@ var BusinessCalendarSchema = DefaultEntitySchema.extend({
 
 // src/business-calendar/index.ts
 var import_zod104 = __toESM(require("zod"));
-var businessCalendarContract = (0, import_core36.initContract)().router({
-  createBusinessCalendar: {
-    method: "POST",
-    path: "business-calendar",
-    body: CreateBusinessCalendarSchema,
-    responses: {
-      201: DefaultSuccessResponseSchema.extend({
-        businessCalendar: BusinessCalendarSchema
-      }),
-      500: DefaultErrorResponseSchema
-    }
-  },
-  getAllBusinessCalendar: {
-    method: "GET",
-    path: "business-calendars",
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({
-        businessCalendars: BusinessCalendarSchema.array()
-      }),
-      500: DefaultErrorResponseSchema
-    }
-  },
-  updateBusinessCalendar: {
-    method: "POST",
-    path: "business-calendars/:id",
-    pathParams: import_zod104.default.object({ id: import_zod104.default.string() }),
-    body: UpdateBusinessCalendarSchema,
-    responses: {
-      201: DefaultSuccessResponseSchema.extend({
-        businessCalendar: BusinessCalendarSchema
-      }),
-      500: DefaultErrorResponseSchema
+var businessCalendarContract = (0, import_core36.initContract)().router(
+  {
+    createBusinessCalendar: {
+      method: "POST",
+      path: "",
+      body: CreateBusinessCalendarSchema,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          businessCalendar: BusinessCalendarSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    getAllBusinessCalendar: {
+      method: "GET",
+      path: "",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          businessCalendars: BusinessCalendarSchema.array()
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    updateBusinessCalendar: {
+      method: "POST",
+      path: "/:id",
+      pathParams: import_zod104.default.object({ id: import_zod104.default.string() }),
+      body: UpdateBusinessCalendarSchema,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          businessCalendar: BusinessCalendarSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    deleteBusinessCalendar: {
+      method: "DELETE",
+      path: "/:id",
+      pathParams: import_zod104.default.object({ id: import_zod104.default.string() }),
+      body: null,
+      responses: {
+        200: DefaultSuccessResponseSchema,
+        500: DefaultErrorResponseSchema
+      }
     }
   },
-  deleteBusinessCalendar: {
-    method: "DELETE",
-    path: "business-calendars/:id",
-    pathParams: import_zod104.default.object({ id: import_zod104.default.string() }),
-    body: null,
-    responses: {
-      200: DefaultSuccessResponseSchema,
-      500: DefaultErrorResponseSchema
-    }
+  {
+    pathPrefix: "ms/business-calendars"
   }
-});
+);
 
 // src/facebook-feed/index.ts
 var import_core37 = require("@ts-rest/core");
@@ -8387,7 +8756,7 @@ var botContract = (0, import_core40.initContract)().router(
     }
   },
   {
-    pathPrefix: "/bots"
+    pathPrefix: "ms/bots"
   }
 );
 
@@ -8398,9 +8767,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;
 
@@ -8495,7 +8867,7 @@ var presenceStatusContract = (0, import_core41.initContract)().router(
       summary: "Delete a presence status."
     }
   },
-  { pathPrefix: "presence_status" }
+  { pathPrefix: "ms/presence_status" }
 );
 
 // src/whatsapp/index.ts
@@ -8630,7 +9002,6 @@ var apiContract = (0, import_core43.initContract)().router({
   telephonyExtensionContract,
   attribute: attributeContract,
   tag: tagContract,
-  channel: channelContract,
   aws: awsContract,
   agentPresenceStatus: telephonyAgentPresenceStatusContract,
   userPresenceStatusLog: userPresenceStatusLogContract,
@@ -8638,7 +9009,15 @@ var apiContract = (0, import_core43.initContract)().router({
   evaluateForm: evaluateFormContract,
   upload: uploadContract,
   snippet: snippetContract,
-  bot: botContract
+  bot: botContract,
+  ...(0, import_core43.initContract)().router(
+    {
+      channel: channelContract
+    },
+    {
+      pathPrefix: "ms/"
+    }
+  )
 });
 var contactContract2 = (0, import_core43.initContract)().router({
   contact: contactContract
@@ -8698,10 +9077,10 @@ var workflowContract = (0, import_core43.initContract)().router(
     chat: chatContract
   },
   {
-    pathPrefix: "workflow/"
+    pathPrefix: "ms/workflow/"
   }
 );
-var settingsPathPrefix = "settings/";
+var settingsPathPrefix = "ms/settings/";
 var ticketSettingContract = (0, import_core43.initContract)().router(
   {
     ticketSetting: attributeContract
@@ -8832,7 +9211,7 @@ var generalSettingContract = (0, import_core44.initContract)().router(
     }
   },
   {
-    pathPrefix: "general-setting"
+    pathPrefix: "ms/general-setting"
   }
 );
 
@@ -8913,7 +9292,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({
@@ -8974,7 +9354,7 @@ var automationQueueContract = (0, import_core45.initContract)().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "/automation-queue"
+    pathPrefix: "ms/automation-queue"
   }
 );
 
@@ -10178,7 +10558,7 @@ var holdLabelContract = (0, import_core52.initContract)().router(
       }
     }
   },
-  { pathPrefix: "hold-label" }
+  { pathPrefix: "ms/hold-label" }
 );
 
 // src/subscription/index.ts
@@ -10331,7 +10711,7 @@ var subscriptionContract = (0, import_core53.initContract)().router(
     }
   },
   {
-    pathPrefix: "subscriptions"
+    pathPrefix: "ms/subscriptions"
   }
 );
 
@@ -10402,6 +10782,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,
@@ -10431,6 +10837,7 @@ var settingCxIntelligenceContract = (0, import_core54.initContract)().router(
   cxLogContract,
   dashboardContract,
   evaluateFormContract,
+  exportContract,
   extensionContract,
   facebookFeedContract,
   feedPostContract,
@@ -10473,6 +10880,7 @@ var settingCxIntelligenceContract = (0, import_core54.initContract)().router(
   userContract,
   userNotificationContract,
   userPresenceStatusLogContract,
+  widgetContract,
   widgetSettingContract,
   workflowContract,
   wrapUpFormContract