@chronary/sdk 0.1.3

package/dist/index.js

@@ -0,0 +1,1171 @@
+// src/version.ts
+var VERSION = "0.1.3";
+
+// src/error.ts
+var ChronaryError = class extends Error {
+  status;
+  requestId;
+  headers;
+  errorType;
+  constructor(message, status, requestId, headers, errorType) {
+    super(message);
+    this.name = "ChronaryError";
+    this.status = status;
+    this.requestId = requestId;
+    this.headers = headers;
+    this.errorType = errorType;
+  }
+};
+var AuthenticationError = class extends ChronaryError {
+  constructor(message, requestId, headers) {
+    super(message, 401, requestId, headers, "authentication_error");
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends ChronaryError {
+  retryAfter;
+  constructor(message, requestId, headers) {
+    super(message, 429, requestId, headers, "rate_limit_error");
+    this.name = "RateLimitError";
+    if (headers) {
+      const ra = headers.get("retry-after");
+      if (ra) this.retryAfter = parseInt(ra, 10);
+    }
+  }
+};
+var NotFoundError = class extends ChronaryError {
+  constructor(message, requestId, headers) {
+    super(message, 404, requestId, headers, "not_found");
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends ChronaryError {
+  constructor(message, status, requestId, headers) {
+    super(message, status, requestId, headers, "validation_error");
+    this.name = "ValidationError";
+  }
+};
+var QuotaExceededError = class extends ChronaryError {
+  constructor(message, requestId, headers) {
+    super(message, 402, requestId, headers, "quota_exceeded");
+    this.name = "QuotaExceededError";
+  }
+};
+var TimeoutError = class extends ChronaryError {
+  constructor(message) {
+    super(message, 0);
+    this.name = "TimeoutError";
+  }
+};
+var ConnectionError = class extends ChronaryError {
+  constructor(message) {
+    super(message, 0);
+    this.name = "ConnectionError";
+  }
+};
+
+// src/api-promise.ts
+var APIPromise = class {
+  innerPromise;
+  constructor(responsePromise) {
+    this.innerPromise = responsePromise;
+  }
+  /**
+   * Returns both the parsed data and the raw HTTP response.
+   */
+  async withResponse() {
+    const { data, rawResponse } = await this.innerPromise;
+    return { data, response: rawResponse };
+  }
+  /**
+   * Implements the thenable interface. When awaited, resolves to just the parsed data `T`.
+   */
+  then(onfulfilled, onrejected) {
+    return this.innerPromise.then(
+      (result) => onfulfilled ? onfulfilled(result.data) : result.data,
+      onrejected
+    );
+  }
+  /**
+   * Attaches a rejection handler.
+   */
+  catch(onrejected) {
+    return this.then(void 0, onrejected);
+  }
+  /**
+   * Attaches a handler that runs on both fulfillment and rejection.
+   */
+  finally(onfinally) {
+    return this.then(
+      (value) => {
+        onfinally?.();
+        return value;
+      },
+      (reason) => {
+        onfinally?.();
+        throw reason;
+      }
+    );
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.chronary.ai";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var MAX_RETRY_DELAY = 6e4;
+function getEnvVar(name) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[name];
+    }
+  } catch {
+  }
+  return void 0;
+}
+function resolveLogLevel(config) {
+  if (config.logLevel) return config.logLevel;
+  const envLog = getEnvVar("CHRONARY_LOG");
+  if (envLog && ["debug", "info", "warn", "error", "off"].includes(envLog)) {
+    return envLog;
+  }
+  return "off";
+}
+var LOG_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  off: 4
+};
+var CoreClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  maxRetries;
+  logLevel;
+  fetchFn;
+  userAgent;
+  extraHeaders;
+  constructor(config = {}) {
+    this.apiKey = config.apiKey ?? getEnvVar("CHRONARY_API_KEY") ?? "";
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.logLevel = resolveLogLevel(config);
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.extraHeaders = config.extraHeaders ?? {};
+    let ua = `chronary-ts/${VERSION}`;
+    if (config.appInfo) {
+      ua += ` ${config.appInfo.name}`;
+      if (config.appInfo.version) ua += `/${config.appInfo.version}`;
+    }
+    try {
+      if (typeof process !== "undefined" && process.version) {
+        ua += ` node/${process.version.replace("v", "")}`;
+      }
+    } catch {
+    }
+    this.userAgent = ua;
+  }
+  log(level, message) {
+    if (level === "off" || LOG_PRIORITY[level] < LOG_PRIORITY[this.logLevel]) return;
+    const prefix = `[chronary:${level}]`;
+    switch (level) {
+      case "debug":
+        console.debug(prefix, message);
+        break;
+      case "info":
+        console.info(prefix, message);
+        break;
+      case "warn":
+        console.warn(prefix, message);
+        break;
+      case "error":
+        console.error(prefix, message);
+        break;
+    }
+  }
+  request(method, path, body, query, options) {
+    return new APIPromise(this._request(method, path, body, query, options));
+  }
+  async _request(method, path, body, query, options) {
+    const url = this.buildUrl(path, query);
+    const headers = {
+      "User-Agent": this.userAgent,
+      "X-Chronary-SDK-Version": VERSION,
+      ...this.extraHeaders
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (MUTATING_METHODS.has(method)) {
+      headers["Idempotency-Key"] = options?.idempotencyKey ?? crypto.randomUUID();
+    }
+    const requestTimeout = options?.timeout ?? this.timeout;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = this.retryDelay(attempt, lastError);
+        this.log("info", `Retry #${attempt} after ${delay}ms`);
+        await sleep(delay);
+      }
+      if (options?.signal?.aborted) throw new ChronaryError("Request aborted", 0);
+      const controller = new AbortController();
+      const abortFromCaller = () => controller.abort(options?.signal?.reason);
+      options?.signal?.addEventListener("abort", abortFromCaller, { once: true });
+      const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+      try {
+        this.log("debug", `${method} ${path}`);
+        const startTime = Date.now();
+        const response = await this.fetchFn(url, {
+          method,
+          headers,
+          body: body !== void 0 ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        options?.signal?.removeEventListener("abort", abortFromCaller);
+        const elapsed = Date.now() - startTime;
+        const requestId = response.headers.get("x-request-id") ?? void 0;
+        this.log("debug", `${method} ${path} \u2192 ${response.status} in ${elapsed}ms${requestId ? ` (${requestId})` : ""}`);
+        if (response.ok) {
+          const rawResponse = {
+            status: response.status,
+            headers: response.headers,
+            url: response.url,
+            quota: parseQuotaSnapshot(response.headers)
+          };
+          if (response.status === 204) {
+            return { data: void 0, rawResponse };
+          }
+          const data = await response.json();
+          return { data, rawResponse };
+        }
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          lastError = await this.buildError(response, requestId);
+          continue;
+        }
+        throw await this.buildError(response, requestId);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        options?.signal?.removeEventListener("abort", abortFromCaller);
+        if (err instanceof ChronaryError) throw err;
+        if (err instanceof DOMException && err.name === "AbortError") {
+          if (options?.signal?.aborted) throw new ChronaryError("Request aborted", 0);
+          throw new TimeoutError(`Request timed out after ${requestTimeout}ms`);
+        }
+        if (attempt < this.maxRetries) {
+          lastError = err;
+          continue;
+        }
+        throw new ConnectionError(`Connection failed: ${err.message}`);
+      }
+    }
+    throw lastError ?? new ConnectionError("Request failed after retries");
+  }
+  buildUrl(path, query) {
+    const base = `${this.baseUrl}${path}`;
+    if (!query) return base;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) params.set(key, String(value));
+    }
+    const qs = params.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+  async buildError(response, requestId) {
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+    }
+    const message = errorBody?.error?.message ?? `HTTP ${response.status}`;
+    const rid = requestId ?? errorBody?.error?.request_id;
+    const errorType = errorBody?.error?.type;
+    switch (response.status) {
+      case 400:
+        if (errorType === "validation_error") {
+          return new ValidationError(message, response.status, rid, response.headers);
+        }
+        return new ChronaryError(message, response.status, rid, response.headers, errorType);
+      case 401:
+        return new AuthenticationError(message, rid, response.headers);
+      case 402:
+        return new QuotaExceededError(message, rid, response.headers);
+      case 404:
+        return new NotFoundError(message, rid, response.headers);
+      case 422:
+        return new ValidationError(message, response.status, rid, response.headers);
+      case 429: {
+        if (errorType === "quota_exceeded") {
+          return new QuotaExceededError(message, rid, response.headers);
+        }
+        return new RateLimitError(message, rid, response.headers);
+      }
+      default:
+        return new ChronaryError(message, response.status, rid, response.headers, errorType);
+    }
+  }
+  retryDelay(attempt, lastError) {
+    if (lastError instanceof RateLimitError && lastError.retryAfter) {
+      return Math.min(lastError.retryAfter * 1e3, MAX_RETRY_DELAY);
+    }
+    const base = 500;
+    const exponential = base * Math.pow(2, attempt - 1);
+    const jitter = Math.random() * base;
+    return Math.min(exponential + jitter, MAX_RETRY_DELAY);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseQuotaSnapshot(headers) {
+  const rateLimit = headers.get("ratelimit");
+  const policy = headers.get("ratelimit-policy");
+  if (!rateLimit || !policy) return void 0;
+  const remaining = parseStructuredParam(rateLimit, "r");
+  const resetSeconds = parseStructuredParam(rateLimit, "t");
+  const limit = parseStructuredParam(policy, "q");
+  if (remaining === void 0 || resetSeconds === void 0 || limit === void 0) {
+    return void 0;
+  }
+  return {
+    limit,
+    remaining,
+    resetAt: new Date(Date.now() + resetSeconds * 1e3)
+  };
+}
+function parseStructuredParam(header, key) {
+  const re = new RegExp(`(?:^|;)\\s*${key}=(-?\\d+)(?:;|$)`);
+  const match = re.exec(header);
+  if (!match) return void 0;
+  const n = Number(match[1]);
+  return Number.isFinite(n) ? n : void 0;
+}
+
+// src/pagination.ts
+var PageIterator = class {
+  fetchPage;
+  defaultLimit;
+  initialOffset;
+  constructor(fetchPage, defaultLimit = 50, initialOffset = 0) {
+    this.fetchPage = fetchPage;
+    this.defaultLimit = defaultLimit;
+    this.initialOffset = initialOffset;
+  }
+  async getPage(offset = this.initialOffset, limit) {
+    const l = limit ?? this.defaultLimit;
+    const response = await this.fetchPage(offset, l);
+    return {
+      ...response,
+      hasMore: offset + response.data.length < response.total
+    };
+  }
+  async *[Symbol.asyncIterator]() {
+    let offset = this.initialOffset;
+    const limit = this.defaultLimit;
+    while (true) {
+      const page = await this.fetchPage(offset, limit);
+      for (const item of page.data) {
+        yield item;
+      }
+      offset += page.data.length;
+      if (offset >= page.total || page.data.length === 0) break;
+    }
+  }
+};
+
+// src/resources/agents.ts
+var AgentsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Register your agent with Chronary. Creates a Chronary identity for an agent
+   * that already exists in your system, so it can own calendars, events, and webhooks.
+   */
+  async create(params, options) {
+    return this.client.request("POST", "/v1/agents", params, void 0, options);
+  }
+  async get(id, options) {
+    return this.client.request("GET", `/v1/agents/${id}`, void 0, void 0, options);
+  }
+  list(params = {}) {
+    const { limit = 50, offset = 0, ...filters } = params;
+    return new PageIterator(
+      (offset2, l) => this.client.request("GET", "/v1/agents", void 0, {
+        ...filters,
+        limit: l,
+        offset: offset2
+      }),
+      limit,
+      offset
+    );
+  }
+  async update(id, params, options) {
+    return this.client.request("PATCH", `/v1/agents/${id}`, params, void 0, options);
+  }
+  async delete(id, options) {
+    await this.client.request("DELETE", `/v1/agents/${id}`, void 0, void 0, options);
+  }
+};
+
+// src/resources/calendars.ts
+var CalendarsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params, options) {
+    const { agentId, ...body } = params;
+    const path = agentId ? `/v1/agents/${agentId}/calendars` : "/v1/calendars";
+    return this.client.request("POST", path, body, void 0, options);
+  }
+  async get(id, options) {
+    return this.client.request("GET", `/v1/calendars/${id}`, void 0, void 0, options);
+  }
+  list(params = {}) {
+    const { agentId, limit = 50, offset = 0, ...filters } = params;
+    const path = agentId ? `/v1/agents/${agentId}/calendars` : "/v1/calendars";
+    return new PageIterator(
+      (offset2, l) => this.client.request("GET", path, void 0, {
+        ...filters,
+        limit: l,
+        offset: offset2
+      }),
+      limit,
+      offset
+    );
+  }
+  async update(id, params, options) {
+    return this.client.request("PATCH", `/v1/calendars/${id}`, params, void 0, options);
+  }
+  async delete(id, options) {
+    await this.client.request("DELETE", `/v1/calendars/${id}`, void 0, void 0, options);
+  }
+  async getContext(id, options) {
+    return this.client.request(
+      "GET",
+      `/v1/calendars/${id}/context`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  async setAvailabilityRules(id, params, options) {
+    return this.client.request(
+      "PUT",
+      `/v1/calendars/${id}/availability-rules`,
+      params,
+      void 0,
+      options
+    );
+  }
+  async getAvailabilityRules(id, options) {
+    return this.client.request(
+      "GET",
+      `/v1/calendars/${id}/availability-rules`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  async deleteAvailabilityRules(id, options) {
+    await this.client.request(
+      "DELETE",
+      `/v1/calendars/${id}/availability-rules`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/events.ts
+var EventsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(calendarId, params, options) {
+    return this.client.request(
+      "POST",
+      `/v1/calendars/${calendarId}/events`,
+      params,
+      void 0,
+      options
+    );
+  }
+  async get(calendarId, eventId, options) {
+    return this.client.request(
+      "GET",
+      `/v1/calendars/${calendarId}/events/${eventId}`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  list(params = {}) {
+    const { calendarId, agentId, limit = 50, offset = 0, ...filters } = params;
+    let path;
+    if (agentId) {
+      path = `/v1/agents/${agentId}/events`;
+    } else if (calendarId) {
+      path = `/v1/calendars/${calendarId}/events`;
+    } else {
+      throw new Error("Either calendarId or agentId is required for events.list()");
+    }
+    return new PageIterator(
+      (offset2, l) => this.client.request("GET", path, void 0, {
+        ...filters,
+        limit: l,
+        offset: offset2
+      }),
+      limit,
+      offset
+    );
+  }
+  async update(calendarId, eventId, params, options) {
+    return this.client.request(
+      "PATCH",
+      `/v1/calendars/${calendarId}/events/${eventId}`,
+      params,
+      void 0,
+      options
+    );
+  }
+  async delete(calendarId, eventId, options) {
+    await this.client.request(
+      "DELETE",
+      `/v1/calendars/${calendarId}/events/${eventId}`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Promote a held event (status='hold') to status='confirmed'. Fails with 409
+   * if the event is not a hold, or if the hold has already expired.
+   */
+  async confirm(eventId, options) {
+    return this.client.request(
+      "PUT",
+      `/v1/events/${eventId}/confirm`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Manually release a held event before its TTL, freeing the slot. Fails with
+   * 409 if the event is not a hold.
+   */
+  async release(eventId, options) {
+    return this.client.request(
+      "PUT",
+      `/v1/events/${eventId}/release`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/availability.ts
+var AvailabilityClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async forAgent(agentId, params, options) {
+    return this.client.request(
+      "GET",
+      `/v1/agents/${agentId}/availability`,
+      void 0,
+      {
+        start: params.start,
+        end: params.end,
+        slot_duration: params.slot_duration,
+        include_busy: params.include_busy
+      },
+      options
+    );
+  }
+  async forCalendar(calendarId, params, options) {
+    return this.client.request(
+      "GET",
+      `/v1/calendars/${calendarId}/availability`,
+      void 0,
+      {
+        start: params.start,
+        end: params.end,
+        slot_duration: params.slot_duration,
+        include_busy: params.include_busy
+      },
+      options
+    );
+  }
+  async check(params, options) {
+    return this.client.request(
+      "GET",
+      "/v1/availability",
+      void 0,
+      {
+        agents: params.agents.join(","),
+        start: params.start,
+        end: params.end,
+        slot_duration: params.slot_duration,
+        calendars: params.calendars?.join(","),
+        include_busy: params.include_busy
+      },
+      options
+    );
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params, options) {
+    return this.client.request("POST", "/v1/webhooks", params, void 0, options);
+  }
+  async get(id, options) {
+    return this.client.request("GET", `/v1/webhooks/${id}`, void 0, void 0, options);
+  }
+  list(params = {}) {
+    const { limit = 20, offset = 0, ...filters } = params;
+    return new PageIterator(
+      (offset2, l) => this.client.request("GET", "/v1/webhooks", void 0, {
+        ...filters,
+        limit: l,
+        offset: offset2
+      }),
+      limit,
+      offset
+    );
+  }
+  async update(id, params, options) {
+    return this.client.request("PATCH", `/v1/webhooks/${id}`, params, void 0, options);
+  }
+  async delete(id, options) {
+    await this.client.request("DELETE", `/v1/webhooks/${id}`, void 0, void 0, options);
+  }
+  async listDeliveries(webhookId, params = {}, options) {
+    const { limit = 20, offset = 0, status, include_payload } = params;
+    return this.client.request(
+      "GET",
+      `/v1/webhooks/${webhookId}/deliveries`,
+      void 0,
+      { limit, offset, ...status !== void 0 && { status }, ...include_payload !== void 0 && { include_payload } },
+      options
+    );
+  }
+};
+
+// src/resources/ical-subscriptions.ts
+var ICalSubscriptionsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(agentId, params, options) {
+    return this.client.request(
+      "POST",
+      `/v1/agents/${agentId}/ical-subscriptions`,
+      params,
+      void 0,
+      options
+    );
+  }
+  async get(id, options) {
+    return this.client.request(
+      "GET",
+      `/v1/ical-subscriptions/${id}`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  list(params) {
+    const { agentId, limit = 50, offset = 0, ...filters } = params;
+    return new PageIterator(
+      (offset2, l) => this.client.request(
+        "GET",
+        `/v1/agents/${agentId}/ical-subscriptions`,
+        void 0,
+        { ...filters, limit: l, offset: offset2 }
+      ),
+      limit,
+      offset
+    );
+  }
+  async update(id, params, options) {
+    return this.client.request(
+      "PATCH",
+      `/v1/ical-subscriptions/${id}`,
+      params,
+      void 0,
+      options
+    );
+  }
+  async delete(id, options) {
+    await this.client.request(
+      "DELETE",
+      `/v1/ical-subscriptions/${id}`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  async sync(id, options) {
+    return this.client.request(
+      "POST",
+      `/v1/ical-subscriptions/${id}/sync`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/scheduling.ts
+var SchedulingClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params, options) {
+    return this.client.request(
+      "POST",
+      "/v1/scheduling/proposals",
+      params,
+      void 0,
+      options
+    );
+  }
+  list(params = {}) {
+    const { limit = 50, offset = 0, ...filters } = params;
+    return new PageIterator(
+      (offset2, l) => this.client.request(
+        "GET",
+        "/v1/scheduling/proposals",
+        void 0,
+        { ...filters, limit: l, offset: offset2 }
+      ),
+      limit,
+      offset
+    );
+  }
+  async get(id, options) {
+    return this.client.request(
+      "GET",
+      `/v1/scheduling/proposals/${id}`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  async respond(id, params, options) {
+    return this.client.request(
+      "POST",
+      `/v1/scheduling/proposals/${id}/respond`,
+      params,
+      void 0,
+      options
+    );
+  }
+  async resolve(id, options) {
+    return this.client.request(
+      "POST",
+      `/v1/scheduling/proposals/${id}/resolve`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+  async cancel(id, options) {
+    return this.client.request(
+      "POST",
+      `/v1/scheduling/proposals/${id}/cancel`,
+      void 0,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/usage.ts
+var UsageClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async get(options) {
+    return this.client.request("GET", "/v1/usage", void 0, void 0, options);
+  }
+};
+
+// src/resources/audit-log.ts
+var AuditLogClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list(params, options) {
+    const query = {
+      from: params?.from,
+      to: params?.to,
+      action: params?.action,
+      actor_key_prefix: params?.actor_key_prefix,
+      cursor: params?.cursor,
+      limit: params?.limit
+    };
+    return this.client.request("GET", "/v1/audit-log", void 0, query, options);
+  }
+};
+
+// src/resources/keys.ts
+var KeysClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params, options) {
+    return this.client.request("POST", "/v1/keys", params, void 0, options);
+  }
+  async list(options) {
+    const response = await this.client.request(
+      "GET",
+      "/v1/keys",
+      void 0,
+      void 0,
+      options
+    );
+    return response.keys;
+  }
+  async delete(id, options) {
+    await this.client.request("DELETE", `/v1/keys/${id}`, void 0, void 0, options);
+  }
+};
+
+// src/resources/agent-auth.ts
+var AgentAuthClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Register a new agent + org. Sends an OTP to the provided email.
+   *
+   * No authentication required — callers may construct a `Chronary` client
+   * with no `apiKey` to invoke this method.
+   *
+   * The response is a discriminated union:
+   *   - **New org path** — returns `org_id`, `agent_id`, and `api_key`.
+   *     The `api_key` is restricted to the verify endpoint until the OTP
+   *     is submitted successfully; after verification it unlocks the full API.
+   *   - **Existing-org dedup** — returns only `message`. No credentials are
+   *     leaked when the email matches an existing org (enumeration defense).
+   *
+   * Use `isAgentSignUpNewOrg()` to narrow the union before accessing keys.
+   *
+   * @throws ChronaryError (409 `tos_version_stale`) if `tos_version` is not
+   *   the currently-published version — retry with the value from the
+   *   `current_version` field on the error body.
+   */
+  async signUp(params, options) {
+    return this.client.request(
+      "POST",
+      "/v1/agent/sign-up",
+      params,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Submit the OTP sent during `signUp()` to unlock the API key.
+   *
+   * Must be invoked on a `Chronary` client constructed with the restricted
+   * `api_key` returned by `signUp()` — NOT on the client that issued
+   * `signUp()` itself (which had no key).
+   *
+   * @throws ChronaryError (status 400) when the OTP is wrong or expired.
+   *   The SDK's `ValidationError` class is reserved for HTTP 422; the
+   *   API returns 400 for invalid/expired OTPs, which surfaces as a
+   *   generic `ChronaryError` with the original message.
+   */
+  async verify(params, options) {
+    return this.client.request(
+      "POST",
+      "/v1/agent/verify",
+      params,
+      void 0,
+      options
+    );
+  }
+};
+function isAgentSignUpNewOrg(response) {
+  return "api_key" in response;
+}
+
+// src/resources/waitlist.ts
+var WaitlistClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Join the Chronary waitlist (#442). Used during private preview when open
+   * signup is gated. Creates a real organization row flagged as
+   * `is_waitlisted: true`; an admin flips the flag to activate the account.
+   *
+   * No authentication required — invoke on a `Chronary` client constructed
+   * with no `apiKey`.
+   *
+   * Idempotent on repeat hits: a second call with the same email returns
+   * the existing waitlisted org instead of erroring. An active (non-waitlisted)
+   * account at the same email returns 409 `email_taken`.
+   *
+   * @throws ChronaryError (409 `email_taken`) when an active account already
+   *   exists for this email — direct the user to sign-in instead.
+   * @throws ChronaryError (409 `tos_version_stale`) when the supplied
+   *   `tos_version` doesn't match the currently-published version.
+   * @throws ChronaryError (429 `rate_limit_error`) on the per-IP / per-email
+   *   waitlist limiter.
+   */
+  async join(params, options) {
+    return this.client.request(
+      "POST",
+      "/v1/waitlist",
+      params,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/feedback.ts
+var FeedbackClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Submit structured feedback (bug, feature, or friction) to Chronary.
+   *
+   * Rate-limited to 25 submissions per day per organization (UTC day).
+   * Available on all plans, including free. The 26th submission returns
+   * HTTP 429 with a `Retry-After` header set to the seconds until the
+   * next UTC midnight.
+   */
+  async submit(params, options) {
+    return this.client.request(
+      "POST",
+      "/v1/feedback",
+      params,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/plans.ts
+var PlansClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Fetch the public plan catalog (`GET /v1/plans`).
+   *
+   * Returns all sellable tiers (free, pro, scale) plus the enterprise
+   * tier with `custom_pricing: true`. No authentication required.
+   * Responses are cacheable for 5 minutes at the edge.
+   */
+  async list(options) {
+    return this.client.request("GET", "/v1/plans", void 0, void 0, options);
+  }
+};
+
+// src/resources/account.ts
+var AccountClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Export every row this org owns as a single JSON payload (GDPR Art. 15 + 20
+   * portability / CCPA right-to-know / EU Data Act interoperability).
+   *
+   * **Authentication:** This endpoint is JWT-only — it returns decrypted
+   * webhook secrets and iCal subscription URLs that aren't normally accessible
+   * via API-key endpoints. Configure the SDK with a console JWT (e.g. cookie
+   * value or Bearer token from the console session) as the `apiKey` config to
+   * call this. API keys (`chr_sk_*` / `chr_ak_*`) will return 401.
+   *
+   * In most cases, end users should download via the console UI at
+   * `console.chronary.ai/settings`. The SDK method exists for programmatic
+   * use cases (e.g. server-side compliance tooling holding a delegated JWT).
+   *
+   * **Rate limit:** 10 exports/hour/org.
+   */
+  async export(options) {
+    return this.client.request(
+      "GET",
+      "/v1/auth/export",
+      void 0,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/webhook-verify.ts
+var DEFAULT_TOLERANCE = 5 * 60 * 1e3;
+function bufToHex(buf) {
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function computeSignature(secret, timestamp, payload) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const message = encoder.encode(`${timestamp}.${payload}`);
+  const sig = await crypto.subtle.sign("HMAC", key, message);
+  return `sha256=${bufToHex(sig)}`;
+}
+function constantTimeEqual(a, b) {
+  const encoder = new TextEncoder();
+  const aBuf = encoder.encode(a);
+  const bBuf = encoder.encode(b);
+  if (aBuf.length !== bBuf.length) return false;
+  let diff = 0;
+  for (let i = 0; i < aBuf.length; i++) diff |= aBuf[i] ^ bBuf[i];
+  return diff === 0;
+}
+function getHeader(headers, name) {
+  if (headers instanceof Headers) return headers.get(name);
+  const record = headers;
+  const direct = record[name] ?? record[name.toLowerCase()];
+  if (direct !== void 0) return direct;
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(record)) {
+    if (key.toLowerCase() === lowerName) return value;
+  }
+  return null;
+}
+function extractHeaders(headers) {
+  const get = (name) => {
+    return getHeader(headers, name);
+  };
+  const signature = get("X-Signature") ?? get("x-signature");
+  const timestamp = get("X-Timestamp") ?? get("x-timestamp");
+  if (!signature) throw new ChronaryError("Missing X-Signature header", 0);
+  if (!timestamp) throw new ChronaryError("Missing X-Timestamp header", 0);
+  return { signature, timestamp };
+}
+async function verifySignature(rawBody, headers, secret, options) {
+  if (typeof rawBody !== "string") {
+    throw new ChronaryError(
+      "rawBody must be a string. If you parsed the JSON body, pass the raw string instead.",
+      0
+    );
+  }
+  const { signature, timestamp } = extractHeaders(headers);
+  const tolerance = options?.tolerance ?? DEFAULT_TOLERANCE;
+  const tsMs = parseInt(timestamp, 10) * 1e3;
+  const now = Date.now();
+  if (Math.abs(now - tsMs) > tolerance) {
+    throw new ChronaryError(
+      `Webhook timestamp too old. Received ${timestamp}, current time ${Math.floor(now / 1e3)}. Tolerance: ${tolerance / 1e3}s`,
+      0
+    );
+  }
+  const expected = await computeSignature(secret, timestamp, rawBody);
+  if (!constantTimeEqual(expected, signature)) {
+    throw new ChronaryError("Webhook signature verification failed", 0);
+  }
+}
+async function constructEvent(rawBody, headers, secret, options) {
+  await verifySignature(rawBody, headers, secret, options);
+  const type = getHeader(headers, "X-Chronary-Event-Type");
+  if (!type) throw new ChronaryError("Missing X-Chronary-Event-Type header", 0);
+  const data = JSON.parse(rawBody);
+  return { type, data };
+}
+
+// src/index.ts
+var Chronary = class {
+  agents;
+  calendars;
+  events;
+  availability;
+  webhooks;
+  icalSubscriptions;
+  scheduling;
+  usage;
+  auditLog;
+  keys;
+  agentAuth;
+  waitlist;
+  feedback;
+  plans;
+  account;
+  constructor(config) {
+    const client = new CoreClient(config);
+    this.agents = new AgentsClient(client);
+    this.calendars = new CalendarsClient(client);
+    this.events = new EventsClient(client);
+    this.availability = new AvailabilityClient(client);
+    this.webhooks = new WebhooksClient(client);
+    this.icalSubscriptions = new ICalSubscriptionsClient(client);
+    this.scheduling = new SchedulingClient(client);
+    this.usage = new UsageClient(client);
+    this.auditLog = new AuditLogClient(client);
+    this.keys = new KeysClient(client);
+    this.agentAuth = new AgentAuthClient(client);
+    this.waitlist = new WaitlistClient(client);
+    this.feedback = new FeedbackClient(client);
+    this.plans = new PlansClient(client);
+    this.account = new AccountClient(client);
+  }
+  static webhooks = {
+    verifySignature,
+    constructEvent
+  };
+};
+var index_default = Chronary;
+export {
+  APIPromise,
+  AuthenticationError,
+  Chronary,
+  ChronaryError,
+  ConnectionError,
+  CoreClient,
+  NotFoundError,
+  PageIterator,
+  QuotaExceededError,
+  RateLimitError,
+  TimeoutError,
+  VERSION,
+  ValidationError,
+  constructEvent,
+  index_default as default,
+  isAgentSignUpNewOrg,
+  verifySignature
+};
+//# sourceMappingURL=index.js.map