@middlewr/contracts 0.0.1

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/contracts/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyBxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAE9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AAGpC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASzB,CAAC;AAGF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD9B,CAAC;AAGF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAC;AAGF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBzB,CAAC;AAGF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBxB,CAAC;AAGF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMpB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC"}

package/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contract = exports.tagsContract = exports.linksContract = exports.invitationsContract = exports.workspacesContract = exports.usersContract = void 0;
+const contract_1 = require("@orpc/contract");
+const zod_1 = require("zod");
+const common_schema_1 = require("./common.schema");
+const links_schema_1 = require("./links.schema");
+const tags_schema_1 = require("./tags.schema");
+const users_schema_1 = require("./users.schema");
+const workspaces_schema_1 = require("./workspaces.schema");
+__exportStar(require("./common.schema"), exports);
+__exportStar(require("./links.schema"), exports);
+__exportStar(require("./tags.schema"), exports);
+// Re-export all schemas
+__exportStar(require("./users.schema"), exports);
+__exportStar(require("./workspaces.schema"), exports);
+// Users contract
+exports.usersContract = {
+    me: contract_1.oc.route({ method: 'GET', path: '/api/users/me' }).output(users_schema_1.UserSchema),
+    signIn: contract_1.oc
+        .route({ method: 'POST', path: '/api/users' })
+        .input(users_schema_1.SignInInputSchema)
+        .output(zod_1.z.object({ user: users_schema_1.UserSchema, status: zod_1.z.enum(['created', 'existing']) })),
+    update: contract_1.oc.route({ method: 'PATCH', path: '/api/users/me' }).input(users_schema_1.UpdateUserInputSchema).output(users_schema_1.UserSchema),
+};
+// Workspaces contract
+exports.workspacesContract = {
+    create: contract_1.oc.route({ method: 'POST', path: '/api/workspaces' }).input(workspaces_schema_1.CreateWorkspaceInputSchema).output(workspaces_schema_1.WorkspaceSchema),
+    list: contract_1.oc.route({ method: 'GET', path: '/api/workspaces' }).output(zod_1.z.array(workspaces_schema_1.WorkspaceWithCountSchema)),
+    get: contract_1.oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}' }).input(common_schema_1.WorkspaceIdParamSchema).output(workspaces_schema_1.WorkspaceWithCountSchema),
+    update: contract_1.oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}' })
+        .input(common_schema_1.WorkspaceIdParamSchema.merge(workspaces_schema_1.UpdateWorkspaceInputSchema))
+        .output(workspaces_schema_1.WorkspaceSchema),
+    delete: contract_1.oc.route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}' }).input(common_schema_1.WorkspaceIdParamSchema).output(zod_1.z.void()),
+    transfer: contract_1.oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/transfer' })
+        .input(common_schema_1.WorkspaceIdParamSchema.merge(workspaces_schema_1.TransferOwnershipInputSchema))
+        .output(zod_1.z.void()),
+    // Members
+    listMembers: contract_1.oc
+        .route({ method: 'GET', path: '/api/workspaces/{workspaceId}/members' })
+        .input(common_schema_1.WorkspaceIdParamSchema)
+        .output(zod_1.z.array(workspaces_schema_1.WorkspaceMemberSchema)),
+    updateMember: contract_1.oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}/members/{userId}' })
+        .input(common_schema_1.MemberIdParamSchema.merge(workspaces_schema_1.UpdateMemberInputSchema))
+        .output(workspaces_schema_1.WorkspaceMemberSchema),
+    removeMember: contract_1.oc
+        .route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/members/{userId}' })
+        .input(common_schema_1.MemberIdParamSchema)
+        .output(zod_1.z.void()),
+    // Invitations
+    listInvitations: contract_1.oc
+        .route({ method: 'GET', path: '/api/workspaces/{workspaceId}/invitations' })
+        .input(common_schema_1.WorkspaceIdParamSchema)
+        .output(zod_1.z.array(workspaces_schema_1.WorkspaceInvitationSchema)),
+    createInvitation: contract_1.oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/invitations' })
+        .input(common_schema_1.WorkspaceIdParamSchema.merge(workspaces_schema_1.CreateInvitationInputSchema))
+        .output(workspaces_schema_1.WorkspaceInvitationSchema),
+    revokeInvitation: contract_1.oc
+        .route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/invitations/{invitationId}' })
+        .input(common_schema_1.InvitationIdParamSchema)
+        .output(zod_1.z.void()),
+};
+// Invitations contract (public)
+exports.invitationsContract = {
+    get: contract_1.oc.route({ method: 'GET', path: '/api/invitations/{token}' }).input(common_schema_1.TokenParamSchema).output(workspaces_schema_1.WorkspaceInvitationSchema),
+    accept: contract_1.oc.route({ method: 'POST', path: '/api/invitations/{token}/accept' }).input(common_schema_1.TokenParamSchema).output(workspaces_schema_1.WorkspaceMemberSchema),
+};
+// Links contract
+exports.linksContract = {
+    create: contract_1.oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/links' })
+        .input(common_schema_1.WorkspaceIdParamSchema.merge(links_schema_1.CreateLinkInputSchema))
+        .output(links_schema_1.LinkSchema),
+    list: contract_1.oc
+        .route({ method: 'GET', path: '/api/workspaces/{workspaceId}/links' })
+        .input(common_schema_1.WorkspaceIdParamSchema.merge(links_schema_1.LinkFiltersSchema))
+        .output(links_schema_1.PaginatedLinksSchema),
+    get: contract_1.oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}/links/{linkId}' }).input(common_schema_1.LinkIdParamSchema).output(links_schema_1.LinkSchema),
+    update: contract_1.oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}/links/{linkId}' })
+        .input(common_schema_1.LinkIdParamSchema.merge(links_schema_1.UpdateLinkInputSchema))
+        .output(links_schema_1.LinkSchema),
+    delete: contract_1.oc.route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/links/{linkId}' }).input(common_schema_1.LinkIdParamSchema).output(zod_1.z.void()),
+};
+// Tags contract
+exports.tagsContract = {
+    create: contract_1.oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/tags' })
+        .input(common_schema_1.WorkspaceIdParamSchema.merge(tags_schema_1.CreateTagInputSchema))
+        .output(tags_schema_1.TagSchema),
+    list: contract_1.oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}/tags' }).input(common_schema_1.WorkspaceIdParamSchema).output(zod_1.z.array(tags_schema_1.TagSchema)),
+    get: contract_1.oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}/tags/{tagId}' }).input(common_schema_1.TagIdParamSchema).output(tags_schema_1.TagSchema),
+    update: contract_1.oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}/tags/{tagId}' })
+        .input(common_schema_1.TagIdParamSchema.merge(tags_schema_1.UpdateTagInputSchema))
+        .output(tags_schema_1.TagSchema),
+    delete: contract_1.oc.route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/tags/{tagId}' }).input(common_schema_1.TagIdParamSchema).output(zod_1.z.void()),
+};
+// Full contract
+exports.contract = {
+    users: exports.usersContract,
+    workspaces: exports.workspacesContract,
+    invitations: exports.invitationsContract,
+    links: exports.linksContract,
+    tags: exports.tagsContract,
+};

