@middlewr/contracts 0.0.2 → 0.0.3

package/cjs/index.js

@@ -0,0 +1,334 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contracts/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CreateInvitationInputSchema: () => CreateInvitationInputSchema,
+  CreateLinkInputSchema: () => CreateLinkInputSchema,
+  CreateTagInputSchema: () => CreateTagInputSchema,
+  CreateWorkspaceInputSchema: () => CreateWorkspaceInputSchema,
+  InvitationIdParamSchema: () => InvitationIdParamSchema,
+  LinkFiltersSchema: () => LinkFiltersSchema,
+  LinkIdParamSchema: () => LinkIdParamSchema,
+  LinkSchema: () => LinkSchema,
+  MemberIdParamSchema: () => MemberIdParamSchema,
+  PaginatedLinksSchema: () => PaginatedLinksSchema,
+  SignInInputSchema: () => SignInInputSchema,
+  TagIdParamSchema: () => TagIdParamSchema,
+  TagSchema: () => TagSchema,
+  TokenParamSchema: () => TokenParamSchema,
+  TransferOwnershipInputSchema: () => TransferOwnershipInputSchema,
+  UpdateLinkInputSchema: () => UpdateLinkInputSchema,
+  UpdateMemberInputSchema: () => UpdateMemberInputSchema,
+  UpdateTagInputSchema: () => UpdateTagInputSchema,
+  UpdateUserInputSchema: () => UpdateUserInputSchema,
+  UpdateWorkspaceInputSchema: () => UpdateWorkspaceInputSchema,
+  UserSchema: () => UserSchema,
+  WorkspaceIdParamSchema: () => WorkspaceIdParamSchema,
+  WorkspaceInvitationSchema: () => WorkspaceInvitationSchema,
+  WorkspaceMemberSchema: () => WorkspaceMemberSchema,
+  WorkspaceSchema: () => WorkspaceSchema,
+  WorkspaceWithCountSchema: () => WorkspaceWithCountSchema,
+  contract: () => contract,
+  invitationsContract: () => invitationsContract,
+  linksContract: () => linksContract,
+  tagsContract: () => tagsContract,
+  usersContract: () => usersContract,
+  workspacesContract: () => workspacesContract
+});
+module.exports = __toCommonJS(index_exports);
+var import_contract = require("@orpc/contract");
+var import_zod6 = require("zod");
+
+// src/contracts/common.schema.ts
+var import_zod = require("zod");
+var WorkspaceIdParamSchema = import_zod.z.object({
+  workspace_id: import_zod.z.string().uuid()
+});
+var LinkIdParamSchema = import_zod.z.object({
+  workspace_id: import_zod.z.string().uuid(),
+  link_id: import_zod.z.string().uuid()
+});
+var TagIdParamSchema = import_zod.z.object({
+  workspace_id: import_zod.z.string().uuid(),
+  tag_id: import_zod.z.string().uuid()
+});
+var MemberIdParamSchema = import_zod.z.object({
+  workspace_id: import_zod.z.string().uuid(),
+  user_id: import_zod.z.string().uuid()
+});
+var InvitationIdParamSchema = import_zod.z.object({
+  workspace_id: import_zod.z.string().uuid(),
+  invitation_id: import_zod.z.string().uuid()
+});
+var TokenParamSchema = import_zod.z.object({
+  token: import_zod.z.string()
+});
+
+// src/contracts/links.schema.ts
+var import_zod2 = require("zod");
+var LinkSchema = 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(),
+  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()
+});
+
+// src/contracts/tags.schema.ts
+var import_zod3 = require("zod");
+var TagSchema = import_zod3.z.object({
+  id: import_zod3.z.string().uuid(),
+  workspace_id: import_zod3.z.string().uuid(),
+  name: import_zod3.z.string(),
+  color: import_zod3.z.string().nullable(),
+  created_at: import_zod3.z.coerce.date(),
+  updated_at: import_zod3.z.coerce.date().nullable()
+});
+var CreateTagInputSchema = import_zod3.z.object({
+  name: import_zod3.z.string().min(1).max(50),
+  color: import_zod3.z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
+});
+var UpdateTagInputSchema = import_zod3.z.object({
+  name: import_zod3.z.string().min(1).max(50).optional(),
+  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({
+  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(),
+  created_at: import_zod4.z.coerce.date(),
+  updated_at: import_zod4.z.coerce.date().nullable()
+});
+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 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()
+});
+
+// src/contracts/workspaces.schema.ts
+var import_zod5 = require("zod");
+var WorkspaceSchema = import_zod5.z.object({
+  id: import_zod5.z.string().uuid(),
+  name: import_zod5.z.string(),
+  created_at: import_zod5.z.coerce.date(),
+  updated_at: import_zod5.z.coerce.date().nullable()
+});
+var WorkspaceWithCountSchema = WorkspaceSchema.extend({
+  member_count: import_zod5.z.number().int()
+});
+var CreateWorkspaceInputSchema = import_zod5.z.object({
+  name: import_zod5.z.string().min(1).max(100)
+});
+var UpdateWorkspaceInputSchema = import_zod5.z.object({
+  name: import_zod5.z.string().min(1).max(100).optional()
+});
+var TransferOwnershipInputSchema = import_zod5.z.object({
+  to_user_id: import_zod5.z.string().uuid()
+});
+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(),
+  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()
+});
+var UpdateMemberInputSchema = import_zod5.z.object({
+  permissions: import_zod5.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 CreateInvitationInputSchema = import_zod5.z.object({
+  email: import_zod5.z.string().email(),
+  permissions: import_zod5.z.number().int().min(1)
+});
+
+// src/contracts/index.ts
+var usersContract = {
+  me: import_contract.oc.route({ method: "GET", path: "/api/users/me" }).output(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(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)),
+  get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}" }).input(WorkspaceIdParamSchema).output(WorkspaceWithCountSchema),
+  update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspaceId}" }).input(WorkspaceIdParamSchema.merge(UpdateWorkspaceInputSchema)).output(WorkspaceSchema),
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspaceId}" }).input(WorkspaceIdParamSchema).output(import_zod6.z.void()),
+  transfer: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspaceId}/transfer" }).input(WorkspaceIdParamSchema.merge(TransferOwnershipInputSchema)).output(import_zod6.z.void()),
+  // Members
+  listMembers: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}/members" }).input(WorkspaceIdParamSchema).output(import_zod6.z.array(WorkspaceMemberSchema)),
+  updateMember: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspaceId}/members/{userId}" }).input(MemberIdParamSchema.merge(UpdateMemberInputSchema)).output(WorkspaceMemberSchema),
+  removeMember: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspaceId}/members/{userId}" }).input(MemberIdParamSchema).output(import_zod6.z.void()),
+  // Invitations
+  listInvitations: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}/invitations" }).input(WorkspaceIdParamSchema).output(import_zod6.z.array(WorkspaceInvitationSchema)),
+  createInvitation: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspaceId}/invitations" }).input(WorkspaceIdParamSchema.merge(CreateInvitationInputSchema)).output(WorkspaceInvitationSchema),
+  revokeInvitation: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspaceId}/invitations/{invitationId}" }).input(InvitationIdParamSchema).output(import_zod6.z.void())
+};
+var invitationsContract = {
+  get: import_contract.oc.route({ method: "GET", path: "/api/invitations/{token}" }).input(TokenParamSchema).output(WorkspaceInvitationSchema),
+  accept: import_contract.oc.route({ method: "POST", path: "/api/invitations/{token}/accept" }).input(TokenParamSchema).output(WorkspaceMemberSchema)
+};
+var linksContract = {
+  create: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspaceId}/links" }).input(WorkspaceIdParamSchema.merge(CreateLinkInputSchema)).output(LinkSchema),
+  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}/links" }).input(WorkspaceIdParamSchema.merge(LinkFiltersSchema)).output(PaginatedLinksSchema),
+  get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}/links/{linkId}" }).input(LinkIdParamSchema).output(LinkSchema),
+  update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspaceId}/links/{linkId}" }).input(LinkIdParamSchema.merge(UpdateLinkInputSchema)).output(LinkSchema),
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspaceId}/links/{linkId}" }).input(LinkIdParamSchema).output(import_zod6.z.void())
+};
+var tagsContract = {
+  create: import_contract.oc.route({ method: "POST", path: "/api/workspaces/{workspaceId}/tags" }).input(WorkspaceIdParamSchema.merge(CreateTagInputSchema)).output(TagSchema),
+  list: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}/tags" }).input(WorkspaceIdParamSchema).output(import_zod6.z.array(TagSchema)),
+  get: import_contract.oc.route({ method: "GET", path: "/api/workspaces/{workspaceId}/tags/{tagId}" }).input(TagIdParamSchema).output(TagSchema),
+  update: import_contract.oc.route({ method: "PATCH", path: "/api/workspaces/{workspaceId}/tags/{tagId}" }).input(TagIdParamSchema.merge(UpdateTagInputSchema)).output(TagSchema),
+  delete: import_contract.oc.route({ method: "DELETE", path: "/api/workspaces/{workspaceId}/tags/{tagId}" }).input(TagIdParamSchema).output(import_zod6.z.void())
+};
+var contract = {
+  users: usersContract,
+  workspaces: workspacesContract,
+  invitations: invitationsContract,
+  links: linksContract,
+  tags: tagsContract
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateInvitationInputSchema,
+  CreateLinkInputSchema,
+  CreateTagInputSchema,
+  CreateWorkspaceInputSchema,
+  InvitationIdParamSchema,
+  LinkFiltersSchema,
+  LinkIdParamSchema,
+  LinkSchema,
+  MemberIdParamSchema,
+  PaginatedLinksSchema,
+  SignInInputSchema,
+  TagIdParamSchema,
+  TagSchema,
+  TokenParamSchema,
+  TransferOwnershipInputSchema,
+  UpdateLinkInputSchema,
+  UpdateMemberInputSchema,
+  UpdateTagInputSchema,
+  UpdateUserInputSchema,
+  UpdateWorkspaceInputSchema,
+  UserSchema,
+  WorkspaceIdParamSchema,
+  WorkspaceInvitationSchema,
+  WorkspaceMemberSchema,
+  WorkspaceSchema,
+  WorkspaceWithCountSchema,
+  contract,
+  invitationsContract,
+  linksContract,
+  tagsContract,
+  usersContract,
+  workspacesContract
+});

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

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

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"tags.schema.d.ts","sourceRoot":"","sources":["../../src/contracts/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/cjs/users.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.schema.d.ts","sourceRoot":"","sources":["../../src/contracts/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/cjs/workspaces.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.schema.d.ts","sourceRoot":"","sources":["../../src/contracts/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,qBAAqB;;;;;;;;iBAQhC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AAGH,eAAO,MAAM,yBAAyB;;;;;;;;;iBASpC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC"}

package/esm/common.schema.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const WorkspaceIdParamSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+}, z.core.$strip>;
+export declare const LinkIdParamSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+    link_id: z.ZodString;
+}, z.core.$strip>;
+export declare const TagIdParamSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+    tag_id: z.ZodString;
+}, z.core.$strip>;
+export declare const MemberIdParamSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+    user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const InvitationIdParamSchema: z.ZodObject<{
+    workspace_id: z.ZodString;
+    invitation_id: z.ZodString;
+}, z.core.$strip>;
+export declare const TokenParamSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=common.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.schema.d.ts","sourceRoot":"","sources":["../../src/contracts/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,gBAAgB;;iBAE3B,CAAC"}

package/esm/common.schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const WorkspaceIdParamSchema = z.object({
+    workspace_id: z.string().uuid(),
+});
+export const LinkIdParamSchema = z.object({
+    workspace_id: z.string().uuid(),
+    link_id: z.string().uuid(),
+});
+export const TagIdParamSchema = z.object({
+    workspace_id: z.string().uuid(),
+    tag_id: z.string().uuid(),
+});
+export const MemberIdParamSchema = z.object({
+    workspace_id: z.string().uuid(),
+    user_id: z.string().uuid(),
+});
+export const InvitationIdParamSchema = z.object({
+    workspace_id: z.string().uuid(),
+    invitation_id: z.string().uuid(),
+});
+export const TokenParamSchema = z.object({
+    token: z.string(),
+});