@kl1/contracts 1.3.20 → 1.3.22

package/dist/index.mjs

@@ -195,8 +195,19 @@ var ChannelMetadataSchema = z6.object({
   }).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()
-});
+  facebookFeedIntegrationType: z6.union([z6.literal("own"), z6.literal("business")]).optional(),
+  isCSATEnabled: z6.boolean().optional()
+});
+var CsatPreferencesSchema = z6.object({
+  image: z6.string().optional().nullable(),
+  headline: z6.string(),
+  scaleOptions: z6.array(
+    z6.object({
+      value: z6.string(),
+      label: z6.string().optional().nullable()
+    })
+  )
+}).optional().nullable();
 var ChannelSchema = z6.object({
   id: z6.string().uuid(),
   createdAt: z6.date(),
@@ -598,55 +609,58 @@ 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",
-  // botpress specific
-  "carousel",
-  "card",
-  "choice",
-  "dropdown",
-  "text_with_image",
-  "reaction",
-  "contacts",
+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",
+  z18.literal("carousel"),
+  z18.literal("card"),
+  z18.literal("choice"),
+  z18.literal("dropdown"),
+  z18.literal("text_with_image"),
+  z18.literal("reaction"),
+  z18.literal("contacts"),
   // messenger referral
-  "referral",
+  z18.literal("referral"),
   // system
-  "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")
+];
+var MessageTypeSchema = z18.union(messageTypes);
 var FeedPostTypeSchema = z18.enum([
   "text",
   "added_photos",
@@ -686,6 +700,7 @@ var RoomSchema = DefaultEntitySchema.extend({
   isBotRoom: z18.boolean(),
   direction: MessageDirectionTypeSchema,
   platformContact: PlatformContactSchema,
+  csatStatus: z18.string().nullable(),
   actor: z18.object({
     id: z18.string().uuid(),
     createdAt: z18.date(),
@@ -1218,7 +1233,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(),
@@ -1715,7 +1732,7 @@ var activityLogContract = initContract2().router(
       summary: "Get all activity logs"
     }
   },
-  { pathPrefix: "activity-log" }
+  { pathPrefix: "ms/activity-log" }
 );
 
 // src/attribute/index.ts
@@ -1840,7 +1857,7 @@ var attributeContract = initContract3().router(
     }
   },
   {
-    pathPrefix: "attributes"
+    pathPrefix: "ms/attributes"
   }
 );
 
@@ -1863,7 +1880,7 @@ var authContract = initContract4().router(
       summary: "Get current user"
     }
   },
-  { pathPrefix: "auth" }
+  { pathPrefix: "ms/auth" }
 );
 
 // src/aws/index.ts
@@ -1927,7 +1944,7 @@ var awsContract = initContract5().router(
     }
   },
   {
-    pathPrefix: "aws/s3"
+    pathPrefix: "ms/aws/s3"
   }
 );
 
@@ -2055,7 +2072,7 @@ var categoryContract = initContract6().router(
     }
   },
   {
-    pathPrefix: "categories"
+    pathPrefix: "ms/categories"
   }
 );
 