package/links.schema.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+export declare const LinkSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspace_id: z.ZodString;
+    created_by_id: z.ZodString;
+    original_url: z.ZodString;
+    short_code: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    utm_source: z.ZodNullable<z.ZodString>;
+    utm_medium: z.ZodNullable<z.ZodString>;
+    utm_campaign: z.ZodNullable<z.ZodString>;
+    utm_term: z.ZodNullable<z.ZodString>;
+    utm_content: z.ZodNullable<z.ZodString>;
+    password: z.ZodNullable<z.ZodString>;
+    starts_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    expires_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    is_active: z.ZodBoolean;
+    redirect_type: z.ZodNumber;
+    click_count: z.ZodNumber;
+    click_count_updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const CreateLinkInputSchema: z.ZodObject<{
+    original_url: z.ZodString;
+    short_code: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    utm_source: z.ZodOptional<z.ZodString>;
+    utm_medium: z.ZodOptional<z.ZodString>;
+    utm_campaign: z.ZodOptional<z.ZodString>;
+    utm_term: z.ZodOptional<z.ZodString>;
+    utm_content: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    starts_at: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    expires_at: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    redirect_type: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    tag_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const UpdateLinkInputSchema: z.ZodObject<{
+    original_url: z.ZodOptional<z.ZodString>;
+    short_code: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    utm_source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    utm_medium: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    utm_campaign: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    utm_term: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    utm_content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    starts_at: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    expires_at: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    is_active: z.ZodOptional<z.ZodBoolean>;
+    redirect_type: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    tag_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const LinkFiltersSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    is_active: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    has_expiration: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    expired: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+    created_from: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    created_to: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    expires_from: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    expires_to: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    tag_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sort_by: z.ZodDefault<z.ZodEnum<{
+        title: "title";
+        click_count: "click_count";
+        created_at: "created_at";
+    }>>;
+    sort_order: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    per_page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const PaginatedLinksSchema: z.ZodObject<{
+    links: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspace_id: z.ZodString;
+        created_by_id: z.ZodString;
+        original_url: z.ZodString;
+        short_code: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        utm_source: z.ZodNullable<z.ZodString>;
+        utm_medium: z.ZodNullable<z.ZodString>;
+        utm_campaign: z.ZodNullable<z.ZodString>;
+        utm_term: z.ZodNullable<z.ZodString>;
+        utm_content: z.ZodNullable<z.ZodString>;
+        password: z.ZodNullable<z.ZodString>;
+        starts_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        expires_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        is_active: z.ZodBoolean;
+        redirect_type: z.ZodNumber;
+        click_count: z.ZodNumber;
+        click_count_updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        created_at: z.ZodCoercedDate<unknown>;
+        updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    per_page: z.ZodNumber;
+    total_pages: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=links.schema.d.ts.map

package/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/links.schema.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginatedLinksSchema = exports.LinkFiltersSchema = exports.UpdateLinkInputSchema = exports.CreateLinkInputSchema = exports.LinkSchema = void 0;
+const zod_1 = require("zod");
+exports.LinkSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    workspace_id: zod_1.z.string().uuid(),
+    created_by_id: zod_1.z.string().uuid(),
+    original_url: zod_1.z.string().url(),
+    short_code: zod_1.z.string(),
+    title: zod_1.z.string().nullable(),
+    description: zod_1.z.string().nullable(),
+    utm_source: zod_1.z.string().nullable(),
+    utm_medium: zod_1.z.string().nullable(),
+    utm_campaign: zod_1.z.string().nullable(),
+    utm_term: zod_1.z.string().nullable(),
+    utm_content: zod_1.z.string().nullable(),
+    password: zod_1.z.string().nullable(),
+    starts_at: zod_1.z.coerce.date().nullable(),
+    expires_at: zod_1.z.coerce.date().nullable(),
+    is_active: zod_1.z.boolean(),
+    redirect_type: zod_1.z.number().int(),
+    click_count: zod_1.z.number().int(),
+    click_count_updated_at: zod_1.z.coerce.date().nullable(),
+    created_at: zod_1.z.coerce.date(),
+    updated_at: zod_1.z.coerce.date().nullable(),
+});
+exports.CreateLinkInputSchema = zod_1.z.object({
+    original_url: zod_1.z.string().url().max(2048),
+    short_code: zod_1.z
+        .string()
+        .min(3)
+        .max(50)
+        .regex(/^[a-zA-Z0-9-]+$/)
+        .optional(),
+    title: zod_1.z.string().max(255).optional(),
+    description: zod_1.z.string().max(2000).optional(),
+    utm_source: zod_1.z.string().max(255).optional(),
+    utm_medium: zod_1.z.string().max(255).optional(),
+    utm_campaign: zod_1.z.string().max(255).optional(),
+    utm_term: zod_1.z.string().max(255).optional(),
+    utm_content: zod_1.z.string().max(255).optional(),
+    password: zod_1.z.string().min(4).max(100).optional(),
+    starts_at: zod_1.z.coerce.date().optional(),
+    expires_at: zod_1.z.coerce.date().optional(),
+    redirect_type: zod_1.z.coerce
+        .number()
+        .refine((v) => [301, 302, 307, 308].includes(v))
+        .optional(),
+    tag_ids: zod_1.z.array(zod_1.z.string().uuid()).optional(),
+});
+exports.UpdateLinkInputSchema = zod_1.z.object({
+    original_url: zod_1.z.string().url().max(2048).optional(),
+    short_code: zod_1.z
+        .string()
+        .min(3)
+        .max(50)
+        .regex(/^[a-zA-Z0-9-]+$/)
+        .optional(),
+    title: zod_1.z.string().max(255).nullable().optional(),
+    description: zod_1.z.string().max(2000).nullable().optional(),
+    utm_source: zod_1.z.string().max(255).nullable().optional(),
+    utm_medium: zod_1.z.string().max(255).nullable().optional(),
+    utm_campaign: zod_1.z.string().max(255).nullable().optional(),
+    utm_term: zod_1.z.string().max(255).nullable().optional(),
+    utm_content: zod_1.z.string().max(255).nullable().optional(),
+    password: zod_1.z.string().min(4).max(100).nullable().optional(),
+    starts_at: zod_1.z.coerce.date().nullable().optional(),
+    expires_at: zod_1.z.coerce.date().nullable().optional(),
+    is_active: zod_1.z.boolean().optional(),
+    redirect_type: zod_1.z.coerce
+        .number()
+        .refine((v) => [301, 302, 307, 308].includes(v))
+        .optional(),
+    tag_ids: zod_1.z.array(zod_1.z.string().uuid()).optional(),
+});
+exports.LinkFiltersSchema = zod_1.z.object({
+    search: zod_1.z.string().optional(),
+    is_active: zod_1.z.coerce.boolean().optional(),
+    has_expiration: zod_1.z.coerce.boolean().optional(),
+    expired: zod_1.z.coerce.boolean().optional(),
+    created_from: zod_1.z.coerce.date().optional(),
+    created_to: zod_1.z.coerce.date().optional(),
+    expires_from: zod_1.z.coerce.date().optional(),
+    expires_to: zod_1.z.coerce.date().optional(),
+    tag_ids: zod_1.z.array(zod_1.z.string().uuid()).optional(),
+    sort_by: zod_1.z.enum(['created_at', 'title', 'click_count']).default('created_at'),
+    sort_order: zod_1.z.enum(['asc', 'desc']).default('desc'),
+    page: zod_1.z.coerce.number().int().min(1).default(1),
+    per_page: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+});
+exports.PaginatedLinksSchema = zod_1.z.object({
+    links: zod_1.z.array(exports.LinkSchema),
+    total: zod_1.z.number().int(),
+    page: zod_1.z.number().int(),
+    per_page: zod_1.z.number().int(),
+    total_pages: zod_1.z.number().int(),
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@middlewr/contracts",
+    "version": "0.0.1",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts",
+            "default": "./index.js"
+        }
+    },
+    "peerDependencies": {
+        "@orpc/contract": "^1.13",
+        "zod": "^4.0.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/tags.schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const TagSchema: 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>;
+export declare const CreateTagInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UpdateTagInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+//# sourceMappingURL=tags.schema.d.ts.map

package/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/tags.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateTagInputSchema = exports.CreateTagInputSchema = exports.TagSchema = void 0;
+const zod_1 = require("zod");
+exports.TagSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    workspace_id: zod_1.z.string().uuid(),
+    name: zod_1.z.string(),
+    color: zod_1.z.string().nullable(),
+    created_at: zod_1.z.coerce.date(),
+    updated_at: zod_1.z.coerce.date().nullable(),
+});
+exports.CreateTagInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(50),
+    color: zod_1.z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .optional(),
+});
+exports.UpdateTagInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(50).optional(),
+    color: zod_1.z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .nullable()
+        .optional(),
+});

