@atlasauth/backend 0.18.0 → 0.19.0

package/dist/client/status.d.ts

@@ -0,0 +1,200 @@
+import { type RequestFn } from './request';
+/**
+ * Atlas service status for your instance: the incident subscription (owner
+ * email, `status_incident.*` webhooks, a private RSS / Atom feed) filtered by
+ * region, component and impact; the incidents that concern you; and the
+ * upstream status pages (any Statuspage-compatible URL) your app depends on.
+ *
+ * The public Statuspage-compatible feed itself needs no key:
+ * `https://<frontend api>/v1/status/api/v2/summary.json` (and the other
+ * Statuspage files, RSS and Atom) — point any status page at it.
+ */
+export type StatusComponentId = 'frontend_api' | 'backend_api' | 'database' | 'cache' | 'background_jobs';
+export type StatusImpact = 'none' | 'minor' | 'major' | 'critical';
+export type StatusIncidentStatus = 'investigating' | 'identified' | 'monitoring' | 'resolved' | 'scheduled' | 'in_progress' | 'completed';
+export type StatusDependencyState = 'operational' | 'degraded' | 'partial_outage' | 'major_outage' | 'maintenance' | 'unknown';
+/** `GET /v1/status` (public). */
+export interface ServiceStatus {
+    object: 'status';
+    status: 'operational' | 'degraded' | 'major_outage';
+    updated_at: number;
+    regions: string[];
+    groups: Array<{
+        id: string;
+        name: string;
+        component_ids: string[];
+    }>;
+    components: Array<{
+        id: StatusComponentId;
+        name: string;
+        status: 'operational' | 'degraded' | 'major_outage' | 'unknown';
+        description: string;
+        group: string;
+        regions: string[];
+    }>;
+    incidents: Array<{
+        id: string;
+        kind: 'incident' | 'maintenance';
+        title: string;
+        status: StatusIncidentStatus;
+        impact: StatusImpact;
+        regions: string[];
+        component_ids: string[];
+        started_at: number;
+        resolved_at: number | null;
+        updated_at: number;
+    }>;
+}
+export interface StatusSubscription {
+    object: 'status_subscription';
+    /** A subscription exists (it may be disabled). */
+    subscribed: boolean;
+    enabled: boolean;
+    /** [] = every region. */
+    regions: string[];
+    /** [] = every component. */
+    component_ids: StatusComponentId[];
+    min_impact: 'minor' | 'major' | 'critical';
+    include_maintenance: boolean;
+    email_owners: boolean;
+    webhook: boolean;
+    /** The private feed; treat it as a secret (`rotateFeed` replaces it). */
+    rss_url: string | null;
+    atom_url: string | null;
+    available_regions: string[];
+    available_components: Array<{
+        id: StatusComponentId;
+        name: string;
+    }>;
+    updated_at: number | null;
+}
+export interface UpdateStatusSubscriptionBody {
+    enabled?: boolean;
+    regions?: string[];
+    component_ids?: StatusComponentId[];
+    min_impact?: 'minor' | 'major' | 'critical';
+    include_maintenance?: boolean;
+    email_owners?: boolean;
+    webhook?: boolean;
+}
+export interface StatusIncidentUpdate {
+    id: string;
+    status: StatusIncidentStatus;
+    body: string;
+    created_at: number;
+}
+export interface StatusIncident {
+    object: 'status_incident';
+    id: string;
+    kind: 'incident' | 'maintenance';
+    title: string;
+    status: StatusIncidentStatus;
+    impact: StatusImpact;
+    regions: string[];
+    component_ids: string[];
+    started_at: number;
+    resolved_at: number | null;
+    updated_at: number;
+    source: 'atlas' | 'import' | (string & {});
+    scheduled_for: number | null;
+    scheduled_until: number | null;
+    /** Oldest first. */
+    updates: StatusIncidentUpdate[];
+}
+/** `data` of the `status_incident.created` / `updated` / `resolved` webhook events. */
+export interface StatusIncidentEventData {
+    object: 'status_incident';
+    id: string;
+    kind: 'incident' | 'maintenance';
+    title: string;
+    status: StatusIncidentStatus;
+    impact: StatusImpact;
+    regions: string[];
+    component_ids: string[];
+    /** The part of the incident that matches your subscription. */
+    affected_regions: string[];
+    affected_component_ids: string[];
+    started_at: number;
+    resolved_at: number | null;
+    update: StatusIncidentUpdate;
+    /** The incident on the status page. */
+    url: string;
+}
+export interface StatusDependency {
+    object: 'status_dependency';
+    id: string;
+    name: string;
+    /** Base URL of the Statuspage-compatible page (Atlas reads `{url}/api/v2/summary.json`). */
+    url: string;
+    component_filter: string[];
+    enabled: boolean;
+    state: StatusDependencyState;
+    indicator: string | null;
+    description: string | null;
+    components: Array<{
+        id: string;
+        name: string;
+        status: string;
+    }>;
+    incidents: Array<{
+        id: string;
+        name: string;
+        status: string;
+        impact: string;
+        updatedAt: string | null;
+    }>;
+    last_checked_at: number | null;
+    last_success_at: number | null;
+    last_error: string | null;
+    /** The last check failed or none has succeeded yet: `state` may be out of date. */
+    stale: boolean;
+    created_at: number;
+}
+export interface CreateStatusDependencyBody {
+    name: string;
+    url: string;
+    component_filter?: string[];
+    enabled?: boolean;
+}
+export interface UpdateStatusDependencyBody {
+    name?: string;
+    component_filter?: string[];
+    enabled?: boolean;
+}
+export declare function statusResource(request: RequestFn): {
+    /** `GET /v1/status` — the public service status (components with group and regions, open incidents). */
+    service(): Promise<ServiceStatus>;
+    /** `GET /v1/instance/status_subscription`. */
+    getSubscription(): Promise<StatusSubscription>;
+    /** `PUT /v1/instance/status_subscription` — create or change it; only the fields sent change. */
+    updateSubscription(body: UpdateStatusSubscriptionBody): Promise<StatusSubscription>;
+    /** `DELETE /v1/instance/status_subscription` — turn it off (settings are kept). */
+    disableSubscription(): Promise<StatusSubscription>;
+    /** `POST /v1/instance/status_subscription/rotate_feed` — a new private feed URL; the old one 404s. */
+    rotateFeed(): Promise<StatusSubscription>;
+    /** `GET /v1/instance/status_incidents` — incidents that concern this instance, newest first. */
+    listIncidents(params?: {
+        open?: boolean;
+        limit?: number;
+    }): Promise<{
+        object: "list";
+        data: StatusIncident[];
+    }>;
+    /** `GET /v1/instance/status_dependencies` — with `state`, the worst among the enabled ones. */
+    listDependencies(): Promise<{
+        object: "list";
+        data: StatusDependency[];
+        state: StatusDependencyState;
+    }>;
+    /** `POST /v1/instance/status_dependencies` — read at once; the answer carries the state or `last_error`. */
+    createDependency(body: CreateStatusDependencyBody): Promise<StatusDependency>;
+    getDependency(id: string): Promise<StatusDependency>;
+    updateDependency(id: string, body: UpdateStatusDependencyBody): Promise<StatusDependency>;
+    deleteDependency(id: string): Promise<{
+        object: "status_dependency";
+        id: string;
+        deleted: true;
+    }>;
+    /** `POST /v1/instance/status_dependencies/:id/refresh` — read the page now. */
+    refreshDependency(id: string): Promise<StatusDependency>;
+};