@@ -2154,7 +2171,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()
@@ -2177,6 +2195,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";
@@ -2325,7 +2347,7 @@ var messenger = initContract7().router(
     }
   },
   {
-    pathPrefix: "/messenger"
+    pathPrefix: "messenger"
   }
 );
 var instagram = initContract7().router(
@@ -2355,7 +2377,7 @@ var instagram = initContract7().router(
     }
   },
   {
-    pathPrefix: "/instagram"
+    pathPrefix: "instagram"
   }
 );
 var line = initContract7().router(
@@ -2372,7 +2394,7 @@ var line = initContract7().router(
     }
   },
   {
-    pathPrefix: "/line"
+    pathPrefix: "line"
   }
 );
 var webchat = initContract7().router(
@@ -2392,7 +2414,7 @@ var webchat = initContract7().router(
     }
   },
   {
-    pathPrefix: "/webchat"
+    pathPrefix: "webchat"
   }
 );
 var viber = initContract7().router(
@@ -2412,7 +2434,7 @@ var viber = initContract7().router(
     }
   },
   {
-    pathPrefix: "/viber"
+    pathPrefix: "viber"
   }
 );
 var telegram = initContract7().router(
@@ -2432,7 +2454,7 @@ var telegram = initContract7().router(
     }
   },
   {
-    pathPrefix: "/telegram"
+    pathPrefix: "telegram"
   }
 );
 var whatsapp = initContract7().router(
@@ -2493,14 +2515,33 @@ var whatsapp = initContract7().router(
     }
   },
   {
-    pathPrefix: "/whatsapp"
+    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: "/",
+      path: "channel",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           data: ChannelSchema.array()
@@ -2511,7 +2552,7 @@ var channelContract = initContract7().router(
     },
     disconnect: {
       method: "POST",
-      path: "/disconnect/:channelId",
+      path: "channel/disconnect/:channelId",
       pathParams: z41.object({
         channelId: z41.string().uuid()
       }),
@@ -2526,7 +2567,7 @@ var channelContract = initContract7().router(
     },
     delete: {
       method: "DELETE",
-      path: "/delete/:channelId",
+      path: "channel/delete/:channelId",
       pathParams: z41.object({
         channelId: z41.string().uuid()
       }),
@@ -2541,7 +2582,7 @@ var channelContract = initContract7().router(
     },
     rename: {
       method: "POST",
-      path: "/rename/:channelId",
+      path: "channel/rename/:channelId",
       pathParams: z41.object({
         channelId: z41.string().uuid()
       }),
@@ -2558,7 +2599,7 @@ var channelContract = initContract7().router(
     },
     reconnect: {
       method: "POST",
-      path: "/reconnect/:channelId",
+      path: "channel/reconnect/:channelId",
       pathParams: z41.object({
         channelId: z41.string().uuid()
       }),
@@ -2575,7 +2616,7 @@ var channelContract = initContract7().router(
     },
     relogin: {
       method: "POST",
-      path: "/relogin",
+      path: "channel/relogin",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           channel: ChannelSchema
@@ -2587,7 +2628,7 @@ var channelContract = initContract7().router(
     },
     checknewTenant: {
       method: "GET",
-      path: "/check-new-tenant",
+      path: "channel/check-new-tenant",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           data: tenantCheckedSchema
@@ -2598,7 +2639,7 @@ var channelContract = initContract7().router(
     },
     updateNewTenant: {
       method: "PATCH",
-      path: "/update-new-tenant",
+      path: "channel/update-new-tenant",
       responses: {
         200: DefaultSuccessResponseSchema.extend({
           message: z41.string()
@@ -2611,17 +2652,34 @@ var channelContract = initContract7().router(
       }),
       summary: "Update new tenant"
     },
+    updateChannelCsatPreference: {
+      method: "POST",
+      path: "csat/:channelId",
+      pathParams: z41.object({
+        channelId: z41.string().uuid()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          channel: ChannelSchema
+        }),
+        408: DefaultErrorResponseSchema
+      },
+      body: z41.object({
+        isCSATEnabled: z41.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 = initContract7().router(
@@ -2651,7 +2709,7 @@ var channelFacebookFeedContract = initContract7().router(
     }
   },
   {
-    pathPrefix: "/facebook-feed"
+    pathPrefix: "ms/facebook-feed"
   }
 );
 var channelBotContract = initContract7().router({
@@ -2692,7 +2750,7 @@ var channelSMSContract = initContract7().router(
     }
   },
   {
-    pathPrefix: "/channel/sms"
+    pathPrefix: "channel/sms"
   }
 );
 
@@ -2717,14 +2775,14 @@ var receiveMessageContract = initContract8().router(
       "x-code": z42.string().uuid(),
       "x-tenant": z42.string().uuid()
     }),
-    pathPrefix: "message"
+    pathPrefix: "ms/message"
   }
 );
 var mainFeedContract = initContract8().router(
   {
     getFeedPostById: {
       method: "GET",
-      path: "/feed-post/:id",
+      path: "/:id",
       pathParams: z42.object({
         id: z42.string().uuid()
       }),
@@ -2737,7 +2795,7 @@ var mainFeedContract = initContract8().router(
     },
     getMessagesByParent: {
       method: "GET",
-      path: "/feed-post/message/:parentId/relevance",
+      path: "/message/:parentId/relevance",
       pathParams: z42.object({
         parentId: z42.string().uuid()
       }),
@@ -2754,7 +2812,8 @@ var mainFeedContract = initContract8().router(
     }
   },
   {
-    baseHeaders: DefaultHeaderSchema
+    baseHeaders: DefaultHeaderSchema,
+    pathPrefix: "ms/feed-post"
   }
 );
 var mainChatRoomContract = initContract8().router(
@@ -2889,7 +2948,7 @@ var mainChatRoomContract = initContract8().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 var mainChatContract = initContract8().router(
@@ -3000,7 +3059,7 @@ var mainChatContract = initContract8().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 var initiateMessageContract = initContract8().router(
@@ -3018,7 +3077,7 @@ var initiateMessageContract = initContract8().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 var mainChatMessageContract = initContract8().router(
@@ -3062,7 +3121,7 @@ var mainChatMessageContract = initContract8().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "chat"
+    pathPrefix: "ms/chat"
   }
 );
 
@@ -4038,66 +4097,69 @@ var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
 }).partial().optional();
 
 // src/cx-log/index.ts
-var cxLogContract = initContract12().router({
-  findAll: {
-    method: "GET",
-    path: "/cx-logs",
-    headers: DefaultHeaderSchema,
-    responses: {
-      200: DefaultSuccessResponseSchema.extend({
-        total: z52.number(),
-        page: z52.number(),
-        pageSize: z52.number(),
-        cxLogs: z52.array(CxLogSchemaWithRelations)
-      }),
-      401: DefaultUnauthorizedSchema
+var cxLogContract = initContract12().router(
+  {
+    findAll: {
+      method: "GET",
+      path: "/cx-logs",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          total: z52.number(),
+          page: z52.number(),
+          pageSize: z52.number(),
+          cxLogs: z52.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: z52.object({
+        // biome-ignore lint/style/useNamingConvention: <explanation>
+        "x-tenant": z52.string({ required_error: "Tenant id is required" }),
+        "x-code": z52.string().uuid().optional()
+      }),
+      responses: {
+        200: null,
+        403: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        500: DefaultErrorResponseSchema
+      },
+      body: z52.object({
+        roomId: z52.string().uuid(),
+        slaStatus: z52.enum(["meet", "unmeet", "-"])
+      })
+    }
   },
-  updateSla: {
-    method: "POST",
-    path: "/cx-logs",
-    headers: z52.object({
-      // biome-ignore lint/style/useNamingConvention: <explanation>
-      "x-tenant": z52.string({ required_error: "Tenant id is required" }),
-      "x-code": z52.string().uuid().optional()
-    }),
-    responses: {
-      200: null,
-      403: DefaultUnauthorizedSchema,
-      404: DefaultNotFoundSchema,
-      500: DefaultErrorResponseSchema
-    },
-    body: z52.object({
-      roomId: z52.string().uuid(),
-      slaStatus: z52.enum(["meet", "unmeet", "-"])
-    })
-  }
-});
+  { pathPrefix: "ms" }
+);
 
 // src/dashboard/index.ts
 import { initContract as initContract13 } from "@ts-rest/core";
@@ -4105,19 +4167,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()
@@ -4134,9 +4200,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";
@@ -4291,29 +4362,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(),
@@ -4336,6 +4410,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(
@@ -4350,8 +4467,8 @@ var dashboardContract = initContract13().router(
         200: DefaultSuccessResponseSchema.extend({
           dashboard: DashboardDataSchema
         }),
-        400: z55.object({
-          message: z55.string()
+        400: z56.object({
+          message: z56.string()
         }),
         401: DefaultUnauthorizedSchema
       }
@@ -4366,8 +4483,8 @@ var dashboardContract = initContract13().router(
         200: DefaultSuccessResponseSchema.extend({
           queuecallDashboard: queueCallDashboardDataSchema
         }),
-        400: z55.object({
-          message: z55.string()
+        400: z56.object({
+          message: z56.string()
         }),
         401: DefaultUnauthorizedSchema
       }
@@ -4457,7 +4574,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: {
@@ -4467,6 +4588,16 @@ var dashboardContract = initContract13().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",
@@ -4498,7 +4629,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({
@@ -4511,7 +4642,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({
@@ -4524,7 +4655,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({
@@ -4533,37 +4664,74 @@ var dashboardContract = initContract13().router(
         401: DefaultUnauthorizedSchema
       }
     },
+    exportMessageAverageData: {
+      method: "POST",
+      path: "/export-message-average-data",
+      body: 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: "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: 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: "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({
@@ -4576,7 +4744,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({
@@ -4585,6 +4753,16 @@ var dashboardContract = initContract13().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",
@@ -4594,22 +4772,189 @@ 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)
+        })
+      }
+    },
+    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(),
+          agentMessageStatistics: z56.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: 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(),
+          userCheckInLogsWithDays: z56.array(UserCheckInLogsWithDaySchema)
+        })
+      }
+    },
+    exportUserCheckInLogs: {
+      method: "POST",
+      path: "/export-user-check-in-logs",
+      body: 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()
+                })
+              )
+            })
+          )
+        })
+      }
+    },
+    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
+            })
+          )
+        })
+      }
+    },
+    exportUserCheckInLogsByUserId: {
+      method: "POST",
+      path: "/export-user-check-in-logs-by-user-id",
+      body: z56.object({
+        userId: z56.string().uuid(),
+        selectedDate: z56.string().min(1),
+        fileExtension: ExportFileExtensionSchema
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema
+      }
     }
   },
   {
-    pathPrefix: "dashboard"
+    pathPrefix: "ms/dashboard"
   }
 );
 
 // 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();
 
@@ -4623,30 +4968,30 @@ var evaluateFormContract = initContract14().router(
       body: CreateEvaluateFormSchema,
       responses: {
         201: DefaultSuccessResponseSchema.extend({
-          message: z57.string()
+          message: z58.string()
         }),
         401: DefaultUnauthorizedSchema
       },
       summary: "Create evaluate form"
     }
   },
