@tiempo/sdk 0.0.0-stage → 0.1.1

package/dist/esm/core.d.ts

@@ -0,0 +1,72 @@
+import { ListPromise } from './list.js';
+/** Client options. */
+export interface TiempoConfig {
+    /**
+     * Where the API lives. Defaults to {@link DEFAULT_BASE_URL}, Tiempo itself; set it for the test
+     * deployment (`https://api.uat.tiempo.one`) or a local one (`http://localhost:8080`).
+     */
+    baseUrl?: string;
+    /**
+     * The `Tiempo-Version` to send. Defaults to {@link API_VERSION}, the version
+     * this SDK's types describe; change it only if you know the shapes match.
+     */
+    apiVersion?: string;
+    /** Act for this business (`acct_…`) on every request: sends `Tiempo-Account`. */
+    account?: string;
+    /** Retries after the first attempt for retryable failures. Default 2. */
+    maxRetries?: number;
+    /** Per-attempt timeout in milliseconds. Default 30000. */
+    timeout?: number;
+    /** A `fetch` implementation. Defaults to the global one. */
+    fetch?: typeof fetch;
+}
+/** Per-request options; the last argument of every method. */
+export interface RequestOptions {
+    /** Act for this business (`acct_…`), overriding the client's account. */
+    account?: string;
+    /** Idempotency key for a POST. Default: a fresh UUID per call, reused across its retries. */
+    idempotencyKey?: string;
+    /** Overrides the client's `maxRetries` for this call. */
+    maxRetries?: number;
+    /** Overrides the client's per-attempt `timeout` (ms) for this call. */
+    timeout?: number;
+    /** Aborts the call (including any pending retry). The promise rejects with the signal's reason. */
+    signal?: AbortSignal;
+}
+/** An HTTP call, as generated resource methods describe it. */
+export interface RequestSpec {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    query?: object | undefined;
+    body?: unknown;
+    options?: RequestOptions | undefined;
+    /** A POST that only reads (availability search): sent without an Idempotency-Key. */
+    readOnly?: boolean;
+}
+/** What generated resource classes call. */
+export interface Core {
+    request<T>(spec: RequestSpec): Promise<T>;
+    list<T>(spec: RequestSpec, paginates: boolean): ListPromise<T>;
+}
+export interface ResolvedConfig {
+    apiKey: string;
+    baseUrl: string;
+    apiVersion: string;
+    account: string | undefined;
+    maxRetries: number;
+    timeout: number;
+    fetch: typeof fetch | undefined;
+}
+/** Tiempo's API, where the SDK points unless `baseUrl` says otherwise. */
+export declare const DEFAULT_BASE_URL = "https://api.tiempo.one";
+/** Backoff before retry `attempt` (0-based): 0.5s × 2^n, capped at 8s, jittered to 50–100%. */
+export declare function backoffMs(attempt: number, random?: () => number): number;
+/** Parses `Retry-After` (seconds or an HTTP date) into ms; undefined if absent or unparseable. */
+export declare function retryAfterMs(header: string | null | undefined, now?: number): number | undefined;
+export declare class HttpClient implements Core {
+    readonly config: ResolvedConfig;
+    constructor(config: ResolvedConfig);
+    static resolve(apiKey: string, config: TiempoConfig | undefined): ResolvedConfig;
+    list<T>(spec: RequestSpec, paginates: boolean): ListPromise<T>;
+    request<T>(spec: RequestSpec): Promise<T>;
+}

package/dist/esm/core.js

