@tiempo/sdk 0.0.0-stage → 0.1.1

package/dist/cjs/generated/types.d.ts

@@ -0,0 +1,134 @@
+import type { components, operations } from './openapi.js';
+import type { WithMetadataFilter } from '../shared.js';
+export type { components, operations };
+export type Account = components["schemas"]["Account"];
+export type Attendee = components["schemas"]["Attendee"];
+export type AvailabilityCalendarBlocked = components["schemas"]["AvailabilityCalendarBlocked"];
+export type AvailabilityCalendar = components["schemas"]["AvailabilityCalendarCalendar"];
+export type AvailabilityCalendarDay = components["schemas"]["AvailabilityCalendarDay"];
+export type AvailabilityCalendarDayReason = components["schemas"]["AvailabilityCalendarDayReason"];
+export type AvailabilityCalendarFree = components["schemas"]["AvailabilityCalendarFree"];
+export type AvailabilityCalendarResourceCalendar = components["schemas"]["AvailabilityCalendarResourceCalendar"];
+export type AvailabilityCalendarWorking = components["schemas"]["AvailabilityCalendarWorking"];
+export type Availability = components["schemas"]["AvailabilitySearchAvailability"];
+export type AvailabilitySegmentQuery = components["schemas"]["AvailabilitySearchSegmentQuery"];
+export type AvailabilitySlot = components["schemas"]["AvailabilitySearchSlot"];
+export type AvailabilitySlotSegment = components["schemas"]["AvailabilitySearchSlotSegment"];
+export type Block = components["schemas"]["Block"];
+export type Booking = components["schemas"]["Booking"];
+export type BookingSegment = components["schemas"]["BookingSegment"];
+export type BookingsImportedBooking = components["schemas"]["BookingsImportedBooking"];
+export type BookingsImportedSegment = components["schemas"]["BookingsImportedSegment"];
+export type BookingSegmentInput = components["schemas"]["BookingsSegmentInput"];
+export type CandidateConflict = components["schemas"]["CandidateConflict"];
+export type Conflict = components["schemas"]["Conflict"];
+export type ConflictPreview = components["schemas"]["ConflictPreview"];
+export type ConflictPreviewAffected = components["schemas"]["ConflictPreviewAffected"];
+export type DeletedObject = components["schemas"]["DeletedObject"];
+export type Location = components["schemas"]["Location"];
+export type Resource = components["schemas"]["Resource"];
+export type Schedule = components["schemas"]["Schedule"];
+export type ScheduleInterval = components["schemas"]["ScheduleInterval"];
+export type ScheduleIntervalInput = components["schemas"]["ScheduleIntervalInput"];
+export type ScheduleOverride = components["schemas"]["ScheduleOverride"];
+export type Series = components["schemas"]["Series"];
+export type SeriesTemplate = components["schemas"]["SeriesTemplate"];
+export type SeriesTemplateInput = components["schemas"]["SeriesTemplateInput"];
+export type SeriesTemplateSegment = components["schemas"]["SeriesTemplateSegment"];
+export type SeriesTemplateSegmentInput = components["schemas"]["SeriesTemplateSegmentInput"];
+export type SkippedOccurrence = components["schemas"]["SkippedOccurrence"];
+export type AccountUsage = components["schemas"]["UsageAccountUsage"];
+export type UsageStatement = components["schemas"]["UsageStatement"];
+export type UsageSummary = components["schemas"]["UsageSummary"];
+export type WebhookDelivery = components["schemas"]["WebhookDelivery"];
+export type WebhookDeliveryAttempt = components["schemas"]["WebhookDeliveryAttempt"];
+export type WebhookEndpoint = components["schemas"]["WebhookEndpoint"];
+export type WebhookEndpointResendResult = components["schemas"]["WebhookResendsEndpointResent"];
+/** Params for `list` on `accounts` (GET /v1/accounts). */
+export type AccountListParams = WithMetadataFilter<NonNullable<operations["accounts.list"]["parameters"]["query"]>>;
+/** Params for `create` on `accounts` (POST /v1/accounts). */
+export type AccountCreateParams = NonNullable<operations["accounts.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `accounts` (POST /v1/accounts/{id}). */
+export type AccountUpdateParams = NonNullable<operations["accounts.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `attendees` (POST /v1/attendees/{id}). */
+export type AttendeeUpdateParams = NonNullable<operations["attendees.updateAttendee"]["requestBody"]>["content"]["application/json"];
+/** Params for `cancel` on `attendees` (POST /v1/attendees/{id}/cancel). */
+export type AttendeeCancelParams = NonNullable<operations["attendees.cancelAttendee"]["requestBody"]>["content"]["application/json"];
+/** Params for `search` on `availability` (POST /v1/availability). */
+export type AvailabilitySearchParams = NonNullable<operations["availability.search"]["requestBody"]>["content"]["application/json"];
+/** Params for `calendar` on `availability` (GET /v1/availability/calendar). */
+export type AvailabilityCalendarParams = NonNullable<operations["availability.calendar"]["parameters"]["query"]>;
+/** Params for `list` on `blocks` (GET /v1/blocks). */
+export type BlockListParams = WithMetadataFilter<NonNullable<operations["blocks.list"]["parameters"]["query"]>>;
+/** Params for `create` on `blocks` (POST /v1/blocks). */
+export type BlockCreateParams = NonNullable<operations["blocks.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `blocks` (POST /v1/blocks/{id}). */
+export type BlockUpdateParams = NonNullable<operations["blocks.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `bookings` (GET /v1/bookings). */
+export type BookingListParams = WithMetadataFilter<NonNullable<operations["bookings.list"]["parameters"]["query"]>>;
+/** Params for `create` on `bookings` (POST /v1/bookings). */
+export type BookingCreateParams = NonNullable<operations["bookings.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `import` on `bookings` (POST /v1/bookings/import). */
+export type BookingImportParams = NonNullable<operations["bookings.importBookings"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `bookings` (POST /v1/bookings/{id}). */
+export type BookingUpdateParams = NonNullable<operations["bookings.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `attendees` (GET /v1/bookings/{id}/attendees). */
+export type AttendeeListParams = WithMetadataFilter<NonNullable<operations["attendees.listAttendees"]["parameters"]["query"]>>;
+/** Params for `create` on `attendees` (POST /v1/bookings/{id}/attendees). */
+export type AttendeeCreateParams = NonNullable<operations["attendees.createAttendee"]["requestBody"]>["content"]["application/json"];
+/** Params for `cancel` on `bookings` (POST /v1/bookings/{id}/cancel). */
+export type BookingCancelParams = NonNullable<operations["bookings.cancel"]["requestBody"]>["content"]["application/json"];
+/** Params for `reschedule` on `bookings` (POST /v1/bookings/{id}/reschedule). */
+export type BookingRescheduleParams = NonNullable<operations["bookings.reschedule"]["requestBody"]>["content"]["application/json"];
+/** Params for `create` on `conflictPreviews` (POST /v1/conflict_previews). */
+export type ConflictPreviewCreateParams = NonNullable<operations["conflict_previews.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `events` (GET /v1/events). */
+export type EventListParams = NonNullable<operations["events.list"]["parameters"]["query"]>;
+/** Params for `resend` on `events` (POST /v1/events/{id}/resend). */
+export type EventResendParams = NonNullable<operations["events.resend"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `locations` (GET /v1/locations). */
+export type LocationListParams = WithMetadataFilter<NonNullable<operations["locations.list"]["parameters"]["query"]>>;
+/** Params for `create` on `locations` (POST /v1/locations). */
+export type LocationCreateParams = NonNullable<operations["locations.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `locations` (POST /v1/locations/{id}). */
+export type LocationUpdateParams = NonNullable<operations["locations.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `resources` (GET /v1/resources). */
+export type ResourceListParams = WithMetadataFilter<NonNullable<operations["resources.list"]["parameters"]["query"]>>;
+/** Params for `create` on `resources` (POST /v1/resources). */
+export type ResourceCreateParams = NonNullable<operations["resources.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `resources` (POST /v1/resources/{id}). */
+export type ResourceUpdateParams = NonNullable<operations["resources.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `scheduleOverrides` (GET /v1/schedule_overrides). */
+export type ScheduleOverrideListParams = WithMetadataFilter<NonNullable<operations["schedule_overrides.listOverrides"]["parameters"]["query"]>>;
+/** Params for `create` on `scheduleOverrides` (POST /v1/schedule_overrides). */
+export type ScheduleOverrideCreateParams = NonNullable<operations["schedule_overrides.createOverride"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `scheduleOverrides` (POST /v1/schedule_overrides/{id}). */
+export type ScheduleOverrideUpdateParams = NonNullable<operations["schedule_overrides.updateOverride"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `schedules` (GET /v1/schedules). */
+export type ScheduleListParams = WithMetadataFilter<NonNullable<operations["schedules.list"]["parameters"]["query"]>>;
+/** Params for `create` on `schedules` (POST /v1/schedules). */
+export type ScheduleCreateParams = NonNullable<operations["schedules.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `schedules` (POST /v1/schedules/{id}). */
+export type ScheduleUpdateParams = NonNullable<operations["schedules.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `list` on `series` (GET /v1/series). */
+export type SeriesListParams = WithMetadataFilter<NonNullable<operations["series.list"]["parameters"]["query"]>>;
+/** Params for `create` on `series` (POST /v1/series). */
+export type SeriesCreateParams = NonNullable<operations["series.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `series` (POST /v1/series/{id}). */
+export type SeriesUpdateParams = NonNullable<operations["series.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `cancel` on `series` (POST /v1/series/{id}/cancel). */
+export type SeriesCancelParams = NonNullable<operations["series.cancel"]["requestBody"]>["content"]["application/json"];
+/** Params for `split` on `series` (POST /v1/series/{id}/split). */
+export type SeriesSplitParams = NonNullable<operations["series.split"]["requestBody"]>["content"]["application/json"];
+/** Params for `get` on `usage` (GET /v1/usage). */
+export type UsageGetParams = NonNullable<operations["usage.get"]["parameters"]["query"]>;
+/** Params for `list` on `webhookEndpoints` (GET /v1/webhook_endpoints). */
+export type WebhookEndpointListParams = WithMetadataFilter<NonNullable<operations["webhook_endpoints.list"]["parameters"]["query"]>>;
+/** Params for `create` on `webhookEndpoints` (POST /v1/webhook_endpoints). */
+export type WebhookEndpointCreateParams = NonNullable<operations["webhook_endpoints.create"]["requestBody"]>["content"]["application/json"];
+/** Params for `update` on `webhookEndpoints` (POST /v1/webhook_endpoints/{id}). */
+export type WebhookEndpointUpdateParams = NonNullable<operations["webhook_endpoints.update"]["requestBody"]>["content"]["application/json"];
+/** Params for `deliveries` on `webhookEndpoints` (GET /v1/webhook_endpoints/{id}/deliveries). */
+export type WebhookEndpointDeliveriesParams = NonNullable<operations["webhook_endpoints.deliveries"]["parameters"]["query"]>;
+/** Params for `resend` on `webhookEndpoints` (POST /v1/webhook_endpoints/{id}/resend). */
+export type WebhookEndpointResendParams = NonNullable<operations["webhook_endpoints.resend"]["requestBody"]>["content"]["application/json"];

package/dist/cjs/generated/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Code generated by scripts/generate.mjs from openapi.json. DO NOT EDIT.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,16 @@
+export { Tiempo } from './client.js';
+export { Tiempo as default } from './client.js';
+export { DEFAULT_BASE_URL } from './core.js';
+export type { TiempoConfig, RequestOptions } from './core.js';
+export { ListPromise } from './list.js';
+export type { ListPage, PageParams } from './list.js';
+export { TiempoError, TiempoInvalidRequestError, TiempoAuthenticationError, TiempoPermissionError, TiempoConflictError, TiempoIdempotencyError, TiempoRateLimitError, TiempoAPIError, TiempoConnectionError, TiempoSignatureVerificationError, } from './errors.js';
+export type { TiempoErrorBody } from './errors.js';
+export { EVENT_TYPES, isKnownEventType } from './events.js';
+export type { TiempoEvent, TiempoEventOf, TiempoEventType, EventObject, EventObjectMap } from './events.js';
+export { constructEvent, generateTestHeader, Webhooks, SIGNATURE_HEADER } from './webhooks.js';
+export type { ConstructEventOptions, GenerateTestHeaderOptions } from './webhooks.js';
+export { API_VERSION, SDK_VERSION } from './generated/meta.js';
+export type { WithMetadataFilter } from './shared.js';
+export * from './generated/types.js';
+export * from './generated/resources.js';

package/dist/cjs/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = exports.API_VERSION = exports.SIGNATURE_HEADER = exports.Webhooks = exports.generateTestHeader = exports.constructEvent = exports.isKnownEventType = exports.EVENT_TYPES = exports.TiempoSignatureVerificationError = exports.TiempoConnectionError = exports.TiempoAPIError = exports.TiempoRateLimitError = exports.TiempoIdempotencyError = exports.TiempoConflictError = exports.TiempoPermissionError = exports.TiempoAuthenticationError = exports.TiempoInvalidRequestError = exports.TiempoError = exports.ListPromise = exports.DEFAULT_BASE_URL = exports.default = exports.Tiempo = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "Tiempo", { enumerable: true, get: function () { return client_js_1.Tiempo; } });
+var client_js_2 = require("./client.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return client_js_2.Tiempo; } });
+var core_js_1 = require("./core.js");
+Object.defineProperty(exports, "DEFAULT_BASE_URL", { enumerable: true, get: function () { return core_js_1.DEFAULT_BASE_URL; } });
+var list_js_1 = require("./list.js");
+Object.defineProperty(exports, "ListPromise", { enumerable: true, get: function () { return list_js_1.ListPromise; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "TiempoError", { enumerable: true, get: function () { return errors_js_1.TiempoError; } });
+Object.defineProperty(exports, "TiempoInvalidRequestError", { enumerable: true, get: function () { return errors_js_1.TiempoInvalidRequestError; } });
+Object.defineProperty(exports, "TiempoAuthenticationError", { enumerable: true, get: function () { return errors_js_1.TiempoAuthenticationError; } });
+Object.defineProperty(exports, "TiempoPermissionError", { enumerable: true, get: function () { return errors_js_1.TiempoPermissionError; } });
+Object.defineProperty(exports, "TiempoConflictError", { enumerable: true, get: function () { return errors_js_1.TiempoConflictError; } });
+Object.defineProperty(exports, "TiempoIdempotencyError", { enumerable: true, get: function () { return errors_js_1.TiempoIdempotencyError; } });
+Object.defineProperty(exports, "TiempoRateLimitError", { enumerable: true, get: function () { return errors_js_1.TiempoRateLimitError; } });
+Object.defineProperty(exports, "TiempoAPIError", { enumerable: true, get: function () { return errors_js_1.TiempoAPIError; } });
+Object.defineProperty(exports, "TiempoConnectionError", { enumerable: true, get: function () { return errors_js_1.TiempoConnectionError; } });
+Object.defineProperty(exports, "TiempoSignatureVerificationError", { enumerable: true, get: function () { return errors_js_1.TiempoSignatureVerificationError; } });
+var events_js_1 = require("./events.js");
+Object.defineProperty(exports, "EVENT_TYPES", { enumerable: true, get: function () { return events_js_1.EVENT_TYPES; } });
+Object.defineProperty(exports, "isKnownEventType", { enumerable: true, get: function () { return events_js_1.isKnownEventType; } });
+var webhooks_js_1 = require("./webhooks.js");
+Object.defineProperty(exports, "constructEvent", { enumerable: true, get: function () { return webhooks_js_1.constructEvent; } });
+Object.defineProperty(exports, "generateTestHeader", { enumerable: true, get: function () { return webhooks_js_1.generateTestHeader; } });
+Object.defineProperty(exports, "Webhooks", { enumerable: true, get: function () { return webhooks_js_1.Webhooks; } });
+Object.defineProperty(exports, "SIGNATURE_HEADER", { enumerable: true, get: function () { return webhooks_js_1.SIGNATURE_HEADER; } });
+var meta_js_1 = require("./generated/meta.js");
+Object.defineProperty(exports, "API_VERSION", { enumerable: true, get: function () { return meta_js_1.API_VERSION; } });
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return meta_js_1.SDK_VERSION; } });
+__exportStar(require("./generated/types.js"), exports);
+__exportStar(require("./generated/resources.js"), exports);

package/dist/cjs/list.d.ts

@@ -0,0 +1,43 @@
+/** One page of a list endpoint. */
+export interface ListPage<T> {
+    object: 'list';
+    data: T[];
+    has_more: boolean;
+}
+/** Query params every paginating list accepts. */
+export interface PageParams {
+    limit?: number;
+    starting_after?: string;
+    ending_before?: string;
+    [key: string]: unknown;
+}
+type FetchPage<T> = (params: PageParams) => Promise<ListPage<T>>;
+/**
+ * What a list method returns. `await` it for one page; `for await` over it to
+ * walk every item across pages.
+ *
+ * Iteration moves forward with `starting_after` (the last item's id). If you
+ * passed `ending_before`, it moves backwards with `ending_before` (the first
+ * item's id) and yields each page's items last to first, so you walk away from
+ * your cursor.
+ *
+ * The first page is fetched once, on first use, and shared between `await` and
+ * iteration.
+ */
+export declare class ListPromise<T> implements PromiseLike<ListPage<T>>, AsyncIterable<T> {
+    private readonly fetchPage;
+    private readonly params;
+    private readonly paginates;
+    private first;
+    constructor(fetchPage: FetchPage<T>, params: PageParams, paginates?: boolean);
+    private firstPage;
+    then<R1 = ListPage<T>, R2 = never>(onfulfilled?: ((value: ListPage<T>) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
+    catch<R = never>(onrejected?: ((reason: unknown) => R | PromiseLike<R>) | null): Promise<ListPage<T> | R>;
+    finally(onfinally?: (() => void) | null): Promise<ListPage<T>>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Collects items into an array, stopping after `limit` (required, to avoid surprises). */
+    toArray({ limit }: {
+        limit: number;
+    }): Promise<T[]>;
+}
+export {};

package/dist/cjs/list.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListPromise = void 0;
+function idOf(item) {
+    const id = item && typeof item === 'object' ? item.id : undefined;
+    if (typeof id !== 'string')
+        throw new TypeError('Cannot paginate: list item has no string `id`');
+    return id;
+}
+/**
+ * What a list method returns. `await` it for one page; `for await` over it to
+ * walk every item across pages.
+ *
+ * Iteration moves forward with `starting_after` (the last item's id). If you
+ * passed `ending_before`, it moves backwards with `ending_before` (the first
+ * item's id) and yields each page's items last to first, so you walk away from
+ * your cursor.
+ *
+ * The first page is fetched once, on first use, and shared between `await` and
+ * iteration.
+ */
+class ListPromise {
+    fetchPage;
+    params;
+    paginates;
+    first;
+    constructor(fetchPage, params, paginates = true) {
+        this.fetchPage = fetchPage;
+        this.params = params;
+        this.paginates = paginates;
+    }
+    firstPage() {
+        this.first ??= this.fetchPage(this.params);
+        return this.first;
+    }
+    then(onfulfilled, onrejected) {
+        return this.firstPage().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.firstPage().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.firstPage().finally(onfinally);
+    }
+    async *[Symbol.asyncIterator]() {
+        const backwards = this.params.ending_before !== undefined && this.params.starting_after === undefined;
+        let page = await this.firstPage();
+        for (;;) {
+            const items = backwards ? [...page.data].reverse() : page.data;
+            for (const item of items)
+                yield item;
+            if (!this.paginates || !page.has_more || page.data.length === 0)
+                return;
+            const next = { ...this.params };
+            if (backwards) {
+                next.ending_before = idOf(page.data[0]);
+            }
+            else {
+                delete next.ending_before;
+                next.starting_after = idOf(page.data[page.data.length - 1]);
+            }
+            page = await this.fetchPage(next);
+        }
+    }
+    /** Collects items into an array, stopping after `limit` (required, to avoid surprises). */
+    async toArray({ limit }) {
+        const out = [];
+        if (limit <= 0)
+            return out;
+        for await (const item of this) {
+            out.push(item);
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+}
+exports.ListPromise = ListPromise;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/query.d.ts

@@ -0,0 +1,8 @@
+/** Encodes a path segment. */
+export declare function encodePath(value: string): string;
+/**
+ * Encodes a query object: undefined and null are skipped, booleans become
+ * `true`/`false`, arrays repeat the key, and objects (like `metadata`) become
+ * `key[sub]=value`.
+ */
+export declare function encodeQuery(query: object | undefined): string;

package/dist/cjs/query.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePath = encodePath;
+exports.encodeQuery = encodeQuery;
+/** Encodes a path segment. */
+function encodePath(value) {
+    if (typeof value !== 'string' || value === '') {
+        throw new TypeError(`Expected a non-empty id string, got ${JSON.stringify(value)}`);
+    }
+    return encodeURIComponent(value);
+}
+function scalar(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return String(value);
+}
+function add(out, key, value) {
+    if (value === undefined || value === null)
+        return;
+    if (Array.isArray(value)) {
+        for (const v of value)
+            add(out, key, v);
+        return;
+    }
+    if (typeof value === 'object' && !(value instanceof Date)) {
+        for (const [k, v] of Object.entries(value))
+            add(out, `${key}[${k}]`, v);
+        return;
+    }
+    out.append(key, scalar(value));
+}
+/**
+ * Encodes a query object: undefined and null are skipped, booleans become
+ * `true`/`false`, arrays repeat the key, and objects (like `metadata`) become
+ * `key[sub]=value`.
+ */
+function encodeQuery(query) {
+    if (!query)
+        return '';
+    const out = new URLSearchParams();
+    for (const [k, v] of Object.entries(query))
+        add(out, k, v);
+    const s = out.toString();
+    return s ? `?${s}` : '';
+}

package/dist/cjs/shared.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Replaces the spec's single `metadata[key]` query param with a map. Each entry
+ * is sent as `metadata[k]=v`; several entries must all match.
+ */
+export type WithMetadataFilter<Q> = Omit<Q, 'metadata[key]'> & {
+    metadata?: Record<string, string>;
+};

package/dist/cjs/shared.js

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

package/dist/cjs/webhooks.d.ts

@@ -0,0 +1,34 @@
+import type { TiempoEvent } from './events.js';
+/** The header Tiempo signs webhook deliveries with. */
+export declare const SIGNATURE_HEADER = "Tiempo-Signature";
+export interface ConstructEventOptions {
+    /** Maximum age (and clock skew) of the signature timestamp, in seconds. Default 300. */
+    tolerance?: number;
+    /** The current time, as a `Date` or unix seconds. Default: now. */
+    now?: Date | number;
+}
+export interface GenerateTestHeaderOptions {
+    /** The exact body you will pass to `constructEvent`. */
+    payload: string | Uint8Array;
+    /** The endpoint's `tpw_…` secret. */
+    secret: string;
+    /** Unix seconds. Default: now. */
+    timestamp?: number;
+}
+/**
+ * Verifies a webhook delivery and returns its event.
+ *
+ * Pass the raw request body exactly as received (not re-serialised JSON), the
+ * `Tiempo-Signature` header, and the endpoint's `tpw_…` secret. Throws
+ * {@link TiempoSignatureVerificationError} if the signature doesn't match or
+ * the timestamp is outside `tolerance`.
+ */
+export declare function constructEvent(payload: string | Uint8Array, signatureHeader: string | null | undefined, secret: string, options?: ConstructEventOptions): Promise<TiempoEvent>;
+/** Builds a valid `Tiempo-Signature` header for a payload, for your own tests. */
+export declare function generateTestHeader({ payload, secret, timestamp }: GenerateTestHeaderOptions): Promise<string>;
+/** `tiempo.webhooks`: the same functions, on the client. */
+export declare class Webhooks {
+    readonly constructEvent: typeof constructEvent;
+    readonly generateTestHeader: typeof generateTestHeader;
+    readonly signatureHeader = "Tiempo-Signature";
+}

package/dist/cjs/webhooks.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhooks = exports.SIGNATURE_HEADER = void 0;
+exports.constructEvent = constructEvent;
+exports.generateTestHeader = generateTestHeader;
+const crypto_js_1 = require("./crypto.js");
+const errors_js_1 = require("./errors.js");
+/** The header Tiempo signs webhook deliveries with. */
+exports.SIGNATURE_HEADER = 'Tiempo-Signature';
+const encoder = new TextEncoder();
+function fail(message) {
+    throw new errors_js_1.TiempoSignatureVerificationError({ message });
+}
+function bytesOf(payload) {
+    return typeof payload === 'string' ? encoder.encode(payload) : payload;
+}
+function hex(buf) {
+    return Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, '0')).join('');
+}
+/** Constant-time string comparison (for equal-length hex digests). */
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    return diff === 0;
+}
+async function sign(secret, timestamp, payload) {
+    const { subtle } = await (0, crypto_js_1.webCrypto)();
+    const key = await subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const prefix = encoder.encode(`${timestamp}.`);
+    const message = new Uint8Array(prefix.length + payload.length);
+    message.set(prefix, 0);
+    message.set(payload, prefix.length);
+    return hex(await subtle.sign('HMAC', key, message));
+}
+function parseHeader(header) {
+    let timestamp;
+    const signatures = [];
+    for (const part of header.split(',')) {
+        const eq = part.indexOf('=');
+        if (eq < 0)
+            continue;
+        const key = part.slice(0, eq).trim();
+        const value = part.slice(eq + 1).trim();
+        if (key === 't' && /^\d+$/.test(value))
+            timestamp = Number(value);
+        else if (key === 'v1' && value)
+            signatures.push(value.toLowerCase());
+    }
+    if (timestamp === undefined)
+        fail('Tiempo-Signature header has no timestamp (t=…)');
+    if (signatures.length === 0)
+        fail('Tiempo-Signature header has no v1 signature');
+    return { timestamp, signatures };
+}
+/**
+ * Verifies a webhook delivery and returns its event.
+ *
+ * Pass the raw request body exactly as received (not re-serialised JSON), the
+ * `Tiempo-Signature` header, and the endpoint's `tpw_…` secret. Throws
+ * {@link TiempoSignatureVerificationError} if the signature doesn't match or
+ * the timestamp is outside `tolerance`.
+ */
+async function constructEvent(payload, signatureHeader, secret, options = {}) {
+    if (typeof payload !== 'string' && !(payload instanceof Uint8Array)) {
+        fail('Webhook payload must be the raw body as a string or bytes, not a parsed object (use express.raw()).');
+    }
+    if (typeof signatureHeader !== 'string' || signatureHeader === '')
+        fail('Missing Tiempo-Signature header');
+    if (typeof secret !== 'string' || secret === '')
+        fail('Missing webhook signing secret (tpw_…)');
+    const tolerance = options.tolerance ?? 300;
+    const nowSeconds = options.now instanceof Date
+        ? Math.floor(options.now.getTime() / 1000)
+        : options.now ?? Math.floor(Date.now() / 1000);
+    const { timestamp, signatures } = parseHeader(signatureHeader);
+    const bytes = bytesOf(payload);
+    const expected = await sign(secret, timestamp, bytes);
+    let matched = false;
+    for (const candidate of signatures) {
+        if (timingSafeEqual(candidate, expected))
+            matched = true;
+    }
+    if (!matched)
+        fail('No v1 signature in Tiempo-Signature matches the payload. Check the secret and that the body is unmodified.');
+    if (Math.abs(nowSeconds - timestamp) > tolerance) {
+        fail(`Tiempo-Signature timestamp ${timestamp} is outside the ${tolerance}s tolerance`);
+    }
+    const text = typeof payload === 'string' ? payload : new TextDecoder().decode(payload);
+    let event;
+    try {
+        event = JSON.parse(text);
+    }
+    catch {
+        fail('Webhook payload is not valid JSON');
+    }
+    if (!event || typeof event !== 'object' || event.object !== 'event') {
+        fail('Webhook payload is not a Tiempo event');
+    }
+    return event;
+}
+/** Builds a valid `Tiempo-Signature` header for a payload, for your own tests. */
+async function generateTestHeader({ payload, secret, timestamp }) {
+    const t = timestamp ?? Math.floor(Date.now() / 1000);
+    return `t=${t},v1=${await sign(secret, t, bytesOf(payload))}`;
+}
+/** `tiempo.webhooks`: the same functions, on the client. */
+class Webhooks {
+    constructEvent = constructEvent;
+    generateTestHeader = generateTestHeader;
+    signatureHeader = exports.SIGNATURE_HEADER;
+}
+exports.Webhooks = Webhooks;

package/dist/esm/client.d.ts

@@ -0,0 +1,24 @@
+import { type TiempoConfig } from './core.js';
+import { TiempoResources } from './generated/resources.js';
+import { Webhooks } from './webhooks.js';
+/**
+ * The Tiempo API client.
+ *
+ * ```ts
+ * const tiempo = new Tiempo(process.env.TIEMPO_API_KEY!); // https://api.tiempo.one unless you give a baseUrl
+ * const business = tiempo.withAccount('acct_…');
+ * const booking = await business.bookings.create({ segments: [...] });
+ * ```
+ */
+export declare class Tiempo extends TiempoResources {
+    /** Webhook signature verification. */
+    readonly webhooks: Webhooks;
+    private readonly core;
+    constructor(apiKey: string, config?: TiempoConfig);
+    /** A client that acts for one business (`acct_…`), sharing this one's key and settings. */
+    withAccount(account: string): Tiempo;
+    /** The business this client acts for, if any. */
+    get account(): string | undefined;
+    /** The `Tiempo-Version` this client sends. */
+    get apiVersion(): string;
+}

package/dist/esm/client.js

@@ -0,0 +1,38 @@
+import { HttpClient } from './core.js';
+import { TiempoResources } from './generated/resources.js';
+import { Webhooks } from './webhooks.js';
+/**
+ * The Tiempo API client.
+ *
+ * ```ts
+ * const tiempo = new Tiempo(process.env.TIEMPO_API_KEY!); // https://api.tiempo.one unless you give a baseUrl
+ * const business = tiempo.withAccount('acct_…');
+ * const booking = await business.bookings.create({ segments: [...] });
+ * ```
+ */
+export class Tiempo extends TiempoResources {
+    /** Webhook signature verification. */
+    webhooks;
+    core;
+    constructor(apiKey, config, resolved) {
+        const core = new HttpClient(resolved ?? HttpClient.resolve(apiKey, config));
+        super(core);
+        this.core = core;
+        this.webhooks = new Webhooks();
+    }
+    /** A client that acts for one business (`acct_…`), sharing this one's key and settings. */
+    withAccount(account) {
+        if (typeof account !== 'string' || !account)
+            throw new TypeError('Tiempo: withAccount needs an account id (acct_…)');
+        const cfg = this.core.config;
+        return new Tiempo(cfg.apiKey, { baseUrl: cfg.baseUrl }, { ...cfg, account });
+    }
+    /** The business this client acts for, if any. */
+    get account() {
+        return this.core.config.account;
+    }
+    /** The `Tiempo-Version` this client sends. */
+    get apiVersion() {
+        return this.core.config.apiVersion;
+    }
+}