-  { pathPrefix: "evaluate-forms" }
+  { pathPrefix: "ms/evaluate-forms" }
 );
 
 // 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;
 
@@ -4662,8 +5007,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,
@@ -4675,33 +5020,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,
@@ -4713,12 +5058,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,
@@ -4730,16 +5075,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,
@@ -4751,15 +5096,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,
@@ -4771,13 +5116,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,
@@ -4793,10 +5138,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,
@@ -4806,12 +5151,12 @@ var extensionContract = initContract15().router(
       summary: "Request new extension."
     }
   },
-  { pathPrefix: "extension" }
+  { pathPrefix: "ms/extension" }
 );
 
 // 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",
@@ -4845,8 +5190,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: {
@@ -4858,8 +5203,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: {
@@ -4900,84 +5245,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
@@ -4987,7 +5332,7 @@ var lineContract = initContract17().router({
     path: "sticker",
     responses: {
       200: DefaultSuccessResponseSchema.extend({
-        data: z63.any()
+        data: z64.any()
       }),
       500: DefaultErrorResponseSchema
     },
@@ -5010,7 +5355,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
     }
   },
@@ -5027,8 +5372,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: {
@@ -5040,8 +5385,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: {
@@ -5063,25 +5408,28 @@ var lineContract = initContract17().router({
 
 // src/mail/email-engine-webhooks-events.contract.ts
 import { initContract as initContract18 } from "@ts-rest/core";
-import z64 from "zod";
-var emailEngineWebhooksEventsContract = initContract18().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: z64.string()
-      })
-    },
-    body: null,
-    summary: "Handle email engine webhooks events such as authenticationSuccess, messageNew"
-  }
-});
+import z65 from "zod";
+var emailEngineWebhooksEventsContract = initContract18().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: z65.string()
+        })
+      },
+      body: null,
+      summary: "Handle email engine webhooks events such as authenticationSuccess, messageNew"
+    }
+  },
+  { pathPrefix: "ms" }
+);
 
 // 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",