@@ -0,0 +1,181 @@
+import { webCrypto } from './crypto.js';
+import { TiempoAPIError, TiempoConnectionError, errorFromResponse } from './errors.js';
+import { API_VERSION, SDK_VERSION } from './generated/meta.js';
+import { ListPromise } from './list.js';
+import { encodeQuery } from './query.js';
+/** Tiempo's API, where the SDK points unless `baseUrl` says otherwise. */
+export const DEFAULT_BASE_URL = 'https://api.tiempo.one';
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const MAX_RETRY_AFTER_SECONDS = 60;
+/** Backoff before retry `attempt` (0-based): 0.5s × 2^n, capped at 8s, jittered to 50–100%. */
+export function backoffMs(attempt, random = Math.random) {
+    const base = Math.min(8000, 500 * 2 ** attempt);
+    return Math.round(base * (0.5 + random() * 0.5));
+}
+/** Parses `Retry-After` (seconds or an HTTP date) into ms; undefined if absent or unparseable. */
+export function retryAfterMs(header, now = Date.now()) {
+    if (!header)
+        return undefined;
+    const trimmed = header.trim();
+    let seconds;
+    if (/^\d+(\.\d+)?$/.test(trimmed)) {
+        seconds = Number(trimmed);
+    }
+    else {
+        const at = Date.parse(trimmed);
+        if (Number.isNaN(at))
+            return undefined;
+        seconds = Math.max(0, (at - now) / 1000);
+    }
+    return Math.round(Math.min(seconds, MAX_RETRY_AFTER_SECONDS) * 1000);
+}
+function headersToRecord(headers) {
+    const out = {};
+    headers.forEach((value, key) => {
+        out[key.toLowerCase()] = value;
+    });
+    return out;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted)
+            return reject(signal.reason);
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+const isBrowser = typeof globalThis.window !== 'undefined';
+export class HttpClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    static resolve(apiKey, config) {
+        if (typeof apiKey !== 'string' || apiKey.trim() === '') {
+            throw new TypeError('Tiempo: an API key is required, e.g. new Tiempo(process.env.TIEMPO_API_KEY)');
+        }
+        const baseUrl = config?.baseUrl ?? DEFAULT_BASE_URL;
+        if (typeof baseUrl !== 'string' || !/^https?:\/\//.test(baseUrl)) {
+            throw new TypeError("Tiempo: `baseUrl` must be an http(s) URL, e.g. new Tiempo(key, { baseUrl: 'http://localhost:8080' })");
+        }
+        return {
+            apiKey,
+            baseUrl: baseUrl.replace(/\/+$/, '').replace(/\/v1$/, ''),
+            apiVersion: config?.apiVersion ?? API_VERSION,
+            account: config?.account,
+            maxRetries: config?.maxRetries ?? 2,
+            timeout: config?.timeout ?? 30_000,
+            fetch: config?.fetch,
+        };
+    }
+    list(spec, paginates) {
+        return new ListPromise((params) => this.request({ ...spec, query: params }), { ...spec.query }, paginates);
+    }
+    async request(spec) {
+        const opts = spec.options ?? {};
+        const cfg = this.config;
+        const doFetch = cfg.fetch ?? globalThis.fetch;
+        if (typeof doFetch !== 'function') {
+            throw new TypeError('Tiempo: no global fetch; pass one with { fetch } (Node 18+ has it built in)');
+        }
+        const maxRetries = Math.max(0, opts.maxRetries ?? cfg.maxRetries);
+        const timeout = opts.timeout ?? cfg.timeout;
+        const account = opts.account ?? cfg.account;
+        const url = cfg.baseUrl + spec.path + encodeQuery(spec.query);
+        const headers = {
+            Accept: 'application/json',
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Tiempo-Version': cfg.apiVersion,
+        };
+        if (!isBrowser)
+            headers['User-Agent'] = `tiempo-typescript/${SDK_VERSION}`;
+        if (account)
+            headers['Tiempo-Account'] = account;
+        let body;
+        if (spec.body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(spec.body);
+        }
+        if (spec.method === 'POST' && !spec.readOnly) {
+            headers['Idempotency-Key'] = opts.idempotencyKey ?? (await webCrypto()).randomUUID();
+        }
+        for (let attempt = 0;; attempt++) {
+            if (opts.signal?.aborted)
+                throw opts.signal.reason;
+            const canRetry = attempt < maxRetries;
+            let response;
+            let text;
+            const controller = new AbortController();
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, timeout);
+            const onAbort = () => controller.abort(opts.signal?.reason);
+            opts.signal?.addEventListener('abort', onAbort, { once: true });
+            try {
+                const init = { method: spec.method, headers, signal: controller.signal };
+                if (body !== undefined)
+                    init.body = body;
+                response = await doFetch(url, init);
+                text = await response.text();
+            }
+            catch (err) {
+                if (opts.signal?.aborted)
+                    throw opts.signal.reason;
+                if (canRetry) {
+                    await sleep(backoffMs(attempt), opts.signal);
+                    continue;
+                }
+                throw new TiempoConnectionError({
+                    message: timedOut
+                        ? `Request to Tiempo timed out after ${timeout}ms (${spec.method} ${spec.path})`
+                        : `Could not connect to Tiempo (${spec.method} ${spec.path}): ${err?.message ?? err}`,
+                    cause: err,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+                opts.signal?.removeEventListener('abort', onAbort);
+            }
+            const responseHeaders = headersToRecord(response.headers);
+            let parsed = text;
+            if (text.length > 0) {
+                try {
+                    parsed = JSON.parse(text);
+                }
+                catch {
+                    // keep text
+                }
+            }
+            if (response.ok) {
+                if (typeof parsed === 'string' && text.length > 0) {
+                    // A 2xx that wasn't JSON: don't hand back a string typed as an object.
+                    throw new TiempoAPIError({
+                        message: `Expected a JSON response from Tiempo, got: ${text.slice(0, 200)}`,
+                        statusCode: response.status,
+                        headers: responseHeaders,
+                        raw: text,
+                    });
+                }
+                return (text.length > 0 ? parsed : undefined);
+            }
+            const error = errorFromResponse(response.status, responseHeaders, parsed);
+            const retryable = RETRYABLE_STATUS.has(response.status) ||
+                (response.status === 409 && error.code === 'idempotency_key_in_use');
+            if (retryable && canRetry) {
+                const delay = retryAfterMs(response.headers.get('retry-after')) ?? backoffMs(attempt);
+                await sleep(delay, opts.signal);
+                continue;
+            }
+            throw error;
+        }
+    }
+}

