@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/documents/index.js

@@ -1,4 +1,4 @@
-import { createPage, ValidationError } from '@sixtyninecommerce/core';
+import { createPage, idempotencyKey as mintIdempotencyKey, pageFromVendureList, readOffsetCursor, ValidationError, } from '@sixtyninecommerce/core';
 const API_DOCUMENT_TYPE = {
     invoice: 'INVOICE',
     'credit-note': 'CREDIT_NOTE',
@@ -10,6 +10,18 @@ const API_DOCUMENT_TYPE = {
  * dropped the overflow — a document is a page, not a feed.
  */
 export const MAX_DOCUMENT_EXTENSIONS = 10;
+const DOCUMENT_LINE_FIELDS = /* GraphQL */ `
+  description
+  sku
+  orderLineId
+  quantity
+  unitPriceNet
+  unitPriceWithTax
+  taxRate
+  lineTotalNet
+  lineTotalWithTax
+  unitPriceBasis
+`;
 const INVOICE_FIELDS = /* GraphQL */ `
   id
   invoiceNumber
@@ -21,7 +33,13 @@ const INVOICE_FIELDS = /* GraphQL */ `
   currencyCode
   note
   voidedOn
+  reversedByCreditNoteId
+  supersededByInvoiceId
+  reissueOfInvoiceId
   kind
+  supplementsInvoiceId
+  lines { ${DOCUMENT_LINE_FIELDS} }
+  numberingProvider
   createdAt
 `;
 const CREDIT_NOTE_FIELDS = /* GraphQL */ `
@@ -33,6 +51,11 @@ const CREDIT_NOTE_FIELDS = /* GraphQL */ `
   reason
   invoiceId
   kind
+  reversalOfInvoiceId
+  returnId
+  lines { ${DOCUMENT_LINE_FIELDS} }
+  refundId
+  numberingProvider
   storageKey
   createdAt
 `;
@@ -88,6 +111,15 @@ export const DOCUMENT_DATA_QUERY = /* GraphQL */ `
     documentData(documentId: $documentId, type: $type)
   }
 `;
+export const CREATE_DOCUMENT_DOWNLOAD_URL_MUTATION = /* GraphQL */ `
+  mutation CreateDocumentDownloadUrl($documentId: ID!, $type: DocumentType!) {
+    createDocumentDownloadUrl(documentId: $documentId, type: $type) {
+      url
+      expiresAt
+      filename
+    }
+  }
+`;
 export const ORDER_INVOICES_QUERY = /* GraphQL */ `
   query OrderInvoices($orderId: ID!) {
     orderInvoices(orderId: $orderId) { ${INVOICE_FIELDS} }
@@ -98,6 +130,20 @@ export const ORDER_CREDIT_NOTES_QUERY = /* GraphQL */ `
     orderCreditNotes(orderId: $orderId) { ${CREDIT_NOTE_FIELDS} }
   }
 `;
+export const CUSTOMER_DOCUMENTS_QUERY = /* GraphQL */ `
+  query CustomerDocuments($customerId: ID!, $options: CustomerDocumentListOptions) {
+    customerDocuments(customerId: $customerId, options: $options) {
+      totalItems
+      items {
+        type
+        orderId
+        orderCode
+        invoice { ${INVOICE_FIELDS} }
+        creditNote { ${CREDIT_NOTE_FIELDS} }
+      }
+    }
+  }
+`;
 export const PREVIEW_INVOICE_MUTATION = /* GraphQL */ `
   mutation PreviewInvoice($orderId: ID!, $invoicedOn: String!, $languageCode: String, $note: String) {
     previewInvoice(orderId: $orderId, invoicedOn: $invoicedOn, languageCode: $languageCode, note: $note)
@@ -108,6 +154,23 @@ export const SEND_INVOICE_EMAIL_MUTATION = /* GraphQL */ `
     sendInvoiceEmail(input: $input)
   }
 `;
+export const SEND_CREDIT_NOTE_EMAIL_MUTATION = /* GraphQL */ `
+  mutation SendCreditNoteEmail($input: SendCreditNoteEmailInput!) {
+    sendCreditNoteEmail(input: $input)
+  }
+`;
+export const ORDER_CREDIT_NOTE_EMAIL_SENDS_QUERY = /* GraphQL */ `
+  query OrderCreditNoteEmailSends($orderId: ID!) {
+    orderCreditNoteEmailSends(orderId: $orderId) {
+      id
+      orderId
+      creditNoteId
+      recipientsTo
+      recipientsCc
+      createdAt
+    }
+  }
+`;
 export const ISSUE_PARTIAL_CREDIT_NOTE_MUTATION = /* GraphQL */ `
   mutation IssuePartialCreditNote($input: IssuePartialCreditNoteInput!) {
     issuePartialCreditNote(input: $input) { ${CREDIT_NOTE_FIELDS} }
@@ -118,6 +181,98 @@ export const ISSUE_SUPPLEMENTARY_INVOICE_MUTATION = /* GraphQL */ `
     issueSupplementaryInvoice(input: $input) { ${INVOICE_FIELDS} }
   }
 `;
+const TOTALS_FIELDS = /* GraphQL */ `
+  net
+  tax
+  gross
+  taxSummary { taxRate net tax gross }
+`;
+const INVOICE_CORRECTION_PLAN_FIELDS = /* GraphQL */ `
+      planHash
+      ledger
+      invoice { id invoiceNumber kind totalWithTax creditable currencyCode orderIds voidedOn }
+      outcomes {
+        outcome
+        available
+        unavailableCode
+        unavailableMessage
+        document
+        needsLines
+        prefillsLines
+        needsAddresses
+        allowsRefund
+        allowsNote
+      }
+      prefill {
+        source
+        basis
+        lines { description sku orderLineId quantity unitPrice unitPriceBasis taxRate }
+        seededGross
+        billedGross
+        differs
+      }
+      outcome
+      operation
+      lineTotals { ${TOTALS_FIELDS} }
+      documents {
+        type
+        kind
+        documentDate
+        currencyCode
+        lines { ${DOCUMENT_LINE_FIELDS} }
+        totals { ${TOTALS_FIELDS} }
+        issuer
+        numbering { provider providerLabel external ready legalEntityId testStore }
+      }
+      refund {
+        amount
+        available
+        unavailableCode
+        unavailableMessage
+        options { paymentId method amount refundable }
+        recommendedPaymentId
+      }
+      accountCredit { available unavailableCode message }
+      settlement
+      blockers { code message path }
+`;
+export const PLAN_INVOICE_CORRECTION_QUERY = /* GraphQL */ `
+  query PlanInvoiceCorrection($input: InvoiceCorrectionInput!) {
+    planInvoiceCorrection(input: $input) { ${INVOICE_CORRECTION_PLAN_FIELDS} }
+  }
+`;
+/**
+ * Its own document on purpose: `commitInvoiceCorrection` exists only on an engine with the
+ * correction commit, so on an older one this call alone fails validation.
+ */
+export const COMMIT_INVOICE_CORRECTION_MUTATION = /* GraphQL */ `
+  mutation CommitInvoiceCorrection(
+    $input: InvoiceCorrectionInput!
+    $expectedPlanHash: String!
+    $idempotencyKey: String!
+  ) {
+    commitInvoiceCorrection(
+      input: $input
+      expectedPlanHash: $expectedPlanHash
+      idempotencyKey: $idempotencyKey
+    ) {
+      plan { ${INVOICE_CORRECTION_PLAN_FIELDS} }
+      documents {
+        ledger
+        type
+        id
+        number
+        kind
+        totalWithTax
+        currencyCode
+        issuedOn
+        numberingProvider
+      }
+      refund { id state total paymentId }
+      accountCredit { amount currencyCode unappliedCashIds }
+    }
+  }
+`;
 export const DOCUMENT_EXTENSIONS_QUERY = /* GraphQL */ `
   query DocumentExtensions {
     documentExtensions { ${DOCUMENT_EXTENSION_FIELDS} }
@@ -157,9 +312,12 @@ function toApiType(type) {
  * sees that the block is registered for something — which is why the decoded
  * field is typed `string[]`.
  */
+const DOCUMENT_TYPE_BY_API = new Map(Object.entries(API_DOCUMENT_TYPE).map(([type, api]) => [api, type]));
+function fromApiType(value) {
+    return DOCUMENT_TYPE_BY_API.get(value) ?? value;
+}
 function fromApiTypes(values) {
-    const byApi = new Map(Object.entries(API_DOCUMENT_TYPE).map(([type, api]) => [api, type]));
-    return values.map((value) => byApi.get(value) ?? value);
+    return values.map(fromApiType);
 }
 function toSchema(raw) {
     return { ...raw, documentTypes: fromApiTypes(raw.documentTypes) };
@@ -175,7 +333,19 @@ function decodePdf(base64) {
     }
     return bytes;
 }
+/** The server's default page; the SDK states it so the cursor arithmetic knows the size. */
+const CUSTOMER_DOCUMENTS_PAGE_SIZE = 25;
 export function createDocumentsModule(transport) {
+    const customerDocumentsPage = async (customerId, skip, take, options) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: CUSTOMER_DOCUMENTS_QUERY,
+            variables: { customerId, options: { skip, take } },
+        }, options);
+        const list = data.customerDocuments;
+        const items = list.items.map((item) => ({ ...item, type: fromApiType(item.type) }));
+        return pageFromVendureList({ items, totalItems: list.totalItems }, skip, take, (cursor) => customerDocumentsPage(customerId, readOffsetCursor(cursor), take, options));
+    };
     return {
         // One implementation behind the two overloads the interface declares; the
         // cast is the standard TypeScript shape for that, since an implementation
@@ -232,6 +402,14 @@ export function createDocumentsModule(transport) {
             }, options);
             return data.documentData;
         },
