@microboxlabs/miot-calendar-client 0.2.0 → 0.4.0

package/README.md

@@ -314,6 +314,113 @@ Manually change a slot's status.
 
 ---
 
+### Slot Managers
+
+Slot managers automate slot generation for calendars. Each manager keeps slots generated a configurable number of days in advance and can be triggered manually or by an external scheduler (e.g. K8s CronJob).
+
+#### `slotManagers.list(params?)`
+
+List all slot managers, optionally filtered by active status.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `active` | `boolean` | No | When `true`, return only active managers |
+
+**Returns:** `SlotManagerResponse[]`
+
+#### `slotManagers.create(body)`
+
+Create an automatic slot generation manager for a calendar.
+
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `calendarId` | `string` | Yes | — | Calendar ID to manage |
+| `active` | `boolean` | No | `true` | Enable or disable automatic generation |
+| `daysInAdvance` | `number` | No | `30` | Days ahead to keep slots generated |
+| `batchDays` | `number` | No | `7` | Max days to generate per scheduler run |
+| `reprocessFrom` | `string` | No | — | Force regeneration from this date (`YYYY-MM-DD`) |
+| `reprocessTo` | `string` | No | — | Force regeneration through this date (required with `reprocessFrom`) |
+
+**Returns:** `SlotManagerResponse`
+
+**Throws:** `MiotCalendarApiError` with status `400` if invalid or duplicate.
+
+#### `slotManagers.get(id)`
+
+Get a slot manager by ID.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Slot manager ID |
+
+**Returns:** `SlotManagerResponse`
+
+**Throws:** `MiotCalendarApiError` with status `404` if not found.
+
+#### `slotManagers.update(id, body)`
+
+Update a slot manager's configuration. Takes the same body as `create`. Set `reprocessFrom` + `reprocessTo` to schedule one-shot slot regeneration.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Slot manager ID |
+| `body` | `SlotManagerRequest` | Yes | Updated configuration |
+
+**Returns:** `SlotManagerResponse`
+
+#### `slotManagers.deactivate(id)`
+
+Deactivate a slot manager (soft delete — disables automatic generation without removing history).
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Slot manager ID |
+
+**Returns:** `void` (HTTP 204 — no content)
+
+#### `slotManagers.runAll()`
+
+Synchronously run all active slot managers. Returns when all managers have completed.
+
+**Returns:** `SlotManagerRunResponse[]`
+
+#### `slotManagers.run(id)`
+
+Synchronously run a single slot manager and return its run record.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Slot manager ID |
+
+**Returns:** `SlotManagerRunResponse`
+
+**Throws:** `MiotCalendarApiError` with status `404` if not found.
+
+#### `slotManagers.listAllRuns(params?)`
+
+List recent runs across all managers.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `limit` | `number` | No | `50` | Maximum number of records to return |
+
+**Returns:** `SlotManagerRunResponse[]`
+
+#### `slotManagers.listRuns(id, params?)`
+
+List runs for a specific manager.
+
+| Param | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `id` | `string` | Yes | — | Slot manager ID |
+| `limit` | `number` | No | `20` | Maximum number of records to return |
+
+**Returns:** `SlotManagerRunResponse[]`
+
+**Throws:** `MiotCalendarApiError` with status `404` if manager not found.
+
+---
+
 ### Bookings
 
 #### `bookings.list(params?)`
