@kl1/contracts 1.0.0

package/dist/index.js

@@ -0,0 +1,855 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  apiContract: () => apiContract,
+  categoryContract: () => categoryContract
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/contract.ts
+var import_core10 = require("@ts-rest/core");
+
+// src/auth/index.ts
+var import_core = require("@ts-rest/core");
+var import_zod5 = require("zod");
+
+// src/base-contract.ts
+var import_zod = __toESM(require("zod"));
+var DefaultHeaderSchema = import_zod.default.object({
+  // biome-ignore lint/style/useNamingConvention: <explanation>
+  "x-tenant": import_zod.default.string({ required_error: "Tenant id is required" }),
+  authorization: import_zod.default.string()
+});
+var DefaultEntitySchema = import_zod.default.object({
+  id: import_zod.default.string().uuid(),
+  createdAt: import_zod.default.date(),
+  updatedAt: import_zod.default.date(),
+  deletedAt: import_zod.default.date()
+});
+var DefaultQueryParamsSchema = import_zod.default.object({
+  page: import_zod.default.number().positive().default(1),
+  pageSize: import_zod.default.number().positive().default(10)
+});
+var DefaultSuccessResponseSchema = import_zod.default.object({
+  requestId: import_zod.default.string()
+});
+var DefaultErrorResponseSchema = import_zod.default.object({
+  message: import_zod.default.string(),
+  error: import_zod.default.any()
+});
+var DefaultNotFoundSchema = DefaultErrorResponseSchema;
+var DefaultUnprocessibleSchema = DefaultErrorResponseSchema;
+var DefaultUnauthorizedSchema = DefaultErrorResponseSchema;
+var defaultResponses = {
+  401: DefaultUnauthorizedSchema,
+  404: DefaultNotFoundSchema,
+  422: DefaultUnprocessibleSchema
+};
+
+// src/user/schema.ts
+var import_zod4 = __toESM(require("zod"));
+
+// src/role/schema.ts
+var import_zod3 = __toESM(require("zod"));
+
+// src/permission/schema.ts
+var import_zod2 = __toESM(require("zod"));
+var PermissionSchema = DefaultEntitySchema.extend({
+  systemName: import_zod2.default.string(),
+  displayName: import_zod2.default.string(),
+  description: import_zod2.default.string().nullable()
+});
+
+// src/role/schema.ts
+var RoleSchema = DefaultEntitySchema.extend({
+  systemName: import_zod3.default.string(),
+  displayName: import_zod3.default.string(),
+  description: import_zod3.default.string().nullable(),
+  permissions: import_zod3.default.array(PermissionSchema)
+});
+
+// src/user/schema.ts
+var UserSchema = DefaultEntitySchema.extend({
+  name: import_zod4.default.string(),
+  email: import_zod4.default.string().email(),
+  address: import_zod4.default.string().nullable(),
+  phone: import_zod4.default.string().nullable(),
+  notificationCount: import_zod4.default.number().nullable(),
+  roles: import_zod4.default.array(RoleSchema)
+});
+
+// src/auth/index.ts
+var authContract = (0, import_core.initContract)().router(
+  {
+    refreshToken: {
+      method: "POST",
+      path: "/refresh-token",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          accessToken: import_zod5.z.string(),
+          refreshToken: import_zod5.z.string()
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      body: null,
+      summary: "Refresh token"
+    },
+    exchangeToken: {
+      method: "POST",
+      path: "/exchange-token",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          accessToken: import_zod5.z.string(),
+          refreshToken: import_zod5.z.string()
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      body: null,
+      headers: DefaultHeaderSchema,
+      summary: "Exchange jwt token"
+    },
+    logout: {
+      method: "POST",
+      path: "/logout",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod5.z.string()
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      body: null,
+      summary: "Logout"
+    },
+    me: {
+      method: "GET",
+      path: "/me",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          user: UserSchema
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      summary: "Get current user"
+    }
+  },
+  { pathPrefix: "auth" }
+);
+
+// src/mail/mail-contract.ts
+var import_core6 = require("@ts-rest/core");
+
+// src/mail/room-contract.ts
+var import_core2 = require("@ts-rest/core");
+var import_zod6 = __toESM(require("zod"));
+var roomContract = (0, import_core2.initContract)().router(
+  {
+    create: {
+      method: "POST",
+      path: "/",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod6.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Create a new room for new incoming mail"
+    },
+    get: {
+      method: "GET",
+      path: "/:id",
+      pathParams: import_zod6.default.object({
+        id: import_zod6.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod6.default.string()
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a mail room by id"
+    },
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod6.default.object({
+        id: import_zod6.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod6.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Update a mail room by id"
+    },
+    delete: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod6.default.object({
+        id: import_zod6.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod6.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete a mail room by id"
+    }
+  },
+  {
+    pathPrefix: "/room"
+  }
+);
+
+// src/mail/message-contract.ts
+var import_core3 = require("@ts-rest/core");
+var import_zod7 = __toESM(require("zod"));
+var messageContract = (0, import_core3.initContract)().router(
+  {
+    create: {
+      method: "POST",
+      path: "/",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod7.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Add a new message into a room"
+    },
+    get: {
+      method: "GET",
+      path: "/:id",
+      pathParams: import_zod7.default.object({
+        id: import_zod7.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod7.default.string()
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a message by id"
+    },
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod7.default.object({
+        id: import_zod7.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod7.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Update a message by id"
+    },
+    delete: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod7.default.object({
+        id: import_zod7.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod7.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete a message by id"
+    }
+  },
+  {
+    pathPrefix: "/message"
+  }
+);
+
+// src/mail/account-contract.ts
+var import_core4 = require("@ts-rest/core");
+var import_zod9 = __toESM(require("zod"));
+
+// src/mail/schemas/account.schema.ts
+var import_zod8 = __toESM(require("zod"));
+var mailServerSchema = import_zod8.default.object({
+  id: import_zod8.default.string(),
+  created_at: import_zod8.default.string(),
+  updated_at: import_zod8.default.string(),
+  deletedAt: import_zod8.default.string().nullable(),
+  tenant_id: import_zod8.default.string(),
+  name: import_zod8.default.string(),
+  smtpHost: import_zod8.default.string(),
+  smtpPort: import_zod8.default.string(),
+  smtpTlsPort: import_zod8.default.string(),
+  useTlsForSmtp: import_zod8.default.boolean(),
+  imapHost: import_zod8.default.string(),
+  imapPort: import_zod8.default.string(),
+  imapTlsPort: import_zod8.default.string(),
+  useTlsForImap: import_zod8.default.boolean()
+});
+var mailAccountSchema = import_zod8.default.object({
+  id: import_zod8.default.string(),
+  created_at: import_zod8.default.string(),
+  updated_at: import_zod8.default.string(),
+  deletedAt: import_zod8.default.date().nullable(),
+  tenant_id: import_zod8.default.string(),
+  name: import_zod8.default.string(),
+  address: import_zod8.default.string(),
+  accountId: import_zod8.default.string(),
+  mailServerId: import_zod8.default.string(),
+  mailServer: mailServerSchema,
+  state: import_zod8.default.union([
+    import_zod8.default.literal("init"),
+    import_zod8.default.literal("syncing"),
+    import_zod8.default.literal("connecting"),
+    import_zod8.default.literal("connected"),
+    import_zod8.default.literal("disconnected"),
+    import_zod8.default.literal("authenticationError"),
+    import_zod8.default.literal("connectError"),
+    import_zod8.default.literal("unset")
+  ])
+});
+var accountContractsSchemas = {
+  create: {
+    input: import_zod8.default.object({
+      address: import_zod8.default.string().email("Email address must be valid email."),
+      name: import_zod8.default.string().min(1, "Account name cannot be empty."),
+      password: import_zod8.default.string().min(1, "Password cannot be empty."),
+      mailServerId: import_zod8.default.string().uuid("Invalid mail_server_id")
+    })
+  },
+  getById: {
+    input: import_zod8.default.object({
+      id: import_zod8.default.string().uuid()
+    }),
+    output: mailAccountSchema
+  },
+  getAll: {
+    output: import_zod8.default.array(mailAccountSchema)
+  },
+  update: {
+    input: mailAccountSchema,
+    output: mailAccountSchema
+  },
+  disconnect: {
+    input: import_zod8.default.object({
+      id: import_zod8.default.string().uuid()
+    }),
+    output: mailAccountSchema
+  },
+  reconnect: {
+    input: import_zod8.default.object({
+      id: import_zod8.default.string()
+    }),
+    output: mailAccountSchema
+  },
+  delete: {
+    input: import_zod8.default.object({
+      id: import_zod8.default.string()
+    }),
+    output: mailAccountSchema
+  }
+};
+
+// src/mail/account-contract.ts
+var accountContract = (0, import_core4.initContract)().router(
+  {
+    //#region ........register account
+    create: {
+      method: "POST",
+      path: "",
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          // data: accountContractsSchemas.create.output,
+          message: import_zod9.default.string()
+        }),
+        400: import_zod9.default.object({
+          message: import_zod9.default.string()
+        }),
+        409: import_zod9.default.object({
+          message: import_zod9.default.string()
+        }),
+        500: import_zod9.default.object({
+          message: import_zod9.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: accountContractsSchemas.create.input,
+      summary: "Register a new mail account"
+    },
+    //#endregion register account
+    //#region ........get account
+    getById: {
+      method: "GET",
+      path: "/:id",
+      pathParams: accountContractsSchemas.getById.input,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.getById.output
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a account by id"
+    },
+    //#endregion get account
+    //#region ........get all account
+    //TODO: add pagination parameters
+    getAll: {
+      method: "GET",
+      path: "",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          data: import_zod9.default.any()
+          // data: accountContractsSchemas.getAll.output,
+        }),
+        ...defaultResponses
+      },
+      summary: "Get al accounts"
+    },
+    //#endregion get all accounts
+    //#region ........update account
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod9.default.object({
+        id: import_zod9.default.string().uuid()
+      }),
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.update.output
+        }),
+        ...defaultResponses
+      },
+      body: accountContractsSchemas.update.input.partial(),
+      summary: "Update a account by id"
+    },
+    //#endregion update account
+    //#region ........disconnect account
+    disconnect: {
+      method: "PATCH",
+      path: "/:id/disconnect",
+      pathParams: accountContractsSchemas.disconnect.input,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.disconnect.output
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Disconnect an account"
+    },
+    //#endregion disconnect account
+    //#region ........reconnect account
+    reconnect: {
+      method: "PATCH",
+      path: "/:id/reconnect",
+      pathParams: accountContractsSchemas.reconnect.input,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.reconnect.output
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Reconnect a disconncted account"
+    },
+    //#endregion reconnect account
+    //#region ........delete account
+    delete: {
+      method: "DELETE",
+      path: "/:id",
+      pathParams: accountContractsSchemas.delete.input,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod9.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete an account by id"
+    }
+    //#endregion delete account
+  },
+  {
+    baseHeaders: DefaultHeaderSchema,
+    pathPrefix: "mail/account"
+  }
+);
+
+// src/mail/mail-server.ts
+var import_core5 = require("@ts-rest/core");
+var import_zod10 = __toESM(require("zod"));
+var serverContract = (0, import_core5.initContract)().router(
+  {
+    create: {
+      method: "POST",
+      path: "/",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod10.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Register a new mail server"
+    },
+    get: {
+      method: "GET",
+      path: "/:id",
+      pathParams: import_zod10.default.object({
+        id: import_zod10.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod10.default.string()
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a mail server by id"
+    },
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod10.default.object({
+        id: import_zod10.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod10.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Update a mail server by id"
+    },
+    delete: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod10.default.object({
+        id: import_zod10.default.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: import_zod10.default.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete a mail server by id"
+    }
+  },
+  {
+    pathPrefix: "/server"
+  }
+);
+
+// src/mail/mail-contract.ts
+var mailContract = (0, import_core6.initContract)().router({
+  room: roomContract,
+  message: messageContract,
+  account: accountContract,
+  server: serverContract
+});
+
+// src/cx-log/index.ts
+var import_core7 = require("@ts-rest/core");
+var import_zod13 = __toESM(require("zod"));
+
+// src/cx-log/schema.ts
+var import_zod11 = __toESM(require("zod"));
+var CxLogSchema = DefaultEntitySchema.extend({
+  caseId: import_zod11.default.number(),
+  entityId: import_zod11.default.string().uuid(),
+  entityName: import_zod11.default.string(),
+  contactId: import_zod11.default.string().uuid().nullable(),
+  channel: import_zod11.default.string().nullable(),
+  queueId: import_zod11.default.string().uuid().nullable(),
+  agentId: import_zod11.default.string().uuid().nullable(),
+  direction: import_zod11.default.string().nullable(),
+  startedDate: import_zod11.default.date().nullable(),
+  handledTime: import_zod11.default.number().nullable(),
+  firstResponseTime: import_zod11.default.number().nullable(),
+  disposition: import_zod11.default.string().nullable()
+});
+
+// src/cx-log/validation.ts
+var import_zod12 = __toESM(require("zod"));
+var CustomFieldQueryParamsSchema = import_zod12.default.object({
+  attributeId: import_zod12.default.string(),
+  value: import_zod12.default.string().or(import_zod12.default.array(import_zod12.default.string())),
+  type: import_zod12.default.string()
+});
+var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
+  contactId: import_zod12.default.string().uuid().optional(),
+  channelIds: import_zod12.default.string().uuid().optional(),
+  queueIds: import_zod12.default.string().uuid().optional(),
+  direction: import_zod12.default.enum(["inbound", "outbound"]).array().optional(),
+  sentimentScore: import_zod12.default.enum(["positive", "negative"]).array().optional(),
+  csatScore: import_zod12.default.string().optional(),
+  sla: import_zod12.default.enum(["meet", "unmeet"]).array().optional(),
+  caseId: import_zod12.default.string().optional(),
+  name: import_zod12.default.string().optional(),
+  email: import_zod12.default.string().optional(),
+  phone: import_zod12.default.string().optional(),
+  address: import_zod12.default.string().optional(),
+  company: import_zod12.default.string().optional(),
+  agentIds: import_zod12.default.string().array().optional(),
+  channel: import_zod12.default.string().array().optional(),
+  disposition: import_zod12.default.string().array().optional(),
+  notes: import_zod12.default.string().optional(),
+  contactLabels: import_zod12.default.string().array().optional(),
+  tags: import_zod12.default.string().array().optional(),
+  selectedDate: import_zod12.default.string().optional(),
+  customFields: import_zod12.default.array(CustomFieldQueryParamsSchema).optional()
+});
+
+// src/cx-log/index.ts
+var cxLogContract = (0, import_core7.initContract)().router({
+  findAll: {
+    method: "GET",
+    path: "/cx-logs",
+    headers: DefaultHeaderSchema,
+    responses: {
+      200: DefaultSuccessResponseSchema.extend({
+        total: import_zod13.default.number(),
+        page: import_zod13.default.number(),
+        pageSize: import_zod13.default.number(),
+        cxLogs: import_zod13.default.array(CxLogSchema)
+      }),
+      401: DefaultUnauthorizedSchema
+    },
+    query: GetAllCxLogQueryParamsSchema,
+    summary: "Get all cx-logs"
+  }
+});
+
+// src/mail/email-engine-webhooks-events.contract.ts
+var import_core8 = require("@ts-rest/core");
+var import_zod14 = __toESM(require("zod"));
+var emailEngineWebhooksEventsContract = (0, import_core8.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_zod14.default.string()
+      })
+    },
+    body: null,
+    summary: "Handle email engine webhooks events such as authenticationSuccess, messageNew"
+  }
+});
+
+// src/category/index.ts
+var import_core9 = require("@ts-rest/core");
+var import_zod18 = __toESM(require("zod"));
+
+// utils.ts
+var import_zod15 = require("zod");
+var paginationSchema = import_zod15.z.object({
+  page: import_zod15.z.number().default(1),
+  pageSize: import_zod15.z.number().default(10),
+  total: import_zod15.z.number(),
+  lastPage: import_zod15.z.number().optional().nullable()
+});
+var withPagination = (dataSchema) => {
+  return paginationSchema.extend({
+    data: import_zod15.z.array(dataSchema)
+  });
+};
+
+// src/category/schema.ts
+var import_zod16 = require("zod");
+var categoryLevelSchema = import_zod16.z.union([
+  import_zod16.z.literal(1),
+  import_zod16.z.literal(2),
+  import_zod16.z.literal(3)
+]);
+var categorySchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  value: import_zod16.z.string(),
+  level: categoryLevelSchema,
+  parentId: import_zod16.z.string().nullable(),
+  childCategoryList: import_zod16.z.array(
+    import_zod16.z.object({
+      id: import_zod16.z.string(),
+      value: import_zod16.z.string(),
+      level: categoryLevelSchema,
+      parentId: import_zod16.z.string().nullable(),
+      childCategoryList: import_zod16.z.array(
+        import_zod16.z.object({
+          id: import_zod16.z.string(),
+          value: import_zod16.z.string(),
+          level: categoryLevelSchema,
+          parentId: import_zod16.z.string().nullable(),
+          childCategoryList: import_zod16.z.array(import_zod16.z.any())
+          // This is an empty array.
+        })
+      )
+    })
+  )
+});
+
+// src/category/validation.ts
+var import_zod17 = require("zod");
+var createCategorySchema = import_zod17.z.object({
+  value: import_zod17.z.string(),
+  level: categoryLevelSchema,
+  parentId: import_zod17.z.string().nullable()
+});
+var updateCategorySchema = import_zod17.z.object({ value: import_zod17.z.string() });
+var createCategoryLevelSchema = import_zod17.z.object({
+  name: import_zod17.z.string(),
+  level: categoryLevelSchema
+});
+var updateCategoryLevelSchema = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  name: import_zod17.z.string(),
+  level: categoryLevelSchema
+});
+
+// src/category/index.ts
+var categoryContract = (0, import_core9.initContract)().router(
+  {
+    createCategory: {
+      method: "POST",
+      path: "",
+      headers: DefaultHeaderSchema,
+      body: createCategorySchema,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          category: categorySchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    getCategories: {
+      method: "GET",
+      path: "",
+      query: import_zod18.default.object({
+        page: import_zod18.default.coerce.number().optional(),
+        pageSize: import_zod18.default.coerce.number().optional()
+      }).optional(),
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: withPagination(categorySchema),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    updateCategory: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: import_zod18.default.object({ id: import_zod18.default.string() }),
+      headers: DefaultHeaderSchema.extend({
+        category: categorySchema
+      }),
+      body: updateCategorySchema,
+      responses: {
+        200: DefaultSuccessResponseSchema,
+        500: DefaultErrorResponseSchema
+      }
+    },
+    deleteCategory: {
+      method: "DELETE",
+      path: "/:id",
+      pathParams: import_zod18.default.object({ id: import_zod18.default.string() }),
+      headers: DefaultHeaderSchema,
+      body: import_zod18.default.any().optional(),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({ message: import_zod18.default.string() }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    createCategoryLevel: {
+      method: "POST",
+      path: "/level",
+      headers: DefaultHeaderSchema,
+      body: createCategoryLevelSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          categoryLevel: categoryLevelSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    updateCategoryLevel: {
+      method: "PATCH",
+      path: "/level/:id",
+      pathParams: import_zod18.default.object({ id: import_zod18.default.string() }),
+      headers: DefaultHeaderSchema,
+      body: updateCategoryLevelSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          categoryLevel: categoryLevelSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    }
+  },
+  {
+    pathPrefix: "categories"
+  }
+);
+
+// src/contract.ts
+var apiContract = (0, import_core10.initContract)().router({
+  auth: authContract,
+  mail: mailContract,
+  cxLog: cxLogContract,
+  emailEngineWebhooks: emailEngineWebhooksEventsContract,
+  category: categoryContract
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  apiContract,
+  categoryContract
+});
+//# sourceMappingURL=index.js.map