package/dist/client/status.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusResource = statusResource;
+const request_1 = require("./request");
+function statusResource(request) {
+    return {
+        /** `GET /v1/status` — the public service status (components with group and regions, open incidents). */
+        service() {
+            return request({ method: 'GET', path: '/v1/status' });
+        },
+        /** `GET /v1/instance/status_subscription`. */
+        getSubscription() {
+            return request({ method: 'GET', path: '/v1/instance/status_subscription' });
+        },
+        /** `PUT /v1/instance/status_subscription` — create or change it; only the fields sent change. */
+        updateSubscription(body) {
+            return request({ method: 'PUT', path: '/v1/instance/status_subscription', body });
+        },
+        /** `DELETE /v1/instance/status_subscription` — turn it off (settings are kept). */
+        disableSubscription() {
+            return request({ method: 'DELETE', path: '/v1/instance/status_subscription' });
+        },
+        /** `POST /v1/instance/status_subscription/rotate_feed` — a new private feed URL; the old one 404s. */
+        rotateFeed() {
+            return request({ method: 'POST', path: '/v1/instance/status_subscription/rotate_feed' });
+        },
+        /** `GET /v1/instance/status_incidents` — incidents that concern this instance, newest first. */
+        listIncidents(params = {}) {
+            return request({ method: 'GET', path: '/v1/instance/status_incidents', query: { ...params } });
+        },
+        /** `GET /v1/instance/status_dependencies` — with `state`, the worst among the enabled ones. */
+        listDependencies() {
+            return request({ method: 'GET', path: '/v1/instance/status_dependencies' });
+        },
+        /** `POST /v1/instance/status_dependencies` — read at once; the answer carries the state or `last_error`. */
+        createDependency(body) {
+            return request({ method: 'POST', path: '/v1/instance/status_dependencies', body });
+        },
+        getDependency(id) {
+            return request({ method: 'GET', path: `/v1/instance/status_dependencies/${(0, request_1.enc)(id)}` });
+        },
+        updateDependency(id, body) {
+            return request({ method: 'PATCH', path: `/v1/instance/status_dependencies/${(0, request_1.enc)(id)}`, body });
+        },
+        deleteDependency(id) {
+            return request({ method: 'DELETE', path: `/v1/instance/status_dependencies/${(0, request_1.enc)(id)}` });
+        },
+        /** `POST /v1/instance/status_dependencies/:id/refresh` — read the page now. */
+        refreshDependency(id) {
+            return request({ method: 'POST', path: `/v1/instance/status_dependencies/${(0, request_1.enc)(id)}/refresh` });
+        },
+    };
+}
+//# sourceMappingURL=status.js.map

