@anuragpal02/zcl-contracts 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# @anuragpal02/zcl-contracts
+
+Shared ZCL request/response contracts, Zod schemas, and typed API client.
+
+## Install
+
+```bash
+npm install @anuragpal02/zcl-contracts
+```
+
+The package is public on npmjs.org for now, so consumers do not need a registry token to install it.
+
+## Usage
+
+```ts
+import { sessionResponseSchema } from '@anuragpal02/zcl-contracts'
+import { createZclApiClient } from '@anuragpal02/zcl-contracts/client'
+```
+
+## Publish
+
+Publishing is manual through the `Publish` GitHub Actions workflow. Bump `version` in `package.json`, merge to `main`, then run the workflow with `NPM_TOKEN` configured.

package/dist/auth.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const signupRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const loginRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const sessionUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    emailVerifiedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const sessionResponseSchema: z.ZodObject<{
+    user: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        emailVerifiedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const authSessionResponseSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        emailVerifiedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const logoutResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type AuthSessionResponse = z.infer<typeof authSessionResponseSchema>;
+export type LoginRequest = z.infer<typeof loginRequestSchema>;
+export type LogoutResponse = z.infer<typeof logoutResponseSchema>;
+export type SessionResponse = z.infer<typeof sessionResponseSchema>;
+export type SessionUser = z.infer<typeof sessionUserSchema>;
+export type SignupRequest = z.infer<typeof signupRequestSchema>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;iBAEhC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;iBAEpC,CAAA;AAEF,eAAO,MAAM,oBAAoB;;iBAE/B,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/auth.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { idSchema, isoDateSchema } from './common';
+export const signupRequestSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(8).max(128),
+    name: z.string().min(1).max(120)
+});
+export const loginRequestSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(8).max(128)
+});
+export const sessionUserSchema = z.object({
+    id: idSchema,
+    email: z.string().email(),
+    name: z.string().nullable(),
+    emailVerifiedAt: isoDateSchema.nullable()
+});
+export const sessionResponseSchema = z.object({
+    user: sessionUserSchema.nullable()
+});
+export const authSessionResponseSchema = z.object({
+    user: sessionUserSchema
+});
+export const logoutResponseSchema = z.object({
+    ok: z.literal(true)
+});

package/dist/client.d.ts