package/dist/esm/crypto.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Web Crypto: the global `crypto` (Node 19+, browsers, edge runtimes), else
+ * `node:crypto`'s `webcrypto` (Node 18).
+ */
+export declare function webCrypto(): Promise<Crypto>;

package/dist/esm/crypto.js

@@ -0,0 +1,26 @@
+let cached;
+/**
+ * Web Crypto: the global `crypto` (Node 19+, browsers, edge runtimes), else
+ * `node:crypto`'s `webcrypto` (Node 18).
+ */
+export async function webCrypto() {
+    if (cached)
+        return cached;
+    const g = globalThis.crypto;
+    if (g?.subtle && typeof g.randomUUID === 'function') {
+        cached = g;
+        return g;
+    }
+    const specifier = 'node:crypto';
+    try {
+        const mod = (await import(specifier));
+        if (mod.webcrypto?.subtle) {
+            cached = mod.webcrypto;
+            return cached;
+        }
+    }
+    catch {
+        // fall through
+    }
+    throw new Error('Tiempo: Web Crypto is not available in this runtime (need Node 18+ or a runtime with globalThis.crypto).');
+}

package/dist/esm/errors.d.ts

@@ -0,0 +1,86 @@
+import type { Conflict } from './generated/types.js';
+/**
+ * The `error` object in Tiempo's error envelope. Besides these four, an error can carry fields of
+ * its own, merged straight in: `conflicts` on `booking_conflict` and `session_conflicted`, `occurrences` on
+ * `series_update_conflict`, `seats_available` on `seats_unavailable`.
+ */
+export interface TiempoErrorBody {
+    type?: string;
+    code?: string;
+    message?: string;
+    param?: string | null;
+    [key: string]: unknown;
+}
+/** A series occurrence that doesn't fit an edit (`series_update_conflict`). */
+export interface UnplaceableOccurrence {
+    booking: string;
+    occurrence_key: string;
+    conflicts: Conflict[];
+}
+export interface TiempoErrorInit {
+    message: string;
+    type?: string | undefined;
+    code?: string | undefined;
+    param?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+    statusCode?: number | undefined;
+    headers?: Record<string, string> | undefined;
+    raw?: unknown;
+    cause?: unknown;
+}
+/** Base class for every error the SDK throws. */
+export declare class TiempoError extends Error {
+    /** The server's error `type`, for example `invalid_request_error`. */
+    readonly type: string | undefined;
+    /** A machine-readable code, for example `parameter_invalid`. */
+    readonly code: string | undefined;
+    /** The request parameter the error is about, when there is one. */
+    readonly param: string | undefined;
+    /**
+     * The error's own fields beyond type, code, message and param, for example `{ conflicts: [...] }`.
+     * Empty when there are none. {@link TiempoConflictError} has typed shortcuts.
+     */
+    readonly details: Record<string, unknown>;
+    /** HTTP status, when the server answered. */
+    readonly statusCode: number | undefined;
+    /** Response headers (lower-case names), when the server answered. */
+    readonly headers: Record<string, string>;
+    /** The parsed response body (or text), when the server answered. */
+    readonly raw: unknown;
+    constructor(init: TiempoErrorInit);
+}
+/** 400/404/422: the request was invalid (bad params, unknown id, …). */
+export declare class TiempoInvalidRequestError extends TiempoError {
+}
+/** 401: missing or bad API key. */
+export declare class TiempoAuthenticationError extends TiempoError {
+}
+/** 403: the key can't do this (for example live mode not activated). */
+export declare class TiempoPermissionError extends TiempoError {
+}
+/** 409: the request conflicts with current state (slot taken, already cancelled, …). */
+export declare class TiempoConflictError extends TiempoError {
+    /** Why the time isn't available, per segment (`booking_conflict`, `session_conflicted`). Empty for other conflicts. */
+    get conflicts(): Conflict[];
+    /** Occurrences a series edit couldn't place (`series_update_conflict`). */
+    get occurrences(): UnplaceableOccurrence[];
+    /** Seats still free in the session (`seats_unavailable`). */
+    get seatsAvailable(): number | undefined;
+}
+/** An `Idempotency-Key` was reused with different params, or is still in flight. */
+export declare class TiempoIdempotencyError extends TiempoError {
+}
+/** 429: too many requests. */
+export declare class TiempoRateLimitError extends TiempoError {
+}
+/** 5xx: something went wrong on Tiempo's side. */
+export declare class TiempoAPIError extends TiempoError {
+}
+/** The request never got a response: network failure or timeout. */
+export declare class TiempoConnectionError extends TiempoError {
+}
+/** A webhook's `Tiempo-Signature` didn't verify. */
+export declare class TiempoSignatureVerificationError extends TiempoError {
+}
+/** Builds the right error subclass from an HTTP error response. */
+export declare function errorFromResponse(statusCode: number, headers: Record<string, string>, raw: unknown): TiempoError;

