@kognitivedev/cloud-calendar 0.2.29

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @kognitivedev/cloud-calendar
+
+## 0.2.29
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/client-core@0.2.29

package/dist/client.d.ts

@@ -0,0 +1,46 @@
+import { HttpTransport } from "@kognitivedev/client-core";
+import type { CalendarAvailabilityQueryInput, CalendarAvailabilityResult, CalendarConfirmHoldResult, CalendarEvent, CalendarHold, CalendarResource, CalendarService, CloudCalendarClientConfig, ConfirmCalendarHoldInput, CreateCalendarHoldInput, CreateCalendarResourceInput, CreateCalendarServiceInput, ListCalendarEventsInput, UpdateCalendarResourceInput, UpdateCalendarServiceInput } from "./types";
+export declare class KognitiveCloudCalendarClient {
+    private readonly transport;
+    readonly resources: {
+        list: (input?: {
+            includeAvailability?: boolean;
+        }) => Promise<CalendarResource[]>;
+        create: (input: CreateCalendarResourceInput) => Promise<CalendarResource>;
+        update: (id: string, input: UpdateCalendarResourceInput) => Promise<CalendarResource>;
+    };
+    readonly services: {
+        list: () => Promise<CalendarService[]>;
+        create: (input: CreateCalendarServiceInput) => Promise<CalendarService>;
+        update: (id: string, input: UpdateCalendarServiceInput) => Promise<CalendarService>;
+    };
+    readonly availability: {
+        query: (input: CalendarAvailabilityQueryInput) => Promise<CalendarAvailabilityResult>;
+    };
+    readonly holds: {
+        list: () => Promise<CalendarHold[]>;
+        create: (input: CreateCalendarHoldInput) => Promise<CalendarHold>;
+        confirm: (id: string, input: ConfirmCalendarHoldInput) => Promise<CalendarConfirmHoldResult>;
+        release: (id: string, reason?: string | null) => Promise<CalendarHold>;
+    };
+    readonly events: {
+        list: (input?: ListCalendarEventsInput) => Promise<CalendarEvent[]>;
+        cancel: (id: string, reason?: string | null) => Promise<CalendarEvent>;
+    };
+    constructor(config: CloudCalendarClientConfig | HttpTransport);
+    listResources(input?: {
+        includeAvailability?: boolean;
+    }): Promise<CalendarResource[]>;
+    createResource(input: CreateCalendarResourceInput): Promise<CalendarResource>;
+    updateResource(id: string, input: UpdateCalendarResourceInput): Promise<CalendarResource>;
+    listServices(): Promise<CalendarService[]>;
+    createService(input: CreateCalendarServiceInput): Promise<CalendarService>;
+    updateService(id: string, input: UpdateCalendarServiceInput): Promise<CalendarService>;
+    queryAvailability(input: CalendarAvailabilityQueryInput): Promise<CalendarAvailabilityResult>;
+    listHolds(): Promise<CalendarHold[]>;
+    createHold(input: CreateCalendarHoldInput): Promise<CalendarHold>;
+    confirmHold(id: string, input: ConfirmCalendarHoldInput): Promise<CalendarConfirmHoldResult>;
+    releaseHold(id: string, reason?: string | null): Promise<CalendarHold>;
+    listEvents(input?: ListCalendarEventsInput): Promise<CalendarEvent[]>;
+    cancelEvent(id: string, reason?: string | null): Promise<CalendarEvent>;
+}