package/dist/client/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/client/status.ts"],"names":[],"mappings":";;AA8JA,wCAgDC;AA9MD,uCAAgD;AA8JhD,SAAgB,cAAc,CAAC,OAAkB;IAC/C,OAAO;QACL,wGAAwG;QACxG,OAAO;YACL,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,8CAA8C;QAC9C,eAAe;YACb,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kCAAkC,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,iGAAiG;QACjG,kBAAkB,CAAC,IAAkC;YACnD,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kCAAkC,EAAE,IAAI,EAAE,CAAC,CAAC;QACpF,CAAC;QACD,mFAAmF;QACnF,mBAAmB;YACjB,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,kCAAkC,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,sGAAsG;QACtG,UAAU;YACR,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,8CAA8C,EAAE,CAAC,CAAC;QAC3F,CAAC;QACD,gGAAgG;QAChG,aAAa,CAAC,SAA6C,EAAE;YAC3D,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,+BAA+B,EAAE,KAAK,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC,CAAC;QACjG,CAAC;QACD,+FAA+F;QAC/F,gBAAgB;YACd,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kCAAkC,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,4GAA4G;QAC5G,gBAAgB,CAAC,IAAgC;YAC/C,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kCAAkC,EAAE,IAAI,EAAE,CAAC,CAAC;QACrF,CAAC;QACD,aAAa,CAAC,EAAU;YACtB,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oCAAoC,IAAA,aAAG,EAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QACzF,CAAC;QACD,gBAAgB,CAAC,EAAU,EAAE,IAAgC;YAC3D,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,oCAAoC,IAAA,aAAG,EAAC,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QACjG,CAAC;QACD,gBAAgB,CAAC,EAAU;YACzB,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,oCAAoC,IAAA,aAAG,EAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC5F,CAAC;QACD,+EAA+E;QAC/E,iBAAiB,CAAC,EAAU;YAC1B,OAAO,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,oCAAoC,IAAA,aAAG,EAAC,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;QAClG,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/client/webhooks.d.ts

@@ -1,13 +1,98 @@
+import { type ProvisioningFields, type ProvisioningInput, type ProvisioningMetadata } from './compliance';
 import { type RequestFn } from './request';
