@absolutejs/auth 0.27.0 → 0.29.0-beta.0

package/dist/oidc/config.d.ts

@@ -1,11 +1,14 @@
 import type { RouteString } from '../types';
 import { type SigningKey } from './keys';
-import type { AuthorizationCodeStore, OAuthClientStore, OidcRefreshTokenStore } from './types';
+import type { AuthorizationCodeStore, DeviceAuthorizationStore, OAuthClientStore, OidcRefreshTokenStore } from './types';
 export declare const DEFAULT_OIDC_ROUTE: RouteString;
 export type OidcProviderConfig<UserType> = {
     accessTokenTtlMs?: number;
     authorizationCodeStore: AuthorizationCodeStore;
     clientStore: OAuthClientStore;
+    deviceAuthorizationStore?: DeviceAuthorizationStore;
+    deviceCodeTtlMs?: number;
+    devicePollIntervalSeconds?: number;
     getAccessTokenClaims?: (context: {
         audience?: string;
         clientId: string;
@@ -63,7 +66,7 @@ export declare const issueTokenSet: <UserType>({ claims, clientId, config, dpopJ
     id_token: string;
     refresh_token: string;
     scope: string;
-    token_type: string;
+    token_type: "Bearer" | "DPoP";
 }>;
 export declare const mcpProtectedResourceMetadata: ({ issuer, resource, scopes }: {
     issuer: string;
@@ -75,3 +78,89 @@ export declare const mcpProtectedResourceMetadata: ({ issuer, resource, scopes }
     scopes_supported: string[];
 };
 export declare const verifyPkce: (codeVerifier: string, codeChallenge: string) => Promise<boolean>;
+export type TokenIntrospection = {
+    active: false;
+} | {
+    active: true;
+    client_id: string;
+    exp: number;
+    iat: number;
+    scope: string;
+    sub: string;
+    token_type: 'access_token' | 'refresh_token';
+};
+export type TokenTypeHint = 'access_token' | 'refresh_token';
+export declare const introspectToken: <UserType>({ config, hint, now, token }: {
+    config: OidcProviderConfig<UserType>;
+    hint?: TokenTypeHint;
+    now?: number;
+    token: string;
+}) => Promise<{
+    active: false;
+} | {
+    active: true;
+    client_id: any;
+    exp: any;
+    iat: any;
+    scope: any;
+    sub: any;
+    token_type: "access_token";
+} | {
+    active: true;
+    client_id: string;
+    exp: number;
+    iat: number;
+    scope: string;
+    sub: string;
+    token_type: "refresh_token";
+}>;
+export declare const revokeRefreshToken: <UserType>(config: OidcProviderConfig<UserType>, token: string) => Promise<boolean>;
+export type DeviceAuthorizationResponse = {
+    device_code: string;
+    expires_in: number;
+    interval: number;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+};
+export declare const issueDeviceAuthorization: <UserType>({ clientId, config, now, requestedScopes }: {
+    clientId: string;
+    config: OidcProviderConfig<UserType>;
+    now?: number;
+    requestedScopes: string[];
+}) => Promise<DeviceAuthorizationResponse>;
+export type DeviceDecisionResult = {
+    error: 'already_decided' | 'expired_token' | 'invalid_user_code' | 'not_configured';
+    ok: false;
+} | {
+    ok: true;
+};
+export declare const approveDeviceAuthorization: <UserType>({ config, userCode, userSub }: {
+    config: OidcProviderConfig<UserType>;
+    userCode: string;
+    userSub: string;
+}) => Promise<DeviceDecisionResult>;
+export declare const denyDeviceAuthorization: <UserType>({ config, userCode }: {
+    config: OidcProviderConfig<UserType>;
+    userCode: string;
+}) => Promise<DeviceDecisionResult>;
+export type DeviceCodeExchangeError = 'access_denied' | 'authorization_pending' | 'expired_token' | 'invalid_grant' | 'slow_down';
+export type DeviceCodeExchangeResult = {
+    access_token: string;
+    expires_in: number;
+    id_token: string;
+    ok: true;
+    refresh_token: string;
+    scope: string;
+    token_type: 'Bearer' | 'DPoP';
+} | {
+    error: DeviceCodeExchangeError;
+    ok: false;
+};
+export declare const exchangeDeviceCode: <UserType>({ clientId, config, deviceCode, dpopJkt, now }: {
+    clientId: string;
+    config: OidcProviderConfig<UserType>;
+    deviceCode: string;
+    dpopJkt?: string;
+    now?: number;
+}) => Promise<DeviceCodeExchangeResult>;

package/dist/oidc/inMemoryStores.d.ts

@@ -1,4 +1,5 @@
-import type { AuthorizationCodeStore, OAuthClient, OAuthClientStore, OidcRefreshTokenStore } from './types';
+import type { AuthorizationCodeStore, DeviceAuthorizationStore, OAuthClient, OAuthClientStore, OidcRefreshTokenStore } from './types';
 export declare const createInMemoryAuthorizationCodeStore: () => AuthorizationCodeStore;
+export declare const createInMemoryDeviceAuthorizationStore: () => DeviceAuthorizationStore;
 export declare const createInMemoryOAuthClientStore: (clients: OAuthClient[]) => OAuthClientStore;
 export declare const createInMemoryOidcRefreshTokenStore: () => OidcRefreshTokenStore;

package/dist/oidc/postgresStores.d.ts

@@ -1,5 +1,5 @@
 import { type AnyPgDatabase } from '../stores/postgres';
-import type { AuthorizationCodeStore, OAuthClientStore, OidcRefreshTokenStore } from './types';
+import type { AuthorizationCodeStore, DeviceAuthorizationStore, OAuthClientStore, OidcRefreshTokenStore } from './types';
 export declare const oauthClientsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "auth_oauth_clients";
     schema: undefined;
@@ -386,6 +386,202 @@ export declare const oauthCodesTable: import("drizzle-orm/pg-core").PgTableWithC
     };
     dialect: "pg";
 }>;
+export declare const oauthDeviceAuthorizationsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_oauth_device_authorizations";
+    schema: undefined;
+    columns: {
+        client_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "client_id";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        created_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at_ms";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        device_code_hash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "device_code_hash";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        expires_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at_ms";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        interval_seconds: import("drizzle-orm/pg-core").PgColumn<{
+            name: "interval_seconds";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scopes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scopes";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "array";
+            columnType: "PgArray";
+            data: string[];
+            driverParam: string | string[];
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "scopes";
+                tableName: "auth_oauth_device_authorizations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "scopes";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                enumValues: [string, ...string[]];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 16;
+        }>;
+        user_code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_code";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 16;
+        }>;
+        user_sub: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_sub";
+            tableName: "auth_oauth_device_authorizations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+    };
+    dialect: "pg";
+}>;
 export declare const oauthRefreshTokensTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "auth_oauth_refresh_tokens";
     schema: undefined;
@@ -566,8 +762,10 @@ export declare const oauthRefreshTokensTable: import("drizzle-orm/pg-core").PgTa
     dialect: "pg";
 }>;
 export declare const createNeonAuthorizationCodeStore: (databaseUrl: string) => AuthorizationCodeStore;
+export declare const createNeonDeviceAuthorizationStore: (databaseUrl: string) => DeviceAuthorizationStore;
 export declare const createNeonOAuthClientStore: (databaseUrl: string) => OAuthClientStore;
 export declare const createNeonOidcRefreshTokenStore: (databaseUrl: string) => OidcRefreshTokenStore;
 export declare const createPostgresAuthorizationCodeStore: (db: AnyPgDatabase) => AuthorizationCodeStore;
+export declare const createPostgresDeviceAuthorizationStore: (db: AnyPgDatabase) => DeviceAuthorizationStore;
 export declare const createPostgresOAuthClientStore: (db: AnyPgDatabase) => OAuthClientStore;
 export declare const createPostgresOidcRefreshTokenStore: (db: AnyPgDatabase) => OidcRefreshTokenStore;

package/dist/oidc/routes.d.ts

@@ -60,6 +60,7 @@ export declare const oidcProviderRoutes: <UserType>(config: OidcProviderConfig<U
                 audience?: string | undefined;
                 resource?: string | undefined;
                 refresh_token?: string | undefined;
+                device_code?: string | undefined;
                 client_secret?: string | undefined;
                 grant_type?: string | undefined;
                 code?: string | undefined;
@@ -85,6 +86,113 @@ export declare const oidcProviderRoutes: <UserType>(config: OidcProviderConfig<U
             };
         };
     };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                client_id?: string | undefined;
+                client_secret?: string | undefined;
+                token_type_hint?: string | undefined;
+                token: string;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                authorization?: string | undefined;
+            };
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                client_id?: string | undefined;
+                client_secret?: string | undefined;
+                token_type_hint?: string | undefined;
+                token: string;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                authorization?: string | undefined;
+            };
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                client_id?: string | undefined;
+                scope?: string | undefined;
+                client_secret?: string | undefined;
+            };
+            params: {};
+            query: unknown;
+            headers: {
+                authorization?: string | undefined;
+            };
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                action?: "deny" | "approve" | undefined;
+                user_code: string;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
 } & {
     [x: string]: {
         get: {

package/dist/oidc/types.d.ts

@@ -38,5 +38,25 @@ export type OidcRefreshToken = {
 export type OidcRefreshTokenStore = {
     consumeToken: (tokenHash: string) => Promise<OidcRefreshToken | undefined>;
     deleteForUser: (userId: string) => Promise<void>;
+    getToken: (tokenHash: string) => Promise<OidcRefreshToken | undefined>;
     saveToken: (token: OidcRefreshToken) => Promise<void>;
 };
+export type DeviceAuthorizationStatus = 'approved' | 'denied' | 'pending';
+export type DeviceAuthorization = {
+    clientId: string;
+    createdAt: number;
+    deviceCodeHash: string;
+    expiresAt: number;
+    intervalSeconds: number;
+    scopes: string[];
+    status: DeviceAuthorizationStatus;
+    userCode: string;
+    userSub?: string;
+};
+export type DeviceAuthorizationStore = {
+    deleteByDeviceCodeHash: (deviceCodeHash: string) => Promise<void>;
+    findByDeviceCodeHash: (deviceCodeHash: string) => Promise<DeviceAuthorization | undefined>;
+    findByUserCode: (userCode: string) => Promise<DeviceAuthorization | undefined>;
+    saveDeviceAuthorization: (deviceAuthorization: DeviceAuthorization) => Promise<void>;
+    updateStatus: (deviceCodeHash: string, status: DeviceAuthorizationStatus, userSub?: string) => Promise<void>;
+};

package/dist/webhooks/config.d.ts

@@ -1,5 +1,15 @@
-import type { WebhookEndpoint, WebhookEvent } from './types';
+import type { WebhookDeliveryStore, WebhookEndpoint, WebhookEvent } from './types';
+export declare const DEFAULT_WEBHOOK_RETRY: {
+    readonly attempts: 3;
+    readonly backoffMultiplier: 2;
+    readonly initialDelayMs: 1000;
+};
 export declare const DEFAULT_WEBHOOK_TIMEOUT_MS: number;
+export type WebhookRetryConfig = {
+    attempts?: number;
+    backoffMultiplier?: number;
+    initialDelayMs?: number;
+};
 export type WebhookFetch = (url: string, init: {
     body: string;
     headers: Record<string, string>;
@@ -10,6 +20,7 @@ export type WebhookFetch = (url: string, init: {
     status: number;
 }>;
 export type WebhooksConfig = {
+    deliveryStore?: WebhookDeliveryStore;
     endpoints: WebhookEndpoint[];
     fetch?: WebhookFetch;
     onDeliveryError?: (context: {
@@ -17,5 +28,7 @@ export type WebhooksConfig = {
         error: unknown;
         event: WebhookEvent;
     }) => void | Promise<void>;
+    retry?: WebhookRetryConfig;
+    sleep?: (ms: number) => Promise<void>;
     timeoutMs?: number;
 };

package/dist/webhooks/dispatcher.d.ts

@@ -1,3 +1,3 @@
 import type { AuditEvent } from '../audit/types';
 import { type WebhooksConfig } from './config';
-export declare const createWebhookDispatcher: ({ endpoints, fetch: fetchImpl, onDeliveryError, timeoutMs }: WebhooksConfig) => (event: AuditEvent) => Promise<void>;
+export declare const createWebhookDispatcher: ({ deliveryStore, endpoints, fetch: fetchImpl, onDeliveryError, retry, sleep, timeoutMs }: WebhooksConfig) => (event: AuditEvent) => Promise<void>;

package/dist/webhooks/inMemoryStore.d.ts

@@ -0,0 +1,2 @@
+import type { WebhookDeliveryStore } from './types';
+export declare const createInMemoryWebhookDeliveryStore: () => WebhookDeliveryStore;

package/dist/webhooks/postgresStore.d.ts

@@ -0,0 +1,136 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { WebhookDeliveryStore, WebhookEvent } from './types';
+export declare const webhookDeliveriesTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_webhook_deliveries";
+    schema: undefined;
+    columns: {
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "auth_webhook_deliveries";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        created_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at_ms";
+            tableName: "auth_webhook_deliveries";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endpoint_url: import("drizzle-orm/pg-core").PgColumn<{
+            name: "endpoint_url";
+            tableName: "auth_webhook_deliveries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 2048;
+        }>;
+        envelope_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "envelope_id";
+            tableName: "auth_webhook_deliveries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        envelope_json: import("drizzle-orm/pg-core").PgColumn<{
+            name: "envelope_json";
+            tableName: "auth_webhook_deliveries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WebhookEvent;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WebhookEvent;
+        }>;
+        last_error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error";
+            tableName: "auth_webhook_deliveries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        last_status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_status";
+            tableName: "auth_webhook_deliveries";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonWebhookDeliveryStore: (databaseUrl: string) => WebhookDeliveryStore;
+export declare const createPostgresWebhookDeliveryStore: (db: AnyPgDatabase) => WebhookDeliveryStore;

package/dist/webhooks/types.d.ts

@@ -1,5 +1,6 @@
 import type { AuditEvent, AuditEventType } from '../audit/types';
 export type WebhookEndpoint = {
+    events?: readonly AuditEventType[];
     secret: string;
     url: string;
 };
@@ -9,3 +10,16 @@ export type WebhookEvent = {
     id: string;
     type: AuditEventType;
 };
+export type WebhookDelivery = {
+    attempts: number;
+    createdAt: number;
+    endpointUrl: string;
+    envelope: WebhookEvent;
+    lastError?: string;
+    lastStatus?: number;
+};
+export type WebhookDeliveryStore = {
+    listFailed: (limit?: number) => Promise<WebhookDelivery[]>;
+    recordFailure: (delivery: WebhookDelivery) => Promise<void>;
+    removeFailure: (envelopeId: string) => Promise<void>;
+};