@middlewr/contracts 0.0.2 → 0.0.3

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,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;AACvC,MAAM,MAAM,MAAM,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC"}

package/esm/index.js

@@ -0,0 +1,107 @@
+import { oc } from '@orpc/contract';
+import { z } from 'zod';
+import { InvitationIdParamSchema, LinkIdParamSchema, MemberIdParamSchema, TagIdParamSchema, TokenParamSchema, WorkspaceIdParamSchema, } from './common.schema';
+import { CreateLinkInputSchema, LinkFiltersSchema, LinkSchema, PaginatedLinksSchema, UpdateLinkInputSchema } from './links.schema';
+import { CreateTagInputSchema, TagSchema, UpdateTagInputSchema } from './tags.schema';
+import { SignInInputSchema, UpdateUserInputSchema, UserSchema } from './users.schema';
+import { CreateInvitationInputSchema, CreateWorkspaceInputSchema, TransferOwnershipInputSchema, UpdateMemberInputSchema, UpdateWorkspaceInputSchema, WorkspaceInvitationSchema, WorkspaceMemberSchema, WorkspaceSchema, WorkspaceWithCountSchema, } from './workspaces.schema';
+export * from './common.schema';
+export * from './links.schema';
+export * from './tags.schema';
+// Re-export all schemas
+export * from './users.schema';
+export * from './workspaces.schema';
+// Users contract
+export const usersContract = {
+    me: oc.route({ method: 'GET', path: '/api/users/me' }).output(UserSchema),
+    signIn: oc
+        .route({ method: 'POST', path: '/api/users' })
+        .input(SignInInputSchema)
+        .output(z.object({ user: UserSchema, status: z.enum(['created', 'existing']) })),
+    update: oc.route({ method: 'PATCH', path: '/api/users/me' }).input(UpdateUserInputSchema).output(UserSchema),
+};
+// Workspaces contract
+export const workspacesContract = {
+    create: oc.route({ method: 'POST', path: '/api/workspaces' }).input(CreateWorkspaceInputSchema).output(WorkspaceSchema),
+    list: oc.route({ method: 'GET', path: '/api/workspaces' }).output(z.array(WorkspaceWithCountSchema)),
+    get: oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}' }).input(WorkspaceIdParamSchema).output(WorkspaceWithCountSchema),
+    update: oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}' })
+        .input(WorkspaceIdParamSchema.merge(UpdateWorkspaceInputSchema))
+        .output(WorkspaceSchema),
+    delete: oc.route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}' }).input(WorkspaceIdParamSchema).output(z.void()),
+    transfer: oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/transfer' })
+        .input(WorkspaceIdParamSchema.merge(TransferOwnershipInputSchema))
+        .output(z.void()),
+    // Members
+    listMembers: oc
+        .route({ method: 'GET', path: '/api/workspaces/{workspaceId}/members' })
+        .input(WorkspaceIdParamSchema)
+        .output(z.array(WorkspaceMemberSchema)),
+    updateMember: oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}/members/{userId}' })
+        .input(MemberIdParamSchema.merge(UpdateMemberInputSchema))
+        .output(WorkspaceMemberSchema),
+    removeMember: oc
+        .route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/members/{userId}' })
+        .input(MemberIdParamSchema)
+        .output(z.void()),
+    // Invitations
+    listInvitations: oc
+        .route({ method: 'GET', path: '/api/workspaces/{workspaceId}/invitations' })
+        .input(WorkspaceIdParamSchema)
+        .output(z.array(WorkspaceInvitationSchema)),
+    createInvitation: oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/invitations' })
+        .input(WorkspaceIdParamSchema.merge(CreateInvitationInputSchema))
+        .output(WorkspaceInvitationSchema),
+    revokeInvitation: oc
+        .route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/invitations/{invitationId}' })
+        .input(InvitationIdParamSchema)
+        .output(z.void()),
+};
+// Invitations contract (public)
+export const invitationsContract = {
+    get: oc.route({ method: 'GET', path: '/api/invitations/{token}' }).input(TokenParamSchema).output(WorkspaceInvitationSchema),
+    accept: oc.route({ method: 'POST', path: '/api/invitations/{token}/accept' }).input(TokenParamSchema).output(WorkspaceMemberSchema),
+};
+// Links contract
+export const linksContract = {
+    create: oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/links' })
+        .input(WorkspaceIdParamSchema.merge(CreateLinkInputSchema))
+        .output(LinkSchema),
+    list: oc
+        .route({ method: 'GET', path: '/api/workspaces/{workspaceId}/links' })
+        .input(WorkspaceIdParamSchema.merge(LinkFiltersSchema))
+        .output(PaginatedLinksSchema),
+    get: oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}/links/{linkId}' }).input(LinkIdParamSchema).output(LinkSchema),
+    update: oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}/links/{linkId}' })
+        .input(LinkIdParamSchema.merge(UpdateLinkInputSchema))
+        .output(LinkSchema),
+    delete: oc.route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/links/{linkId}' }).input(LinkIdParamSchema).output(z.void()),
+};
+// Tags contract
+export const tagsContract = {
+    create: oc
+        .route({ method: 'POST', path: '/api/workspaces/{workspaceId}/tags' })
+        .input(WorkspaceIdParamSchema.merge(CreateTagInputSchema))
+        .output(TagSchema),
+    list: oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}/tags' }).input(WorkspaceIdParamSchema).output(z.array(TagSchema)),
+    get: oc.route({ method: 'GET', path: '/api/workspaces/{workspaceId}/tags/{tagId}' }).input(TagIdParamSchema).output(TagSchema),
+    update: oc
+        .route({ method: 'PATCH', path: '/api/workspaces/{workspaceId}/tags/{tagId}' })
+        .input(TagIdParamSchema.merge(UpdateTagInputSchema))
+        .output(TagSchema),
+    delete: oc.route({ method: 'DELETE', path: '/api/workspaces/{workspaceId}/tags/{tagId}' }).input(TagIdParamSchema).output(z.void()),
+};
+// Full contract
+export const contract = {
+    users: usersContract,
+    workspaces: workspacesContract,
+    invitations: invitationsContract,
+    links: linksContract,
+    tags: tagsContract,
+};

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

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