+        async downloadUrl(documentId, type, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: CREATE_DOCUMENT_DOWNLOAD_URL_MUTATION,
+                variables: { documentId, type: toApiType(type) },
+            }, options);
+            return data.createDocumentDownloadUrl;
+        },
         async invoices(orderId, options) {
             const data = await transport.graphql({ api: 'admin', query: ORDER_INVOICES_QUERY, variables: { orderId } }, options);
             return wholeList(data.orderInvoices, 'orderInvoices');
@@ -240,6 +418,12 @@ export function createDocumentsModule(transport) {
             const data = await transport.graphql({ api: 'admin', query: ORDER_CREDIT_NOTES_QUERY, variables: { orderId } }, options);
             return wholeList(data.orderCreditNotes, 'orderCreditNotes');
         },
+        forCustomer(customerId, options) {
+            // The Admin API is offset-paged; the offset hides inside the cursor (spec §9.3).
+            const take = options?.limit ?? CUSTOMER_DOCUMENTS_PAGE_SIZE;
+            const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return customerDocumentsPage(customerId, skip, take, options);
+        },
         async previewInvoice(orderId, options) {
             const data = await transport.graphql({
                 api: 'admin',
@@ -257,10 +441,52 @@ export function createDocumentsModule(transport) {
             const data = await transport.graphql({ api: 'admin', query: SEND_INVOICE_EMAIL_MUTATION, variables: { input } }, options);
             return data.sendInvoiceEmail;
         },
+        async sendCreditNoteEmail(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SEND_CREDIT_NOTE_EMAIL_MUTATION,
+                variables: {
+                    input: {
+                        creditNoteId: input.creditNoteId,
+                        recipientsTo: input.recipientsTo,
+                        recipientsCc: input.recipientsCc ?? null,
+                    },
+                },
+            }, options);
+            return data.sendCreditNoteEmail;
+        },
+        async creditNoteEmailSends(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_CREDIT_NOTE_EMAIL_SENDS_QUERY, variables: { orderId } }, options);
+            return wholeList(data.orderCreditNoteEmailSends, 'orderCreditNoteEmailSends');
+        },
         async issuePartialCreditNote(input, options) {
             const data = await transport.graphql({ api: 'admin', query: ISSUE_PARTIAL_CREDIT_NOTE_MUTATION, variables: { input } }, options);
             return data.issuePartialCreditNote;
         },