package/dist/esm/errors.js

@@ -0,0 +1,120 @@
+/** Base class for every error the SDK throws. */
+export class TiempoError extends Error {
+    /** The server's error `type`, for example `invalid_request_error`. */
+    type;
+    /** A machine-readable code, for example `parameter_invalid`. */
+    code;
+    /** The request parameter the error is about, when there is one. */
+    param;
+    /**
+     * The error's own fields beyond type, code, message and param, for example `{ conflicts: [...] }`.
+     * Empty when there are none. {@link TiempoConflictError} has typed shortcuts.
+     */
+    details;
+    /** HTTP status, when the server answered. */
+    statusCode;
+    /** Response headers (lower-case names), when the server answered. */
+    headers;
+    /** The parsed response body (or text), when the server answered. */
+    raw;
+    constructor(init) {
+        super(init.message, init.cause !== undefined ? { cause: init.cause } : undefined);
+        this.name = new.target.name;
+        this.type = init.type;
+        this.code = init.code;
+        this.param = init.param;
+        this.details = init.details ?? {};
+        this.statusCode = init.statusCode;
+        this.headers = init.headers ?? {};
+        this.raw = init.raw;
+    }
+}
+/** 400/404/422: the request was invalid (bad params, unknown id, …). */
+export class TiempoInvalidRequestError extends TiempoError {
+}
+/** 401: missing or bad API key. */
+export class TiempoAuthenticationError extends TiempoError {
+}
+/** 403: the key can't do this (for example live mode not activated). */
+export class TiempoPermissionError extends TiempoError {
+}
+/** 409: the request conflicts with current state (slot taken, already cancelled, …). */
+export class TiempoConflictError extends TiempoError {
+    /** Why the time isn't available, per segment (`booking_conflict`, `session_conflicted`). Empty for other conflicts. */
+    get conflicts() {
+        return Array.isArray(this.details.conflicts) ? this.details.conflicts : [];
+    }
+    /** Occurrences a series edit couldn't place (`series_update_conflict`). */
+    get occurrences() {
+        return Array.isArray(this.details.occurrences) ? this.details.occurrences : [];
+    }
+    /** Seats still free in the session (`seats_unavailable`). */
+    get seatsAvailable() {
+        return typeof this.details.seats_available === 'number' ? this.details.seats_available : undefined;
+    }
+}
+/** An `Idempotency-Key` was reused with different params, or is still in flight. */
+export class TiempoIdempotencyError extends TiempoError {
+}
+/** 429: too many requests. */
+export class TiempoRateLimitError extends TiempoError {
+}
+/** 5xx: something went wrong on Tiempo's side. */
+export class TiempoAPIError extends TiempoError {
+}
+/** The request never got a response: network failure or timeout. */
+export class TiempoConnectionError extends TiempoError {
+}
+/** A webhook's `Tiempo-Signature` didn't verify. */
+export class TiempoSignatureVerificationError extends TiempoError {
+}
+const BY_TYPE = {
+    invalid_request_error: TiempoInvalidRequestError,
+    authentication_error: TiempoAuthenticationError,
+    permission_error: TiempoPermissionError,
+    conflict_error: TiempoConflictError,
+    idempotency_error: TiempoIdempotencyError,
+    rate_limit_error: TiempoRateLimitError,
+    api_error: TiempoAPIError,
+    internal_error: TiempoAPIError,
+};
+function byStatus(status) {
+    if (status === 401)
+        return TiempoAuthenticationError;
+    if (status === 403)
+        return TiempoPermissionError;
+    if (status === 409)
+        return TiempoConflictError;
+    if (status === 429)
+        return TiempoRateLimitError;
+    if (status >= 400 && status < 500)
+        return TiempoInvalidRequestError;
+    return TiempoAPIError;
+}
+/** Builds the right error subclass from an HTTP error response. */
+export function errorFromResponse(statusCode, headers, raw) {
+    const body = raw && typeof raw === 'object' && 'error' in raw && raw.error && typeof raw.error === 'object'
+        ? raw.error
+        : undefined;
+    const Cls = (body?.type && BY_TYPE[body.type]) || byStatus(statusCode);
+    const message = body?.message ?? (typeof raw === 'string' && raw.length > 0 && raw.length < 500 ? raw : `HTTP ${statusCode}`);
+    return new Cls({
+        message,
+        type: body?.type,
+        code: body?.code,
+        param: body?.param ?? undefined,
+        details: body ? extraFields(body) : undefined,
+        statusCode,
+        headers,
+        raw,
+    });
+}
+const ENVELOPE_FIELDS = new Set(['type', 'code', 'message', 'param']);
+function extraFields(body) {
+    const out = {};
+    for (const [key, value] of Object.entries(body)) {
+        if (!ENVELOPE_FIELDS.has(key))
+            out[key] = value;
+    }
+    return out;
+}

