@edge-markets/connect-node 1.7.0 → 1.8.0

package/dist/index.d.ts

@@ -1,16 +1,23 @@
 import * as node_https from 'node:https';
-import { EdgeEnvironment, TransferCategory, User, VerifyIdentityOptions, VerifyIdentityResult, Balance, Transfer, ListTransfersParams, TransferList, CreateVerificationSessionRequest, VerificationSession, VerificationSessionStatusResponse, EdgeTokens, EdgeWebhookEvent } from '@edge-markets/connect';
-export { Balance, BaseWebhookEvent, ConsentRevokedEventData, CreateVerificationSessionRequest, EDGE_WEBHOOK_EVENT_TYPES, EdgeApiError, EdgeAuthenticationError, EdgeConsentRequiredError, EdgeEnvironment, EdgeError, EdgeIdentityVerificationError, EdgeInsufficientScopeError, EdgeNetworkError, EdgeNotFoundError, EdgeTokenExchangeError, EdgeTokens, EdgeWebhookEvent, EdgeWebhookEventType, ListTransfersParams, SdkGeolocation, TRANSFER_CATEGORIES, Transfer, TransferCategory, TransferCompletedEventData, TransferExpiredEventData, TransferFailedEventData, TransferList, TransferListItem, TransferProcessingEventData, TransferStatus, TransferType, User, UserAddress, VerificationSession, VerificationSessionStatus, VerificationSessionStatusResponse, VerifyIdentityAddress, VerifyIdentityOptions, VerifyIdentityResult, VerifyIdentityScores, getEnvironmentConfig, isApiError, isAuthenticationError, isConsentRequiredError, isEdgeError, isIdentityVerificationError, isNetworkError, isProductionEnvironment } from '@edge-markets/connect';
+import { EdgeEnvironment, TransferCategory, Transfer, VerificationSession, TransferType, User, VerifyIdentityOptions, VerifyIdentityResult, Balance, ListTransfersParams, TransferList, CreateVerificationSessionRequest, VerificationSessionStatusResponse, EdgeTokens, EdgeWebhookEvent, TransferStatus, EdgeWebhookEventType } from '@edge-markets/connect';
+export { Balance, BaseWebhookEvent, ConsentRevokedEventData, CreateVerificationSessionRequest, EDGE_WEBHOOK_EVENT_TYPES, EdgeApiError, EdgeAuthenticationError, EdgeConsentRequiredError, EdgeEnvironment, EdgeError, EdgeIdentityVerificationError, EdgeInsufficientScopeError, EdgeNetworkError, EdgeNotFoundError, EdgeTokenExchangeError, EdgeTokens, EdgeValidationError, EdgeWebhookEvent, EdgeWebhookEventType, ListTransfersParams, SdkGeolocation, TRANSFER_CATEGORIES, Transfer, TransferCategory, TransferCompletedEventData, TransferExpiredEventData, TransferFailedEventData, TransferList, TransferListItem, TransferProcessingEventData, TransferStatus, TransferType, User, UserAddress, VerificationSession, VerificationSessionStatus, VerificationSessionStatusResponse, VerifyIdentityAddress, VerifyIdentityOptions, VerifyIdentityResult, VerifyIdentityScores, getEnvironmentConfig, isApiError, isAuthenticationError, isConsentRequiredError, isEdgeError, isIdentityVerificationError, isNetworkError, isProductionEnvironment } from '@edge-markets/connect';
 