+        async planCorrection(input, options) {
+            const data = await transport.graphql({ api: 'admin', query: PLAN_INVOICE_CORRECTION_QUERY, variables: { input } }, options);
+            return data.planInvoiceCorrection;
+        },
+        async commitCorrection(input, options) {
+            const key = options.idempotencyKey ?? mintIdempotencyKey();
+            try {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: COMMIT_INVOICE_CORRECTION_MUTATION,
+                    // The input goes out as given, never normalised: it must be the request the plan was
+                    // made for, and a retry under the same key must send the same one.
+                    variables: { input, expectedPlanHash: options.expectedPlanHash, idempotencyKey: key },
+                }, { ...options, idempotencyKey: key });
+                return { ...data.commitInvoiceCorrection, idempotencyKey: key };
+            }
+            catch (error) {
+                // The key the caller retries under, when it did not choose one.
+                if (error !== null && typeof error === 'object' && !('idempotencyKey' in error)) {
+                    Object.defineProperty(error, 'idempotencyKey', { value: key, enumerable: true });
+                }
+                throw error;
+            }
+        },
         async issueSupplementaryInvoice(input, options) {
             const data = await transport.graphql({ api: 'admin', query: ISSUE_SUPPLEMENTARY_INVOICE_MUTATION, variables: { input } }, options);
             return data.issueSupplementaryInvoice;

package/dist/events/index.d.ts

@@ -0,0 +1,259 @@
+import { createEventHandler, type EventsClient, type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * A webhook subscription: where the platform POSTs this store's events, which ones, and
+ * how the destination is doing. The index signature keeps fields a newer platform adds.
+ */
+export interface EventSubscription {
+    id: string;
+    name: string;
+    /** The endpoint. Must resolve to a public address; the platform re-checks it per delivery. */
+    url: string;
+    /** Exact types, family wildcards (`order.*`) or `*`, as given. */
+    eventFilters: string[];
+    enabled: boolean;
+    /** Failures in a row that count toward auto-disable (a transient failure does not). */
+    consecutiveFailures: number;
+    /** ISO-8601 UTC, or null while enabled. */
+    disabledAt: string | null;
+    disabledReason: string | null;
+    /** Set when retention destroyed events this subscription had not yet received. */
+    gapDetectedAt: string | null;
+    lastDeliveredAt: string | null;
+    createdAt: string;
+    /** Whether this destination receives customer identity stripped. */
+    redactCustomerIdentity: boolean;
+    /**
+     * The app installation this subscription belongs to, or null for the store's
+     * own. An app's subscription follows the app's declarations: `update`,
+     * `setEnabled`, `rotateSecret` and `remove` refuse it (`ConflictError`,
+     * `SUBSCRIPTION_OWNED_BY_APP`) — uninstall the app or approve its declarations
+     * instead. Absent from a platform older than app subscriptions.
+     */
+    ownerInstallationId?: string | null;
+    /** `filters`, or `compliance_only` for an uninstalled app awaiting its redact request. */
+    deliveryScope?: string;
+    /** How the most recent attempt ended (`delivered`, `transient`, …), null before the first. */
+    lastOutcome?: string | null;
+    lastAttemptAt?: string | null;
+    [extra: string]: unknown;
+}
+/** What `create` answers: the subscription plus its signing secret, shown this ONCE. */
+export interface CreatedEventSubscription extends EventSubscription {
+    /**
+     * The signing secret (hex). Store it now — no read returns it again. Pass it to
+     * `createEventHandler` / `verifyEventDelivery`; its Standard Webhooks spelling for other
+     * libraries is `whsec_` + base64 of this string's UTF-8 bytes.
+     */
+    secret: string;
+}
+/** What `rotateSecret` answers: the NEW secret, shown this once. */
+export interface RotatedEventSubscriptionSecret {
+    /** The new secret (hex), the spelling `create` answers. Store it now. */
+    secret: string;
+    /** The same key material as a Standard Webhooks `whsec_` secret, for stock libraries. */
+    secretStandard: string;
+    /**
+     * ISO-8601 UTC. Until then every delivery is signed with BOTH secrets
+     * (`webhook-signature: v1,<new> v1,<old>`) and the legacy `x-webhook-signature` with the
+     * OLD one, so verify with `[newSecret, oldSecret]` meanwhile and drop the old one after.
+     */
+    previousExpiresAt: string;
+    [extra: string]: unknown;
+}
+export interface EventSubscriptionInput {
+    name: string;
+    url: string;
+    eventFilters: string[];
+    /** Strip customer identity before signing. Default false. */
+    redactCustomerIdentity?: boolean;
+}
+export type EventSubscriptionUpdate = Partial<EventSubscriptionInput>;
+/** One delivery attempt, newest first. */
+export interface EventDelivery {
+    id: string;
+    eventId: string;
+    eventType: string;
+    logSeq: string;
+    attempt: number;
+    /** `delivered` | `transient` | `fault` | `dead_lettered` | … */
+    outcome: string;
+    /** The subscriber's HTTP status, or null when nothing came back. */
+    responseStatus: number | null;
+    durationMs: number | null;
+    error: string | null;
+    /** Per-attempt evidence the dispatcher recorded; keys as stored. */
+    evidence: Record<string, unknown> | null;
+    createdAt: string;
+    [extra: string]: unknown;
+}
+/**
+ * What `sendTest` answered: how the endpoint took ONE synthetic delivery. An endpoint that
+ * refused it is still an answer (`delivered: false`), not a thrown error.
+ */
+export interface EventSendTestResult {
+    /** True when the endpoint answered 2xx. */
+    delivered: boolean;
+    /** `delivered` | `transient` | `subscription_fault` | `dead_lettered` — as a real delivery's would. */
+    outcome: string;
+    /** The endpoint's HTTP status, or null when nothing came back. */
+    status: number | null;
+    durationMs: number;
+    /** The synthetic envelope's `id` (its `webhook-id`). It is not in the event log. */
+    webhookId: string;
+    /** Why nothing came back — a timeout, a refused connection, an endpoint the platform refused. */
+    error: string | null;
+    [extra: string]: unknown;
+}
+export interface EventSendTestOptions extends Call {
+    /**
+     * The envelope `data` to send, verbatim (a JSON object, at most 64 KiB). Omit it for the
+     * platform's example payload of the type.
+     */
+    data?: Record<string, unknown>;
+}
+/** Most event ids one `redrive` call may name. */
+export declare const MAX_REDRIVE_EVENT_IDS = 100;
+/**
+ * What `redrive` answered for one id. `queued`: it will be delivered again;
+ * `already_queued`: a request for it is still waiting; `filtered_out`: the subscription does
+ * not take its type; `expired`: it has left the event log; `not_found`: no such event in this
+ * store's log.
+ */
+export type RedriveRequestState = 'queued' | 'already_queued' | 'filtered_out' | 'expired' | 'not_found' | (string & {});
+export interface RedriveAnswer {
+    items: Array<{
+        eventId: string;
+        state: RedriveRequestState;
+    }>;
+}
+/** One redrive request, as the platform tracks it. */
+export interface EventRedrive {
+    id: string;
+    eventId: string;
+    logSeq: string;
+    occurredAt: string;
+    requestedAt: string;
+    /** `<kind>:<id>` of the principal that asked (`user:`, `api_token:`, `app_installation:`). */
+    requestedBy: string | null;
+    /** `queued` until the platform settles it, then `delivered` or `failed`. */
+    state: 'queued' | 'delivered' | 'failed' | (string & {});
+    attempts: number;
+    /** The last delivery outcome, or why it settled without one (`expired`, `filtered_out`). */
+    lastOutcome: string | null;
+    completedAt: string | null;
+    [extra: string]: unknown;
+}
+export interface EventSubscriptionsModule {
+    /** Needs `ReadSettings` or `ManageEventSubscriptions`. Newest first. */
+    list(options?: ListOptions): Promise<Page<EventSubscription>>;
+    /**
+     * Needs `ManageEventSubscriptions` (or `UpdateSettings`). Answers the secret ONCE. Takes no idempotency key: the route is
+     * deliberately not idempotent, because a stored replay would keep the secret for 24 hours
+     * — so a retry after a lost response creates a second subscription; `list` and `remove`
+     * the spare.
+     */
+    create(input: EventSubscriptionInput, options?: Omit<Call, 'idempotencyKey'>): Promise<CreatedEventSubscription>;
+    /** Needs `ManageEventSubscriptions` (or `UpdateSettings`). Name, endpoint, filters and the redaction flag. */
+    update(id: string, input: EventSubscriptionUpdate, options?: Call): Promise<EventSubscription>;
+    /** Needs `ManageEventSubscriptions` (or `UpdateSettings`). Turning a subscription on clears its failure count. */
+    setEnabled(id: string, enabled: boolean, options?: Call): Promise<EventSubscription>;
+    /** Needs `ManageEventSubscriptions` (or `UpdateSettings`). */
+    remove(id: string, options?: Call): Promise<void>;
+    /**
+     * Needs `ManageEventSubscriptions` (or `UpdateSettings`). Issues a new signing secret and answers it ONCE. The secret it
+     * replaces keeps co-signing for 24 hours (`previousExpiresAt`), so a receiver switches
+     * over without dropping a delivery:
+     *
+     * ```ts
+     * const { secret } = await admin.events.subscriptions.rotateSecret(id);
+     * // deploy the receiver with both, newest first …
+     * createEventHandler({ secret: [secret, oldSecret], on: { … } });
+     * // … and drop oldSecret after previousExpiresAt.
+     * ```
+     *
+     * A second rotation inside that window is refused (`ConflictError`, 409,
+     * `ROTATION_IN_PROGRESS`). `{ force: true }` rotates anyway and the OLDER secret stops
+     * signing at once — receivers still holding only it stop verifying. The secret being
+     * replaced always keeps co-signing, forced or not, so to revoke a LEAKED current secret
+     * immediately call `rotateSecret(id, { force: true })` TWICE: the second call drops the
+     * leaked secret. (Both forced: a plain call is refused while an overlap is running.) Takes no idempotency key, like `create`: the answer carries a secret. A retry
+     * after a lost answer is refused `ROTATION_IN_PROGRESS`; recover with `force`.
+     */
+    rotateSecret(id: string, options?: {
+        force?: boolean;
+    } & Omit<Call, 'idempotencyKey'>): Promise<RotatedEventSubscriptionSecret>;
+    /**
+     * Needs `ReadSettings` or `ManageEventSubscriptions`. Recent attempts, newest first. A `sendTest` attempt is listed
+     * too, marked `evidence.test === true` (its `logSeq` is `"0"`: it was never in the log).
+     */
+    deliveries(id: string, options?: ListOptions): Promise<Page<EventDelivery>>;
+    /**
+     * Needs `ManageEventSubscriptions` (or `UpdateSettings`). Sign and POST ONE synthetic event of `type` to this
+     * subscription's endpoint — to prove a receiver verifies and parses a delivery without
+     * waiting for the store to produce one:
+     *
+     * ```ts
+     * const result = await admin.events.subscriptions.sendTest(id, 'order.created');
+     * if (!result.delivered) console.error(result.status ?? result.error);
+     * ```
+     *
+     * The envelope is signed, redacted and SSRF-checked like a real delivery, with a fresh
+     * `id`, `actor: { type: 'system', id: 'system:send-test' }` and `test: true` — acknowledge
+     * it and do not act on it. It is never written to the event log (not in `poll` or
+     * `stream`), never moves the subscription's position and never counts toward auto-disable.
+     * `data` defaults to the platform's example payload for the type.
+     *
+     * Works on a disabled subscription (check a fixed endpoint before `setEnabled(id, true)`).
+     * Refused: an uncatalogued type (`ValidationError`, `UNKNOWN_EVENT_TYPE`); a type outside
+     * the subscription's filters (`BusinessRuleError`, 422, `EVENT_TYPE_NOT_SUBSCRIBED`); an
+     * app's subscription (`ConflictError`, `SUBSCRIPTION_OWNED_BY_APP`); a closed store
+     * (`PermissionDeniedError`, 403, `CHANNEL_SOFT_DELETED`, as everywhere else). Takes an idempotency key: a retry under the same key
+     * replays the first answer instead of sending a second test.
+     */
+    sendTest(id: string, type: string, options?: EventSendTestOptions): Promise<EventSendTestResult>;
+}
+/**
+ * Platform events (headless spec §6.9): pull the store's event log, answer webhooks, and
+ * manage where they are pushed.
+ *
+ * `poll` / `pollAll` / `replay` / `head` read `GET /events`, and `stream` / `streamTicket`
+ * push the same events over Server-Sent Events (`GET /events/stream`); all of them need a
+ * MACHINE credential holding `ReadPlatformEvents` and scoped to one channel, and a stream
+ * cursor and a feed cursor are interchangeable. A credential's live streams are limited
+ * (one by default): opening another closes the oldest (`EventStreamClosedError`,
+ * `superseded`). Events reach the log
+ * through relays that tick once a minute, so a stream delivers them up to about a minute
+ * after the change.
+ *
+ * `subscriptions.*`, `redrive` and `redrives` need `ManageEventSubscriptions` — the `events`
+ * API-token template grants it beside `ReadPlatformEvents`. Reads also accept `ReadSettings`;
+ * writes still accept `UpdateSettings` for credentials minted before the permission existed,
+ * a transition that a later release ends (announced in the changelog first).
+ */
+export interface EventsModule extends EventsClient {
+    /**
+     * `events.subscribe` — build a webhook endpoint `(Request) => Promise<Response>` with typed
+     * per-event handlers. Needs no credential: it verifies with the subscription secret.
+     */
+    subscribe: typeof createEventHandler;
+    subscriptions: EventSubscriptionsModule;
+    /**
+     * Needs `ManageEventSubscriptions` (or `UpdateSettings`). Queue chosen events to be delivered to ONE subscription again — a
+     * dead letter, or any event still in the log that passes the subscription's filters (a
+     * replay to one destination). 1-100 ids. Answers a state per id; only `queued` ids will be
+     * delivered.
+     *
+     * A queued id is delivered again with the same envelope `id`, so `webhook-id` dedupe holds;
+     * only `delivered_at` / `webhook-timestamp` move. `redrives` shows it `delivered`, or
+     * `failed` when the endpoint dead-letters it again or keeps refusing it (8 attempts). Events
+     * that have left the log (`expired`) are recovered from the pull feed (`events.replay`).
+     * A disabled subscription is refused
+     * (`BusinessRuleError`, 422, `SUBSCRIPTION_DISABLED`). Takes an idempotency key: a retry
+     * under the same key replays the first answer.
+     */
+    redrive(subscriptionId: string, eventIds: readonly string[], options?: Call): Promise<RedriveAnswer>;
+    /** Needs `ReadSettings` or `ManageEventSubscriptions`. One subscription's redrive requests, newest first. */
+    redrives(subscriptionId: string, options?: ListOptions): Promise<Page<EventRedrive>>;
+}
+export declare function createEventsModule(transport: Transport): EventsModule;