@middlewr/contracts 0.0.7 → 0.0.8

package/{cjs → dist/cjs}/index.js

@@ -17,13 +17,16 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/contracts/index.ts
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CreateDomainInputSchema: () => CreateDomainInputSchema,
   CreateInvitationInputSchema: () => CreateInvitationInputSchema,
   CreateLinkInputSchema: () => CreateLinkInputSchema,
   CreateTagInputSchema: () => CreateTagInputSchema,
   CreateWorkspaceInputSchema: () => CreateWorkspaceInputSchema,
+  DomainIdParamSchema: () => DomainIdParamSchema,
+  DomainSchema: () => DomainSchema,
   InvitationIdParamSchema: () => InvitationIdParamSchema,
   LinkFiltersSchema: () => LinkFiltersSchema,
   LinkIdParamSchema: () => LinkIdParamSchema,
@@ -35,6 +38,7 @@ __export(index_exports, {
   TagSchema: () => TagSchema,
   TokenParamSchema: () => TokenParamSchema,
   TransferOwnershipInputSchema: () => TransferOwnershipInputSchema,
+  UpdateDomainInputSchema: () => UpdateDomainInputSchema,
   UpdateLinkInputSchema: () => UpdateLinkInputSchema,
   UpdateMemberInputSchema: () => UpdateMemberInputSchema,
   UpdateTagInputSchema: () => UpdateTagInputSchema,
@@ -48,6 +52,7 @@ __export(index_exports, {
   WorkspaceSchema: () => WorkspaceSchema,
   WorkspaceWithCountSchema: () => WorkspaceWithCountSchema,
   contract: () => contract,
+  domainsContract: () => domainsContract,
   invitationsContract: () => invitationsContract,
   linksContract: () => linksContract,
   tagsContract: () => tagsContract,
@@ -56,9 +61,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_contract = require("@orpc/contract");
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
-// src/contracts/common.schema.ts
+// src/common.schema.ts
 var import_zod = require("zod");
 var WorkspaceIdParamSchema = import_zod.z.object({
   workspace_id: import_zod.z.string().uuid()
@@ -79,92 +84,40 @@ var InvitationIdParamSchema = import_zod.z.object({
   workspace_id: import_zod.z.string().uuid(),
   invitation_id: import_zod.z.string().uuid()
 });
+var DomainIdParamSchema = import_zod.z.object({
+  workspace_id: import_zod.z.string().uuid(),
+  domain_id: import_zod.z.string().uuid()
+});
 var TokenParamSchema = import_zod.z.object({
   token: import_zod.z.string()
 });
 
-// src/contracts/links.schema.ts
+// src/domains.schema.ts
 var import_zod2 = require("zod");
-var LinkSchema = import_zod2.z.object({
+var DomainSchema = import_zod2.z.object({
   id: import_zod2.z.string().uuid(),
-  workspace_id: import_zod2.z.string().uuid(),
-  created_by_id: import_zod2.z.string().uuid(),
-  original_url: import_zod2.z.string().url(),
-  short_code: import_zod2.z.string(),
-  title: import_zod2.z.string().nullable(),
-  description: import_zod2.z.string().nullable(),
-  utm_source: import_zod2.z.string().nullable(),
-  utm_medium: import_zod2.z.string().nullable(),
-  utm_campaign: import_zod2.z.string().nullable(),
-  utm_term: import_zod2.z.string().nullable(),
-  utm_content: import_zod2.z.string().nullable(),
-  password: import_zod2.z.string().nullable(),
-  starts_at: import_zod2.z.coerce.date().nullable(),
-  expires_at: import_zod2.z.coerce.date().nullable(),
-  is_active: import_zod2.z.boolean(),
-  redirect_type: import_zod2.z.number().int(),
-  click_count: import_zod2.z.number().int(),
-  click_count_updated_at: import_zod2.z.coerce.date().nullable(),
+  workspace_id: import_zod2.z.string().uuid().nullable(),
+  created_by_id: import_zod2.z.string().uuid().nullable(),
+  domain: import_zod2.z.string(),
+  is_verified: import_zod2.z.boolean(),
   created_at: import_zod2.z.coerce.date(),
   updated_at: import_zod2.z.coerce.date().nullable()
 });
-var CreateLinkInputSchema = import_zod2.z.object({
-  original_url: import_zod2.z.string().url().max(2048),
-  short_code: import_zod2.z.string().min(3).max(50).regex(/^[a-zA-Z0-9-]+$/).optional(),
-  title: import_zod2.z.string().max(255).optional(),
-  description: import_zod2.z.string().max(2e3).optional(),
-  utm_source: import_zod2.z.string().max(255).optional(),
-  utm_medium: import_zod2.z.string().max(255).optional(),
-  utm_campaign: import_zod2.z.string().max(255).optional(),
-  utm_term: import_zod2.z.string().max(255).optional(),
-  utm_content: import_zod2.z.string().max(255).optional(),
-  password: import_zod2.z.string().min(4).max(100).optional(),
-  starts_at: import_zod2.z.coerce.date().optional(),
-  expires_at: import_zod2.z.coerce.date().optional(),
-  redirect_type: import_zod2.z.coerce.number().refine((v) => [301, 302, 307, 308].includes(v)).optional(),
-  tag_ids: import_zod2.z.array(import_zod2.z.string().uuid()).optional()
-});
-var UpdateLinkInputSchema = import_zod2.z.object({
-  original_url: import_zod2.z.string().url().max(2048).optional(),
-  short_code: import_zod2.z.string().min(3).max(50).regex(/^[a-zA-Z0-9-]+$/).optional(),
-  title: import_zod2.z.string().max(255).nullable().optional(),
-  description: import_zod2.z.string().max(2e3).nullable().optional(),
-  utm_source: import_zod2.z.string().max(255).nullable().optional(),
-  utm_medium: import_zod2.z.string().max(255).nullable().optional(),
-  utm_campaign: import_zod2.z.string().max(255).nullable().optional(),
-  utm_term: import_zod2.z.string().max(255).nullable().optional(),
-  utm_content: import_zod2.z.string().max(255).nullable().optional(),
-  password: import_zod2.z.string().min(4).max(100).nullable().optional(),
-  starts_at: import_zod2.z.coerce.date().nullable().optional(),
-  expires_at: import_zod2.z.coerce.date().nullable().optional(),
-  is_active: import_zod2.z.boolean().optional(),
-  redirect_type: import_zod2.z.coerce.number().refine((v) => [301, 302, 307, 308].includes(v)).optional(),
-  tag_ids: import_zod2.z.array(import_zod2.z.string().uuid()).optional()
-});
-var LinkFiltersSchema = import_zod2.z.object({
-  search: import_zod2.z.string().optional(),
-  is_active: import_zod2.z.coerce.boolean().optional(),
-  has_expiration: import_zod2.z.coerce.boolean().optional(),
-  expired: import_zod2.z.coerce.boolean().optional(),
-  created_from: import_zod2.z.coerce.date().optional(),
-  created_to: import_zod2.z.coerce.date().optional(),
-  expires_from: import_zod2.z.coerce.date().optional(),
-  expires_to: import_zod2.z.coerce.date().optional(),
-  tag_ids: import_zod2.z.array(import_zod2.z.string().uuid()).optional(),
-  sort_by: import_zod2.z.enum(["created_at", "title", "click_count"]).default("created_at"),
-  sort_order: import_zod2.z.enum(["asc", "desc"]).default("desc"),
-  page: import_zod2.z.coerce.number().int().min(1).default(1),
-  per_page: import_zod2.z.coerce.number().int().min(1).max(100).default(20)
-});
-var PaginatedLinksSchema = import_zod2.z.object({
-  links: import_zod2.z.array(LinkSchema),
-  total: import_zod2.z.number().int(),
-  page: import_zod2.z.number().int(),
-  per_page: import_zod2.z.number().int(),
-  total_pages: import_zod2.z.number().int()
+var CreateDomainInputSchema = import_zod2.z.object({
+  domain: import_zod2.z.string().min(1).max(253).regex(/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/, {
+    message: "Invalid domain format"
+  })
+});
+var UpdateDomainInputSchema = import_zod2.z.object({
+  domain: import_zod2.z.string().min(1).max(253).regex(/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/, {
+    message: "Invalid domain format"
+  }).optional()
 });
 
-// src/contracts/tags.schema.ts
+// src/links.schema.ts
+var import_zod4 = require("zod");
+
+// src/tags.schema.ts
 var import_zod3 = require("zod");
 var TagSchema = import_zod3.z.object({
   id: import_zod3.z.string().uuid(),
@@ -183,102 +136,187 @@ var UpdateTagInputSchema = import_zod3.z.object({
   color: import_zod3.z.string().regex(/^#[0-9A-Fa-f]{6}$/).nullable().optional()
 });
 
-// src/contracts/users.schema.ts
-var import_zod4 = require("zod");
-var UserSchema = import_zod4.z.object({
+// src/links.schema.ts
+var LinkSchema = import_zod4.z.object({
   id: import_zod4.z.string().uuid(),
-  external_id: import_zod4.z.string(),
-  email: import_zod4.z.string().email(),
-  email_verified_at: import_zod4.z.coerce.date().nullable(),
-  first_name: import_zod4.z.string().nullable(),
-  last_name: import_zod4.z.string().nullable(),
+  workspace_id: import_zod4.z.string().uuid(),
+  domain_id: import_zod4.z.string().uuid(),
+  created_by_id: import_zod4.z.string().uuid(),
+  original_url: import_zod4.z.string().url(),
+  short_code: import_zod4.z.string(),
+  title: import_zod4.z.string().nullable(),
+  description: import_zod4.z.string().nullable(),
+  utm_source: import_zod4.z.string().nullable(),
+  utm_medium: import_zod4.z.string().nullable(),
+  utm_campaign: import_zod4.z.string().nullable(),
+  utm_term: import_zod4.z.string().nullable(),
+  utm_content: import_zod4.z.string().nullable(),
+  password: import_zod4.z.string().nullable(),
+  starts_at: import_zod4.z.coerce.date().nullable(),
+  expires_at: import_zod4.z.coerce.date().nullable(),
+  is_active: import_zod4.z.boolean(),
+  redirect_type: import_zod4.z.number().int(),
+  click_count: import_zod4.z.coerce.number().int(),
+  click_count_updated_at: import_zod4.z.coerce.date().nullable(),
   created_at: import_zod4.z.coerce.date(),
-  updated_at: import_zod4.z.coerce.date().nullable()
+  updated_at: import_zod4.z.coerce.date().nullable(),
+  tags: import_zod4.z.array(TagSchema)
 });
-var SignInInputSchema = import_zod4.z.object({
-  first_name: import_zod4.z.string().min(1).max(100).optional(),
-  last_name: import_zod4.z.string().min(1).max(100).optional()
+var CreateLinkInputSchema = import_zod4.z.object({
+  original_url: import_zod4.z.string().url().max(2048),
+  domain_id: import_zod4.z.string().uuid().optional(),
+  short_code: import_zod4.z.string().min(3).max(50).regex(/^[a-zA-Z0-9-]+$/).optional(),
+  title: import_zod4.z.string().max(255).optional(),
+  description: import_zod4.z.string().max(2e3).optional(),
+  utm_source: import_zod4.z.string().max(255).optional(),
+  utm_medium: import_zod4.z.string().max(255).optional(),
+  utm_campaign: import_zod4.z.string().max(255).optional(),
+  utm_term: import_zod4.z.string().max(255).optional(),
+  utm_content: import_zod4.z.string().max(255).optional(),
+  password: import_zod4.z.string().min(4).max(100).optional(),
+  starts_at: import_zod4.z.coerce.date().optional(),
+  expires_at: import_zod4.z.coerce.date().optional(),
+  redirect_type: import_zod4.z.coerce.number().refine((v) => [301, 302, 307, 308].includes(v)).optional(),
+  tag_ids: import_zod4.z.array(import_zod4.z.string().uuid()).optional()
 });
-var UpdateUserInputSchema = import_zod4.z.object({
-  first_name: import_zod4.z.string().min(1).max(100).optional(),
-  last_name: import_zod4.z.string().min(1).max(100).optional()
+var UpdateLinkInputSchema = import_zod4.z.object({
+  original_url: import_zod4.z.string().url().max(2048).optional(),
+  domain_id: import_zod4.z.string().uuid().optional(),
+  short_code: import_zod4.z.string().min(3).max(50).regex(/^[a-zA-Z0-9-]+$/).optional(),
+  title: import_zod4.z.string().max(255).nullable().optional(),
+  description: import_zod4.z.string().max(2e3).nullable().optional(),
+  utm_source: import_zod4.z.string().max(255).nullable().optional(),
+  utm_medium: import_zod4.z.string().max(255).nullable().optional(),
+  utm_campaign: import_zod4.z.string().max(255).nullable().optional(),
+  utm_term: import_zod4.z.string().max(255).nullable().optional(),
+  utm_content: import_zod4.z.string().max(255).nullable().optional(),
+  password: import_zod4.z.string().min(4).max(100).nullable().optional(),
+  starts_at: import_zod4.z.coerce.date().nullable().optional(),
+  expires_at: import_zod4.z.coerce.date().nullable().optional(),
+  is_active: import_zod4.z.boolean().optional(),
+  redirect_type: import_zod4.z.coerce.number().refine((v) => [301, 302, 307, 308].includes(v)).optional(),
+  tag_ids: import_zod4.z.array(import_zod4.z.string().uuid()).optional()
+});
+var LinkFiltersSchema = import_zod4.z.object({
+  search: import_zod4.z.string().optional(),
+  domain_id: import_zod4.z.string().uuid().optional(),
+  is_active: import_zod4.z.coerce.boolean().optional(),
+  has_expiration: import_zod4.z.coerce.boolean().optional(),
+  expired: import_zod4.z.coerce.boolean().optional(),
+  created_from: import_zod4.z.coerce.date().optional(),
+  created_to: import_zod4.z.coerce.date().optional(),
+  expires_from: import_zod4.z.coerce.date().optional(),
+  expires_to: import_zod4.z.coerce.date().optional(),
+  tag_ids: import_zod4.z.array(import_zod4.z.string().uuid()).optional(),
+  sort_by: import_zod4.z.enum(["created_at", "title", "click_count"]).default("created_at"),
+  sort_order: import_zod4.z.enum(["asc", "desc"]).default("desc"),
+  page: import_zod4.z.coerce.number().int().min(1).default(1),
+  per_page: import_zod4.z.coerce.number().int().min(1).max(100).default(20)
+});
+var PaginatedLinksSchema = import_zod4.z.object({
+  links: import_zod4.z.array(LinkSchema),
+  total: import_zod4.z.number().int(),
+  page: import_zod4.z.number().int(),
+  per_page: import_zod4.z.number().int(),
+  total_pages: import_zod4.z.number().int()
 });
 
-// src/contracts/workspaces.schema.ts
+// src/users.schema.ts
 var import_zod5 = require("zod");
-var WorkspaceSchema = import_zod5.z.object({
+var UserSchema = import_zod5.z.object({
   id: import_zod5.z.string().uuid(),
-  name: import_zod5.z.string(),
+  external_id: import_zod5.z.string(),
+  email: import_zod5.z.string().email(),
+  email_verified_at: import_zod5.z.coerce.date().nullable(),
+  first_name: import_zod5.z.string().nullable(),
+  last_name: import_zod5.z.string().nullable(),
   created_at: import_zod5.z.coerce.date(),
   updated_at: import_zod5.z.coerce.date().nullable()
 });
+var SignInInputSchema = import_zod5.z.object({
+  first_name: import_zod5.z.string().min(1).max(100).optional(),
+  last_name: import_zod5.z.string().min(1).max(100).optional()
+});
+var UpdateUserInputSchema = import_zod5.z.object({
+  first_name: import_zod5.z.string().min(1).max(100).optional(),
+  last_name: import_zod5.z.string().min(1).max(100).optional()
+});
+
+// src/workspaces.schema.ts
+var import_zod6 = require("zod");
+var WorkspaceSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid(),
+  name: import_zod6.z.string(),
+  created_at: import_zod6.z.coerce.date(),
+  updated_at: import_zod6.z.coerce.date().nullable()
+});
 var WorkspaceWithCountSchema = WorkspaceSchema.extend({
-  member_count: import_zod5.z.number().int()
+  member_count: import_zod6.z.number().int()
 });
-var CreateWorkspaceInputSchema = import_zod5.z.object({
-  name: import_zod5.z.string().min(1).max(100)
+var CreateWorkspaceInputSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1).max(100)
 });
-var UpdateWorkspaceInputSchema = import_zod5.z.object({
-  name: import_zod5.z.string().min(1).max(100).optional()
+var UpdateWorkspaceInputSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1).max(100).optional()
 });
-var TransferOwnershipInputSchema = import_zod5.z.object({
-  to_user_id: import_zod5.z.string().uuid()
+var TransferOwnershipInputSchema = import_zod6.z.object({
+  to_user_id: import_zod6.z.string().uuid()
 });
-var WorkspaceMemberUserSchema = import_zod5.z.object({
-  id: import_zod5.z.string().uuid(),
-  email: import_zod5.z.string().email(),
-  first_name: import_zod5.z.string().nullable(),
-  last_name: import_zod5.z.string().nullable()
+var WorkspaceMemberUserSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid(),
+  email: import_zod6.z.string().email(),
+  first_name: import_zod6.z.string().nullable(),
+  last_name: import_zod6.z.string().nullable()
 });
-var WorkspaceMemberSchema = import_zod5.z.object({
-  id: import_zod5.z.string().uuid(),
-  workspace_id: import_zod5.z.string().uuid(),
-  user_id: import_zod5.z.string().uuid(),
+var WorkspaceMemberSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid(),
+  workspace_id: import_zod6.z.string().uuid(),
+  user_id: import_zod6.z.string().uuid(),
   user: WorkspaceMemberUserSchema,
-  permissions: import_zod5.z.number().int(),
-  joined_at: import_zod5.z.coerce.date(),
-  created_at: import_zod5.z.coerce.date(),
-  updated_at: import_zod5.z.coerce.date().nullable()
+  permissions: import_zod6.z.number().int(),
+  joined_at: import_zod6.z.coerce.date(),
+  created_at: import_zod6.z.coerce.date(),
+  updated_at: import_zod6.z.coerce.date().nullable()
 });
-var UpdateMemberInputSchema = import_zod5.z.object({
-  permissions: import_zod5.z.number().int().min(1)
+var UpdateMemberInputSchema = import_zod6.z.object({
+  permissions: import_zod6.z.number().int().min(1)
 });
-var WorkspaceInvitationSchema = import_zod5.z.object({
-  id: import_zod5.z.string().uuid(),
-  workspace_id: import_zod5.z.string().uuid(),
-  email: import_zod5.z.string().email(),
-  token: import_zod5.z.string(),
-  permissions: import_zod5.z.number().int(),
-  invited_by_id: import_zod5.z.string().uuid(),
-  expires_at: import_zod5.z.coerce.date(),
-  created_at: import_zod5.z.coerce.date()
+var WorkspaceInvitationSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid(),
+  workspace_id: import_zod6.z.string().uuid(),
+  email: import_zod6.z.string().email(),
+  token: import_zod6.z.string(),
+  permissions: import_zod6.z.number().int(),
+  invited_by_id: import_zod6.z.string().uuid(),
+  expires_at: import_zod6.z.coerce.date(),
+  created_at: import_zod6.z.coerce.date()
 });
-var CreateInvitationInputSchema = import_zod5.z.object({
-  email: import_zod5.z.string().email(),
-  permissions: import_zod5.z.number().int().min(1)
+var CreateInvitationInputSchema = import_zod6.z.object({
+  email: import_zod6.z.string().email(),
+  permissions: import_zod6.z.number().int().min(1)
 });
 
-// src/contracts/index.ts
+// src/index.ts
 var usersContract = {
-  me: import_contract.oc.route({ method: "GET", path: "/api/users/me" }).output(import_zod6.z.object({ user: UserSchema })),
-  signIn: import_contract.oc.route({ method: "POST", path: "/api/users" }).input(SignInInputSchema).output(import_zod6.z.object({ user: UserSchema, status: import_zod6.z.enum(["created", "existing"]) })),
-  update: import_contract.oc.route({ method: "PATCH", path: "/api/users/me" }).input(UpdateUserInputSchema).output(import_zod6.z.object({ user: UserSchema }))
+  me: import_contract.oc.route({ method: "GET", path: "/api/users/me" }).output(import_zod7.z.object({ user: UserSchema })),
+  signIn: import_contract.oc.route({ method: "POST", path: "/api/users" }).input(SignInInputSchema).output(import_zod7.z.object({ user: UserSchema, status: import_zod7.z.enum(["created", "existing"]) })),
+  update: import_contract.oc.route({ method: "PATCH", path: "/api/users/me" }).input(UpdateUserInputSchema).output(import_zod7.z.object({ user: UserSchema }))
 };
 var workspacesContract = {
   create: import_contract.oc.route({ method: "POST", path: "/api/workspaces" }).input(CreateWorkspaceInputSchema).output(WorkspaceSchema),
-  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces" }).output(import_zod6.z.array(WorkspaceWithCountSchema)),
+  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces" }).output(import_zod7.z.array(WorkspaceWithCountSchema)),
   get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}" }).input(WorkspaceIdParamSchema).output(WorkspaceWithCountSchema),
   update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspace_id}" }).input(WorkspaceIdParamSchema.merge(UpdateWorkspaceInputSchema)).output(WorkspaceSchema),
-  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}" }).input(WorkspaceIdParamSchema).output(import_zod6.z.void()),
-  transfer: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspace_id}/transfer" }).input(WorkspaceIdParamSchema.merge(TransferOwnershipInputSchema)).output(import_zod6.z.void()),
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}" }).input(WorkspaceIdParamSchema).output(import_zod7.z.void()),
+  transfer: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspace_id}/transfer" }).input(WorkspaceIdParamSchema.merge(TransferOwnershipInputSchema)).output(import_zod7.z.void()),
   // Members
-  listMembers: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/members" }).input(WorkspaceIdParamSchema).output(import_zod6.z.array(WorkspaceMemberSchema)),
+  listMembers: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/members" }).input(WorkspaceIdParamSchema).output(import_zod7.z.array(WorkspaceMemberSchema)),
   updateMember: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspace_id}/members/{user_id}" }).input(MemberIdParamSchema.merge(UpdateMemberInputSchema)).output(WorkspaceMemberSchema),
-  removeMember: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/members/{user_id}" }).input(MemberIdParamSchema).output(import_zod6.z.void()),
+  removeMember: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/members/{user_id}" }).input(MemberIdParamSchema).output(import_zod7.z.void()),
   // Invitations
-  listInvitations: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/invitations" }).input(WorkspaceIdParamSchema).output(import_zod6.z.array(WorkspaceInvitationSchema)),
+  listInvitations: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/invitations" }).input(WorkspaceIdParamSchema).output(import_zod7.z.array(WorkspaceInvitationSchema)),
   createInvitation: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspace_id}/invitations" }).input(WorkspaceIdParamSchema.merge(CreateInvitationInputSchema)).output(WorkspaceInvitationSchema),
-  revokeInvitation: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/invitations/{invitation_id}" }).input(InvitationIdParamSchema).output(import_zod6.z.void())
+  revokeInvitation: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/invitations/{invitation_id}" }).input(InvitationIdParamSchema).output(import_zod7.z.void())
 };
 var invitationsContract = {
   get: import_contract.oc.route({ method: "GET", path: "/api/invitations/{token}" }).input(TokenParamSchema).output(WorkspaceInvitationSchema),
@@ -289,28 +327,39 @@ var linksContract = {
   list: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/links" }).input(WorkspaceIdParamSchema.merge(LinkFiltersSchema)).output(PaginatedLinksSchema),
   get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/links/{link_id}" }).input(LinkIdParamSchema).output(LinkSchema),
   update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspace_id}/links/{link_id}" }).input(LinkIdParamSchema.merge(UpdateLinkInputSchema)).output(LinkSchema),
-  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/links/{link_id}" }).input(LinkIdParamSchema).output(import_zod6.z.void())
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/links/{link_id}" }).input(LinkIdParamSchema).output(import_zod7.z.void())
 };
 var tagsContract = {
   create: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspace_id}/tags" }).input(WorkspaceIdParamSchema.merge(CreateTagInputSchema)).output(TagSchema),
-  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/tags" }).input(WorkspaceIdParamSchema).output(import_zod6.z.array(TagSchema)),
+  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/tags" }).input(WorkspaceIdParamSchema).output(import_zod7.z.array(TagSchema)),
   get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/tags/{tag_id}" }).input(TagIdParamSchema).output(TagSchema),
   update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspace_id}/tags/{tag_id}" }).input(TagIdParamSchema.merge(UpdateTagInputSchema)).output(TagSchema),
-  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/tags/{tag_id}" }).input(TagIdParamSchema).output(import_zod6.z.void())
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/tags/{tag_id}" }).input(TagIdParamSchema).output(import_zod7.z.void())
+};
+var domainsContract = {
+  create: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspace_id}/domains" }).input(WorkspaceIdParamSchema.merge(CreateDomainInputSchema)).output(DomainSchema),
+  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/domains" }).input(WorkspaceIdParamSchema).output(import_zod7.z.array(DomainSchema)),
+  get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspace_id}/domains/{domain_id}" }).input(DomainIdParamSchema).output(DomainSchema),
+  update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspace_id}/domains/{domain_id}" }).input(DomainIdParamSchema.merge(UpdateDomainInputSchema)).output(DomainSchema),
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspace_id}/domains/{domain_id}" }).input(DomainIdParamSchema).output(import_zod7.z.void())
 };
 var contract = {
   users: usersContract,
   workspaces: workspacesContract,
   invitations: invitationsContract,
   links: linksContract,
-  tags: tagsContract
+  tags: tagsContract,
+  domains: domainsContract
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CreateDomainInputSchema,
   CreateInvitationInputSchema,
   CreateLinkInputSchema,
   CreateTagInputSchema,
   CreateWorkspaceInputSchema,
+  DomainIdParamSchema,
+  DomainSchema,
   InvitationIdParamSchema,
   LinkFiltersSchema,
   LinkIdParamSchema,
@@ -322,6 +371,7 @@ var contract = {
   TagSchema,
   TokenParamSchema,
   TransferOwnershipInputSchema,
+  UpdateDomainInputSchema,
   UpdateLinkInputSchema,
   UpdateMemberInputSchema,
   UpdateTagInputSchema,
@@ -335,6 +385,7 @@ var contract = {
   WorkspaceSchema,
   WorkspaceWithCountSchema,
   contract,
+  domainsContract,
   invitationsContract,
   linksContract,
   tagsContract,

package/{cjs → dist/cjs}/links.schema.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 export declare const LinkSchema: z.ZodObject<{
     id: z.ZodString;
     workspace_id: z.ZodString;
+    domain_id: z.ZodString;
     created_by_id: z.ZodString;
     original_url: z.ZodString;
     short_code: z.ZodString;
@@ -17,13 +18,22 @@ export declare const LinkSchema: z.ZodObject<{
     expires_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
     is_active: z.ZodBoolean;
     redirect_type: z.ZodNumber;
-    click_count: z.ZodNumber;
+    click_count: z.ZodCoercedNumber<unknown>;
     click_count_updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
     created_at: z.ZodCoercedDate<unknown>;
     updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    tags: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspace_id: z.ZodString;
+        name: z.ZodString;
+        color: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodCoercedDate<unknown>;
+        updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const CreateLinkInputSchema: z.ZodObject<{
     original_url: z.ZodString;
+    domain_id: z.ZodOptional<z.ZodString>;
     short_code: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
@@ -40,6 +50,7 @@ export declare const CreateLinkInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const UpdateLinkInputSchema: z.ZodObject<{
     original_url: z.ZodOptional<z.ZodString>;
+    domain_id: z.ZodOptional<z.ZodString>;
     short_code: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -57,6 +68,7 @@ export declare const UpdateLinkInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const LinkFiltersSchema: z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
+    domain_id: z.ZodOptional<z.ZodString>;
     is_active: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
     has_expiration: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
     expired: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
@@ -66,9 +78,9 @@ export declare const LinkFiltersSchema: z.ZodObject<{
     expires_to: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     tag_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     sort_by: z.ZodDefault<z.ZodEnum<{
+        created_at: "created_at";
         title: "title";
         click_count: "click_count";
-        created_at: "created_at";
     }>>;
     sort_order: z.ZodDefault<z.ZodEnum<{
         asc: "asc";
@@ -81,6 +93,7 @@ export declare const PaginatedLinksSchema: z.ZodObject<{
     links: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         workspace_id: z.ZodString;
+        domain_id: z.ZodString;
         created_by_id: z.ZodString;
         original_url: z.ZodString;
         short_code: z.ZodString;
@@ -96,10 +109,18 @@ export declare const PaginatedLinksSchema: z.ZodObject<{
         expires_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
         is_active: z.ZodBoolean;
         redirect_type: z.ZodNumber;
-        click_count: z.ZodNumber;
+        click_count: z.ZodCoercedNumber<unknown>;
         click_count_updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
         created_at: z.ZodCoercedDate<unknown>;
         updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        tags: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            workspace_id: z.ZodString;
+            name: z.ZodString;
+            color: z.ZodNullable<z.ZodString>;
+            created_at: z.ZodCoercedDate<unknown>;
+            updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     total: z.ZodNumber;
     page: z.ZodNumber;

package/dist/cjs/links.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.schema.d.ts","sourceRoot":"","sources":["../../src/links.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBrB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAwBhC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAyBhC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;iBAe5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAC"}

package/dist/cjs/tags.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.schema.d.ts","sourceRoot":"","sources":["../../src/tags.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;iBAOpB,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;iBAM/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;iBAO/B,CAAC"}

package/dist/cjs/users.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.schema.d.ts","sourceRoot":"","sources":["../../src/users.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;iBASrB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC"}

package/dist/cjs/workspaces.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.schema.d.ts","sourceRoot":"","sources":["../../src/workspaces.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;iBAK1B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;iBAEnC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;iBAErC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAGH,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;iBAShC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AAGH,eAAO,MAAM,yBAAyB;;;;;;;;;iBASpC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC"}

package/{esm → dist/esm}/common.schema.d.ts

@@ -18,6 +18,10 @@ export declare const InvitationIdParamSchema: z.ZodObject<{
     workspace_id: z.ZodString;
     invitation_id: z.ZodString;
 }, z.core.$strip>;
+export declare const DomainIdParamSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+    domain_id: z.ZodString;
+}, z.core.$strip>;
 export declare const TokenParamSchema: z.ZodObject<{
     token: z.ZodString;
 }, z.core.$strip>;

package/dist/esm/common.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.schema.d.ts","sourceRoot":"","sources":["../../src/common.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC"}

package/dist/esm/domains.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const DomainSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspace_id: z.ZodNullable<z.ZodString>;
+    created_by_id: z.ZodNullable<z.ZodString>;
+    domain: z.ZodString;
+    is_verified: z.ZodBoolean;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const CreateDomainInputSchema: z.ZodObject<{
+    domain: z.ZodString;
+}, z.core.$strip>;
+export declare const UpdateDomainInputSchema: z.ZodObject<{
+    domain: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=domains.schema.d.ts.map

package/dist/esm/domains.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domains.schema.d.ts","sourceRoot":"","sources":["../../src/domains.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,YAAY;;;;;;;;iBAQvB,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBAQlC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBASlC,CAAC"}