+type RequestEndpoint = 'connect_api' | 'oauth_token' | 'partner_webhook_sync';
 interface RequestInfo {
     method: string;
     url: string;
     body?: unknown;
+    endpoint?: RequestEndpoint;
+    attempt?: number;
 }
 interface ResponseInfo {
     status: number;
     body: unknown;
     durationMs: number;
+    method?: string;
+    url?: string;
+    endpoint?: RequestEndpoint;
+    attempt?: number;
 }
 interface RetryConfig {
     maxRetries?: number;
@@ -23,6 +30,17 @@ interface EdgeConnectServerConfig {
     clientSecret: string;
     environment: EdgeEnvironment;
     apiBaseUrl?: string;
+    /**
+     * Override the partner dashboard API base URL.
+     *
+     * Most integrations should omit this. The SDK derives the dashboard base
+     * from `apiBaseUrl` by replacing `/connect/v1` with `/v1`, matching the
+     * EDGE Connect gateway layout:
+     *
+     * - user-scoped API: `https://connect-staging.edgeboost.io/connect/v1`
+     * - partner dashboard API: `https://connect-staging.edgeboost.io/v1`
+     */
+    partnerApiBaseUrl?: string;
     oauthBaseUrl?: string;
     /**
      * @deprecated cognitoDomain is no longer used. Token exchange now goes through EdgeBoost API.
@@ -63,9 +81,19 @@ interface EdgeConnectServerConfig {
 }
 interface MtlsConfig {
     enabled: boolean;
+    /** Client certificate PEM used to authenticate this partner to EDGE Connect. */
     cert: string;
+    /** Client private key PEM paired with `cert`. */
     key: string;
-    ca?: string;
+    /**
+     * Optional additional server trust root(s), as PEM text.
+     *
+     * The SDK appends these certificates to Node's default public trust store
+     * instead of replacing it. Public EDGE Connect gateways use public ACM
+     * certificates, so most partners should omit this unless EDGE provides a
+     * private server CA for a non-public endpoint.
+     */
+    ca?: string | string[];
 }
 interface TransferOptions {
     type: 'debit' | 'credit';
@@ -75,6 +103,38 @@ interface TransferOptions {
     category?: TransferCategory;
 }
 
+interface TransferAmountLimits {
+    min?: string | number;
+    max?: string | number;
+}
+interface CreateTransferIdempotencyKeyOptions {
+    partnerUserId: string;
+    type: TransferType;
+    amount: string | number;
+    category?: TransferCategory;
+    externalId?: string;
+    nonce?: string;
+    namespace?: string;
+}
+interface TransferIntent {
+    type: TransferType;
+    amount: string | number;
+    category?: TransferCategory | null;
+}
+interface StartTransferVerificationOptions {
+    transfer: TransferOptions;
+    origin: string;
+}
+interface StartTransferVerificationResult {
+    transfer: Transfer;
+    verificationSession: VerificationSession;
+}
+declare function normalizeMoneyAmount(value: string | number): string;
+declare function validateTransferAmount(value: string | number, limits?: TransferAmountLimits): string;
+declare function createTransferIdempotencyKey(options: CreateTransferIdempotencyKeyOptions): string;
+declare function assertSameTransferIntent(existing: TransferIntent, requested: TransferIntent): void;
+declare function startTransferVerification(client: Pick<EdgeUserClient, 'initiateTransfer' | 'createVerificationSession'>, options: StartTransferVerificationOptions): Promise<StartTransferVerificationResult>;
+
 /**
  * A lightweight, user-scoped API client created via {@link EdgeConnectServer.forUser}.
  *
@@ -89,6 +149,7 @@ declare class EdgeUserClient {
     verifyIdentity(options: VerifyIdentityOptions): Promise<VerifyIdentityResult>;
     getBalance(): Promise<Balance>;
     initiateTransfer(options: TransferOptions): Promise<Transfer>;
+    startTransferVerification(options: StartTransferVerificationOptions): Promise<StartTransferVerificationResult>;
     getTransfer(transferId: string): Promise<Transfer>;
     listTransfers(params?: ListTransfersParams): Promise<TransferList>;
     revokeConsent(): Promise<{
@@ -107,6 +168,92 @@ declare class EdgeUserClient {
     getVerificationSessionStatus(transferId: string, sessionId: string): Promise<VerificationSessionStatusResponse>;
 }
 
+type EdgeTokenVaultKeyMaterial = string | Buffer | Uint8Array;
+interface EdgeTokenVaultKey {
+    id: string;
+    key: EdgeTokenVaultKeyMaterial;
+}
+interface EdgeTokenVaultOptions {
+    currentKey: EdgeTokenVaultKey;
+    previousKeys?: EdgeTokenVaultKey[];
+}
+declare class EdgeTokenVault {
+    private readonly currentKey;
+    private readonly keysById;
+    constructor(options: EdgeTokenVaultOptions);
+    encryptTokens(tokens: EdgeTokens): string;
+    decryptTokens(envelope: string): EdgeTokens;
+    isEncrypted(value: unknown): value is string;
+}
+declare function createEdgeTokenVault(options: EdgeTokenVaultOptions): EdgeTokenVault;
+declare function isEdgeTokenVaultEnvelope(value: unknown): value is string;
+
+type EdgeTokenStoreValue = EdgeTokens | string;
+interface EdgeTokenStoreSaveContext {
+    tokens: EdgeTokens;
+    refreshed: boolean;
+}
+interface EdgeTokenStore {
+    load: (subjectId: string) => Promise<EdgeTokenStoreValue | null | undefined> | EdgeTokenStoreValue | null | undefined;
+    save: (subjectId: string, value: EdgeTokenStoreValue, context: EdgeTokenStoreSaveContext) => Promise<void> | void;
+}
+interface EdgeUserSessionOptions {
+    edge: Pick<EdgeConnectServer, 'forUser' | 'refreshTokens'>;
+    subjectId: string;
+    tokenStore: EdgeTokenStore;
+    tokenVault?: Pick<EdgeTokenVault, 'encryptTokens' | 'decryptTokens' | 'isEncrypted'>;
+    refreshSkewMs?: number;
+    now?: () => number;
+    onRefresh?: (tokens: EdgeTokens) => Promise<void> | void;
+}
+interface GetValidTokensOptions {
+    forceRefresh?: boolean;
+}
+declare class EdgeUserSession {
+    private readonly edge;
+    private readonly subjectId;
+    private readonly tokenStore;
+    private readonly tokenVault?;
+    private readonly refreshSkewMs;
+    private readonly now;
+    private readonly onRefresh?;
+    constructor(options: EdgeUserSessionOptions);
+    getValidTokens(options?: GetValidTokensOptions): Promise<EdgeTokens>;
+    getClient(options?: GetValidTokensOptions): Promise<EdgeUserClient>;
+    withClient<T>(callback: (client: EdgeUserClient, tokens: EdgeTokens) => Promise<T> | T): Promise<T>;
+    saveTokens(tokens: EdgeTokens, refreshed?: boolean): Promise<void>;
+    private loadTokens;
+}
+declare function createEdgeUserSession(options: EdgeUserSessionOptions): EdgeUserSession;
+
+interface WebhookReconcilerCursorStore {
+    load: () => Promise<string | null | undefined> | string | null | undefined;
+    save: (cursor: string) => Promise<void> | void;
+}
+interface WebhookReconcilerOptions {
+    edge: Pick<EdgeConnectServer, 'syncWebhookEvents'>;
+    cursorStore: WebhookReconcilerCursorStore;
+    processEvent: (event: EdgeWebhookEvent) => Promise<void> | void;
+    limit?: SyncWebhookEventsOptions['limit'];
+    maxPages?: number;
+}
+interface WebhookReconcilerRunResult {
+    processed: number;
+    pages: number;
+    cursor?: string;
+    hasMore: boolean;
+    skipped: boolean;
+    reason?: 'already_running' | 'empty_page_with_has_more' | 'max_pages_reached';
+}
+declare class EdgeWebhookReconciler {
+    private readonly options;
+    private running;
+    constructor(options: WebhookReconcilerOptions);
+    run(): Promise<WebhookReconcilerRunResult>;
+    private runInternal;
+}
+declare function createWebhookReconciler(options: WebhookReconcilerOptions): EdgeWebhookReconciler;
+
 /**
  * Options for {@link EdgeConnectServer.syncWebhookEvents}.
  */
@@ -142,6 +289,7 @@ interface SyncWebhookEventsResult {
 declare class EdgeConnectServer {
     private readonly config;
     private readonly apiBaseUrl;
+    private readonly partnerApiBaseUrl;
     private readonly oauthBaseUrl;
     private readonly timeout;
     private readonly retryConfig;
@@ -163,6 +311,7 @@ declare class EdgeConnectServer {
      * or per user session and discard it when the token changes.
      */
     forUser(accessToken: string): EdgeUserClient;
+    createUserSession(options: Omit<EdgeUserSessionOptions, 'edge'>): EdgeUserSession;
     exchangeCode(code: string, codeVerifier: string, redirectUri?: string): Promise<EdgeTokens>;
     refreshTokens(refreshToken: string): Promise<EdgeTokens>;
     /** @internal Called by {@link EdgeUserClient} — not part of the public API. */
@@ -205,9 +354,18 @@ declare class EdgeConnectServer {
      * @throws {EdgeApiError} For other non-2xx responses after retries
      */
     syncWebhookEvents(options?: SyncWebhookEventsOptions): Promise<SyncWebhookEventsResult>;
+    /**
+     * Creates a cursor-based webhook reconciler bound to this SDK instance.
+     *
+     * Use this from cron jobs to process events returned by
+     * {@link EdgeConnectServer.syncWebhookEvents} without hand-writing
+     * pagination, cursor advancement, or process-level concurrency guards.
+     */
+    createWebhookReconciler(options: Omit<WebhookReconcilerOptions, 'edge'>): EdgeWebhookReconciler;
     /**
      * Builds the sync URL with normalized query parameters.
      */
+    private normalizeSyncWebhookEventsOptions;
     private buildSyncUrl;
     /**
      * Issues a GET to the sync endpoint with the partner Bearer token. Kept
@@ -228,6 +386,9 @@ declare class EdgeConnectServer {
      * to `syncWebhookEvents` re-fetches it. Not part of the public API.
      */
     _resetPartnerTokenCache(): void;
+    private redactPartnerTokenResponseBody;
+    private redactPartnerSyncResponseBody;
+    private drainResponseBody;
     private getRetryDelay;
     private sleep;
     private fetchWithTimeout;
@@ -236,6 +397,87 @@ declare class EdgeConnectServer {
     private handleApiErrorFromBody;
 }
 
+type EdgeConnectEnv = Record<string, string | undefined>;
+interface CreateEdgeConnectServerFromEnvOptions {
+    env?: EdgeConnectEnv;
+    requireMtls?: boolean;
+    timeout?: number;
+    retry?: RetryConfig;
+    onRequest?: (info: RequestInfo) => void;
+    onResponse?: (info: ResponseInfo) => void;
+    mle?: EdgeConnectServerConfig['mle'];
+}
+interface EdgeConnectServerFromEnvCapabilities {
+    mtlsEnabled: boolean;
+    webhookSyncConfigured: boolean;
+    customApiBaseUrl: boolean;
+    customOAuthBaseUrl: boolean;
+    customPartnerApiBaseUrl: boolean;
+}
+interface EdgeConnectServerFromEnvResult {
+    server: EdgeConnectServer;
+    config: EdgeConnectServerConfig;
+    capabilities: EdgeConnectServerFromEnvCapabilities;
+    warnings: string[];
+}
+declare function createEdgeConnectServerFromEnv(options?: CreateEdgeConnectServerFromEnvOptions): EdgeConnectServerFromEnvResult;
+
+interface EdgeProblemJson {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    code: string;
+    details?: Record<string, unknown>;
+}
+interface EdgeHttpError {
+    status: number;
+    body: EdgeProblemJson;
+}
+declare function toEdgeHttpError(error: unknown): EdgeHttpError;
+declare function toEdgeProblemJson(error: unknown): EdgeProblemJson;
+
+interface PartnerIdentityAddress {
+    street?: string | null;
+    line1?: string | null;
+    address1?: string | null;
+    city?: string | null;
+    state?: string | null;
+    zip?: string | null;
+    postalCode?: string | null;
+}
+interface PartnerIdentityProfile {
+    firstName?: string | null;
+    givenName?: string | null;
+    lastName?: string | null;
+    familyName?: string | null;
+    address?: PartnerIdentityAddress | null;
+}
+interface IdentityPolicy {
+    minNameScore?: number;
+    minAddressScore?: number;
+    requireZipMatch?: boolean;
+    requireApiVerified?: boolean;
+}
+interface IdentityPolicyEvaluation {
+    verified: boolean;
+    reasons: string[];
+    scores?: VerifyIdentityResult['scores'];
+}
+declare function buildVerifyIdentityPayload(profile: PartnerIdentityProfile): VerifyIdentityOptions;
+declare function evaluateIdentityResult(result: VerifyIdentityResult, policy?: IdentityPolicy): IdentityPolicyEvaluation;
+
+interface TransferWebhookIntent {
+    transferId: string;
+    type?: TransferType;
+    amount?: string | number;
+    status?: TransferStatus;
+}
+declare function isTransferWebhookEvent(event: EdgeWebhookEvent): event is Extract<EdgeWebhookEvent, {
+    type: `transfer.${string}`;
+}>;
+declare function assertTransferEventMatchesIntent(event: EdgeWebhookEvent, intent: TransferWebhookIntent): void;
+
 /**
  * Webhook Signature Verification (SDK-001)
  *
@@ -300,4 +542,24 @@ interface VerifyWebhookSignatureOptions {
  */
 declare function verifyWebhookSignature(header: string, body: string, secret: string, options?: VerifyWebhookSignatureOptions): boolean;
 
-export { EdgeConnectServer, type EdgeConnectServerConfig, EdgeUserClient, type MtlsConfig, type RequestInfo, type ResponseInfo, type RetryConfig, type SyncWebhookEventsOptions, type SyncWebhookEventsResult, type TransferOptions, type VerifyWebhookSignatureOptions, verifyWebhookSignature };
+type EdgeWebhookRawBody = string | Buffer | Uint8Array;
+type EdgeWebhookSignatureHeader = string | string[] | undefined | null;
+interface ParseAndVerifyWebhookOptions extends VerifyWebhookSignatureOptions {
+    rawBody: EdgeWebhookRawBody;
+    signatureHeader: EdgeWebhookSignatureHeader;
+    secret: string;
+    receivedAt?: Date;
+}
+interface ParsedEdgeWebhook {
+    event: EdgeWebhookEvent;
+    eventId: string;
+    eventType: EdgeWebhookEventType;
+    signatureTimestamp: number;
+    receivedAt: Date;
+}
+declare function parseAndVerifyWebhook(options: ParseAndVerifyWebhookOptions): ParsedEdgeWebhook;
+declare function extractWebhookSignatureTimestamp(header: EdgeWebhookSignatureHeader): number | undefined;
+declare function isEdgeWebhookEvent(value: unknown): value is EdgeWebhookEvent;
+declare function validateEdgeWebhookEvent(value: unknown): EdgeWebhookEvent;
+
+export { type CreateEdgeConnectServerFromEnvOptions, type CreateTransferIdempotencyKeyOptions, type EdgeConnectEnv, EdgeConnectServer, type EdgeConnectServerConfig, type EdgeConnectServerFromEnvCapabilities, type EdgeConnectServerFromEnvResult, type EdgeHttpError, type EdgeProblemJson, type EdgeTokenStore, type EdgeTokenStoreSaveContext, type EdgeTokenStoreValue, EdgeTokenVault, type EdgeTokenVaultKey, type EdgeTokenVaultKeyMaterial, type EdgeTokenVaultOptions, EdgeUserClient, EdgeUserSession, type EdgeUserSessionOptions, type EdgeWebhookRawBody, EdgeWebhookReconciler, type EdgeWebhookSignatureHeader, type GetValidTokensOptions, type IdentityPolicy, type IdentityPolicyEvaluation, type MtlsConfig, type ParseAndVerifyWebhookOptions, type ParsedEdgeWebhook, type PartnerIdentityAddress, type PartnerIdentityProfile, type RequestInfo, type ResponseInfo, type RetryConfig, type StartTransferVerificationOptions, type StartTransferVerificationResult, type SyncWebhookEventsOptions, type SyncWebhookEventsResult, type TransferAmountLimits, type TransferIntent, type TransferOptions, type TransferWebhookIntent, type VerifyWebhookSignatureOptions, type WebhookReconcilerCursorStore, type WebhookReconcilerOptions, type WebhookReconcilerRunResult, assertSameTransferIntent, assertTransferEventMatchesIntent, buildVerifyIdentityPayload, createEdgeConnectServerFromEnv, createEdgeTokenVault, createEdgeUserSession, createTransferIdempotencyKey, createWebhookReconciler, evaluateIdentityResult, extractWebhookSignatureTimestamp, isEdgeTokenVaultEnvelope, isEdgeWebhookEvent, isTransferWebhookEvent, normalizeMoneyAmount, parseAndVerifyWebhook, startTransferVerification, toEdgeHttpError, toEdgeProblemJson, validateEdgeWebhookEvent, validateTransferAmount, verifyWebhookSignature };