@@ -5116,8 +5464,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: {
@@ -5129,8 +5477,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: {
@@ -5161,9 +5509,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,
@@ -5173,9 +5521,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,
@@ -5195,7 +5543,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: {
@@ -5203,9 +5551,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
@@ -5213,20 +5561,20 @@ var permissionContract = initContract20().router(
       summary: "Get all permissions"
     }
   },
-  { pathPrefix: "permission" }
+  { pathPrefix: "ms/permission" }
 );
 
 // 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;
 
@@ -5242,8 +5590,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
@@ -5253,17 +5601,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
@@ -5273,15 +5621,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
@@ -5291,11 +5639,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."
@@ -5303,12 +5651,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
@@ -5316,24 +5664,24 @@ var roleContract = initContract21().router(
       summary: "Get role by Id"
     }
   },
-  { pathPrefix: "role" }
+  { pathPrefix: "ms/role" }
 );
 
 // 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(
@@ -5356,7 +5704,7 @@ var tagContract = initContract22().router(
       query: GetTagsSchema,
       responses: {
         200: DefaultSuccessResponseSchema.extend({
-          tags: z70.array(TagSchema)
+          tags: z71.array(TagSchema)
         }),
         500: DefaultErrorResponseSchema
       },
@@ -5365,7 +5713,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({
@@ -5378,18 +5726,18 @@ 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
     }
   },
   {
-    pathPrefix: "tags"
+    pathPrefix: "ms/tags"
   }
 );
 