@@ -533,6 +640,59 @@ interface UpdateSlotStatusRequest {
 }
 ```
 
+### `SlotManagerRequest`
+
+```ts
+interface SlotManagerRequest {
+  calendarId: string;           // Calendar ID to manage
+  active?: boolean;             // Enable/disable (default: true)
+  daysInAdvance?: number;       // Days ahead to keep generated (default: 30)
+  batchDays?: number;           // Max days per scheduler run (default: 7)
+  reprocessFrom?: string;       // YYYY-MM-DD — one-shot regeneration start
+  reprocessTo?: string;         // YYYY-MM-DD — one-shot regeneration end
+}
+```
+
+### `SlotManagerResponse`
+
+```ts
+interface SlotManagerResponse {
+  id: string;
+  calendarId: string;
+  calendarCode: string;
+  calendarName: string;
+  active: boolean;
+  daysInAdvance: number;
+  batchDays: number;
+  reprocessFrom?: string;       // Cleared after successful run
+  reprocessTo?: string;         // Cleared after successful run
+  lastRunAt?: string;           // ISO 8601
+  lastRunStatus?: string;       // IDLE, RUNNING, SUCCESS, FAILED, SKIPPED
+  lastRunError?: string;        // Error message from last failed run
+  generatedThrough?: string;    // YYYY-MM-DD — latest date with generated slots
+  createdAt: string;            // ISO 8601
+  updatedAt: string;            // ISO 8601
+}
+```
+
+### `SlotManagerRunResponse`
+
+```ts
+interface SlotManagerRunResponse {
+  id: string;
+  managerId: string;
+  triggeredBy: string;          // SCHEDULER, API, CLI
+  startedAt: string;            // ISO 8601
+  finishedAt?: string;          // ISO 8601
+  status: string;               // RUNNING, SUCCESS, FAILED, SKIPPED
+  slotsCreated: number;
+  slotsSkipped: number;
+  generatedFrom?: string;       // YYYY-MM-DD
+  generatedThrough?: string;    // YYYY-MM-DD
+  errorMessage?: string;
+}
+```
+
 ### `BookingRequest`
 
 ```ts

package/dist/index.cjs