package/dist/esm/events.d.ts

@@ -0,0 +1,23 @@
+import { EVENT_TYPES, type EventObjectMap, type TiempoEventType } from './generated/events.js';
+import type { components } from './generated/openapi.js';
+export { EVENT_TYPES };
+export type { EventObjectMap, TiempoEventType };
+/** The object an event of type `T` carries in `data.object`. */
+export type EventObject<T extends TiempoEventType> = EventObjectMap[T];
+type EventEnvelope = Omit<components['schemas']['Event'], 'type' | 'data'>;
+/** One event of a specific type. */
+export interface TiempoEventOf<T extends TiempoEventType> extends EventEnvelope {
+    type: T;
+    data: {
+        /** The object the event is about, as it was just after the change. */
+        object: EventObject<T>;
+        /** On `*.updated`: the changed fields' previous values. Null otherwise. */
+        previous_attributes: Partial<EventObject<T>> | null;
+    };
+}
+/** Any Tiempo event. Narrow on `type` to get a typed `data.object`. */
+export type TiempoEvent = {
+    [T in TiempoEventType]: TiempoEventOf<T>;
+}[TiempoEventType];
+/** True if `type` is one this SDK knows about. */
+export declare function isKnownEventType(type: string): type is TiempoEventType;

package/dist/esm/events.js

@@ -0,0 +1,8 @@
+import { EVENT_TYPES } from './generated/events.js';
+// The event list and each type's object come from the spec (Event.type and its
+// x-tiempo-event-objects map) via `npm run generate`; see src/generated/events.ts.
+export { EVENT_TYPES };
+/** True if `type` is one this SDK knows about. */
+export function isKnownEventType(type) {
+    return EVENT_TYPES.includes(type);
+}

package/dist/esm/generated/events.d.ts

