@microboxlabs/miot-calendar-client 0.1.3 → 0.3.0

package/README.md

@@ -89,11 +89,12 @@ const client = createMiotCalendarClient({
 
 #### `calendars.list(params?)`
 
-List all calendars, optionally filtered by active status.
+List all calendars, optionally filtered by active status or group membership.
 
 | Param | Type | Required | Description |
 |-------|------|----------|-------------|
 | `active` | `boolean` | No | Filter by active status |
+| `groupCode` | `string` | No | Filter calendars belonging to this group code |
 
 **Returns:** `CalendarResponse[]`
 
@@ -120,6 +121,7 @@ Create a new calendar.
 | `description` | `string` | No | — | Optional description |
 | `timezone` | `string` | No | `"UTC"` | IANA timezone |
 | `active` | `boolean` | No | `true` | Whether the calendar is active |
+| `groups` | `string[]` | No | — | Group codes to assign. `null` = no change; `[]` = remove all; `["code"]` = replace all |
 
 **Returns:** `CalendarResponse`
 
@@ -130,7 +132,7 @@ Replace a calendar's fields. Takes the same body as `create`.
 | Param | Type | Required | Description |
 |-------|------|----------|-------------|
 | `id` | `string` | Yes | Calendar ID |
-| `body` | `CalendarRequest` | Yes | Updated calendar data |
+| `body` | `CalendarRequest` | Yes | Updated calendar data (include `groups` to reassign group membership) |
 
 **Returns:** `CalendarResponse`
 
@@ -192,6 +194,70 @@ Update a time window. Takes the same body as `createTimeWindow`.
 
 ---
 
+### Groups
+
+Calendar groups let you organize calendars into named collections. Calendars can belong to multiple groups; use `CalendarRequest.groups` on create or update to manage membership.
+
+#### `groups.list(params?)`
+
+List all calendar groups, optionally filtered by active status.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `active` | `boolean` | No | Filter by active status |
+
+**Returns:** `CalendarGroupResponse[]`
+
+#### `groups.get(id)`
+
+Get a single calendar group by ID.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Group ID |
+
+**Returns:** `CalendarGroupResponse`
+
+**Throws:** `MiotCalendarApiError` with status `404` if not found.
+
+#### `groups.create(body)`
+
+Create a new calendar group.
+
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `code` | `string` | Yes | — | Unique code identifier (max 50 chars) |
+| `name` | `string` | Yes | — | Display name (max 255 chars) |
+| `description` | `string` | No | — | Optional description |
+| `active` | `boolean` | No | `true` | Whether the group is active |
+
+**Returns:** `CalendarGroupResponse`
+
+**Throws:** `MiotCalendarApiError` with status `400` if the code is already taken.
+
+#### `groups.update(id, body)`
+
+Replace a calendar group's fields. Takes the same body as `create`.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Group ID |
+| `body` | `CalendarGroupRequest` | Yes | Updated group data |
+
+**Returns:** `CalendarGroupResponse`
+
+#### `groups.deactivate(id)`
+
+Deactivate a calendar group (soft delete). Calendars in the group are not affected.
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | `string` | Yes | Group ID |
+
+**Returns:** `void` (HTTP 204 — no content)
+
+---
+
 ### Slots
 
 #### `slots.list(params)`
@@ -321,6 +387,31 @@ List all bookings for a specific resource.
 
 ## Types
 
+### `CalendarGroupRequest`
+
+```ts
+interface CalendarGroupRequest {
+  code: string;           // Unique code identifier (max 50 chars)
+  name: string;           // Display name (max 255 chars)
+  description?: string;   // Optional description
+  active?: boolean;       // Active status (default: true)
+}
+```
+
+### `CalendarGroupResponse`
+
+```ts
+interface CalendarGroupResponse {
+  id: string;
+  code: string;
+  name: string;
+  description?: string;
+  active: boolean;
+  createdAt: string;      // ISO 8601
+  updatedAt: string;      // ISO 8601
+}
+```
+
 ### `CalendarRequest`
 
 ```ts
@@ -330,6 +421,7 @@ interface CalendarRequest {
   description?: string;   // Optional description
   timezone?: string;      // IANA timezone (default: "UTC")
   active?: boolean;       // Active status (default: true)
+  groups?: string[];      // Group codes to assign. null = no change; [] = remove all; ["code"] = replace all
 }
 ```
 
@@ -341,10 +433,11 @@ interface CalendarResponse {
   code: string;
   name: string;
   description?: string;
-  timezone: string;       // Always present (default: "UTC")
-  active: boolean;        // Always present (default: true)
-  createdAt: string;      // ISO 8601
-  updatedAt: string;      // ISO 8601
+  timezone: string;                    // Always present (default: "UTC")
+  active: boolean;                     // Always present (default: true)
+  createdAt: string;                   // ISO 8601
+  updatedAt: string;                   // ISO 8601
+  groups?: CalendarGroupResponse[];    // Groups this calendar belongs to
 }
 ```
 

package/dist/index.cjs

@@ -0,0 +1,225 @@
+"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}`);
+    },
+    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,244 @@
+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[];
+}
+interface CalendarResponse {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    timezone: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    groups?: CalendarGroupResponse[];
+}
+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>;
+        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

@@ -27,12 +27,28 @@ 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[];
 }
 interface CalendarResponse {
     id: string;
@@ -43,6 +59,7 @@ interface CalendarResponse {
     active: boolean;
     createdAt: string;
     updatedAt: string;
+    groups?: CalendarGroupResponse[];
 }
 interface TimeWindowRequest {
     name: string;
@@ -101,6 +118,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;
@@ -130,6 +185,7 @@ declare function createMiotCalendarClient(config: ClientConfig): {
     calendars: {
         list(params?: {
             active?: boolean;
+            groupCode?: string;
         }): Promise<CalendarResponse[]>;
         get(id: string): Promise<CalendarResponse>;
         create(body: CalendarRequest): Promise<CalendarResponse>;
@@ -139,6 +195,32 @@ declare function createMiotCalendarClient(config: ClientConfig): {
         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;
@@ -159,4 +241,4 @@ declare class MiotCalendarApiError extends Error {
     constructor(status: number, body: ErrorResponse | string);
 }
 
-export { type BookingListResponse, type BookingRequest, type BookingResponse, 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}

@@ -66,9 +66,9 @@ function createCalendarsApi(fetcher) {
   };
 }
 
-// src/resources/slots.ts
-var BASE3 = "/api/v1/miot-calendar/slots";
-function createSlotsApi(fetcher) {
+// src/resources/groups.ts
+var BASE3 = "/api/v1/miot-calendar/groups";
+function createGroupsApi(fetcher) {
   return {
     list(params) {
       return fetcher("GET", BASE3, { query: params });
@@ -76,11 +76,67 @@ function createSlotsApi(fetcher) {
     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", `${BASE3}/generate`, { body });
+      return fetcher("POST", `${BASE5}/generate`, { body });
     },
     updateStatus(id, body) {
-      return fetcher("PATCH", `${BASE3}/${id}/status`, { body });
+      return fetcher("PATCH", `${BASE5}/${id}/status`, { body });
     }
   };
 }
@@ -130,6 +186,8 @@ function createMiotCalendarClient(config) {
   return {
     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.1.3",
+  "version": "0.3.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"