@@ -5397,31 +5745,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
@@ -5429,27 +5777,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",
@@ -5483,7 +5816,7 @@ var telephonyAgentPresenceStatusContract = initContract23().router(
       summary: "Update presence status"
     }
   },
-  { pathPrefix: "telephony" }
+  { pathPrefix: "ms/telephony" }
 );
 
 // src/telephony-cdr/index.ts
@@ -5805,7 +6138,7 @@ var telephonyCdrContract = initContract24().router(
       }
     }
   },
-  { pathPrefix: "telephony-cdr" }
+  { pathPrefix: "ms/telephony-cdr" }
 );
 
 // src/telephony-extension/index.ts
@@ -5862,7 +6195,7 @@ var telephonyExtensionContract = initContract25().router(
       summary: "Get all extension list by yeastar"
     }
   },
-  { pathPrefix: "telephony" }
+  { pathPrefix: "ms/telephony" }
 );
 
 // src/ticket/index.ts
@@ -6543,7 +6876,7 @@ var userContract = initContract27().router(
       summary: "Delete a user."
     }
   },
-  { pathPrefix: "user" }
+  { pathPrefix: "ms/user" }
 );
 
 // src/user-presence-status-log/index.ts
@@ -6603,7 +6936,7 @@ var userPresenceStatusLogContract = initContract28().router(
       }
     }
   },
-  { pathPrefix: "user-presence-status-log" }
+  { pathPrefix: "ms/user-presence-status-log" }
 );
 
 // src/widget/index.ts