package/dist/client.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveCloudCalendarClient = void 0;
+const client_core_1 = require("@kognitivedev/client-core");
+const BASE_PATH = "/api/cloud/calendar";
+function isTransportLike(value) {
+    return Boolean(value && typeof value === "object" && "baseUrl" in value && "json" in value && "raw" in value);
+}
+function toQueryDate(value) {
+    if (!value)
+        return undefined;
+    return value instanceof Date ? value.toISOString() : value;
+}
+class KognitiveCloudCalendarClient {
+    constructor(config) {
+        this.resources = {
+            list: (input = {}) => this.listResources(input),
+            create: (input) => this.createResource(input),
+            update: (id, input) => this.updateResource(id, input),
+        };
+        this.services = {
+            list: () => this.listServices(),
+            create: (input) => this.createService(input),
+            update: (id, input) => this.updateService(id, input),
+        };
+        this.availability = {
+            query: (input) => this.queryAvailability(input),
+        };
+        this.holds = {
+            list: () => this.listHolds(),
+            create: (input) => this.createHold(input),
+            confirm: (id, input) => this.confirmHold(id, input),
+            release: (id, reason) => this.releaseHold(id, reason),
+        };
+        this.events = {
+            list: (input = {}) => this.listEvents(input),
+            cancel: (id, reason) => this.cancelEvent(id, reason),
+        };
+        this.transport = isTransportLike(config) ? config : new client_core_1.HttpTransport(config);
+    }
+    async listResources(input = {}) {
+        const path = input.includeAvailability
+            ? (0, client_core_1.withQuery)(`${BASE_PATH}/resources`, { include: "availability" })
+            : `${BASE_PATH}/resources`;
+        const res = await this.transport.json(path);
+        return res.resources;
+    }
+    async createResource(input) {
+        return this.transport.json(`${BASE_PATH}/resources`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async updateResource(id, input) {
+        return this.transport.json(`${BASE_PATH}/resources/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            body: JSON.stringify(input),
+        });
+    }
+    async listServices() {
+        const res = await this.transport.json(`${BASE_PATH}/services`);
+        return res.services;
+    }
+    async createService(input) {
+        return this.transport.json(`${BASE_PATH}/services`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async updateService(id, input) {
+        return this.transport.json(`${BASE_PATH}/services/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            body: JSON.stringify(input),
+        });
+    }
+    async queryAvailability(input) {
+        return this.transport.json(`${BASE_PATH}/availability/query`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async listHolds() {
+        const res = await this.transport.json(`${BASE_PATH}/holds`);
+        return res.holds;
+    }
+    async createHold(input) {
+        return this.transport.json(`${BASE_PATH}/holds`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async confirmHold(id, input) {
+        return this.transport.json(`${BASE_PATH}/holds/${encodeURIComponent(id)}/confirm`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async releaseHold(id, reason) {
+        return this.transport.json(`${BASE_PATH}/holds/${encodeURIComponent(id)}/release`, {
+            method: "POST",
+            body: JSON.stringify({ reason }),
+        });
+    }
+    async listEvents(input = {}) {
+        const res = await this.transport.json((0, client_core_1.withQuery)(`${BASE_PATH}/events`, {
+            resourceId: input.resourceId,
+            from: toQueryDate(input.from),
+            to: toQueryDate(input.to),
+        }));
+        return res.events;
+    }
+    async cancelEvent(id, reason) {
+        return this.transport.json(`${BASE_PATH}/events/${encodeURIComponent(id)}/cancel`, {
+            method: "POST",
+            body: JSON.stringify({ reason }),
+        });
+    }
+}
+exports.KognitiveCloudCalendarClient = KognitiveCloudCalendarClient;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { KognitiveCloudCalendarClient } from "./client";
+export type { CalendarAvailabilityQueryInput, CalendarAvailabilityResult, CalendarAvailabilityRule, CalendarBlackout, CalendarBooker, CalendarConfirmHoldResult, CalendarEvent, CalendarEventStatus, CalendarHold, CalendarHoldStatus, CalendarResource, CalendarService, CalendarSlot, CalendarStatus, CloudCalendarClientConfig, ConfirmCalendarHoldInput, CreateCalendarHoldInput, CreateCalendarResourceInput, CreateCalendarServiceInput, ListCalendarEventsInput, LogLevel, UpdateCalendarResourceInput, UpdateCalendarServiceInput, } from "./types";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveCloudCalendarClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "KognitiveCloudCalendarClient", { enumerable: true, get: function () { return client_1.KognitiveCloudCalendarClient; } });

package/dist/types.d.ts

@@ -0,0 +1,152 @@
+import type { HttpTransportConfig, LogLevel } from "@kognitivedev/client-core";
+export type { LogLevel };
+export interface CloudCalendarClientConfig extends HttpTransportConfig {
+}
+export type CalendarStatus = "active" | "disabled" | "archived" | string;
+export type CalendarHoldStatus = "active" | "confirmed" | "released" | "expired" | string;
+export type CalendarEventStatus = "confirmed" | "cancelled" | string;
+export interface CalendarBooker {
+    name: string;
+    email?: string | null;
+    phone?: string | null;
+    [key: string]: unknown;
+}
+export interface CalendarAvailabilityRule {
+    id?: string;
+    projectId?: string;
+    resourceId?: string;
+    weekday: number;
+    startTime: string;
+    endTime: string;
+    status?: CalendarStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface CalendarBlackout {
+    id?: string;
+    projectId?: string;
+    resourceId?: string;
+    startAt: string | Date;
+    endAt: string | Date;
+    reason?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface CalendarResource {
+    id: string;
+    projectId: string;
+    name: string;
+    slug: string;
+    timezone: string;
+    status: CalendarStatus;
+    metadata: Record<string, unknown>;
+    availabilityRules?: CalendarAvailabilityRule[];
+    blackouts?: CalendarBlackout[];
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export interface CalendarService {
+    id: string;
+    projectId: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    durationMinutes: number;
+    bufferBeforeMinutes: number;
+    bufferAfterMinutes: number;
+    status: CalendarStatus;
+    metadata: Record<string, unknown>;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export interface CalendarHold {
+    id: string;
+    projectId: string;
+    resourceId: string;
+    serviceId: string;
+    status: CalendarHoldStatus;
+    startAt: string | Date;
+    endAt: string | Date;
+    expiresAt: string | Date;
+    booker: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    confirmedEventId?: string | null;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export interface CalendarEvent {
+    id: string;
+    projectId: string;
+    resourceId: string;
+    serviceId: string;
+    holdId?: string | null;
+    status: CalendarEventStatus;
+    startAt: string | Date;
+    endAt: string | Date;
+    booker: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    cancelledAt?: string | Date | null;
+    cancelReason?: string | null;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+export interface CreateCalendarResourceInput {
+    name: string;
+    slug?: string;
+    timezone?: string;
+    status?: CalendarStatus;
+    metadata?: Record<string, unknown>;
+    availabilityRules?: CalendarAvailabilityRule[];
+    blackouts?: CalendarBlackout[];
+}
+export type UpdateCalendarResourceInput = Partial<CreateCalendarResourceInput>;
+export interface CreateCalendarServiceInput {
+    name: string;
+    slug?: string;
+    description?: string | null;
+    durationMinutes?: number;
+    bufferBeforeMinutes?: number;
+    bufferAfterMinutes?: number;
+    status?: CalendarStatus;
+    metadata?: Record<string, unknown>;
+}
+export type UpdateCalendarServiceInput = Partial<CreateCalendarServiceInput>;
+export interface CalendarAvailabilityQueryInput {
+    resourceId: string;
+    serviceId: string;
+    rangeStart: string | Date;
+    rangeEnd: string | Date;
+    requestedStart?: string | Date | null;
+    metadata?: Record<string, unknown>;
+}
+export interface CalendarSlot {
+    start: string;
+    end: string;
+    resourceId: string;
+    serviceId: string;
+    timezone: string;
+    status: "available";
+}
+export interface CalendarAvailabilityResult {
+    slots: CalendarSlot[];
+    count: number;
+}
+export interface CreateCalendarHoldInput {
+    resourceId: string;
+    serviceId: string;
+    startAt: string | Date;
+    booker?: Partial<CalendarBooker> | Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    ttlMinutes?: number;
+}
+export interface ConfirmCalendarHoldInput {
+    booker: Partial<CalendarBooker> | Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface CalendarConfirmHoldResult {
+    hold: CalendarHold;
+    event: CalendarEvent;
+}
+export interface ListCalendarEventsInput {
+    resourceId?: string;
+    from?: string | Date;
+    to?: string | Date;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kognitivedev/cloud-calendar",
+  "version": "0.2.29",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --noCheck",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@kognitivedev/client-core": "^0.2.29"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "description": "Cloud calendar SDK for Kognitive scheduling APIs",
+  "keywords": [
+    "kognitive",
+    "calendar",
+    "scheduling",
+    "cloud",
+    "sdk"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/cloud-calendar"
+  },
+  "homepage": "https://kognitive.dev"
+}

package/src/client.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { KognitiveCloudCalendarClient } from "./client";
+
+function createClient(calls: Array<{ input: string; init?: RequestInit }>) {
+  return new KognitiveCloudCalendarClient({
+    baseUrl: "https://api.example.test",
+    apiKey: "kog_test",
+    fetch: async (input, init) => {
+      calls.push({ input: String(input), init });
+      return new Response(JSON.stringify({ resources: [], services: [], holds: [], events: [], slots: [], count: 0 }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    },
+  });
+}
+
+describe("KognitiveCloudCalendarClient", () => {
+  it("passes API key auth and builds availability URL", async () => {
+    const calls: Array<{ input: string; init?: RequestInit }> = [];
+    const client = createClient(calls);
+
+    await client.availability.query({
+      resourceId: "resource-1",
+      serviceId: "service-1",
+      rangeStart: "2026-05-20T00:00:00.000Z",
+      rangeEnd: "2026-05-21T00:00:00.000Z",
+    });
+
+    expect(calls[0].input).toBe("https://api.example.test/api/cloud/calendar/availability/query");
+    expect(new Headers(calls[0].init?.headers).get("Authorization")).toBe("Bearer kog_test");
+    expect(calls[0].init?.method).toBe("POST");
+  });
+
+  it("builds resource include query", async () => {
+    const calls: Array<{ input: string; init?: RequestInit }> = [];
+    const client = createClient(calls);
+
+    await client.resources.list({ includeAvailability: true });
+
+    expect(calls[0].input).toBe("https://api.example.test/api/cloud/calendar/resources?include=availability");
+  });
+});

package/src/client.ts

@@ -0,0 +1,155 @@
+import { HttpTransport, type HttpTransportConfig, withQuery } from "@kognitivedev/client-core";
+import type {
+  CalendarAvailabilityQueryInput,
+  CalendarAvailabilityResult,
+  CalendarConfirmHoldResult,
+  CalendarEvent,
+  CalendarHold,
+  CalendarResource,
+  CalendarService,
+  CloudCalendarClientConfig,
+  ConfirmCalendarHoldInput,
+  CreateCalendarHoldInput,
+  CreateCalendarResourceInput,
+  CreateCalendarServiceInput,
+  ListCalendarEventsInput,
+  UpdateCalendarResourceInput,
+  UpdateCalendarServiceInput,
+} from "./types";
+
+const BASE_PATH = "/api/cloud/calendar";
+
+function isTransportLike(value: unknown): value is HttpTransport {
+  return Boolean(value && typeof value === "object" && "baseUrl" in value && "json" in value && "raw" in value);
+}
+
+function toQueryDate(value: string | Date | undefined): string | undefined {
+  if (!value) return undefined;
+  return value instanceof Date ? value.toISOString() : value;
+}
+
+export class KognitiveCloudCalendarClient {
+  private readonly transport: HttpTransport;
+
+  readonly resources = {
+    list: (input: { includeAvailability?: boolean } = {}) => this.listResources(input),
+    create: (input: CreateCalendarResourceInput) => this.createResource(input),
+    update: (id: string, input: UpdateCalendarResourceInput) => this.updateResource(id, input),
+  };
+
+  readonly services = {
+    list: () => this.listServices(),
+    create: (input: CreateCalendarServiceInput) => this.createService(input),
+    update: (id: string, input: UpdateCalendarServiceInput) => this.updateService(id, input),
+  };
+
+  readonly availability = {
+    query: (input: CalendarAvailabilityQueryInput) => this.queryAvailability(input),
+  };
+
+  readonly holds = {
+    list: () => this.listHolds(),
+    create: (input: CreateCalendarHoldInput) => this.createHold(input),
+    confirm: (id: string, input: ConfirmCalendarHoldInput) => this.confirmHold(id, input),
+    release: (id: string, reason?: string | null) => this.releaseHold(id, reason),
+  };
+
+  readonly events = {
+    list: (input: ListCalendarEventsInput = {}) => this.listEvents(input),
+    cancel: (id: string, reason?: string | null) => this.cancelEvent(id, reason),
+  };
+
+  constructor(config: CloudCalendarClientConfig | HttpTransport) {
+    this.transport = isTransportLike(config) ? config : new HttpTransport(config as HttpTransportConfig);
+  }
+
+  async listResources(input: { includeAvailability?: boolean } = {}): Promise<CalendarResource[]> {
+    const path = input.includeAvailability
+      ? withQuery(`${BASE_PATH}/resources`, { include: "availability" })
+      : `${BASE_PATH}/resources`;
+    const res = await this.transport.json<{ resources: CalendarResource[] }>(path);
+    return res.resources;
+  }
+
+  async createResource(input: CreateCalendarResourceInput): Promise<CalendarResource> {
+    return this.transport.json<CalendarResource>(`${BASE_PATH}/resources`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async updateResource(id: string, input: UpdateCalendarResourceInput): Promise<CalendarResource> {
+    return this.transport.json<CalendarResource>(`${BASE_PATH}/resources/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async listServices(): Promise<CalendarService[]> {
+    const res = await this.transport.json<{ services: CalendarService[] }>(`${BASE_PATH}/services`);
+    return res.services;
+  }
+
+  async createService(input: CreateCalendarServiceInput): Promise<CalendarService> {
+    return this.transport.json<CalendarService>(`${BASE_PATH}/services`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async updateService(id: string, input: UpdateCalendarServiceInput): Promise<CalendarService> {
+    return this.transport.json<CalendarService>(`${BASE_PATH}/services/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async queryAvailability(input: CalendarAvailabilityQueryInput): Promise<CalendarAvailabilityResult> {
+    return this.transport.json<CalendarAvailabilityResult>(`${BASE_PATH}/availability/query`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async listHolds(): Promise<CalendarHold[]> {
+    const res = await this.transport.json<{ holds: CalendarHold[] }>(`${BASE_PATH}/holds`);
+    return res.holds;
+  }
+
+  async createHold(input: CreateCalendarHoldInput): Promise<CalendarHold> {
+    return this.transport.json<CalendarHold>(`${BASE_PATH}/holds`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async confirmHold(id: string, input: ConfirmCalendarHoldInput): Promise<CalendarConfirmHoldResult> {
+    return this.transport.json<CalendarConfirmHoldResult>(`${BASE_PATH}/holds/${encodeURIComponent(id)}/confirm`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async releaseHold(id: string, reason?: string | null): Promise<CalendarHold> {
+    return this.transport.json<CalendarHold>(`${BASE_PATH}/holds/${encodeURIComponent(id)}/release`, {
+      method: "POST",
+      body: JSON.stringify({ reason }),
+    });
+  }
+
+  async listEvents(input: ListCalendarEventsInput = {}): Promise<CalendarEvent[]> {
+    const res = await this.transport.json<{ events: CalendarEvent[] }>(withQuery(`${BASE_PATH}/events`, {
+      resourceId: input.resourceId,
+      from: toQueryDate(input.from),
+      to: toQueryDate(input.to),
+    }));
+    return res.events;
+  }
+
+  async cancelEvent(id: string, reason?: string | null): Promise<CalendarEvent> {
+    return this.transport.json<CalendarEvent>(`${BASE_PATH}/events/${encodeURIComponent(id)}/cancel`, {
+      method: "POST",
+      body: JSON.stringify({ reason }),
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+export { KognitiveCloudCalendarClient } from "./client";
+export type {
+  CalendarAvailabilityQueryInput,
+  CalendarAvailabilityResult,
+  CalendarAvailabilityRule,
+  CalendarBlackout,
+  CalendarBooker,
+  CalendarConfirmHoldResult,
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarHold,
+  CalendarHoldStatus,
+  CalendarResource,
+  CalendarService,
+  CalendarSlot,
+  CalendarStatus,
+  CloudCalendarClientConfig,
+  ConfirmCalendarHoldInput,
+  CreateCalendarHoldInput,
+  CreateCalendarResourceInput,
+  CreateCalendarServiceInput,
+  ListCalendarEventsInput,
+  LogLevel,
+  UpdateCalendarResourceInput,
+  UpdateCalendarServiceInput,
+} from "./types";

package/src/types.ts

@@ -0,0 +1,172 @@
+import type { HttpTransportConfig, LogLevel } from "@kognitivedev/client-core";
+
+export type { LogLevel };
+
+export interface CloudCalendarClientConfig extends HttpTransportConfig {}
+
+export type CalendarStatus = "active" | "disabled" | "archived" | string;
+export type CalendarHoldStatus = "active" | "confirmed" | "released" | "expired" | string;
+export type CalendarEventStatus = "confirmed" | "cancelled" | string;
+
+export interface CalendarBooker {
+  name: string;
+  email?: string | null;
+  phone?: string | null;
+  [key: string]: unknown;
+}
+
+export interface CalendarAvailabilityRule {
+  id?: string;
+  projectId?: string;
+  resourceId?: string;
+  weekday: number;
+  startTime: string;
+  endTime: string;
+  status?: CalendarStatus;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CalendarBlackout {
+  id?: string;
+  projectId?: string;
+  resourceId?: string;
+  startAt: string | Date;
+  endAt: string | Date;
+  reason?: string | null;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CalendarResource {
+  id: string;
+  projectId: string;
+  name: string;
+  slug: string;
+  timezone: string;
+  status: CalendarStatus;
+  metadata: Record<string, unknown>;
+  availabilityRules?: CalendarAvailabilityRule[];
+  blackouts?: CalendarBlackout[];
+  createdAt: string | Date;
+  updatedAt: string | Date;
+}
+
+export interface CalendarService {
+  id: string;
+  projectId: string;
+  name: string;
+  slug: string;
+  description: string | null;
+  durationMinutes: number;
+  bufferBeforeMinutes: number;
+  bufferAfterMinutes: number;
+  status: CalendarStatus;
+  metadata: Record<string, unknown>;
+  createdAt: string | Date;
+  updatedAt: string | Date;
+}
+
+export interface CalendarHold {
+  id: string;
+  projectId: string;
+  resourceId: string;
+  serviceId: string;
+  status: CalendarHoldStatus;
+  startAt: string | Date;
+  endAt: string | Date;
+  expiresAt: string | Date;
+  booker: Record<string, unknown>;
+  metadata: Record<string, unknown>;
+  confirmedEventId?: string | null;
+  createdAt: string | Date;
+  updatedAt: string | Date;
+}
+
+export interface CalendarEvent {
+  id: string;
+  projectId: string;
+  resourceId: string;
+  serviceId: string;
+  holdId?: string | null;
+  status: CalendarEventStatus;
+  startAt: string | Date;
+  endAt: string | Date;
+  booker: Record<string, unknown>;
+  metadata: Record<string, unknown>;
+  cancelledAt?: string | Date | null;
+  cancelReason?: string | null;
+  createdAt: string | Date;
+  updatedAt: string | Date;
+}
+
+export interface CreateCalendarResourceInput {
+  name: string;
+  slug?: string;
+  timezone?: string;
+  status?: CalendarStatus;
+  metadata?: Record<string, unknown>;
+  availabilityRules?: CalendarAvailabilityRule[];
+  blackouts?: CalendarBlackout[];
+}
+
+export type UpdateCalendarResourceInput = Partial<CreateCalendarResourceInput>;
+
+export interface CreateCalendarServiceInput {
+  name: string;
+  slug?: string;
+  description?: string | null;
+  durationMinutes?: number;
+  bufferBeforeMinutes?: number;
+  bufferAfterMinutes?: number;
+  status?: CalendarStatus;
+  metadata?: Record<string, unknown>;
+}
+
+export type UpdateCalendarServiceInput = Partial<CreateCalendarServiceInput>;
+
+export interface CalendarAvailabilityQueryInput {
+  resourceId: string;
+  serviceId: string;
+  rangeStart: string | Date;
+  rangeEnd: string | Date;
+  requestedStart?: string | Date | null;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CalendarSlot {
+  start: string;
+  end: string;
+  resourceId: string;
+  serviceId: string;
+  timezone: string;
+  status: "available";
+}
+
+export interface CalendarAvailabilityResult {
+  slots: CalendarSlot[];
+  count: number;
+}
+
+export interface CreateCalendarHoldInput {
+  resourceId: string;
+  serviceId: string;
+  startAt: string | Date;
+  booker?: Partial<CalendarBooker> | Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  ttlMinutes?: number;
+}
+
+export interface ConfirmCalendarHoldInput {
+  booker: Partial<CalendarBooker> | Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CalendarConfirmHoldResult {
+  hold: CalendarHold;
+  event: CalendarEvent;
+}
+
+export interface ListCalendarEventsInput {
+  resourceId?: string;
+  from?: string | Date;
+  to?: string | Date;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "noEmit": false,
+    "incremental": false,
+    "baseUrl": ".",
+    "paths": {
+      "@kognitivedev/client-core": [
+        "../client-core/dist/index.d.ts"
+      ]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["src/*.test.ts", "src/**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@kognitivedev/client-core": new URL("../client-core/src/index.ts", import.meta.url).pathname,
+    },
+  },
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});