@@ -0,0 +1,42 @@
+import { type AuthSessionResponse, type LoginRequest, type LogoutResponse, type SessionResponse, type SignupRequest } from './auth';
+import { type ApiErrorCode } from './common';
+import { type CreateWorkspaceRequest, type Workspace, type WorkspaceMembership } from './workspaces';
+type FetchLike = (request: Request) => Promise<Response>;
+export type ZclApiClientOptions = {
+    baseUrl: string;
+    fetch?: FetchLike;
+};
+export type WorkspaceWithMembership = Workspace & {
+    membership: WorkspaceMembership;
+};
+export type WorkspaceListResponse = {
+    data: WorkspaceWithMembership[];
+    pagination: {
+        nextCursor: string | null;
+    };
+};
+export declare class ZclApiError extends Error {
+    readonly code: ApiErrorCode;
+    readonly status: number;
+    readonly requestId?: string | undefined;
+    constructor(code: ApiErrorCode, message: string, status: number, requestId?: string | undefined);
+}
+export declare function createZclApiClient(options: ZclApiClientOptions): {
+    auth: {
+        signup(input: SignupRequest): Promise<AuthSessionResponse>;
+        login(input: LoginRequest): Promise<AuthSessionResponse>;
+        logout(): Promise<LogoutResponse>;
+    };
+    session: {
+        get(): Promise<SessionResponse>;
+    };
+    workspaces: {
+        list(): Promise<WorkspaceListResponse>;
+        create(input: CreateWorkspaceRequest): Promise<{
+            data: Workspace;
+        }>;
+    };
+};
+export type ZclApiClient = ReturnType<typeof createZclApiClient>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,QAAQ,CAAA;AACf,OAAO,EAA2C,KAAK,YAAY,EAAE,MAAM,UAAU,CAAA;AACrF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,SAAS,EACd,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAA;AAErB,KAAK,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAExD,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG;IAChD,UAAU,EAAE,mBAAmB,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,uBAAuB,EAAE,CAAA;IAC/B,UAAU,EAAE;QACV,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAC1B,CAAA;CACF,CAAA;AAQD,qBAAa,WAAY,SAAQ,KAAK;aAElB,IAAI,EAAE,YAAY;aAElB,MAAM,EAAE,MAAM;aACd,SAAS,CAAC,EAAE,MAAM;gBAHlB,IAAI,EAAE,YAAY,EAClC,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,YAAA;CAKrC;AA8BD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB;;sBAkD3C,aAAa,GAAG,OAAO,CAAC,mBAAmB,CAAC;qBAM7C,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC;kBAM9C,OAAO,CAAC,cAAc,CAAC;;;eAK1B,OAAO,CAAC,eAAe,CAAC;;;gBAKvB,OAAO,CAAC,qBAAqB,CAAC;sBAGxB,sBAAsB,GAAG,OAAO,CAAC;YAAE,IAAI,EAAE,SAAS,CAAA;SAAE,CAAC;;EAQxE;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/client.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { authSessionResponseSchema, loginRequestSchema, logoutResponseSchema, sessionResponseSchema, signupRequestSchema } from './auth';
+import { errorResponseSchema, listResponseSchema } from './common';
+import { createWorkspaceRequestSchema, workspaceMembershipSchema, workspaceSchema } from './workspaces';
+const workspaceListResponseSchema = listResponseSchema(workspaceSchema.extend({
+    membership: workspaceMembershipSchema
+}));
+export class ZclApiError extends Error {
+    code;
+    status;
+    requestId;
+    constructor(code, message, status, requestId) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.requestId = requestId;
+        this.name = 'ZclApiError';
+    }
+}
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+async function readJson(response) {
+    const text = await response.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ZclApiError('internal_error', 'API response was not valid JSON', response.status);
+    }
+}
+function parseResponse(schema, body, status) {
+    const result = schema.safeParse(body);
+    if (!result.success) {
+        throw new ZclApiError('internal_error', 'API response failed validation', status);
+    }
+    return result.data;
+}
+export function createZclApiClient(options) {
+    const fetcher = options.fetch ?? fetch;
+    async function request(path, schema, init = {}) {
+        const headers = new Headers(init.headers);
+        const { body: requestBody, ...requestInitBase } = init;
+        let body;
+        if (requestBody !== undefined) {
+            headers.set('content-type', 'application/json');
+            body = JSON.stringify(requestBody);
+        }
+        const requestInit = {
+            ...requestInitBase,
+            headers,
+            credentials: 'include'
+        };
+        if (body !== undefined) {
+            requestInit.body = body;
+        }
+        const response = await fetcher(new Request(joinUrl(options.baseUrl, path), requestInit));
+        const responseBody = await readJson(response);
+        if (!response.ok) {
+            const error = errorResponseSchema.safeParse(responseBody);
+            if (error.success) {
+                throw new ZclApiError(error.data.error.code, error.data.error.message, response.status, error.data.error.requestId);
+            }
+            throw new ZclApiError('internal_error', 'API request failed', response.status);
+        }
+        return parseResponse(schema, responseBody, response.status);
+    }
+    return {
+        auth: {
+            signup(input) {
+                return request('/auth/signup', authSessionResponseSchema, {
+                    method: 'POST',
+                    body: signupRequestSchema.parse(input)
+                });
+            },
+            login(input) {
+                return request('/auth/login', authSessionResponseSchema, {
+                    method: 'POST',
+                    body: loginRequestSchema.parse(input)
+                });
+            },
+            logout() {
+                return request('/auth/logout', logoutResponseSchema, { method: 'POST' });
+            }
+        },
+        session: {
+            get() {
+                return request('/session', sessionResponseSchema);
+            }
+        },
+        workspaces: {
+            list() {
+                return request('/workspaces', workspaceListResponseSchema);
+            },
+            create(input) {
+                return request('/workspaces', z.object({ data: workspaceSchema }), {
+                    method: 'POST',
+                    body: createWorkspaceRequestSchema.parse(input)
+                });
+            }
+        }
+    };
+}