@@ -6616,21 +6949,40 @@ var FieldsSchema = z86.object({ data: z86.array(z86.string()) });
 var WidgetPositionSchema = z86.union([
   z86.literal("menu"),
   z86.literal("ticket_detail"),
-  z86.literal("contact_detail")
+  z86.literal("contact_detail"),
+  z86.literal("contact_profile"),
+  z86.literal("inbox_detail")
+]);
+var WidgetTypeSchema = z86.union([
+  z86.literal("iframe"),
+  z86.literal("custom")
+]);
+var WidgetHeaderSchema = z86.object({
+  key: z86.string(),
+  value: z86.string()
+});
+var WidgetMethodSchema = z86.union([
+  z86.literal("get"),
+  z86.literal("post")
 ]);
 var WidgetSchema = DefaultEntitySchema.extend({
   name: z86.string(),
   description: z86.string().nullable(),
-  position: WidgetPositionSchema.nullable(),
+  position: WidgetPositionSchema,
   fields: FieldsSchema,
-  url: z86.string()
+  url: z86.string(),
+  type: WidgetTypeSchema.nullable(),
+  headers: z86.array(WidgetHeaderSchema).nullable(),
+  method: WidgetMethodSchema.nullable(),
+  fileKey: z86.string().nullable(),
+  fileUrl: z86.string().nullable()
 });
 
 // src/widget/validation.ts
 import z87 from "zod";
 var CreateWidgetSchema = z87.object({
   name: z87.string(),
-  description: z87.string(),
+  description: z87.string().optional(),
   url: z87.string(),
   position: WidgetPositionSchema,
   fields: z87.object({
@@ -6638,7 +6990,11 @@ var CreateWidgetSchema = z87.object({
       // Array of attribute system names
       z87.array(z87.string())
     )
-  }).optional()
+  }).optional(),
+  type: WidgetTypeSchema,
+  headers: z87.array(WidgetHeaderSchema).optional(),
+  method: WidgetMethodSchema.optional(),
+  fileKey: z87.string().nullable()
 });
 var UpdateWidgetSchema = CreateWidgetSchema;
 var GetWidgetUrlPathQuerySchema = z87.object({
@@ -6790,7 +7146,7 @@ var widgetContract = initContract29().router(
       summary: "Delete a widget."
     }
   },
-  { pathPrefix: "widget" }
+  { pathPrefix: "ms/widget" }
 );
 
 // src/wrap-up-form/index.ts
@@ -6940,7 +7296,7 @@ var wrapUpFormContract = initContract30().router(
       summary: "Update a wrap up form."
     }
   },
-  { pathPrefix: "wrap-up-form" }
+  { pathPrefix: "ms/wrap-up-form" }
 );
 
 // src/upload/index.ts
@@ -7004,7 +7360,7 @@ var uploadContract = initContract31().router(
     }
   },
   {
-    pathPrefix: "/upload"
+    pathPrefix: "ms/upload"
   }
 );
 
@@ -7334,7 +7690,7 @@ var userNotificationContract = initContract34().router(
     }
   },
   {
-    pathPrefix: "notification"
+    pathPrefix: "ms/notification"
   }
 );
 
@@ -7491,7 +7847,7 @@ var snippetContract = initContract35().router(
     }
   },
   {
-    pathPrefix: "snippets"
+    pathPrefix: "ms/snippets"
   }
 );
 
@@ -7570,51 +7926,56 @@ var BusinessCalendarSchema = DefaultEntitySchema.extend({
 
 // src/business-calendar/index.ts
 import z104 from "zod";
-var businessCalendarContract = initContract36().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: z104.object({ id: z104.string() }),
-    body: UpdateBusinessCalendarSchema,
-    responses: {
-      201: DefaultSuccessResponseSchema.extend({
-        businessCalendar: BusinessCalendarSchema
-      }),
-      500: DefaultErrorResponseSchema
+var businessCalendarContract = initContract36().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: z104.object({ id: z104.string() }),
+      body: UpdateBusinessCalendarSchema,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          businessCalendar: BusinessCalendarSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    deleteBusinessCalendar: {
+      method: "DELETE",
+      path: "/:id",
+      pathParams: z104.object({ id: z104.string() }),
+      body: null,
+      responses: {
+        200: DefaultSuccessResponseSchema,
+        500: DefaultErrorResponseSchema
+      }
     }
   },
-  deleteBusinessCalendar: {
-    method: "DELETE",
-    path: "business-calendars/:id",
-    pathParams: z104.object({ id: z104.string() }),
-    body: null,
-    responses: {
-      200: DefaultSuccessResponseSchema,
-      500: DefaultErrorResponseSchema
-    }
+  {
+    pathPrefix: "ms/business-calendars"
   }
-});
+);
 
 // src/facebook-feed/index.ts
 import { initContract as initContract37 } from "@ts-rest/core";