@@ -0,0 +1,51 @@
+import type { Account, Attendee, Block, Booking, Location, Resource, Schedule, ScheduleOverride, Series, SkippedOccurrence } from './types.js';
+/** Every event type Tiempo sends (from the spec's Event.type). */
+export declare const EVENT_TYPES: readonly ["account.created", "account.updated", "account.deleted", "location.created", "location.updated", "location.deleted", "resource.created", "resource.updated", "resource.archived", "resource.unarchived", "resource.deleted", "schedule.created", "schedule.updated", "schedule.deleted", "schedule_override.created", "schedule_override.updated", "schedule_override.deleted", "block.created", "block.updated", "block.deleted", "booking.created", "booking.confirmed", "booking.rescheduled", "booking.cancelled", "booking.expired", "booking.completed", "booking.no_show", "booking.updated", "booking.conflicted", "booking.conflict_resolved", "booking.imported", "attendee.created", "attendee.confirmed", "attendee.cancelled", "attendee.expired", "attendee.completed", "attendee.no_show", "attendee.updated", "series.created", "series.updated", "series.split", "series.cancelled", "series.ended", "series.occurrence_skipped"];
+export type TiempoEventType = (typeof EVENT_TYPES)[number];
+/** The object each event type carries in `data.object`. */
+export interface EventObjectMap {
+    "account.created": Account;
+    "account.updated": Account;
+    "account.deleted": Account;
+    "location.created": Location;
+    "location.updated": Location;
+    "location.deleted": Location;
+    "resource.created": Resource;
+    "resource.updated": Resource;
+    "resource.archived": Resource;
+    "resource.unarchived": Resource;
+    "resource.deleted": Resource;
+    "schedule.created": Schedule;
+    "schedule.updated": Schedule;
+    "schedule.deleted": Schedule;
+    "schedule_override.created": ScheduleOverride;
+    "schedule_override.updated": ScheduleOverride;
+    "schedule_override.deleted": ScheduleOverride;
+    "block.created": Block;
+    "block.updated": Block;
+    "block.deleted": Block;
+    "booking.created": Booking;
+    "booking.confirmed": Booking;
+    "booking.rescheduled": Booking;
+    "booking.cancelled": Booking;
+    "booking.expired": Booking;
+    "booking.completed": Booking;
+    "booking.no_show": Booking;
+    "booking.updated": Booking;
+    "booking.conflicted": Booking;
+    "booking.conflict_resolved": Booking;
+    "booking.imported": Booking;
+    "attendee.created": Attendee;
+    "attendee.confirmed": Attendee;
+    "attendee.cancelled": Attendee;
+    "attendee.expired": Attendee;
+    "attendee.completed": Attendee;
+    "attendee.no_show": Attendee;
+    "attendee.updated": Attendee;
+    "series.created": Series;
+    "series.updated": Series;
+    "series.split": Series;
+    "series.cancelled": Series;
+    "series.ended": Series;
+    "series.occurrence_skipped": SkippedOccurrence;
+}

package/dist/esm/generated/events.js

@@ -0,0 +1,48 @@
+// Code generated by scripts/generate.mjs from openapi.json. DO NOT EDIT.
+/** Every event type Tiempo sends (from the spec's Event.type). */
+export const EVENT_TYPES = [
+    "account.created",
+    "account.updated",
+    "account.deleted",
+    "location.created",
+    "location.updated",
+    "location.deleted",
+    "resource.created",
+    "resource.updated",
+    "resource.archived",
+    "resource.unarchived",
+    "resource.deleted",
+    "schedule.created",
+    "schedule.updated",
+    "schedule.deleted",
+    "schedule_override.created",
+    "schedule_override.updated",
+    "schedule_override.deleted",
+    "block.created",
+    "block.updated",
+    "block.deleted",
+    "booking.created",
+    "booking.confirmed",
+    "booking.rescheduled",
+    "booking.cancelled",
+    "booking.expired",
+    "booking.completed",
+    "booking.no_show",
+    "booking.updated",
+    "booking.conflicted",
+    "booking.conflict_resolved",
+    "booking.imported",
+    "attendee.created",
+    "attendee.confirmed",
+    "attendee.cancelled",
+    "attendee.expired",
+    "attendee.completed",
+    "attendee.no_show",
+    "attendee.updated",
+    "series.created",
+    "series.updated",
+    "series.split",
+    "series.cancelled",
+    "series.ended",
+    "series.occurrence_skipped",
+];

package/dist/esm/generated/meta.d.ts

@@ -0,0 +1,4 @@
+/** The dated API version this SDK's types describe. Sent as `Tiempo-Version` on every request. */
+export declare const API_VERSION = "2026-10-16";
+/** This package's version. */
+export declare const SDK_VERSION = "0.1.1";

package/dist/esm/generated/meta.js

@@ -0,0 +1,5 @@
+// Code generated by scripts/generate.mjs from openapi.json. DO NOT EDIT.
+/** The dated API version this SDK's types describe. Sent as `Tiempo-Version` on every request. */
+export const API_VERSION = "2026-10-16";
+/** This package's version. */
+export const SDK_VERSION = "0.1.1";