-export interface WebhookEndpoint {
+export type WebhookDestinationType = 'https' | 'aws_eventbridge' | 'gcp_pubsub' | 'cloudflare_queue';
+/** Where deliveries go. Credentials are never returned. */
+export type WebhookDestination = {
+    type: 'https';
+} | {
+    type: 'aws_eventbridge';
+    region: string;
+    event_bus_name: string;
+    source?: string;
+} | {
+    type: 'gcp_pubsub';
+    project_id: string;
+    topic_id: string;
+} | {
+    type: 'cloudflare_queue';
+    account_id: string;
+    queue_id: string;
+};
+/** Your own credentials for an event destination (stored encrypted, write-only). */
+export type WebhookDestinationCredentials = {
+    access_key_id: string;
+    secret_access_key: string;
+    session_token?: string;
+} | {
+    service_account_json: string | Record<string, unknown>;
+} | {
+    api_token: string;
+};
+export interface WebhookLastFailure {
+    at: number;
+    status: number | null;
+    error: string | null;
+}
+export interface WebhookAutoDisableRule {
+    after_failing_ms: number;
+    after_consecutive_failures: number;
+    consecutive_failures_min_failing_ms: number;
+    description: string;
+}
+export interface WebhookRetention {
+    events_days: number;
+    delivery_log_days: number;
+    replay_window_days: number;
+}
+export interface WebhookEndpoint extends ProvisioningFields {
     object: 'webhook_endpoint';
     id: string;
+    /** The HTTPS receiver, or a descriptor such as `aws-eventbridge://us-east-1/default`. */
     url: string;
+    description?: string | null;
     enabled_events: string[];
+    /** Which names `*` delivers under. */
+    event_naming?: 'canonical' | 'legacy';
     active: boolean;
+    /** A third-party receiver: preflight does not flag its host. */
+    external?: boolean;
+    signature_versions?: Array<'v1' | 'v2'>;
+    destination?: WebhookDestination & {
+        credentials_set?: boolean;
+    };
+    health?: 'healthy' | 'failing' | 'disabled';
     /** Start of the current failure streak (epoch ms), or null when the last delivery succeeded. */
     failing_since?: number | null;
+    /** Start of the streak that preceded the last re-enable (epoch ms); what `since: 'failing_since'` resolves to once the live streak is cleared. */
+    last_failing_since?: number | null;
     disabled_at: number | null;
+    last_success_at?: number | null;
+    last_failure?: WebhookLastFailure | null;
+    consecutive_failures?: number;
+    /** Share of attempts in the last 24 hours that succeeded (0–1), null with none. */
+    success_rate_24h?: number | null;
+    attempts_24h?: {
+        succeeded: number;
+        failed: number;
+    };
+    /** Who is emailed when it fails; null = the account's owners. */
+    alert_contacts?: string[] | null;
+    alerts_sent?: {
+        first_sent_at: number | null;
+        second_sent_at: number | null;
+        disabled_sent_at: number | null;
+    };
+    auto_disable?: WebhookAutoDisableRule;
+    /** On an update that re-enabled the endpoint: the replay that re-sends what it missed. */
+    replay?: {
+        since: number;
+        method: 'POST';
+        path: string;
+        note: string;
+    } | null;
+    /** On create / upsert: whether this call created it. */
+    created?: boolean;
+    updated_at?: number;
     /**
      * While a secret rotation overlap is open: when the previous secret stops
      * signing deliveries (epoch ms). Until then every delivery carries two
@@ -24,8 +109,9 @@ export interface WebhookDelivery {
     object: 'webhook_delivery';
     id: string;
     event_id: string;
-    /** The event type, or null once the event has passed its retention. */
+    /** The name the event was delivered as, or null once the event has passed its retention. */
     event_type?: string | null;
+    latency_ms?: number | null;
     attempt_number: number;
     max_attempts?: number;
     /** The payload that was sent (null once the event has passed its retention). */
@@ -45,16 +131,95 @@ export interface WebhookDelivery {
     delivered_at: number | null;
     created_at: number;
 }
-export interface CreateWebhookEndpointBody {
-    url: string;
-    /** Each entry is `"*"` or a known event name. */
+export interface WebhookEndpointSettings {
+    /** Each entry is `"*"` or an event name (canonical or a deprecated spelling). */
     enabled_events?: string[];
+    event_naming?: 'canonical' | 'legacy';
+    external?: boolean;
+    signature_versions?: Array<'v1' | 'v2'>;
+    /** Up to 20 addresses; null = the account's owners. */
+    alert_contacts?: string[] | null;
+    description?: string | null;
+    /** An event destination instead of an HTTPS url. */
+    destination?: WebhookDestination;
+    destination_credentials?: WebhookDestinationCredentials;
+}
+export interface CreateWebhookEndpointBody extends WebhookEndpointSettings, ProvisioningInput {
+    /** Required unless `destination` is an event destination. */
+    url?: string;
 }
 /** Change an endpoint in place. The signing secret is kept. */
-export interface UpdateWebhookEndpointBody {
+export interface UpdateWebhookEndpointBody extends WebhookEndpointSettings {
     url?: string;
-    enabled_events?: string[];
     active?: boolean;
+    /** Replaces the provisioning metadata. */
+    metadata?: ProvisioningMetadata;
+}
+/** Find-or-create by url. */
+export interface UpsertWebhookEndpointBody extends WebhookEndpointSettings {
+    url: string;
+}
+/** The inline result of `test(id, { wait })`. */
+export interface WebhookTestResult {
+    object: 'webhook_test_result';
+    delivery_id: string;
+    event_id: string;
+    status: 'success' | 'failed';
+    http_status: number | null;
+    latency_ms: number | null;
+    response_snippet: string | null;
+    error: string | null;
+    signature_header_sent: string | null;
+    will_retry: boolean;
+}
+export interface WebhookWindow {
+    /** Epoch ms or ISO 8601 (at most 90 days ago), or the keyword `'failing_since'` for the endpoint's own failure streak. */
+    since?: number | string;
+    until?: number | string;
+}
+export interface WebhookBulkResult {
+    object: 'webhook_redelivery' | 'webhook_replay';
+    endpoint_id: string;
+    queued: number;
+    events_considered?: number;
+    has_more: boolean;
+    /** Pass as `since` to continue. */
+    next_since: number | null;
+    retention: WebhookRetention;
+}
+export interface EgressIps {
+    object: 'egress_ips';
+    /** false: this deployment does not send from fixed addresses. */
+    static: boolean;
+    ipv4: string[];
+    ipv6: string[];
+    applies_to: string[];
+    note: string;
+}
+export type DeliveryTargetKind = 'webhook_endpoint' | 'referral_connection' | 'backchannel_receiver' | 'integration';
+export interface DeliveryHealth {
+    object: 'delivery_health';
+    kind: DeliveryTargetKind;
+    target_id: string;
+    url: string | null;
+    label: string | null;
+    state: 'healthy' | 'failing' | 'disabled';
+    failing_since: number | null;
+    disabled_at: number | null;
+    last_success_at: number | null;
+    last_failure: WebhookLastFailure | null;
+    consecutive_failures: number;
+    success_rate_24h: number | null;
+    attempts_24h: {
+        succeeded: number;
+        failed: number;
+    };
+    alert_contacts: string[] | null;
+    alerts: {
+        first_sent_at: number | null;
+        second_sent_at: number | null;
+        disabled_sent_at: number | null;
+    };
 }
 /** One subscribable event, described. */
 export interface WebhookEventCatalogEntry {
@@ -62,8 +227,18 @@ export interface WebhookEventCatalogEntry {
     description: string;
     /** Who should act on it, e.g. `rp_sessions`, `rp_accounts`, `dsar`. Empty: no relying party needs it. */
     relevant_for: string[];
-    /** Set on a superseded spelling: subscribe to this event instead. */
+    /** Set on a deprecated spelling: subscribe to this canonical event instead. */
     deprecated_alias_of?: string;
+    /** `rename`: sent whenever the canonical event is; `companion`: only for some occurrences. */
+    alias_kind?: 'rename' | 'companion';
+    deprecated_at?: string;
+    /** After this the deprecated spelling is no longer sent (ISO 8601). */
+    sunset_at?: string;
+    /** JSON pointer to this event's payload schema in the OpenAPI document (`components.schemas.WebhookEvent.<name>`). */
+    payload_schema?: string;
+    version?: number;
+    /** When the event became available (YYYY-MM-DD). */
+    since?: string;
 }
 /** The endpoint list plus the delivery settings that apply to every endpoint. */
 export interface WebhookEndpointList {
@@ -81,6 +256,15 @@ export interface WebhookEndpointList {
     retry_schedule_ms?: number[];
     /** Delivery attempts per event before it is marked failed. */
     max_attempts?: number;
+    auto_disable?: WebhookAutoDisableRule;
+    retention?: WebhookRetention;
+    signature_versions?: string[];
+    destination_types?: Array<{
+        type: WebhookDestinationType;
+        name: string;
+        config: string[];
+        credentials: string[];
+    }>;
 }
 export interface WebhookSigningSecret {
     object: 'webhook_secret';
@@ -110,12 +294,33 @@ export interface WebhookDeliveryQueued {
     note: string;
 }
 export interface ListWebhookDeliveriesParams {
-    /** How many deliveries to return (1–100, default 50). */
+    /** How many deliveries to return (1–1000, default 50). */
     limit?: number;
+    starting_after?: string;
+    status?: 'pending' | 'success' | 'failed';
+    /** Comma-separated event names. */
+    event_type?: string;
+    /** Epoch ms or ISO 8601. */
+    since?: number | string;
+    until?: number | string;
 }
 export declare function webhooksResource(request: RequestFn): {
     endpoints: {
-        list(): Promise<WebhookEndpointList>;
+        /** `includeDeprecated` adds the deprecated event spellings to the catalogue. */
+        /** `metadata` filters on provisioning tags (`?metadata[key]=value`). */
+        list(opts?: {
+            includeDeprecated?: boolean;
+            metadata?: ProvisioningMetadata;
+        }): Promise<WebhookEndpointList>;
+        get(id: string): Promise<WebhookEndpoint>;
+        /**
+         * Find-or-create by url: updates the endpoint with this url to `body`, or
+         * creates it (then `secret` is in the result, once). Safe to run on every deploy.
+         */
+        upsertByUrl(body: UpsertWebhookEndpointBody, idempotencyKey?: string): Promise<WebhookEndpoint & {
+            secret?: string;
+            created: boolean;
+        }>;
         /** Update url, enabled_events or active. The signing secret is kept. */
         update(id: string, body: UpdateWebhookEndpointBody): Promise<WebhookEndpoint>;
         /** Show the current signing secret again. Audited. */
@@ -126,8 +331,23 @@ export declare function webhooksResource(request: RequestFn): {
          * every delivery is signed with both, so a verifier holding either passes.
          */
         rotateSecret(id: string, body?: RotateWebhookSecretBody): Promise<WebhookSigningSecret>;
-        /** Send a synthetic `webhook.test` event to this endpoint only. */
+        /** Send a synthetic `webhook.test` event to this endpoint only (queued for the worker). */
         test(id: string): Promise<WebhookDeliveryQueued>;
+        /**
+         * Send `webhook.test` now and return the result: status, HTTP status,
+         * latency, response snippet, error and the signature header sent.
+         * `wait` is at most 10 s (`'10s'`, `'5000ms'`).
+         */
+        testNow(id: string, wait?: string): Promise<WebhookTestResult>;
+        /** Bulk redeliver every event whose latest attempt in the window has `status` (default failed). */
+        redeliverWindow(id: string, body?: WebhookWindow & {
+            status?: "failed" | "success";
+        }, idempotencyKey?: string): Promise<WebhookBulkResult>;
+        /** Re-send everything since `since` the endpoint subscribes to and has not received. */
+        replay(id: string, body: WebhookWindow & {
+            since: number | string;
+            event_type?: string;
+        }, idempotencyKey?: string): Promise<WebhookBulkResult>;
         /** Redeliver a past event as a fresh attempt (409 once past its retention). */
         redeliver(id: string, deliveryId: string): Promise<WebhookDeliveryQueued>;
         create(body: CreateWebhookEndpointBody, idempotencyKey?: string): Promise<WebhookEndpointWithSecret>;
@@ -143,6 +363,19 @@ export declare function webhooksResource(request: RequestFn): {
         has_more: boolean;
         next_cursor?: string | null;
     }>;
+    /** The addresses deliveries leave from (public). */
+    egressIps(): Promise<EgressIps>;
+    /** Delivery health of every outbound target (webhooks, referral connection, back-channel receivers, integrations). */
+    health(params?: {
+        kind?: DeliveryTargetKind;
+        state?: "unhealthy" | "all";
+    }): Promise<{
+        data: DeliveryHealth[];
+        has_more: boolean;
+        unhealthy_count: number;
+    }>;
+    /** Set who is emailed when a target fails (null = the account's owners). */
+    setAlertContacts(kind: DeliveryTargetKind, targetId: string, alertContacts: string[] | null): Promise<DeliveryHealth>;
     /** Redeliver a past event (same as `endpoints.redeliver`). */
     redeliver(endpointId: string, deliveryId: string): Promise<WebhookDeliveryQueued>;
 };

package/dist/client/webhooks.js

@@ -1,12 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webhooksResource = webhooksResource;
+const compliance_1 = require("./compliance");
 const request_1 = require("./request");
 function webhooksResource(request) {
     return {
         endpoints: {
-            list() {
-                return request({ method: 'GET', path: '/v1/webhook_endpoints' });
+            /** `includeDeprecated` adds the deprecated event spellings to the catalogue. */
+            /** `metadata` filters on provisioning tags (`?metadata[key]=value`). */
+            list(opts = {}) {
+                return request({
+                    method: 'GET',
+                    path: '/v1/webhook_endpoints',
+                    query: { ...(opts.includeDeprecated ? { include_deprecated: 'true' } : {}), ...(0, compliance_1.metadataQuery)(opts.metadata) },
+                });
+            },
+            get(id) {
+                return request({ method: 'GET', path: `/v1/webhook_endpoints/${(0, request_1.enc)(id)}` });
+            },
+            /**
+             * Find-or-create by url: updates the endpoint with this url to `body`, or
+             * creates it (then `secret` is in the result, once). Safe to run on every deploy.
+             */
+            upsertByUrl(body, idempotencyKey) {
+                return request({ method: 'PUT', path: '/v1/webhook_endpoints/by_url', body, idempotencyKey });
             },
             /** Update url, enabled_events or active. The signing secret is kept. */
             update(id, body) {
@@ -24,10 +41,26 @@ function webhooksResource(request) {
             rotateSecret(id, body) {
                 return request({ method: 'POST', path: `/v1/webhook_endpoints/${(0, request_1.enc)(id)}/rotate_secret`, body });
             },
-            /** Send a synthetic `webhook.test` event to this endpoint only. */
+            /** Send a synthetic `webhook.test` event to this endpoint only (queued for the worker). */
             test(id) {
                 return request({ method: 'POST', path: `/v1/webhook_endpoints/${(0, request_1.enc)(id)}/test` });
             },
+            /**
+             * Send `webhook.test` now and return the result: status, HTTP status,
+             * latency, response snippet, error and the signature header sent.
+             * `wait` is at most 10 s (`'10s'`, `'5000ms'`).
+             */
+            testNow(id, wait = '10s') {
+                return request({ method: 'POST', path: `/v1/webhook_endpoints/${(0, request_1.enc)(id)}/test`, query: { wait } });
+            },
+            /** Bulk redeliver every event whose latest attempt in the window has `status` (default failed). */
+            redeliverWindow(id, body = {}, idempotencyKey) {
+                return request({ method: 'POST', path: `/v1/webhook_endpoints/${(0, request_1.enc)(id)}/redeliver`, body, idempotencyKey });
+            },
+            /** Re-send everything since `since` the endpoint subscribes to and has not received. */
+            replay(id, body, idempotencyKey) {
+                return request({ method: 'POST', path: `/v1/webhook_endpoints/${(0, request_1.enc)(id)}/replay`, body, idempotencyKey });
+            },
             /** Redeliver a past event as a fresh attempt (409 once past its retention). */
             redeliver(id, deliveryId) {
                 return request({
@@ -50,6 +83,22 @@ function webhooksResource(request) {
                 query: { ...params },
             });
         },
+        /** The addresses deliveries leave from (public). */
+        egressIps() {
+            return request({ method: 'GET', path: '/v1/meta/egress_ips' });
+        },
+        /** Delivery health of every outbound target (webhooks, referral connection, back-channel receivers, integrations). */
+        health(params = {}) {
+            return request({ method: 'GET', path: '/v1/delivery_health', query: { ...params } });
+        },
+        /** Set who is emailed when a target fails (null = the account's owners). */
+        setAlertContacts(kind, targetId, alertContacts) {
+            return request({
+                method: 'PUT',
+                path: `/v1/delivery_health/${(0, request_1.enc)(kind)}/${(0, request_1.enc)(targetId)}/alert_contacts`,
+                body: { alert_contacts: alertContacts },
+            });
+        },
         /** Redeliver a past event (same as `endpoints.redeliver`). */
         redeliver(endpointId, deliveryId) {
             return request({