@@ -8280,7 +8641,7 @@ var botContract = initContract40().router(
     }
   },
   {
-    pathPrefix: "/bots"
+    pathPrefix: "ms/bots"
   }
 );
 
@@ -8291,9 +8652,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;
 
@@ -8388,7 +8752,7 @@ var presenceStatusContract = initContract41().router(
       summary: "Delete a presence status."
     }
   },
-  { pathPrefix: "presence_status" }
+  { pathPrefix: "ms/presence_status" }
 );
 
 // src/whatsapp/index.ts
@@ -8523,7 +8887,6 @@ var apiContract = initContract43().router({
   telephonyExtensionContract,
   attribute: attributeContract,
   tag: tagContract,
-  channel: channelContract,
   aws: awsContract,
   agentPresenceStatus: telephonyAgentPresenceStatusContract,
   userPresenceStatusLog: userPresenceStatusLogContract,
@@ -8531,7 +8894,15 @@ var apiContract = initContract43().router({
   evaluateForm: evaluateFormContract,
   upload: uploadContract,
   snippet: snippetContract,
-  bot: botContract
+  bot: botContract,
+  ...initContract43().router(
+    {
+      channel: channelContract
+    },
+    {
+      pathPrefix: "ms/"
+    }
+  )
 });
 var contactContract2 = initContract43().router({
   contact: contactContract
@@ -8591,10 +8962,10 @@ var workflowContract = initContract43().router(
     chat: chatContract
   },
   {
-    pathPrefix: "workflow/"
+    pathPrefix: "ms/workflow/"
   }
 );
-var settingsPathPrefix = "settings/";
+var settingsPathPrefix = "ms/settings/";
 var ticketSettingContract = initContract43().router(
   {
     ticketSetting: attributeContract
@@ -8725,7 +9096,7 @@ var generalSettingContract = initContract44().router(
     }
   },
   {
-    pathPrefix: "general-setting"
+    pathPrefix: "ms/general-setting"
   }
 );
 
@@ -8806,7 +9177,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({
@@ -8867,7 +9239,7 @@ var automationQueueContract = initContract45().router(
   },
   {
     baseHeaders: DefaultHeaderSchema,
-    pathPrefix: "/automation-queue"
+    pathPrefix: "ms/automation-queue"
   }
 );
 
@@ -10071,7 +10443,7 @@ var holdLabelContract = initContract52().router(
       }
     }
   },
-  { pathPrefix: "hold-label" }
+  { pathPrefix: "ms/hold-label" }
 );
 
 // src/subscription/index.ts
@@ -10224,7 +10596,7 @@ var subscriptionContract = initContract53().router(
     }
   },
   {
-    pathPrefix: "subscriptions"
+    pathPrefix: "ms/subscriptions"
   }
 );
 
@@ -10295,6 +10667,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,
@@ -10323,6 +10721,7 @@ export {
   cxLogContract,
   dashboardContract,
   evaluateFormContract,
+  exportContract,
   extensionContract2 as extensionContract,
   facebookFeedContract2 as facebookFeedContract,
   feedPostContract,
@@ -10365,6 +10764,7 @@ export {
   userContract,
   userNotificationContract,
   userPresenceStatusLogContract,
+  widgetContract,
   widgetSettingContract,
   workflowContract,
   wrapUpFormContract