@chronary/sdk 0.1.3

package/dist/index.d.cts

@@ -0,0 +1,1016 @@
+/**
+ * APIPromise wraps a fetch call as a thenable so callers can `await` it
+ * for parsed data, or call `.withResponse()` to get both parsed data and the raw
+ * Response (headers, status, etc.).
+ *
+ * ```ts
+ * // Normal — just the data
+ * const agent = await client.agents.get('agt_1');
+ *
+ * // With response access
+ * const { data, response } = await client.agents.get('agt_1').withResponse();
+ * console.log(response.status);
+ * console.log(response.headers.get('x-request-id'));
+ * ```
+ */
+/**
+ * Parsed quota snapshot from the IETF `RateLimit` / `RateLimit-Policy` headers
+ * (draft-ietf-httpapi-ratelimit-headers). Present on responses from endpoints
+ * that enforce quotas (most authenticated routes); absent on unauthenticated
+ * or unlimited-plan responses.
+ */
+interface QuotaSnapshot {
+    /** Configured ceiling (e.g. `1_000_000` API calls/month). Parsed from `RateLimit-Policy`. */
+    limit: number;
+    /** Remaining quota in the current window. Parsed from `RateLimit`. */
+    remaining: number;
+    /** Wall-clock time when the window resets. Computed from the `t=` delta-seconds in `RateLimit`. */
+    resetAt: Date;
+}
+interface RawResponse {
+    status: number;
+    headers: Headers;
+    url: string;
+    /**
+     * Typed view of the IETF RateLimit headers when present. Use this instead of
+     * parsing `headers.get('ratelimit')` yourself. `undefined` for responses
+     * that don't emit quota headers (public endpoints, unlimited plans).
+     */
+    quota?: QuotaSnapshot;
+}
+interface WithResponse<T> {
+    data: T;
+    response: RawResponse;
+}
+/**
+ * APIPromise is a thenable that resolves to `T` when awaited, but also
+ * exposes `.withResponse()` to get both the data and raw HTTP response.
+ *
+ * Because it implements `.then()`, it can be awaited, used with `Promise.all()`,
+ * and chained with `.then()` / `.catch()` / `.finally()`.
+ */
+declare class APIPromise<T> implements PromiseLike<T> {
+    private innerPromise;
+    constructor(responsePromise: Promise<{
+        data: T;
+        rawResponse: RawResponse;
+    }>);
+    /**
+     * Returns both the parsed data and the raw HTTP response.
+     */
+    withResponse(): Promise<WithResponse<T>>;
+    /**
+     * Implements the thenable interface. When awaited, resolves to just the parsed data `T`.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    /**
+     * Attaches a rejection handler.
+     */
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    /**
+     * Attaches a handler that runs on both fulfillment and rejection.
+     */
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+
+interface ChronaryConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+    logLevel?: LogLevel;
+    fetch?: typeof globalThis.fetch;
+    appInfo?: AppInfo;
+    /**
+     * Extra headers to attach to every request. Used by wrapper packages
+     * (e.g. `chronary-mcp`) to set `X-Chronary-Client` so the API can
+     * attribute the wrapper's traffic separately from the bare TS SDK's.
+     * Header keys here override the SDK defaults — choose wisely.
+     */
+    extraHeaders?: Record<string, string>;
+}
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'off';
+interface AppInfo {
+    name: string;
+    version?: string;
+}
+interface RequestOptions {
+    signal?: AbortSignal;
+    timeout?: number;
+    idempotencyKey?: string;
+}
+interface PageResponse<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface Page<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+interface Agent {
+    id: string;
+    orgId: string;
+    name: string;
+    type: 'ai' | 'human' | 'resource';
+    description: string | null;
+    status: 'active' | 'paused' | 'decommissioned';
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateAgentParams {
+    name: string;
+    type: 'ai' | 'human' | 'resource';
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateAgentParams {
+    name?: string;
+    description?: string | null;
+    metadata?: Record<string, unknown>;
+    status?: 'active' | 'paused';
+}
+interface ListAgentsParams {
+    type?: 'ai' | 'human' | 'resource';
+    status?: 'active' | 'paused' | 'decommissioned';
+    limit?: number;
+    offset?: number;
+}
+interface Calendar {
+    id: string;
+    orgId: string;
+    agentId: string | null;
+    name: string;
+    timezone: string;
+    metadata: Record<string, unknown>;
+    ical_url: string;
+    deletedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateCalendarParams {
+    name: string;
+    timezone: string;
+    agent_status?: 'idle' | 'working' | 'waiting' | 'error';
+    metadata?: Record<string, unknown>;
+}
+interface UpdateCalendarParams {
+    name?: string;
+    timezone?: string;
+    agent_status?: 'idle' | 'working' | 'waiting' | 'error';
+    metadata?: Record<string, unknown>;
+}
+interface ListCalendarsParams {
+    agentId?: string;
+    include?: 'all';
+    limit?: number;
+    offset?: number;
+}
+type EventStatus = 'confirmed' | 'tentative' | 'cancelled' | 'hold';
+interface CalendarEvent {
+    id: string;
+    calendarId: string;
+    orgId: string;
+    title: string;
+    description: string | null;
+    startTime: string;
+    endTime: string;
+    allDay: boolean;
+    status: EventStatus;
+    source: 'internal' | 'external_ical';
+    metadata: Record<string, unknown>;
+    holdExpiresAt: string | null;
+    holdPriority: number | null;
+    deletedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateEventParams {
+    title: string;
+    start_time: string;
+    end_time: string;
+    description?: string;
+    all_day?: boolean;
+    status?: EventStatus;
+    metadata?: Record<string, unknown>;
+    /** ISO 8601 timestamp. Required when status='hold'. Must be 30s-15min in the future. */
+    hold_expires_at?: string;
+    /** Priority for conflict resolution. Only valid with status='hold'. 0-100. */
+    hold_priority?: number;
+}
+interface UpdateEventParams {
+    title?: string;
+    description?: string | null;
+    start_time?: string;
+    end_time?: string;
+    all_day?: boolean;
+    /** Holds cannot be updated via PATCH — use /confirm or /release instead. */
+    status?: 'confirmed' | 'tentative' | 'cancelled';
+    metadata?: Record<string, unknown>;
+}
+interface ListEventsParams {
+    calendarId?: string;
+    agentId?: string;
+    start_after?: string;
+    start_before?: string;
+    status?: EventStatus;
+    source?: 'internal' | 'external_ical';
+    limit?: number;
+    offset?: number;
+}
+type SlotDuration = '15m' | '30m' | '45m' | '1h' | '2h';
+interface AvailabilitySlot {
+    start: string;
+    end: string;
+}
+interface BusyBlock {
+    start: string;
+    end: string;
+    calendar_id?: string;
+    event_id?: string;
+}
+interface AvailabilityParams {
+    start: string;
+    end: string;
+    slot_duration?: SlotDuration;
+    include_busy?: boolean;
+}
+interface CrossAgentAvailabilityParams {
+    agents: string[];
+    start: string;
+    end: string;
+    slot_duration?: SlotDuration;
+    calendars?: string[];
+    include_busy?: boolean;
+}
+interface AvailabilityResponse {
+    agents: string[];
+    slots: AvailabilitySlot[];
+    per_agent_busy?: Record<string, BusyBlock[]>;
+}
+type AgentStatus = 'idle' | 'working' | 'waiting' | 'error';
+interface CalendarContext {
+    calendar_id: string;
+    now: string;
+    agent_status: AgentStatus;
+    current_event: CalendarEvent | null;
+    next_event: CalendarEvent | null;
+    recent_events: CalendarEvent[];
+    upcoming: CalendarEvent[];
+}
+interface WorkingHoursDay {
+    start: string;
+    end: string;
+}
+interface WorkingHours {
+    mon?: WorkingHoursDay;
+    tue?: WorkingHoursDay;
+    wed?: WorkingHoursDay;
+    thu?: WorkingHoursDay;
+    fri?: WorkingHoursDay;
+    sat?: WorkingHoursDay;
+    sun?: WorkingHoursDay;
+}
+interface AvailabilityRules {
+    id: string;
+    calendar_id: string;
+    buffer_before_minutes: number;
+    buffer_after_minutes: number;
+    working_hours: WorkingHours | null;
+    timezone: string;
+    created_at: string;
+    updated_at: string;
+}
+interface SetAvailabilityRulesParams {
+    buffer_before_minutes?: number;
+    buffer_after_minutes?: number;
+    working_hours?: WorkingHours | null;
+    timezone?: string;
+}
+interface Webhook {
+    id: string;
+    orgId: string;
+    url: string;
+    secret?: string;
+    events: string[];
+    active: boolean;
+    createdAt: string;
+}
+interface CreateWebhookParams {
+    url: string;
+    events: string[];
+}
+interface UpdateWebhookParams {
+    url?: string;
+    events?: string[];
+    active?: boolean;
+}
+interface ListWebhooksParams {
+    limit?: number;
+    offset?: number;
+}
+interface WebhookDelivery {
+    id: string;
+    subscription_id: string;
+    event_type: string;
+    status: 'pending' | 'delivered' | 'failed';
+    attempts: number;
+    last_attempt_at: string | null;
+    next_retry_at: string | null;
+    created_at: string;
+    payload?: Record<string, unknown>;
+}
+interface WebhookDeliveryStats {
+    pending: number;
+    delivered: number;
+    failed: number;
+}
+interface WebhookDeliveryListResponse {
+    data: WebhookDelivery[];
+    total: number;
+    limit: number;
+    offset: number;
+    stats: WebhookDeliveryStats;
+}
+interface ListWebhookDeliveriesParams {
+    limit?: number;
+    offset?: number;
+    status?: 'pending' | 'delivered' | 'failed';
+    include_payload?: boolean;
+}
+interface ICalSubscription {
+    id: string;
+    orgId: string;
+    agentId: string;
+    calendarId: string;
+    url: string;
+    label: string | null;
+    status: 'active' | 'error' | 'paused';
+    lastSyncedAt: string | null;
+    lastError: string | null;
+    createdAt: string;
+}
+interface CreateICalSubscriptionParams {
+    calendar_id: string;
+    url: string;
+    label?: string;
+}
+interface UpdateICalSubscriptionParams {
+    label?: string;
+    url?: string;
+}
+interface ListICalSubscriptionsParams {
+    agentId?: string;
+    status?: 'active' | 'error' | 'paused';
+    limit?: number;
+    offset?: number;
+}
+type ProposalStatus = 'pending' | 'confirmed' | 'expired' | 'cancelled';
+interface ProposalSlot {
+    id?: string;
+    start_time: string;
+    end_time: string;
+    weight?: number;
+    calendar_id?: string | null;
+}
+type ProposalResponseAction = 'accept' | 'decline' | 'counter';
+interface ProposalResponse {
+    id: string;
+    agent_id: string;
+    response: ProposalResponseAction;
+    selected_slot_id: string | null;
+    counter_slots: ProposalSlot[] | null;
+    message: string | null;
+    created_at: string;
+}
+interface ProposalSummary {
+    id: string;
+    title: string;
+    description: string | null;
+    organizer_agent_id: string;
+    participant_agent_ids: string[];
+    calendar_id: string;
+    status: ProposalStatus;
+    expires_at: string | null;
+    resolved_slot: ProposalSlot | null;
+    created_event_id: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface Proposal extends ProposalSummary {
+    slots: ProposalSlot[];
+    responses: ProposalResponse[];
+}
+interface CreateProposalParams {
+    title: string;
+    description?: string;
+    organizer_agent_id: string;
+    participant_agent_ids: string[];
+    calendar_id: string;
+    slots: ProposalSlot[];
+    expires_at?: string;
+    metadata?: Record<string, unknown>;
+}
+interface RespondToProposalParams {
+    agent_id: string;
+    response: ProposalResponseAction;
+    selected_slot_id?: string;
+    counter_slots?: ProposalSlot[];
+    message?: string;
+}
+interface ListProposalsParams {
+    status?: ProposalStatus;
+    organizer_agent_id?: string;
+    limit?: number;
+    offset?: number;
+}
+type ResolveProposalResponse = {
+    status: 'confirmed';
+    resolved_slot: ProposalSlot;
+} | {
+    status: 'cancelled';
+    reason: string;
+};
+interface CancelProposalResponse {
+    status: 'cancelled';
+}
+interface ScopedApiKey {
+    id: string;
+    key_prefix: string;
+    agent_id: string;
+    label: string | null;
+    created_at: string;
+}
+interface CreatedScopedApiKey extends ScopedApiKey {
+    key: string;
+}
+interface CreateScopedApiKeyParams {
+    agent_id: string;
+    label?: string;
+}
+interface UsageMetric {
+    used: number;
+    limit: number | null;
+}
+/**
+ * Temporal-hold lifecycle counters for the current period. Informational —
+ * not gated by any plan limit. The funnel identity
+ * `created = confirmed + expired + active` holds, where `active` is derived
+ * (not stored). Counts cover all three end-of-hold paths: TTL expiry,
+ * manual release, and priority-bump.
+ */
+interface HoldsUsage {
+    created: number;
+    confirmed: number;
+    expired: number;
+}
+/**
+ * Availability requests that touched more than one calendar in the current
+ * period. Informational — gated separately by the
+ * `cross_calendar_availability` capability, not by this counter.
+ */
+interface CrossCalendarQueriesUsage {
+    used: number;
+}
+interface Usage {
+    period_start: string;
+    period_end: string;
+    plan: string;
+    agents: UsageMetric;
+    calendars: UsageMetric;
+    events: UsageMetric;
+    api_calls: UsageMetric;
+    webhooks: UsageMetric;
+    availability_queries: UsageMetric;
+    ical_subscriptions: UsageMetric;
+    proposals: UsageMetric;
+    holds: HoldsUsage;
+    cross_calendar_queries: CrossCalendarQueriesUsage;
+}
+interface AuditLogEntry {
+    id: string;
+    action: string;
+    /** First 20 chars of the actor API key. Never the full key. */
+    actor_key_prefix: string | null;
+    /** Scoped-key agent ID when the actor used a chr_ak_* key. */
+    agent_id: string | null;
+    /** Entity IDs extracted from the request path (e.g. "agt_1/cal_2"). */
+    resource: string | null;
+    ip: string | null;
+    status: number;
+    method: string;
+    /** Route template with entity IDs replaced by :id placeholders. */
+    path: string;
+    duration_ms: number;
+    request_id: string | null;
+    created_at: string;
+}
+interface ListAuditLogParams {
+    /** Lower bound (inclusive, ISO-8601). Clamped to the retention window. */
+    from?: string;
+    /** Upper bound (inclusive, ISO-8601). Defaults to now. */
+    to?: string;
+    /** Filter by exact action name, e.g. "agent.create". */
+    action?: string;
+    /** Filter by the first 20 chars of the actor API key. */
+    actor_key_prefix?: string;
+    /** Opaque cursor from a previous response for keyset pagination. */
+    cursor?: string;
+    /** Page size (1–200). Defaults to 50. */
+    limit?: number;
+}
+interface AuditLogResponse {
+    data: AuditLogEntry[];
+    pagination: {
+        /** Opaque cursor for the next page. Null if no more results. */
+        next_cursor: string | null;
+    };
+    /**
+     * Audit-log retention window for the caller's plan (days).
+     * Null = unlimited (Custom tier, per-contract).
+     */
+    retention_days: number | null;
+    /**
+     * True when the requested `from` was outside the retention window and
+     * was clamped. Display an upgrade hint when this is true.
+     */
+    range_clamped: boolean;
+}
+type PlanId = 'free' | 'pro' | 'custom';
+interface PlanLimits {
+    agents: number | null;
+    calendars: number | null;
+    events: number | null;
+    api_calls: number | null;
+    webhook_deliveries: number | null;
+    availability_queries: number | null;
+    ical_subscriptions: number | null;
+    proposals: number | null;
+}
+interface Plan {
+    id: PlanId;
+    name: string;
+    tagline: string;
+    /** Recurring monthly amount in the smallest currency unit (USD cents). `null` for custom-priced tiers. */
+    price: number | null;
+    /** Lowercase ISO-4217 code. `null` for custom-priced tiers. */
+    currency: string | null;
+    /** Enforced caps. `null` for custom-priced tiers. */
+    limits: PlanLimits | null;
+    /** Marketing copy — not machine-readable. Use `limits` for capability checks. */
+    display_features: string[];
+    /** Hint for UIs to highlight a tier (currently `pro`). */
+    recommended: boolean;
+    /** Present and `true` for the enterprise tier. */
+    custom_pricing?: boolean;
+    /** Sales contact URL for custom-priced tiers. */
+    contact_url?: string;
+}
+interface PlansListResponse {
+    plans: Plan[];
+}
+interface AgentSignUpParams {
+    /** Email address to send the verification code to. */
+    email: string;
+    /** Display name of the signing-up agent (1–100 chars). */
+    agent_name: string;
+    /** Exact ToS version string the caller has accepted. */
+    tos_version: string;
+}
+/**
+ * Response when a new org was created. Includes credentials for the
+ * restricted "unverified" stage — use `api_key` to construct a second
+ * `Chronary` client and call `agentAuth.verify({ otp })`.
+ */
+interface AgentSignUpNewOrgResponse {
+    org_id: string;
+    agent_id: string;
+    /** API key. Limited to the verify endpoint until OTP succeeds. */
+    api_key: string;
+    /** Opaque confirmation — always `"Verification code sent to email"`. */
+    message: string;
+}
+/**
+ * Response when the email matched an existing org. To prevent enumeration,
+ * only a generic confirmation message is returned; no credentials.
+ */
+interface AgentSignUpExistingOrgResponse {
+    message: string;
+}
+type AgentSignUpResponse = AgentSignUpNewOrgResponse | AgentSignUpExistingOrgResponse;
+interface AgentVerifyParams {
+    /** Six-digit numeric code from the verification email. */
+    otp: string;
+}
+interface AgentVerifyResponse {
+    verified: true;
+    /** Opaque confirmation — always `"Full access unlocked"`. */
+    message: string;
+}
+interface WaitlistJoinParams {
+    /** Email address to join the waitlist with. */
+    email: string;
+    /** Optional display name. Derived from the email's local-part if omitted. */
+    name?: string;
+    /** Optional ToS version string the caller has accepted. */
+    tos_version?: string;
+}
+interface WaitlistedOrg {
+    id: string;
+    name: string;
+    email: string;
+    is_waitlisted: true;
+    waitlisted_at: string;
+    signup_source: string;
+}
+interface WaitlistJoinResponse {
+    data: WaitlistedOrg;
+    message: string;
+}
+type FeedbackType = 'bug' | 'feature' | 'friction';
+interface SubmitFeedbackParams {
+    type: FeedbackType;
+    /** Free-text description, 10–2000 characters. */
+    message: string;
+    /** Optional JSON metadata (SDK version, endpoint, error context, etc.). */
+    context?: Record<string, unknown>;
+}
+interface FeedbackAcceptedResponse {
+    status: 'accepted';
+}
+type WebhookEventType = 'agent.created' | 'agent.updated' | 'event.created' | 'event.updated' | 'event.deleted' | 'event.started' | 'event.ended' | 'event.hold_created' | 'event.hold_expired' | 'event.hold_released' | 'event.hold_confirmed' | 'proposal.created' | 'proposal.responded' | 'proposal.confirmed' | 'proposal.expired' | 'proposal.cancelled' | 'webhook.deactivated';
+interface WebhookEvent {
+    type: WebhookEventType;
+    data: Record<string, unknown>;
+}
+interface VerifyOptions {
+    tolerance?: number;
+}
+/**
+ * Response shape for `GET /v1/auth/export` (GDPR Art. 15 + 20 portability).
+ * Encrypted fields (event titles/descriptions, iCal URLs, webhook secrets)
+ * are returned in plaintext. Sensitive fields (key hashes, password hashes,
+ * OTP hashes, claim revocation tokens, internal scheduling state) are omitted.
+ */
+interface DataExport {
+    exported_at: string;
+    format_version: '1';
+    org: {
+        id: string;
+        name: string;
+        email: string;
+        plan: string;
+        signup_source: string;
+        status: string;
+        oauth_provider: string | null;
+        oauth_provider_id: string | null;
+        email_verified: boolean;
+        onboarding_completed_at: string | null;
+        accepted_terms_version: string | null;
+        accepted_terms_at: string | null;
+        created_at: string;
+        updated_at: string;
+    };
+    agents: unknown[];
+    calendars: unknown[];
+    events: unknown[];
+    availability_rules: unknown[];
+    ical_subscriptions: unknown[];
+    webhook_subscriptions: unknown[];
+    api_keys: unknown[];
+    scheduling_proposals: unknown[];
+    proposal_slots: unknown[];
+    proposal_responses: unknown[];
+    usage_records: unknown[];
+    quota_counters: unknown[];
+    tos_acceptances: unknown[];
+    account_claims_initiated: unknown[];
+    account_claims_targeting_this_org: unknown[];
+    feedback_submissions: unknown[];
+}
+
+declare class CoreClient {
+    readonly baseUrl: string;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly logLevel;
+    private readonly fetchFn;
+    private readonly userAgent;
+    private readonly extraHeaders;
+    constructor(config?: ChronaryConfig);
+    private log;
+    request<T>(method: string, path: string, body?: unknown, query?: Record<string, string | number | boolean | undefined>, options?: RequestOptions): APIPromise<T>;
+    private _request;
+    private buildUrl;
+    private buildError;
+    private retryDelay;
+}
+
+declare class PageIterator<T> implements AsyncIterable<T> {
+    private readonly fetchPage;
+    private readonly defaultLimit;
+    private readonly initialOffset;
+    constructor(fetchPage: (offset: number, limit: number) => PromiseLike<PageResponse<T>>, defaultLimit?: number, initialOffset?: number);
+    getPage(offset?: number, limit?: number): Promise<Page<T>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+
+declare class AgentsClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    /**
+     * 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.
+     */
+    create(params: CreateAgentParams, options?: RequestOptions): Promise<Agent>;
+    get(id: string, options?: RequestOptions): Promise<Agent>;
+    list(params?: ListAgentsParams): PageIterator<Agent>;
+    update(id: string, params: UpdateAgentParams, options?: RequestOptions): Promise<Agent>;
+    delete(id: string, options?: RequestOptions): Promise<void>;
+}
+
+declare class CalendarsClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    create(params: CreateCalendarParams & {
+        agentId?: string;
+    }, options?: RequestOptions): Promise<Calendar>;
+    get(id: string, options?: RequestOptions): Promise<Calendar>;
+    list(params?: ListCalendarsParams): PageIterator<Calendar>;
+    update(id: string, params: UpdateCalendarParams, options?: RequestOptions): Promise<Calendar>;
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    getContext(id: string, options?: RequestOptions): Promise<CalendarContext>;
+    setAvailabilityRules(id: string, params: SetAvailabilityRulesParams, options?: RequestOptions): Promise<AvailabilityRules>;
+    getAvailabilityRules(id: string, options?: RequestOptions): Promise<AvailabilityRules>;
+    deleteAvailabilityRules(id: string, options?: RequestOptions): Promise<void>;
+}
+
+declare class EventsClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    create(calendarId: string, params: CreateEventParams, options?: RequestOptions): Promise<CalendarEvent>;
+    get(calendarId: string, eventId: string, options?: RequestOptions): Promise<CalendarEvent>;
+    list(params?: ListEventsParams): PageIterator<CalendarEvent>;
+    update(calendarId: string, eventId: string, params: UpdateEventParams, options?: RequestOptions): Promise<CalendarEvent>;
+    delete(calendarId: string, eventId: string, options?: RequestOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    confirm(eventId: string, options?: RequestOptions): Promise<CalendarEvent>;
+    /**
+     * Manually release a held event before its TTL, freeing the slot. Fails with
+     * 409 if the event is not a hold.
+     */
+    release(eventId: string, options?: RequestOptions): Promise<CalendarEvent>;
+}
+
+declare class AvailabilityClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    forAgent(agentId: string, params: AvailabilityParams, options?: RequestOptions): Promise<AvailabilityResponse>;
+    forCalendar(calendarId: string, params: AvailabilityParams, options?: RequestOptions): Promise<AvailabilityResponse>;
+    check(params: CrossAgentAvailabilityParams, options?: RequestOptions): Promise<AvailabilityResponse>;
+}
+
+declare class WebhooksClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    create(params: CreateWebhookParams, options?: RequestOptions): Promise<Webhook>;
+    get(id: string, options?: RequestOptions): Promise<Webhook>;
+    list(params?: ListWebhooksParams): PageIterator<Webhook>;
+    update(id: string, params: UpdateWebhookParams, options?: RequestOptions): Promise<Webhook>;
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    listDeliveries(webhookId: string, params?: ListWebhookDeliveriesParams, options?: RequestOptions): Promise<WebhookDeliveryListResponse>;
+}
+
+declare class ICalSubscriptionsClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    create(agentId: string, params: CreateICalSubscriptionParams, options?: RequestOptions): Promise<ICalSubscription>;
+    get(id: string, options?: RequestOptions): Promise<ICalSubscription>;
+    list(params: ListICalSubscriptionsParams & {
+        agentId: string;
+    }): PageIterator<ICalSubscription>;
+    update(id: string, params: UpdateICalSubscriptionParams, options?: RequestOptions): Promise<ICalSubscription>;
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    sync(id: string, options?: RequestOptions): Promise<{
+        status: string;
+    }>;
+}
+
+declare class SchedulingClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    create(params: CreateProposalParams, options?: RequestOptions): Promise<ProposalSummary>;
+    list(params?: ListProposalsParams): PageIterator<ProposalSummary>;
+    get(id: string, options?: RequestOptions): Promise<Proposal>;
+    respond(id: string, params: RespondToProposalParams, options?: RequestOptions): Promise<ProposalResponse>;
+    resolve(id: string, options?: RequestOptions): Promise<ResolveProposalResponse>;
+    cancel(id: string, options?: RequestOptions): Promise<CancelProposalResponse>;
+}
+
+declare class UsageClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    get(options?: RequestOptions): Promise<Usage>;
+}
+
+declare class AuditLogClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    list(params?: ListAuditLogParams, options?: RequestOptions): Promise<AuditLogResponse>;
+}
+
+declare class KeysClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    create(params: CreateScopedApiKeyParams, options?: RequestOptions): Promise<CreatedScopedApiKey>;
+    list(options?: RequestOptions): Promise<ScopedApiKey[]>;
+    delete(id: string, options?: RequestOptions): Promise<void>;
+}
+
+declare class AgentAuthClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    /**
+     * 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.
+     */
+    signUp(params: AgentSignUpParams, options?: RequestOptions): Promise<AgentSignUpResponse>;
+    /**
+     * 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.
+     */
+    verify(params: AgentVerifyParams, options?: RequestOptions): Promise<AgentVerifyResponse>;
+}
+/**
+ * Type guard — narrows an `AgentSignUpResponse` to the new-org branch.
+ * The existing-org dedup branch returns only `message`, so this is the
+ * caller's cue that credentials are present.
+ */
+declare function isAgentSignUpNewOrg(response: AgentSignUpResponse): response is AgentSignUpNewOrgResponse;
+
+declare class WaitlistClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    /**
+     * 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.
+     */
+    join(params: WaitlistJoinParams, options?: RequestOptions): Promise<WaitlistJoinResponse>;
+}
+
+declare class FeedbackClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    /**
+     * 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.
+     */
+    submit(params: SubmitFeedbackParams, options?: RequestOptions): Promise<FeedbackAcceptedResponse>;
+}
+
+declare class PlansClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    /**
+     * 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.
+     */
+    list(options?: RequestOptions): Promise<PlansListResponse>;
+}
+
+declare class AccountClient {
+    private readonly client;
+    constructor(client: CoreClient);
+    /**
+     * 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.
+     */
+    export(options?: RequestOptions): Promise<DataExport>;
+}
+
+declare function verifySignature(rawBody: string, headers: Headers | Record<string, string>, secret: string, options?: VerifyOptions): Promise<void>;
+declare function constructEvent(rawBody: string, headers: Headers | Record<string, string>, secret: string, options?: VerifyOptions): Promise<WebhookEvent>;
+
+declare const VERSION = "0.1.3";
+
+declare class ChronaryError extends Error {
+    readonly status: number;
+    readonly requestId: string | undefined;
+    readonly headers: Headers | undefined;
+    readonly errorType: string | undefined;
+    constructor(message: string, status: number, requestId?: string, headers?: Headers, errorType?: string);
+}
+declare class AuthenticationError extends ChronaryError {
+    constructor(message: string, requestId?: string, headers?: Headers);
+}
+declare class RateLimitError extends ChronaryError {
+    readonly retryAfter: number | undefined;
+    constructor(message: string, requestId?: string, headers?: Headers);
+}
+declare class NotFoundError extends ChronaryError {
+    constructor(message: string, requestId?: string, headers?: Headers);
+}
+declare class ValidationError extends ChronaryError {
+    constructor(message: string, status: number, requestId?: string, headers?: Headers);
+}
+declare class QuotaExceededError extends ChronaryError {
+    constructor(message: string, requestId?: string, headers?: Headers);
+}
+declare class TimeoutError extends ChronaryError {
+    constructor(message: string);
+}
+declare class ConnectionError extends ChronaryError {
+    constructor(message: string);
+}
+
+declare class Chronary {
+    readonly agents: AgentsClient;
+    readonly calendars: CalendarsClient;
+    readonly events: EventsClient;
+    readonly availability: AvailabilityClient;
+    readonly webhooks: WebhooksClient;
+    readonly icalSubscriptions: ICalSubscriptionsClient;
+    readonly scheduling: SchedulingClient;
+    readonly usage: UsageClient;
+    readonly auditLog: AuditLogClient;
+    readonly keys: KeysClient;
+    readonly agentAuth: AgentAuthClient;
+    readonly waitlist: WaitlistClient;
+    readonly feedback: FeedbackClient;
+    readonly plans: PlansClient;
+    readonly account: AccountClient;
+    constructor(config?: ChronaryConfig);
+    static webhooks: {
+        verifySignature: typeof verifySignature;
+        constructEvent: typeof constructEvent;
+    };
+}
+
+export { APIPromise, type Agent, type AgentSignUpExistingOrgResponse, type AgentSignUpNewOrgResponse, type AgentSignUpParams, type AgentSignUpResponse, type AgentStatus, type AgentVerifyParams, type AgentVerifyResponse, type AppInfo, type AuditLogEntry, type AuditLogResponse, AuthenticationError, type AvailabilityParams, type AvailabilityResponse, type AvailabilityRules, type AvailabilitySlot, type BusyBlock, type Calendar, type CalendarContext, type CalendarEvent, type CancelProposalResponse, Chronary, type ChronaryConfig, ChronaryError, ConnectionError, CoreClient, type CreateAgentParams, type CreateCalendarParams, type CreateEventParams, type CreateICalSubscriptionParams, type CreateProposalParams, type CreateScopedApiKeyParams, type CreateWebhookParams, type CreatedScopedApiKey, type CrossAgentAvailabilityParams, type DataExport, type FeedbackAcceptedResponse, type FeedbackType, type ICalSubscription, type ListAgentsParams, type ListAuditLogParams, type ListCalendarsParams, type ListEventsParams, type ListICalSubscriptionsParams, type ListProposalsParams, type ListWebhookDeliveriesParams, type ListWebhooksParams, type LogLevel, NotFoundError, type Page, PageIterator, type PageResponse, type Plan, type PlanId, type PlanLimits, type PlansListResponse, type Proposal, type ProposalResponse, type ProposalResponseAction, type ProposalSlot, type ProposalStatus, type ProposalSummary, QuotaExceededError, type QuotaSnapshot, RateLimitError, type RawResponse, type RequestOptions, type ResolveProposalResponse, type RespondToProposalParams, type ScopedApiKey, type SetAvailabilityRulesParams, type SlotDuration, type SubmitFeedbackParams, TimeoutError, type UpdateAgentParams, type UpdateCalendarParams, type UpdateEventParams, type UpdateICalSubscriptionParams, type UpdateWebhookParams, type Usage, type UsageMetric, VERSION, ValidationError, type VerifyOptions, type WaitlistJoinParams, type WaitlistJoinResponse, type WaitlistedOrg, type Webhook, type WebhookDelivery, type WebhookDeliveryListResponse, type WebhookDeliveryStats, type WebhookEvent, type WebhookEventType, type WithResponse, type WorkingHours, type WorkingHoursDay, constructEvent, Chronary as default, isAgentSignUpNewOrg, verifySignature };