@@ -0,0 +1,228 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MiotCalendarApiError: () => MiotCalendarApiError,
+  createMiotCalendarClient: () => createMiotCalendarClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var MiotCalendarApiError = class extends Error {
+  constructor(status, body) {
+    super(typeof body === "string" ? body : body.message);
+    this.status = status;
+    this.body = body;
+  }
+  name = "MiotCalendarApiError";
+};
+
+// src/resources/bookings.ts
+var BASE = "/api/v1/miot-calendar/bookings";
+function createBookingsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE}/${id}`);
+    },
+    create(body, options) {
+      return fetcher("POST", BASE, {
+        body,
+        headers: options?.userId ? { "X-User-Id": options.userId } : void 0
+      });
+    },
+    cancel(id) {
+      return fetcher("DELETE", `${BASE}/${id}`);
+    },
+    listByResource(resourceId) {
+      return fetcher("GET", `${BASE}/resource/${resourceId}`);
+    }
+  };
+}
+
+// src/resources/calendars.ts
+var BASE2 = "/api/v1/miot-calendar/calendars";
+function createCalendarsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE2, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE2}/${id}`);
+    },
+    create(body) {
+      return fetcher("POST", BASE2, { body });
+    },
+    update(id, body) {
+      return fetcher("PUT", `${BASE2}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE2}/${id}`);
+    },
+    purge(id) {
+      return fetcher("DELETE", `${BASE2}/${id}/purge`);
+    },
+    listTimeWindows(calendarId) {
+      return fetcher("GET", `${BASE2}/${calendarId}/time-windows`);
+    },
+    createTimeWindow(calendarId, body) {
+      return fetcher("POST", `${BASE2}/${calendarId}/time-windows`, { body });
+    },
+    updateTimeWindow(calendarId, timeWindowId, body) {
+      return fetcher("PUT", `${BASE2}/${calendarId}/time-windows/${timeWindowId}`, {
+        body
+      });
+    }
+  };
+}
+
+// src/resources/groups.ts
+var BASE3 = "/api/v1/miot-calendar/groups";
+function createGroupsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE3, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE3}/${id}`);
+    },
+    create(body) {
+      return fetcher("POST", BASE3, { body });
+    },
+    update(id, body) {
+      return fetcher("PUT", `${BASE3}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE3}/${id}`);
+    }
+  };
+}
+
+// src/resources/slot-managers.ts
+var BASE4 = "/api/v1/miot-calendar/slot-managers";
+function createSlotManagersApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE4, { query: params });
+    },
+    create(body) {
+      return fetcher("POST", BASE4, { body });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE4}/${id}`);
+    },
+    update(id, body) {
+      return fetcher("PUT", `${BASE4}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE4}/${id}`);
+    },
+    runAll() {
+      return fetcher("POST", `${BASE4}/run`);
+    },
+    run(id) {
+      return fetcher("POST", `${BASE4}/${id}/run`);
+    },
+    listAllRuns(params) {
+      return fetcher("GET", `${BASE4}/runs`, { query: params });
+    },
+    listRuns(id, params) {
+      return fetcher("GET", `${BASE4}/${id}/runs`, { query: params });
+    }
+  };
+}
+
+// src/resources/slots.ts
+var BASE5 = "/api/v1/miot-calendar/slots";
+function createSlotsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE5, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE5}/${id}`);
+    },
+    generate(body) {
+      return fetcher("POST", `${BASE5}/generate`, { body });
+    },
+    updateStatus(id, body) {
+      return fetcher("PATCH", `${BASE5}/${id}/status`, { body });
+    }
+  };
+}
+
+// src/client.ts
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path, baseUrl);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function createMiotCalendarClient(config) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const fetcher = async (method, path, options) => {
+    const url = buildUrl(config.baseUrl, path, options?.query);
+    const headers = {
+      ...config.headers,
+      ...options?.headers
+    };
+    if (options?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetchFn(url, {
+      method,
+      headers,
+      body: options?.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = await response.text();
+      }
+      throw new MiotCalendarApiError(response.status, body);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  };
+  return {
+    bookings: createBookingsApi(fetcher),
+    calendars: createCalendarsApi(fetcher),
+    groups: createGroupsApi(fetcher),
+    slotManagers: createSlotManagersApi(fetcher),
+    slots: createSlotsApi(fetcher)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MiotCalendarApiError,
+  createMiotCalendarClient
+});

package/dist/index.d.mts

@@ -0,0 +1,247 @@
+type SlotStatus = "OPEN" | "FULL" | "CLOSED";
+interface ResourceData {
+    id: string;
+    type?: string;
+    label?: string;
+    data?: Record<string, unknown>;
+}
+interface SlotData {
+    date: string;
+    hour: number;
+    minutes: number;
+}
+interface BookingRequest {
+    calendarId: string;
+    resource: ResourceData;
+    slot: SlotData;
+}
+interface BookingResponse {
+    id: string;
+    calendarId: string;
+    resource: ResourceData;
+    slot: SlotData;
+    createdAt: string;
+    createdBy?: string;
+}
+interface BookingListResponse {
+    data: BookingResponse[];
+    total: number;
+}
+interface CalendarGroupRequest {
+    code: string;
+    name: string;
+    description?: string;
+    active?: boolean;
+}
+interface CalendarGroupResponse {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CalendarRequest {
+    code: string;
+    name: string;
+    description?: string;
+    timezone?: string;
+    active?: boolean;
+    groups?: string[];
+    autoSlotManager?: boolean;
+}
+interface CalendarResponse {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    timezone: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    groups?: CalendarGroupResponse[];
+    hasSlotManager?: boolean;
+}
+interface TimeWindowRequest {
+    name: string;
+    startHour: number;
+    endHour: number;
+    validFrom: string;
+    slotDurationMinutes?: number;
+    capacityPerSlot?: number;
+    daysOfWeek?: string;
+    validTo?: string;
+    active?: boolean;
+}
+interface TimeWindowResponse {
+    id: string;
+    calendarId: string;
+    name: string;
+    startHour: number;
+    endHour: number;
+    slotDurationMinutes: number;
+    capacityPerSlot: number;
+    daysOfWeek: string;
+    validFrom: string;
+    validTo?: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GenerateSlotsRequest {
+    calendarId: string;
+    startDate: string;
+    endDate: string;
+}
+interface GenerateSlotsResponse {
+    slotsCreated: number;
+    slotsSkipped: number;
+    message: string;
+}
+interface SlotResponse {
+    id: string;
+    calendarId: string;
+    timeWindowId?: string;
+    slotDate: string;
+    slotHour: number;
+    slotMinutes: number;
+    capacity: number;
+    currentOccupancy: number;
+    availableCapacity: number;
+    status: SlotStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlotListResponse {
+    data: SlotResponse[];
+    total: number;
+}
+interface UpdateSlotStatusRequest {
+    status: SlotStatus;
+}
+interface SlotManagerRequest {
+    calendarId: string;
+    active?: boolean;
+    daysInAdvance?: number;
+    batchDays?: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+}
+interface SlotManagerResponse {
+    id: string;
+    calendarId: string;
+    calendarCode: string;
+    calendarName: string;
+    active: boolean;
+    daysInAdvance: number;
+    batchDays: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+    lastRunAt?: string;
+    lastRunStatus?: string;
+    lastRunError?: string;
+    generatedThrough?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlotManagerRunResponse {
+    id: string;
+    managerId: string;
+    triggeredBy: string;
+    startedAt: string;
+    finishedAt?: string;
+    status: string;
+    slotsCreated: number;
+    slotsSkipped: number;
+    generatedFrom?: string;
+    generatedThrough?: string;
+    errorMessage?: string;
+}
+interface ErrorResponse {
+    error: string;
+    message: string;
+    status: number;
+    timestamp: string;
+}
+interface ClientConfig {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+
+declare function createMiotCalendarClient(config: ClientConfig): {
+    bookings: {
+        list(params?: {
+            calendarId?: string;
+            startDate?: string;
+            endDate?: string;
+        }): Promise<BookingListResponse>;
+        get(id: string): Promise<BookingResponse>;
+        create(body: BookingRequest, options?: {
+            userId?: string;
+        }): Promise<BookingResponse>;
+        cancel(id: string): Promise<void>;
+        listByResource(resourceId: string): Promise<BookingListResponse>;
+    };
+    calendars: {
+        list(params?: {
+            active?: boolean;
+            groupCode?: string;
+        }): Promise<CalendarResponse[]>;
+        get(id: string): Promise<CalendarResponse>;
+        create(body: CalendarRequest): Promise<CalendarResponse>;
+        update(id: string, body: CalendarRequest): Promise<CalendarResponse>;
+        deactivate(id: string): Promise<void>;
+        purge(id: string): Promise<void>;
+        listTimeWindows(calendarId: string): Promise<TimeWindowResponse[]>;
+        createTimeWindow(calendarId: string, body: TimeWindowRequest): Promise<TimeWindowResponse>;
+        updateTimeWindow(calendarId: string, timeWindowId: string, body: TimeWindowRequest): Promise<TimeWindowResponse>;
+    };
+    groups: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<CalendarGroupResponse[]>;
+        get(id: string): Promise<CalendarGroupResponse>;
+        create(body: CalendarGroupRequest): Promise<CalendarGroupResponse>;
+        update(id: string, body: CalendarGroupRequest): Promise<CalendarGroupResponse>;
+        deactivate(id: string): Promise<void>;
+    };
+    slotManagers: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<SlotManagerResponse[]>;
+        create(body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        get(id: string): Promise<SlotManagerResponse>;
+        update(id: string, body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        deactivate(id: string): Promise<void>;
+        runAll(): Promise<SlotManagerRunResponse[]>;
+        run(id: string): Promise<SlotManagerRunResponse>;
+        listAllRuns(params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+        listRuns(id: string, params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+    };
+    slots: {
+        list(params: {
+            calendarId: string;
+            available?: boolean;
+            startDate?: string;
+            endDate?: string;
+        }): Promise<SlotListResponse>;
+        get(id: string): Promise<SlotResponse>;
+        generate(body: GenerateSlotsRequest): Promise<GenerateSlotsResponse>;
+        updateStatus(id: string, body: UpdateSlotStatusRequest): Promise<SlotResponse>;
+    };
+};
+
+declare class MiotCalendarApiError extends Error {
+    readonly status: number;
+    readonly body: ErrorResponse | string;
+    name: "MiotCalendarApiError";
+    constructor(status: number, body: ErrorResponse | string);
+}
+
+export { type BookingListResponse, type BookingRequest, type BookingResponse, type CalendarGroupRequest, type CalendarGroupResponse, type CalendarRequest, type CalendarResponse, type ClientConfig, type ErrorResponse, type GenerateSlotsRequest, type GenerateSlotsResponse, MiotCalendarApiError, type ResourceData, type SlotData, type SlotListResponse, type SlotManagerRequest, type SlotManagerResponse, type SlotManagerRunResponse, type SlotResponse, type SlotStatus, type TimeWindowRequest, type TimeWindowResponse, type UpdateSlotStatusRequest, createMiotCalendarClient };

package/dist/index.d.ts

@@ -49,6 +49,7 @@ interface CalendarRequest {
     timezone?: string;
     active?: boolean;
     groups?: string[];
+    autoSlotManager?: boolean;
 }
 interface CalendarResponse {
     id: string;
@@ -60,6 +61,7 @@ interface CalendarResponse {
     createdAt: string;
     updatedAt: string;
     groups?: CalendarGroupResponse[];
+    hasSlotManager?: boolean;
 }
 interface TimeWindowRequest {
     name: string;
@@ -118,6 +120,44 @@ interface SlotListResponse {
 interface UpdateSlotStatusRequest {
     status: SlotStatus;
 }
+interface SlotManagerRequest {
+    calendarId: string;
+    active?: boolean;
+    daysInAdvance?: number;
+    batchDays?: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+}
+interface SlotManagerResponse {
+    id: string;
+    calendarId: string;
+    calendarCode: string;
+    calendarName: string;
+    active: boolean;
+    daysInAdvance: number;
+    batchDays: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+    lastRunAt?: string;
+    lastRunStatus?: string;
+    lastRunError?: string;
+    generatedThrough?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlotManagerRunResponse {
+    id: string;
+    managerId: string;
+    triggeredBy: string;
+    startedAt: string;
+    finishedAt?: string;
+    status: string;
+    slotsCreated: number;
+    slotsSkipped: number;
+    generatedFrom?: string;
+    generatedThrough?: string;
+    errorMessage?: string;
+}
 interface ErrorResponse {
     error: string;
     message: string;
@@ -153,6 +193,7 @@ declare function createMiotCalendarClient(config: ClientConfig): {
         create(body: CalendarRequest): Promise<CalendarResponse>;
         update(id: string, body: CalendarRequest): Promise<CalendarResponse>;
         deactivate(id: string): Promise<void>;
+        purge(id: string): Promise<void>;
         listTimeWindows(calendarId: string): Promise<TimeWindowResponse[]>;
         createTimeWindow(calendarId: string, body: TimeWindowRequest): Promise<TimeWindowResponse>;
         updateTimeWindow(calendarId: string, timeWindowId: string, body: TimeWindowRequest): Promise<TimeWindowResponse>;
@@ -166,6 +207,23 @@ declare function createMiotCalendarClient(config: ClientConfig): {
         update(id: string, body: CalendarGroupRequest): Promise<CalendarGroupResponse>;
         deactivate(id: string): Promise<void>;
     };
+    slotManagers: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<SlotManagerResponse[]>;
+        create(body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        get(id: string): Promise<SlotManagerResponse>;
+        update(id: string, body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        deactivate(id: string): Promise<void>;
+        runAll(): Promise<SlotManagerRunResponse[]>;
+        run(id: string): Promise<SlotManagerRunResponse>;
+        listAllRuns(params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+        listRuns(id: string, params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+    };
     slots: {
         list(params: {
             calendarId: string;
@@ -186,4 +244,4 @@ declare class MiotCalendarApiError extends Error {
     constructor(status: number, body: ErrorResponse | string);
 }
 
-export { type BookingListResponse, type BookingRequest, type BookingResponse, type CalendarGroupRequest, type CalendarGroupResponse, type CalendarRequest, type CalendarResponse, type ClientConfig, type ErrorResponse, type GenerateSlotsRequest, type GenerateSlotsResponse, MiotCalendarApiError, type ResourceData, type SlotData, type SlotListResponse, type SlotResponse, type SlotStatus, type TimeWindowRequest, type TimeWindowResponse, type UpdateSlotStatusRequest, createMiotCalendarClient };
+export { type BookingListResponse, type BookingRequest, type BookingResponse, type CalendarGroupRequest, type CalendarGroupResponse, type CalendarRequest, type CalendarResponse, type ClientConfig, type ErrorResponse, type GenerateSlotsRequest, type GenerateSlotsResponse, MiotCalendarApiError, type ResourceData, type SlotData, type SlotListResponse, type SlotManagerRequest, type SlotManagerResponse, type SlotManagerRunResponse, type SlotResponse, type SlotStatus, type TimeWindowRequest, type TimeWindowResponse, type UpdateSlotStatusRequest, createMiotCalendarClient };

package/dist/{index.js → index.mjs}

@@ -52,6 +52,9 @@ function createCalendarsApi(fetcher) {
     deactivate(id) {
       return fetcher("DELETE", `${BASE2}/${id}`);
     },
+    purge(id) {
+      return fetcher("DELETE", `${BASE2}/${id}/purge`);
+    },
     listTimeWindows(calendarId) {
       return fetcher("GET", `${BASE2}/${calendarId}/time-windows`);
     },
@@ -88,21 +91,55 @@ function createGroupsApi(fetcher) {
   };
 }
 
-// src/resources/slots.ts
-var BASE4 = "/api/v1/miot-calendar/slots";
-function createSlotsApi(fetcher) {
+// src/resources/slot-managers.ts
+var BASE4 = "/api/v1/miot-calendar/slot-managers";
+function createSlotManagersApi(fetcher) {
   return {
     list(params) {
       return fetcher("GET", BASE4, { query: params });
     },
+    create(body) {
+      return fetcher("POST", BASE4, { body });
+    },
     get(id) {
       return fetcher("GET", `${BASE4}/${id}`);
     },
+    update(id, body) {
+      return fetcher("PUT", `${BASE4}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE4}/${id}`);
+    },
+    runAll() {
+      return fetcher("POST", `${BASE4}/run`);
+    },
+    run(id) {
+      return fetcher("POST", `${BASE4}/${id}/run`);
+    },
+    listAllRuns(params) {
+      return fetcher("GET", `${BASE4}/runs`, { query: params });
+    },
+    listRuns(id, params) {
+      return fetcher("GET", `${BASE4}/${id}/runs`, { query: params });
+    }
+  };
+}
+
+// src/resources/slots.ts
+var BASE5 = "/api/v1/miot-calendar/slots";
+function createSlotsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE5, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE5}/${id}`);
+    },
     generate(body) {
-      return fetcher("POST", `${BASE4}/generate`, { body });
+      return fetcher("POST", `${BASE5}/generate`, { body });
     },
     updateStatus(id, body) {
-      return fetcher("PATCH", `${BASE4}/${id}/status`, { body });
+      return fetcher("PATCH", `${BASE5}/${id}/status`, { body });
     }
   };
 }
@@ -153,6 +190,7 @@ function createMiotCalendarClient(config) {
     bookings: createBookingsApi(fetcher),
     calendars: createCalendarsApi(fetcher),
     groups: createGroupsApi(fetcher),
+    slotManagers: createSlotManagersApi(fetcher),
     slots: createSlotsApi(fetcher)
   };
 }

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@microboxlabs/miot-calendar-client",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/microboxlabs/modulariot",
     "directory": "packages/miot-calendar-client"
   },
-  "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [
@@ -19,6 +24,7 @@
   ],
   "scripts": {
     "build": "tsup",
+    "dev": "tsup --watch",
     "test": "vitest run",
     "lint": "eslint .",
     "check-types": "tsc --noEmit"