package/dist/common.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const idSchema: z.ZodString;
+export declare const isoDateSchema: z.ZodString;
+export declare const apiErrorCodeSchema: z.ZodEnum<{
+    bad_request: "bad_request";
+    unauthorized: "unauthorized";
+    forbidden: "forbidden";
+    conflict: "conflict";
+    not_found: "not_found";
+    validation_failed: "validation_failed";
+    internal_error: "internal_error";
+}>;
+export declare const errorResponseSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            bad_request: "bad_request";
+            unauthorized: "unauthorized";
+            forbidden: "forbidden";
+            conflict: "conflict";
+            not_found: "not_found";
+            validation_failed: "validation_failed";
+            internal_error: "internal_error";
+        }>;
+        message: z.ZodString;
+        requestId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const paginationSchema: z.ZodObject<{
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare function apiSuccessSchema<TSchema extends z.ZodType>(schema: TSchema): z.ZodObject<{
+    data: TSchema;
+}, z.core.$strip>;
+export declare function listResponseSchema<TSchema extends z.ZodType>(itemSchema: TSchema): z.ZodObject<{
+    data: z.ZodArray<TSchema>;
+    pagination: z.ZodObject<{
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ApiErrorCode = z.infer<typeof apiErrorCodeSchema>;
+export type ErrorResponse = z.infer<typeof errorResponseSchema>;
+export type Pagination = z.infer<typeof paginationSchema>;
+//# sourceMappingURL=common.d.ts.map

package/dist/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,QAAQ,aAAoB,CAAA;AACzC,eAAO,MAAM,aAAa,aAAwB,CAAA;AAElD,eAAO,MAAM,kBAAkB;;;;;;;;EAQ7B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iBAM9B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;iBAE3B,CAAA;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO;;kBAE1E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,SAAS,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO;;;;;kBAKhF;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/common.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export const idSchema = z.string().uuid();
+export const isoDateSchema = z.string().datetime();
+export const apiErrorCodeSchema = z.enum([
+    'bad_request',
+    'unauthorized',
+    'forbidden',
+    'conflict',
+    'not_found',
+    'validation_failed',
+    'internal_error'
+]);
+export const errorResponseSchema = z.object({
+    error: z.object({
+        code: apiErrorCodeSchema,
+        message: z.string().min(1),
+        requestId: z.string().optional()
+    })
+});
+export const paginationSchema = z.object({
+    nextCursor: z.string().nullable()
+});
+export function apiSuccessSchema(schema) {
+    return z.object({ data: schema });
+}
+export function listResponseSchema(itemSchema) {
+    return z.object({
+        data: z.array(itemSchema),
+        pagination: paginationSchema
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './auth';
+export * from './client';
+export * from './common';
+export * from './projects';
+export * from './workspaces';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './auth';
+export * from './client';
+export * from './common';
+export * from './projects';
+export * from './workspaces';

package/dist/projects.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const projectVisibilitySchema: z.ZodEnum<{
+    private: "private";
+    workspace: "workspace";
+}>;
+export declare const projectStatusSchema: z.ZodEnum<{
+    active: "active";
+    archived: "archived";
+    deleted: "deleted";
+}>;
+export declare const ledPanelSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ledMapSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    panels: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    bounds: z.ZodObject<{
+        minX: z.ZodNumber;
+        minY: z.ZodNumber;
+        maxX: z.ZodNumber;
+        maxY: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        aspectRatio: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    createdByUserId: z.ZodString;
+    name: z.ZodString;
+    visibility: z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        deleted: "deleted";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const createProjectRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>>;
+}, z.core.$strip>;
+export type CreateProjectRequest = z.input<typeof createProjectRequestSchema>;
+export type LedMap = z.infer<typeof ledMapSchema>;
+export type LedPanel = z.infer<typeof ledPanelSchema>;
+export type Project = z.infer<typeof projectSchema>;
+export type ProjectStatus = z.infer<typeof projectStatusSchema>;
+export type ProjectVisibility = z.infer<typeof projectVisibilitySchema>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../src/projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,uBAAuB;;;EAAmC,CAAA;AACvE,eAAO,MAAM,mBAAmB;;;;EAA4C,CAAA;AAE5E,eAAO,MAAM,cAAc;;;;;;;iBAOzB,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;iBAYvB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;iBASxB,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;iBAGrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC7E,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/projects.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { idSchema, isoDateSchema } from './common';
+export const projectVisibilitySchema = z.enum(['private', 'workspace']);
+export const projectStatusSchema = z.enum(['active', 'archived', 'deleted']);
+export const ledPanelSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    x: z.number().int(),
+    y: z.number().int()
+});
+export const ledMapSchema = z.object({
+    version: z.number().int().nonnegative(),
+    panels: z.array(ledPanelSchema),
+    bounds: z.object({
+        minX: z.number(),
+        minY: z.number(),
+        maxX: z.number(),
+        maxY: z.number(),
+        width: z.number().positive(),
+        height: z.number().positive(),
+        aspectRatio: z.number().positive()
+    })
+});
+export const projectSchema = z.object({
+    id: idSchema,
+    workspaceId: idSchema,
+    createdByUserId: idSchema,
+    name: z.string().min(1),
+    visibility: projectVisibilitySchema,
+    status: projectStatusSchema,
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema
+});
+export const createProjectRequestSchema = z.object({
+    name: z.string().min(1).max(120),
+    visibility: projectVisibilitySchema.default('private')
+});

package/dist/workspaces.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const workspaceTypeSchema: z.ZodEnum<{
+    personal: "personal";
+    organization: "organization";
+}>;
+export declare const workspaceRoleSchema: z.ZodEnum<{
+    owner: "owner";
+    admin: "admin";
+    artist: "artist";
+    viewer: "viewer";
+}>;
+export declare const workspaceMembershipStatusSchema: z.ZodEnum<{
+    active: "active";
+    invited: "invited";
+    disabled: "disabled";
+}>;
+export declare const workspaceSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        personal: "personal";
+        organization: "organization";
+    }>;
+    name: z.ZodString;
+    slug: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const createWorkspaceRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodDefault<z.ZodLiteral<"organization">>;
+}, z.core.$strip>;
+export declare const workspaceMembershipSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        owner: "owner";
+        admin: "admin";
+        artist: "artist";
+        viewer: "viewer";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        invited: "invited";
+        disabled: "disabled";
+    }>;
+}, z.core.$strip>;
+export type CreateWorkspaceRequest = z.input<typeof createWorkspaceRequestSchema>;
+export type Workspace = z.infer<typeof workspaceSchema>;
+export type WorkspaceMembership = z.infer<typeof workspaceMembershipSchema>;
+export type WorkspaceMembershipStatus = z.infer<typeof workspaceMembershipStatusSchema>;
+export type WorkspaceRole = z.infer<typeof workspaceRoleSchema>;
+export type WorkspaceType = z.infer<typeof workspaceTypeSchema>;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/workspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../src/workspaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,mBAAmB;;;EAAuC,CAAA;AACvE,eAAO,MAAM,mBAAmB;;;;;EAAiD,CAAA;AACjF,eAAO,MAAM,+BAA+B;;;;EAA4C,CAAA;AAExF,eAAO,MAAM,eAAe;;;;;;;;;;iBAO1B,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBAKpC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AACjF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/workspaces.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { idSchema, isoDateSchema } from './common';
+export const workspaceTypeSchema = z.enum(['personal', 'organization']);
+export const workspaceRoleSchema = z.enum(['owner', 'admin', 'artist', 'viewer']);
+export const workspaceMembershipStatusSchema = z.enum(['active', 'invited', 'disabled']);
+export const workspaceSchema = z.object({
+    id: idSchema,
+    type: workspaceTypeSchema,
+    name: z.string().min(1),
+    slug: z.string().min(1),
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema
+});
+export const createWorkspaceRequestSchema = z.object({
+    name: z.string().min(1).max(120),
+    type: z.literal('organization').default('organization')
+});
+export const workspaceMembershipSchema = z.object({
+    workspaceId: idSchema,
+    userId: idSchema,
+    role: workspaceRoleSchema,
+    status: workspaceMembershipStatusSchema
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@anuragpal02/zcl-contracts",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "prebuild": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "zod": "^4.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "vitest": "^4.0.0"
+  }
+}