package/users.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const UserSchema: z.ZodObject<{
+    id: z.ZodString;
+    external_id: z.ZodString;
+    email: z.ZodString;
+    email_verified_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const SignInInputSchema: z.ZodObject<{
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UpdateUserInputSchema: z.ZodObject<{
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=users.schema.d.ts.map

package/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/users.schema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateUserInputSchema = exports.SignInInputSchema = exports.UserSchema = void 0;
+const zod_1 = require("zod");
+exports.UserSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    external_id: zod_1.z.string(),
+    email: zod_1.z.string().email(),
+    email_verified_at: zod_1.z.coerce.date().nullable(),
+    first_name: zod_1.z.string().nullable(),
+    last_name: zod_1.z.string().nullable(),
+    created_at: zod_1.z.coerce.date(),
+    updated_at: zod_1.z.coerce.date().nullable(),
+});
+exports.SignInInputSchema = zod_1.z.object({
+    first_name: zod_1.z.string().min(1).max(100).optional(),
+    last_name: zod_1.z.string().min(1).max(100).optional(),
+});
+exports.UpdateUserInputSchema = zod_1.z.object({
+    first_name: zod_1.z.string().min(1).max(100).optional(),
+    last_name: zod_1.z.string().min(1).max(100).optional(),
+});

package/workspaces.schema.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const WorkspaceSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const WorkspaceWithCountSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    member_count: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CreateWorkspaceInputSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const UpdateWorkspaceInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TransferOwnershipInputSchema: z.ZodObject<{
+    to_user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const WorkspaceMemberSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspace_id: z.ZodString;
+    user_id: z.ZodString;
+    permissions: z.ZodNumber;
+    joined_at: z.ZodCoercedDate<unknown>;
+    created_at: z.ZodCoercedDate<unknown>;
+    updated_at: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const UpdateMemberInputSchema: z.ZodObject<{
+    permissions: z.ZodNumber;
+}, z.core.$strip>;
+export declare const WorkspaceInvitationSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspace_id: z.ZodString;
+    email: z.ZodString;
+    token: z.ZodString;
+    permissions: z.ZodNumber;
+    invited_by_id: z.ZodString;
+    expires_at: z.ZodCoercedDate<unknown>;
+    created_at: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export declare const CreateInvitationInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    permissions: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=workspaces.schema.d.ts.map

package/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/workspaces.schema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateInvitationInputSchema = exports.WorkspaceInvitationSchema = exports.UpdateMemberInputSchema = exports.WorkspaceMemberSchema = exports.TransferOwnershipInputSchema = exports.UpdateWorkspaceInputSchema = exports.CreateWorkspaceInputSchema = exports.WorkspaceWithCountSchema = exports.WorkspaceSchema = void 0;
+const zod_1 = require("zod");
+exports.WorkspaceSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    name: zod_1.z.string(),
+    created_at: zod_1.z.coerce.date(),
+    updated_at: zod_1.z.coerce.date().nullable(),
+});
+exports.WorkspaceWithCountSchema = exports.WorkspaceSchema.extend({
+    member_count: zod_1.z.number().int(),
+});
+exports.CreateWorkspaceInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(100),
+});
+exports.UpdateWorkspaceInputSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(100).optional(),
+});
+exports.TransferOwnershipInputSchema = zod_1.z.object({
+    to_user_id: zod_1.z.string().uuid(),
+});
+// Workspace member schemas
+exports.WorkspaceMemberSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    workspace_id: zod_1.z.string().uuid(),
+    user_id: zod_1.z.string().uuid(),
+    permissions: zod_1.z.number().int(),
+    joined_at: zod_1.z.coerce.date(),
+    created_at: zod_1.z.coerce.date(),
+    updated_at: zod_1.z.coerce.date().nullable(),
+});
+exports.UpdateMemberInputSchema = zod_1.z.object({
+    permissions: zod_1.z.number().int().min(1),
+});
+// Invitation schemas
+exports.WorkspaceInvitationSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    workspace_id: zod_1.z.string().uuid(),
+    email: zod_1.z.string().email(),
+    token: zod_1.z.string(),
+    permissions: zod_1.z.number().int(),
+    invited_by_id: zod_1.z.string().uuid(),
+    expires_at: zod_1.z.coerce.date(),
+    created_at: zod_1.z.coerce.date(),
+});
+exports.CreateInvitationInputSchema = zod_1.z.object({
+    email: zod_1.z.string().email(),
+    permissions: zod_1.z.number().int().min(1),
+});