package/esm/package.json

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

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const TagSchema = z.object({
+    id: z.string().uuid(),
+    workspace_id: z.string().uuid(),
+    name: z.string(),
+    color: z.string().nullable(),
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date().nullable(),
+});
+export const CreateTagInputSchema = z.object({
+    name: z.string().min(1).max(50),
+    color: z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .optional(),
+});
+export const UpdateTagInputSchema = z.object({
+    name: z.string().min(1).max(50).optional(),
+    color: z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .nullable()
+        .optional(),
+});

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const UserSchema = z.object({
+    id: z.string().uuid(),
+    external_id: z.string(),
+    email: z.string().email(),
+    email_verified_at: z.coerce.date().nullable(),
+    first_name: z.string().nullable(),
+    last_name: z.string().nullable(),
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date().nullable(),
+});
+export const SignInInputSchema = z.object({
+    first_name: z.string().min(1).max(100).optional(),
+    last_name: z.string().min(1).max(100).optional(),
+});
+export const UpdateUserInputSchema = z.object({
+    first_name: z.string().min(1).max(100).optional(),
+    last_name: z.string().min(1).max(100).optional(),
+});

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export const WorkspaceSchema = z.object({
+    id: z.string().uuid(),
+    name: z.string(),
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date().nullable(),
+});
+export const WorkspaceWithCountSchema = WorkspaceSchema.extend({
+    member_count: z.number().int(),
+});
+export const CreateWorkspaceInputSchema = z.object({
+    name: z.string().min(1).max(100),
+});
+export const UpdateWorkspaceInputSchema = z.object({
+    name: z.string().min(1).max(100).optional(),
+});
+export const TransferOwnershipInputSchema = z.object({
+    to_user_id: z.string().uuid(),
+});
+// Workspace member schemas
+export const WorkspaceMemberSchema = z.object({
+    id: z.string().uuid(),
+    workspace_id: z.string().uuid(),
+    user_id: z.string().uuid(),
+    permissions: z.number().int(),
+    joined_at: z.coerce.date(),
+    created_at: z.coerce.date(),
+    updated_at: z.coerce.date().nullable(),
+});
+export const UpdateMemberInputSchema = z.object({
+    permissions: z.number().int().min(1),
+});
+// Invitation schemas
+export const WorkspaceInvitationSchema = z.object({
+    id: z.string().uuid(),
+    workspace_id: z.string().uuid(),
+    email: z.string().email(),
+    token: z.string(),
+    permissions: z.number().int(),
+    invited_by_id: z.string().uuid(),
+    expires_at: z.coerce.date(),
+    created_at: z.coerce.date(),
+});
+export const CreateInvitationInputSchema = z.object({
+    email: z.string().email(),
+    permissions: z.number().int().min(1),
+});

package/package.json

@@ -1,13 +1,14 @@
 {
     "name": "@middlewr/contracts",
-    "version": "0.0.2",
-    "main": "index.js",
-    "types": "index.d.ts",
-    "type": "module",
+    "version": "0.0.3",
+    "main": "./cjs/index.js",
+    "module": "./esm/index.js",
+    "types": "./esm/index.d.ts",
     "exports": {
         ".": {
-            "types": "./index.d.ts",
-            "default": "./index.js"
+            "types": "./esm/index.d.ts",
+            "import": "./esm/index.js",
+            "require": "./cjs/index.js"
         }
     },
     "peerDependencies": {

package/common.schema.d.ts.map

@@ -1 +0,0 @@
-{"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/common.schema.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenParamSchema = exports.InvitationIdParamSchema = exports.MemberIdParamSchema = exports.TagIdParamSchema = exports.LinkIdParamSchema = exports.WorkspaceIdParamSchema = void 0;
-const zod_1 = require("zod");
-exports.WorkspaceIdParamSchema = zod_1.z.object({
-    workspace_id: zod_1.z.string().uuid(),
-});
-exports.LinkIdParamSchema = zod_1.z.object({
-    workspace_id: zod_1.z.string().uuid(),
-    link_id: zod_1.z.string().uuid(),
-});
-exports.TagIdParamSchema = zod_1.z.object({
-    workspace_id: zod_1.z.string().uuid(),
-    tag_id: zod_1.z.string().uuid(),
-});
-exports.MemberIdParamSchema = zod_1.z.object({
-    workspace_id: zod_1.z.string().uuid(),
-    user_id: zod_1.z.string().uuid(),
-});
-exports.InvitationIdParamSchema = zod_1.z.object({
-    workspace_id: zod_1.z.string().uuid(),
-    invitation_id: zod_1.z.string().uuid(),
-});
-exports.TokenParamSchema = zod_1.z.object({
-    token: zod_1.z.string(),
-});

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/contracts/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,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;AACvC,MAAM,MAAM,MAAM,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC"}