@adcp/sdk 15.8.1 → 15.9.1

package/dist/lib/reporting/ledger/managed-postgres.mjs

@@ -12,7 +12,9 @@ import {
 import {
   adjustmentReceiptEvidenceMatches,
   assertMaterializationOutcome,
-  receiptEvidenceMatches
+  receiptEvidenceMatches,
+  REPORTING_DESTINATION_PATTERNS_V1,
+  REPORTING_DESTINATION_TRANSPORT_PATTERN_V1
 } from "./managed.mjs";
 const REPORTING_MANAGED_DELIVERY_MIGRATION = `
 CREATE TABLE IF NOT EXISTS adcp_reporting_destination_authorizations (
@@ -223,6 +225,60 @@ CREATE INDEX IF NOT EXISTS adcp_reporting_materialization_tombstones_obligation
 
 ALTER TABLE adcp_reporting_destination_authorizations
   ADD COLUMN IF NOT EXISTS cleanup_lease_issued_at TIMESTAMPTZ;
+
+-- Delivery pattern and transport recorded on the authorization generation, so
+-- a revocation can be routed to the transport that holds the provider grant.
+-- Both are immutable for a generation (a new delivery contract mints a new
+-- destination_ref generation) and NULL for a generation whose contract is not
+-- known. The block runs once, in the same statement batch that adds the
+-- columns: it backfills a row only when every binding on that exact
+-- (account_id, destination_ref, generation) agrees on the method and carries
+-- the same transport, and otherwise leaves the row NULL. A later re-run finds
+-- the columns present and does nothing, so a generation that was left NULL
+-- stays NULL rather than being re-decided by whichever binding arrived since.
+DO $pattern_transport$
+DECLARE
+  unresolved BIGINT;
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.columns
+     WHERE table_schema = current_schema()
+       AND table_name = 'adcp_reporting_destination_authorizations'
+       AND column_name = 'transport'
+  ) THEN
+    ALTER TABLE adcp_reporting_destination_authorizations ADD COLUMN IF NOT EXISTS pattern TEXT;
+    ALTER TABLE adcp_reporting_destination_authorizations ADD COLUMN IF NOT EXISTS transport TEXT;
+    WITH agreed AS (
+      SELECT authz.account_id, authz.destination_ref, authz.generation,
+             MIN(binding.data->>'method') AS pattern,
+             MIN(binding.data->>'transport') AS transport
+        FROM adcp_reporting_destination_authorizations authz
+        JOIN adcp_reporting_managed_bindings binding
+          ON binding.account_id = authz.account_id
+         AND binding.destination_ref = authz.destination_ref
+         AND binding.authorization_generation = authz.generation
+       WHERE authz.pattern IS NULL AND authz.transport IS NULL
+       GROUP BY authz.account_id, authz.destination_ref, authz.generation
+      HAVING COUNT(*) = COUNT(binding.data->>'method')
+         AND COUNT(DISTINCT binding.data->>'method') = 1
+         AND COUNT(*) = COUNT(binding.data->>'transport')
+         AND COUNT(DISTINCT binding.data->>'transport') = 1
+    )
+    UPDATE adcp_reporting_destination_authorizations authz
+       SET pattern = agreed.pattern,
+           transport = agreed.transport,
+           data = authz.data || jsonb_build_object('pattern', agreed.pattern, 'transport', agreed.transport)
+      FROM agreed
+     WHERE authz.account_id = agreed.account_id
+       AND authz.destination_ref = agreed.destination_ref
+       AND authz.generation = agreed.generation;
+    SELECT COUNT(*) INTO unresolved FROM adcp_reporting_destination_authorizations WHERE transport IS NULL;
+    IF unresolved > 0 THEN
+      RAISE NOTICE 'adcp_reporting_destination_authorizations: % generation(s) left without pattern/transport; list them with PostgresReportingManagedDeliveryStore.listDestinationAuthorizationsWithoutContract()', unresolved;
+    END IF;
+  END IF;
+END
+$pattern_transport$;
 `.trim();
 const GENERIC_RECEIPT_MESSAGE = "Receipt does not match authorized current reporting evidence";
 const MAX_PLAN = 1e3;
@@ -267,6 +323,7 @@ class PostgresReportingManagedDeliveryStore {
   statusRetentionDays;
   pendingRecoveryWindowSeconds;
   policyRegistered = false;
+  bindingAdmission;
   notificationActivityPort;
   /**
    * Durably records the agent-wide advertised recovery window.
@@ -760,16 +817,35 @@ class PostgresReportingManagedDeliveryStore {
   }
   async authorizeDestination(input) {
     positiveInteger(input.generation, "generation");
+    const pattern = input.pattern ?? null;
+    const transport = input.transport ?? null;
+    if (pattern !== null && !REPORTING_DESTINATION_PATTERNS_V1.includes(pattern)) {
+      throw new TypeError(
+        "Destination authorization pattern must be file_transfer, dataset_share, or warehouse_materialization"
+      );
+    }
+    if (transport !== null) {
+      if (pattern === null) throw new TypeError("Destination authorization transport requires its pattern");
+      if (typeof transport !== "string" || !REPORTING_DESTINATION_TRANSPORT_PATTERN_V1.test(transport)) {
+        throw new TypeError("Destination authorization transport must match ^[a-z][a-z0-9_.-]{0,63}$");
+      }
+    }
     await this.transaction(async (client) => {
       await advisoryLock(client, accountLock(input.account_id));
       await advisoryLock(client, authLock(input.account_id, input.destination_ref));
       const current = await client.query(
-        `SELECT generation::text FROM adcp_reporting_destination_authorizations
+        `SELECT generation::text, pattern, transport FROM adcp_reporting_destination_authorizations
           WHERE account_id = $1 AND destination_ref = $2 AND revoked_at IS NULL`,
         [input.account_id, input.destination_ref]
       );
       if (current.rowCount) {
-        if (Number(current.rows[0].generation) === input.generation) return;
+        if (Number(current.rows[0].generation) === input.generation) {
+          const recorded2 = current.rows[0];
+          if (pattern !== null && pattern !== recorded2.pattern || transport !== null && transport !== recorded2.transport) {
+            throw new Error("Destination authorization pattern and transport are immutable for a generation");
+          }
+          return;
+        }
         throw new Error("A destination authorization generation is already current");
       }
       const latest = await client.query(
@@ -786,12 +862,20 @@ class PostgresReportingManagedDeliveryStore {
         // `revoked_at` also violates the table's own ordering check whenever
         // the caller's clock runs ahead.
         `INSERT INTO adcp_reporting_destination_authorizations
-          (account_id, destination_ref, generation, authorized_at, data)
-         VALUES ($1, $2, $3, clock_timestamp(),
+          (account_id, destination_ref, generation, authorized_at, pattern, transport, data)
+         VALUES ($1, $2, $3, clock_timestamp(), $6::text, $7::text,
                  $4::jsonb || jsonb_build_object(
                    'authorized_at', ${rfc3339Micro("clock_timestamp()")},
                    'requested_authorized_at', $5::text))`,
-        [input.account_id, input.destination_ref, input.generation, JSON.stringify(input), input.authorized_at]
+        [
+          input.account_id,
+          input.destination_ref,
+          input.generation,
+          JSON.stringify(input),
+          input.authorized_at,
+          pattern,
+          transport
+        ]
       );
     });
   }
@@ -831,6 +915,9 @@ class PostgresReportingManagedDeliveryStore {
       return updated.rowCount === 1;
     });
   }
+  setBindingAdmission(admit) {
+    this.bindingAdmission = admit;
+  }
   async installBinding(binding) {
     positiveInteger(binding.resource_retention_days, "resource_retention_days");
     if (binding.reconciliation_mode === "consumer_receipt" && binding.verification_profile !== "canonical_digest") {
@@ -840,6 +927,7 @@ class PostgresReportingManagedDeliveryStore {
     if (binding.semantic_fingerprint !== expectedFingerprint) {
       throw new Error("Managed binding semantic fingerprint does not match its immutable content");
     }
+    this.bindingAdmission?.(binding);
     await this.ensurePolicyRegistered();
     return this.transaction(async (client) => {
       const registeredPolicy = await this.readPolicy(client, "update");
@@ -856,7 +944,9 @@ class PostgresReportingManagedDeliveryStore {
         return { inserted: false };
       }
       const eligible = await client.query(
-        `SELECT configuration.data AS configuration FROM adcp_reporting_configurations configuration
+        `SELECT configuration.data AS configuration,
+                authz.pattern AS authz_pattern, authz.transport AS authz_transport
+           FROM adcp_reporting_configurations configuration
           JOIN adcp_reporting_destination_authorizations authz
             ON authz.account_id = $2 AND authz.destination_ref = $5
            AND authz.generation = $6 AND authz.revoked_at IS NULL
@@ -877,6 +967,15 @@ class PostgresReportingManagedDeliveryStore {
       );
       if (!eligible.rowCount) throw new Error("Managed binding is not authorized for the exact Core configuration");
       const configuration = eligible.rows[0].configuration;
+      const recordedContract = eligible.rows[0];
+      if (recordedContract.authz_pattern !== null && binding.method !== recordedContract.authz_pattern) {
+        throw new Error("Managed binding method differs from the pattern recorded on its destination authorization");
+      }
+      if (recordedContract.authz_transport !== null && binding.transport !== recordedContract.authz_transport) {
+        throw new Error(
+          "Managed binding transport differs from the transport recorded on its destination authorization"
+        );
+      }
       const advertisedRecoveryWindowSeconds = registeredPolicy.recoveryWindowSeconds;
       if (advertisedRecoveryWindowSeconds !== null) {
         const windowMilliseconds = Number(configuration.schedule?.recoveryWindowMilliseconds);
@@ -1430,7 +1529,10 @@ class PostgresReportingManagedDeliveryStore {
           FROM candidate
          WHERE target.account_id = candidate.account_id AND target.destination_ref = candidate.destination_ref
            AND target.generation = candidate.generation
-         RETURNING target.data, target.cleanup_lease_generation::text AS generation,
+         RETURNING target.data || jsonb_strip_nulls(
+                     jsonb_build_object('pattern', target.pattern, 'transport', target.transport)
+                   ) AS data,
+                   target.cleanup_lease_generation::text AS generation,
                    target.cleanup_lease_expires_at AS expires_at,
                    target.revoked_at AS revoked_at,
                    CASE WHEN $4::bigint IS NULL THEN NULL
@@ -1753,6 +1855,51 @@ class PostgresReportingManagedDeliveryStore {
       return plan;
     }, context.signal);
   }
+  /**
+   * Generations that carry no recorded pattern/transport, with why the
+   * migration backfill could not infer them. These are routed to a router's
+   * `legacyDefault` (or fail revocation with a typed error) until the host
+   * supplies the contract. Read-only; it never edits a row.
+   *
+   * `no_binding`: nothing to infer from. `binding_without_transport`: at least
+   * one binding names no transport. `bindings_disagree`: the bindings name
+   * different methods or transports. `not_recorded`: the bindings agree, but
+   * the generation was created without a contract after the one-time backfill
+   * ran, so nothing records it.
+   */
+  async listDestinationAuthorizationsWithoutContract(input = {}) {
+    const limit = input.limit ?? 1e3;
+    positiveInteger(limit, "limit");
+    if (limit > MAX_PLAN) throw new RangeError(`limit must not exceed ${MAX_PLAN}`);
+    const result = await this.query(
+      `SELECT authz.account_id, authz.destination_ref, authz.generation::text AS generation,
+              COUNT(binding.configuration_id)::text AS bindings,
+              COUNT(DISTINCT binding.data->>'method')::text AS methods,
+              COUNT(DISTINCT binding.data->>'transport')::text AS transports,
+              COUNT(binding.data->>'transport')::text AS with_transport
+         FROM adcp_reporting_destination_authorizations authz
+         LEFT JOIN adcp_reporting_managed_bindings binding
+           ON binding.account_id = authz.account_id
+          AND binding.destination_ref = authz.destination_ref
+          AND binding.authorization_generation = authz.generation
+        WHERE (authz.pattern IS NULL OR authz.transport IS NULL)
+          AND ($1::text IS NULL OR authz.account_id = $1)
+        GROUP BY authz.account_id, authz.destination_ref, authz.generation
+        ORDER BY authz.account_id, authz.destination_ref, authz.generation
+        LIMIT $2`,
+      [input.account_id ?? null, limit]
+    );
+    return result.rows.map((row) => {
+      const bindings = Number(row.bindings);
+      const reason = bindings === 0 ? "no_binding" : Number(row.with_transport) < bindings ? "binding_without_transport" : Number(row.methods) > 1 || Number(row.transports) > 1 ? "bindings_disagree" : "not_recorded";
+      return {
+        account_id: row.account_id,
+        destination_ref: row.destination_ref,
+        generation: Number(row.generation),
+        reason
+      };
+    });
+  }
   async isAuthorizationCurrent(input) {
     const result = await this.query(
       `SELECT 1 FROM adcp_reporting_destination_authorizations

package/dist/lib/reporting/ledger/managed-router.d.mts

@@ -0,0 +1,123 @@
+import type { ReportingVerification } from '../../types/index.mjs';
+import { type ReportingDestinationAuthorizationV1, type ReportingDestinationPatternV1, type ReportingManagedDeliveryAdapterV1 } from './managed.mjs';
+import type { ReportingManagedDeliveryBindingV1 } from './types.mjs';
+type VerificationProfile = ReportingVerification['verification_profile'];
+/** Why a delivery, read, revocation or admission could not be routed. */
+export type ReportingManagedDeliveryRoutingErrorCodeV1 = 
+/** No route is installed for the pattern and transport. */
+'REPORTING_ROUTE_NOT_FOUND'
+/** The binding names no transport and the router has no usable `legacyDefault`. */
+ | 'REPORTING_ROUTE_TRANSPORT_REQUIRED'
+/** The authorization recorded no pattern/transport and the router has no usable `legacyDefault`. */
+ | 'REPORTING_ROUTE_CONTRACT_UNRECORDED'
+/** The binding's verification profile is not one its route can verify. */
+ | 'REPORTING_ROUTE_VERIFICATION_UNSUPPORTED';
+export type ReportingManagedDeliveryRoutingOperationV1 = 'deliver' | 'read' | 'revoke' | 'admit_binding' | 'admit_offering';
+/**
+ * Raised by the router before it touches any adapter. The fields are the
+ * non-secret routing facts only: no destination, location or credential.
+ */
+export declare class ReportingManagedDeliveryRoutingErrorV1 extends Error {
+    readonly code: ReportingManagedDeliveryRoutingErrorCodeV1;
+    readonly operation: ReportingManagedDeliveryRoutingOperationV1;
+    readonly pattern: string | undefined;
+    readonly transport: string | undefined;
+    readonly verificationProfile: string | undefined;
+    constructor(code: ReportingManagedDeliveryRoutingErrorCodeV1, operation: ReportingManagedDeliveryRoutingOperationV1, detail: {
+        pattern?: string | undefined;
+        transport?: string | undefined;
+        verificationProfile?: string | undefined;
+    }, message: string);
+}
+/**
+ * Raised by `router.probe()` when at least one route's probe failed. Carries
+ * the ids of the failing routes and nothing else from the provider; the
+ * individual errors are on `cause` (an `AggregateError`) for seller logs only.
+ */
+export declare class ReportingManagedDeliveryProbeErrorV1 extends Error {
+    readonly failedRouteIds: readonly string[];
+    constructor(failedRouteIds: readonly string[], errors: readonly unknown[]);
+}
+export interface ReportingManagedDeliveryRouteV1 {
+    /** Stable id used in per-route counts and probe failures. Lowercase token, at most 64 characters. */
+    id: string;
+    /** The pattern and transport this route serves. Exactly one route may match a pair. */
+    match: {
+        pattern: ReportingDestinationPatternV1;
+        transport: string;
+    };
+    /**
+     * The adapter that serves it. It must declare
+     * `revocationFencesDeliveryGenerations: true` and a non-empty
+     * `verificationProfiles`; its profiles are what a binding routed here may use.
+     */
+    adapter: ReportingManagedDeliveryAdapterV1;
+}
+export interface CreateReportingManagedDeliveryAdapterRouterOptionsV1 {
+    routes: readonly ReportingManagedDeliveryRouteV1[];
+    /**
+     * Id of the route that takes work recorded before pattern and transport
+     * existed: a binding with no `transport`, and a destination authorization
+     * with no recorded pattern/transport. Without it that work fails with a
+     * typed error rather than being guessed or sent to every route. A binding
+     * or authorization that does state a pattern is only sent here if it is this
+     * route's pattern.
+     */
+    legacyDefault?: string;
+    /**
+     * Per-route budget for `probe()`. Defaults to 10 seconds and must be below the
+     * runtime's 30 second probe deadline, so a hung route is still named in the startup error.
+     */
+    probeTimeoutMilliseconds?: number;
+}
+/** What a router exposes about a route. The adapter itself stays private to the router. */
+export interface ReportingManagedDeliveryRouteDescriptionV1 {
+    readonly id: string;
+    readonly match: Readonly<{
+        pattern: ReportingDestinationPatternV1;
+        transport: string;
+    }>;
+    readonly verificationProfiles: readonly VerificationProfile[];
+}
+/**
+ * A `ReportingManagedDeliveryAdapterV1` that dispatches to one adapter per
+ * (pattern, transport). The optional hooks are always present on a router.
+ */
+export interface ReportingManagedDeliveryAdapterRouterV1 extends ReportingManagedDeliveryAdapterV1 {
+    readonly routes: readonly ReportingManagedDeliveryRouteDescriptionV1[];
+    readonly legacyDefault: string | undefined;
+    probe(context: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    admitBinding(binding: ReportingManagedDeliveryBindingV1): void;
+    admitOffering(offering: {
+        method: {
+            pattern: string;
+            transport: string;
+        };
+        reconciliation_mode?: string;
+    }): void;
+    routeIdFor(target: Readonly<{
+        binding: ReportingManagedDeliveryBindingV1;
+    } | {
+        authorization: ReportingDestinationAuthorizationV1;
+    }>): string | undefined;
+}
+/**
+ * One managed-delivery runtime across several transports.
+ *
+ * The router is pure dispatch with no state of its own, so every fence the
+ * store and worker provide (leases, the authorization-generation check,
+ * settlement, the retry and attempt caps, revocation SLA accounting) is
+ * untouched and keeps working per materialization whatever route served it.
+ *
+ * - `deliver()` and `read()` choose the route from the immutable binding
+ *   alone (`binding.method` and `binding.transport`), never from request
+ *   input, materialization state or the resource.
+ * - `revoke()` chooses it from the pattern and transport recorded on the
+ *   authorization generation. It never fans out.
+ * - Nothing that cannot be routed reaches an adapter: the router throws a
+ *   `ReportingManagedDeliveryRoutingErrorV1` first.
+ */
+export declare function createReportingManagedDeliveryAdapterRouterV1(options: CreateReportingManagedDeliveryAdapterRouterOptionsV1): ReportingManagedDeliveryAdapterRouterV1;
+export {};

package/dist/lib/reporting/ledger/managed-router.d.ts

@@ -0,0 +1,123 @@
+import type { ReportingVerification } from '../../types';
+import { type ReportingDestinationAuthorizationV1, type ReportingDestinationPatternV1, type ReportingManagedDeliveryAdapterV1 } from './managed';
+import type { ReportingManagedDeliveryBindingV1 } from './types';
+type VerificationProfile = ReportingVerification['verification_profile'];
+/** Why a delivery, read, revocation or admission could not be routed. */
+export type ReportingManagedDeliveryRoutingErrorCodeV1 = 
+/** No route is installed for the pattern and transport. */
+'REPORTING_ROUTE_NOT_FOUND'
+/** The binding names no transport and the router has no usable `legacyDefault`. */
+ | 'REPORTING_ROUTE_TRANSPORT_REQUIRED'
+/** The authorization recorded no pattern/transport and the router has no usable `legacyDefault`. */
+ | 'REPORTING_ROUTE_CONTRACT_UNRECORDED'
+/** The binding's verification profile is not one its route can verify. */
+ | 'REPORTING_ROUTE_VERIFICATION_UNSUPPORTED';
+export type ReportingManagedDeliveryRoutingOperationV1 = 'deliver' | 'read' | 'revoke' | 'admit_binding' | 'admit_offering';
+/**
+ * Raised by the router before it touches any adapter. The fields are the
+ * non-secret routing facts only: no destination, location or credential.
+ */
+export declare class ReportingManagedDeliveryRoutingErrorV1 extends Error {
+    readonly code: ReportingManagedDeliveryRoutingErrorCodeV1;
+    readonly operation: ReportingManagedDeliveryRoutingOperationV1;
+    readonly pattern: string | undefined;
+    readonly transport: string | undefined;
+    readonly verificationProfile: string | undefined;
+    constructor(code: ReportingManagedDeliveryRoutingErrorCodeV1, operation: ReportingManagedDeliveryRoutingOperationV1, detail: {
+        pattern?: string | undefined;
+        transport?: string | undefined;
+        verificationProfile?: string | undefined;
+    }, message: string);
+}
+/**
+ * Raised by `router.probe()` when at least one route's probe failed. Carries
+ * the ids of the failing routes and nothing else from the provider; the
+ * individual errors are on `cause` (an `AggregateError`) for seller logs only.
+ */
+export declare class ReportingManagedDeliveryProbeErrorV1 extends Error {
+    readonly failedRouteIds: readonly string[];
+    constructor(failedRouteIds: readonly string[], errors: readonly unknown[]);
+}
+export interface ReportingManagedDeliveryRouteV1 {
+    /** Stable id used in per-route counts and probe failures. Lowercase token, at most 64 characters. */
+    id: string;
+    /** The pattern and transport this route serves. Exactly one route may match a pair. */
+    match: {
+        pattern: ReportingDestinationPatternV1;
+        transport: string;
+    };
+    /**
+     * The adapter that serves it. It must declare
+     * `revocationFencesDeliveryGenerations: true` and a non-empty
+     * `verificationProfiles`; its profiles are what a binding routed here may use.
+     */
+    adapter: ReportingManagedDeliveryAdapterV1;
+}
+export interface CreateReportingManagedDeliveryAdapterRouterOptionsV1 {
+    routes: readonly ReportingManagedDeliveryRouteV1[];
+    /**
+     * Id of the route that takes work recorded before pattern and transport
+     * existed: a binding with no `transport`, and a destination authorization
+     * with no recorded pattern/transport. Without it that work fails with a
+     * typed error rather than being guessed or sent to every route. A binding
+     * or authorization that does state a pattern is only sent here if it is this
+     * route's pattern.
+     */
+    legacyDefault?: string;
+    /**
+     * Per-route budget for `probe()`. Defaults to 10 seconds and must be below the
+     * runtime's 30 second probe deadline, so a hung route is still named in the startup error.
+     */
+    probeTimeoutMilliseconds?: number;
+}
+/** What a router exposes about a route. The adapter itself stays private to the router. */
+export interface ReportingManagedDeliveryRouteDescriptionV1 {
+    readonly id: string;
+    readonly match: Readonly<{
+        pattern: ReportingDestinationPatternV1;
+        transport: string;
+    }>;
+    readonly verificationProfiles: readonly VerificationProfile[];
+}
+/**
+ * A `ReportingManagedDeliveryAdapterV1` that dispatches to one adapter per
+ * (pattern, transport). The optional hooks are always present on a router.
+ */
+export interface ReportingManagedDeliveryAdapterRouterV1 extends ReportingManagedDeliveryAdapterV1 {
+    readonly routes: readonly ReportingManagedDeliveryRouteDescriptionV1[];
+    readonly legacyDefault: string | undefined;
+    probe(context: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    admitBinding(binding: ReportingManagedDeliveryBindingV1): void;
+    admitOffering(offering: {
+        method: {
+            pattern: string;
+            transport: string;
+        };
+        reconciliation_mode?: string;
+    }): void;
+    routeIdFor(target: Readonly<{
+        binding: ReportingManagedDeliveryBindingV1;
+    } | {
+        authorization: ReportingDestinationAuthorizationV1;
+    }>): string | undefined;
+}
+/**
+ * One managed-delivery runtime across several transports.
+ *
+ * The router is pure dispatch with no state of its own, so every fence the
+ * store and worker provide (leases, the authorization-generation check,
+ * settlement, the retry and attempt caps, revocation SLA accounting) is
+ * untouched and keeps working per materialization whatever route served it.
+ *
+ * - `deliver()` and `read()` choose the route from the immutable binding
+ *   alone (`binding.method` and `binding.transport`), never from request
+ *   input, materialization state or the resource.
+ * - `revoke()` chooses it from the pattern and transport recorded on the
+ *   authorization generation. It never fans out.
+ * - Nothing that cannot be routed reaches an adapter: the router throws a
+ *   `ReportingManagedDeliveryRoutingErrorV1` first.
+ */
+export declare function createReportingManagedDeliveryAdapterRouterV1(options: CreateReportingManagedDeliveryAdapterRouterOptionsV1): ReportingManagedDeliveryAdapterRouterV1;
+export {};