@timbro/payments 0.1.0-next.0

package/dist/payments-client.js

@@ -0,0 +1,670 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import createClient from "openapi-fetch";
+import { verifySignedWebhookBody } from "./webhook-signature.js";
+const TRAILING_SLASH = /\/$/;
+const CONTENT_DIGEST = /^sha-256=:([A-Za-z0-9+/]+={0,2}):$/;
+const DELTA_SECONDS = /^\d+$/;
+const EVENT_ID = /^event_[0-9a-hjkmnp-tv-z]{24,}$/;
+const PAYMENT_ID = /^payment_[0-9a-hjkmnp-tv-z]{24,}$/;
+const FISCAL_DOCUMENT_ID = /^fiscal_document_[0-9a-hjkmnp-tv-z]{24,}$/;
+const MERCHANT_RNC = /^\d{9}$/;
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+export class PaymentsError extends Error {
+    status;
+    code;
+    title;
+    requestId;
+    problems;
+    retryAfterSeconds;
+    isRetryable;
+    constructor(input) {
+        super(input.title, input.cause === undefined ? undefined : { cause: input.cause });
+        this.name = "PaymentsError";
+        this.status = input.status;
+        this.code = input.code;
+        this.title = input.title;
+        this.requestId = input.requestId;
+        this.problems = input.problems ?? [];
+        this.retryAfterSeconds = input.retryAfterSeconds;
+        this.isRetryable =
+            input.code === "transport_failure" ||
+                input.retryAfterSeconds !== undefined ||
+                RETRYABLE_STATUSES.has(input.status);
+    }
+}
+export function createTimbroPayments(options) {
+    const secretKey = options.secretKey;
+    if (secretKey === undefined || secretKey.trim() === "") {
+        throw new TypeError("Timbro Payments secretKey is required.");
+    }
+    const baseUrl = (options.baseUrl ?? "https://api.timbro.dev").replace(TRAILING_SLASH, "");
+    const transport = options.fetch ?? globalThis.fetch;
+    const fetcher = async (input, init) => {
+        try {
+            return await transport(input, init);
+        }
+        catch (cause) {
+            throw transportError(cause);
+        }
+    };
+    const headers = {
+        authorization: `Bearer ${secretKey}`,
+    };
+    const client = createClient({ baseUrl, fetch: fetcher, headers });
+    const listPayments = async (params) => {
+        const response = await client.GET("/v1/payments", params === undefined
+            ? {}
+            : { params: { query: params } });
+        return decodePaymentList(requireData(response));
+    };
+    const listWebhookEndpoints = async (params) => {
+        const response = await client.GET("/v1/webhook_endpoints", params === undefined
+            ? {}
+            : { params: { query: params } });
+        return decodeWebhookEndpointList(requireData(response));
+    };
+    const listWebhookDeliveries = async (webhookEndpointId, params) => {
+        const response = await client.GET("/v1/webhook_endpoints/{webhookEndpointId}/deliveries", {
+            params: {
+                path: { webhookEndpointId },
+                ...(params === undefined
+                    ? {}
+                    : { query: params }),
+            },
+        });
+        return decodeWebhookDeliveryList(requireData(response));
+    };
+    const listMerchantAccounts = async (params) => {
+        const response = await client.GET("/v1/merchant_accounts", params === undefined
+            ? {}
+            : { params: { query: params } });
+        return decodeMerchantAccountList(requireData(response));
+    };
+    const listRefunds = async (params) => {
+        const response = await client.GET("/v1/refunds", params === undefined
+            ? {}
+            : {
+                params: {
+                    query: params,
+                },
+            });
+        return requireData(response);
+    };
+    return {
+        payments: {
+            async create(command) {
+                const { idempotencyKey, ...body } = command;
+                const response = await client.POST("/v1/payments", {
+                    body: createPaymentBody(body),
+                    params: { header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) } },
+                });
+                return decodePayment(requireData(response));
+            },
+            async retrieve(paymentId) {
+                return decodePayment(requireData(await client.GET("/v1/payments/{paymentId}", { params: { path: { paymentId } } })));
+            },
+            async cancel(command) {
+                const { paymentId, idempotencyKey } = command;
+                return decodePayment(requireData(await client.POST("/v1/payments/{paymentId}/cancel", {
+                    params: {
+                        path: { paymentId },
+                        header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) },
+                    },
+                })));
+            },
+            async attachExternalFiscalDocumentReference(command) {
+                const { paymentId, idempotencyKey, ...body } = command;
+                return decodePayment(requireData(await client.POST("/v1/payments/{paymentId}/fiscal-document-reference", {
+                    params: {
+                        path: { paymentId },
+                        header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) },
+                    },
+                    body: body,
+                })));
+            },
+            async refund(command) {
+                const response = await client.POST("/v1/payments/{paymentId}/refunds", {
+                    params: {
+                        path: { paymentId: command.paymentId },
+                        header: { "idempotency-key": requireIdempotencyKey(command.idempotencyKey) },
+                    },
+                });
+                return decodeRefund(requireData(response));
+            },
+            list: listPayments,
+            listAll(params) {
+                return walkCollection((cursor) => listPayments({ ...params, ...(cursor === undefined ? {} : { cursor }) }));
+            },
+        },
+        refunds: {
+            async create(command) {
+                const { idempotencyKey, ...body } = command;
+                return decodeRefund(requireData(await client.POST("/v1/refunds", {
+                    body: body,
+                    params: { header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) } },
+                })));
+            },
+            async attachFiscalCoordination(command) {
+                const { refundId, idempotencyKey, ...body } = command;
+                return decodeRefund(requireData(await client.POST("/v1/refunds/{refundId}/fiscal-coordination", {
+                    params: {
+                        path: { refundId },
+                        header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) },
+                    },
+                    body: body,
+                })));
+            },
+            async retrieve(refundId) {
+                return decodeRefund(requireData(await client.GET("/v1/refunds/{refundId}", { params: { path: { refundId } } })));
+            },
+            list: listRefunds,
+            listAll(params) {
+                return walkCollection((cursor) => listRefunds({ ...params, ...(cursor === undefined ? {} : { cursor }) }));
+            },
+        },
+        merchantAccounts: {
+            list: listMerchantAccounts,
+            async retrieveCheckoutCapabilities(merchantAccountId) {
+                return requireData(await client.GET("/v1/merchant_accounts/{merchantAccountId}/checkout_capabilities", {
+                    params: { path: { merchantAccountId } },
+                }));
+            },
+            listAll(params) {
+                return walkCollection((cursor) => listMerchantAccounts({ ...params, ...(cursor === undefined ? {} : { cursor }) }));
+            },
+            async retrieve(merchantAccountId) {
+                return decodeMerchantAccount(requireData(await client.GET("/v1/merchant_accounts/{merchantAccountId}", {
+                    params: { path: { merchantAccountId } },
+                })));
+            },
+        },
+        merchantCheckoutPolicy: {
+            async retrieve() {
+                return requireData(await client.GET("/v1/merchant_checkout_policy"));
+            },
+        },
+        merchantOnboarding: {
+            async verifyRnc(input) {
+                const response = await client.POST("/v1/merchant_onboarding/rnc_verification", {
+                    body: { rnc: requireMerchantRnc(input.rnc) },
+                });
+                return decodeMerchantRncVerification(requireData(response));
+            },
+        },
+        webhookEndpoints: {
+            async create(command) {
+                const { idempotencyKey, ...body } = command;
+                return decodeWebhookEndpoint(requireData(await client.POST("/v1/webhook_endpoints", {
+                    params: { header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) } },
+                    body: body,
+                })));
+            },
+            async rotateSecret(command) {
+                return decodeWebhookEndpoint(requireData(await client.POST("/v1/webhook_endpoints/{webhookEndpointId}/rotate-secret", {
+                    params: {
+                        path: { webhookEndpointId: command.webhookEndpointId },
+                        header: {
+                            "idempotency-key": requireIdempotencyKey(command.idempotencyKey),
+                        },
+                    },
+                })));
+            },
+            async suspend(webhookEndpointId) {
+                return decodeWebhookEndpoint(requireData(await client.POST("/v1/webhook_endpoints/{webhookEndpointId}/suspend", {
+                    params: { path: { webhookEndpointId } },
+                })));
+            },
+            async reactivate(webhookEndpointId) {
+                return decodeWebhookEndpoint(requireData(await client.POST("/v1/webhook_endpoints/{webhookEndpointId}/reactivate", {
+                    params: { path: { webhookEndpointId } },
+                })));
+            },
+            async delete(webhookEndpointId) {
+                requireSuccess(await client.DELETE("/v1/webhook_endpoints/{webhookEndpointId}", {
+                    params: { path: { webhookEndpointId } },
+                }));
+            },
+            list: listWebhookEndpoints,
+            listAll(params) {
+                return walkCollection((cursor) => listWebhookEndpoints({ ...params, ...(cursor === undefined ? {} : { cursor }) }));
+            },
+            async retrieve(webhookEndpointId) {
+                return decodeWebhookEndpoint(requireData(await client.GET("/v1/webhook_endpoints/{webhookEndpointId}", {
+                    params: { path: { webhookEndpointId } },
+                })));
+            },
+            listDeliveries: listWebhookDeliveries,
+            listAllDeliveries(webhookEndpointId, params) {
+                return walkCollection((cursor) => listWebhookDeliveries(webhookEndpointId, {
+                    ...params,
+                    ...(cursor === undefined ? {} : { cursor }),
+                }));
+            },
+            async replay(command) {
+                const { webhookEndpointId, idempotencyKey, ...scope } = command;
+                return requireData(await client.POST("/v1/webhook_endpoints/{webhookEndpointId}/replays", {
+                    params: {
+                        path: { webhookEndpointId },
+                        header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) },
+                    },
+                    body: scope,
+                }));
+            },
+        },
+        fiscalDeliveries: {
+            async create(command) {
+                const { fiscalDocumentId, idempotencyKey, ...body } = command;
+                return decodeFiscalDelivery(requireData((await client.POST("/v1/fiscal_documents/{fiscalDocumentId}/deliveries", {
+                    params: {
+                        path: { fiscalDocumentId },
+                        header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) },
+                    },
+                    body,
+                }))));
+            },
+        },
+        fiscalDocuments: {
+            async retrieve(fiscalDocumentId) {
+                return decodeFiscalDocument(requireData(await client.GET("/v1/fiscal_documents/{fiscalDocumentId}", {
+                    params: { path: { fiscalDocumentId } },
+                })));
+            },
+            async correct(command) {
+                const { fiscalDocumentId, idempotencyKey, ...body } = command;
+                return decodeFiscalDocument(requireData(await client.POST("/v1/fiscal_documents/{fiscalDocumentId}/corrections", {
+                    params: {
+                        path: { fiscalDocumentId },
+                        header: { "idempotency-key": requireIdempotencyKey(idempotencyKey) },
+                    },
+                    body: body,
+                })));
+            },
+            retrieveSignedDocument: (fiscalDocumentId) => retrieveArtifact(fetcher, headers, baseUrl, fiscalDocumentId, "signed-document"),
+            retrievePrintedRepresentation: (fiscalDocumentId) => retrieveArtifact(fetcher, headers, baseUrl, fiscalDocumentId, "printed-representation"),
+        },
+        webhooks: { verify: verifyWebhook },
+    };
+}
+function createPaymentBody(command) {
+    return {
+        source: command.source,
+        sale: command.sale,
+        invoicing: command.invoicing,
+        ...(command.returnUrl === undefined ? {} : { returnUrl: command.returnUrl }),
+        ...(command.serviceLabel === undefined ? {} : { serviceLabel: command.serviceLabel }),
+        ...(command.checkoutDisplay === undefined ? {} : { checkoutDisplay: command.checkoutDisplay }),
+        ...(command.merchantAccountId === undefined
+            ? {}
+            : { merchantAccountId: command.merchantAccountId }),
+        ...(command.checkoutPreferences === undefined
+            ? {}
+            : { checkoutPreferences: command.checkoutPreferences }),
+        ...(command.testOptions === undefined ? {} : { testOptions: command.testOptions }),
+    };
+}
+function decodePayment(value) {
+    return {
+        id: value.id,
+        object: "payment",
+        status: value.status,
+        amount: value.amount,
+        voluntaryTip: value.voluntaryTip,
+        totalAmount: value.totalAmount,
+        saleReference: value.saleReference,
+        source: value.source,
+        ...(value.returnUrl === undefined ? {} : { returnUrl: value.returnUrl }),
+        ...(value.serviceLabel === undefined ? {} : { serviceLabel: value.serviceLabel }),
+        ...(value.description === undefined ? {} : { description: value.description }),
+        ...(value.breakdown === undefined ? {} : { breakdown: value.breakdown }),
+        sale: value.sale,
+        checkoutDisplay: {
+            mode: value.checkoutDisplay.mode,
+            wallets: value.checkoutDisplay.wallets,
+        },
+        ...(value.nextAction === undefined
+            ? {}
+            : {
+                nextAction: {
+                    type: "redirect",
+                    url: value.nextAction.url,
+                    expiresAt: value.nextAction.expiresAt,
+                },
+            }),
+        isLiveMode: value.isLiveMode,
+        expiresAt: value.expiresAt,
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+        fiscalDocument: value.fiscalDocument === null ? null : decodeFiscalDocument(value.fiscalDocument),
+        paymentMethodSummary: value.paymentMethodSummary,
+        ...(value.capturedPayment === undefined ? {} : { capturedPayment: value.capturedPayment }),
+        problem: value.problem,
+        split: value.split,
+    };
+}
+function decodeRefund(value) {
+    if (value.status === "succeeded" && value.completedAt === undefined) {
+        throw new Error("Succeeded refund is missing completedAt");
+    }
+    if (value.status === "declined" &&
+        (value.decline === undefined || value.completedAt === undefined)) {
+        throw new Error("Declined refund is missing its terminal fields");
+    }
+    if (value.status === "operator_required" &&
+        (value.problem === undefined || value.completedAt === undefined)) {
+        throw new Error("Operator-required refund is missing its terminal fields");
+    }
+    return value;
+}
+function decodePaymentList(value) {
+    return {
+        object: "list",
+        data: value.data.map(decodePayment),
+        hasMore: value.hasMore,
+        nextCursor: value.nextCursor,
+    };
+}
+function decodeFiscalDelivery(value) {
+    return "problem" in value
+        ? { email: value.email, status: value.status, problem: value.problem }
+        : { email: value.email, status: value.status };
+}
+function decodeFiscalDocument(value) {
+    const base = {
+        id: value.id,
+        object: "fiscal_document",
+        paymentId: value.paymentId,
+        issuanceMode: value.issuanceMode,
+        kind: value.kind,
+        ...(value.merchantInvoiceNumber === undefined
+            ? {}
+            : { merchantInvoiceNumber: value.merchantInvoiceNumber }),
+        ...(value.merchantOrderNumber === undefined
+            ? {}
+            : { merchantOrderNumber: value.merchantOrderNumber }),
+        revision: value.revision,
+        ...(value.buyer === undefined ? {} : { buyer: value.buyer }),
+        ...(value.governmentEligibility === undefined
+            ? {}
+            : { governmentEligibility: value.governmentEligibility }),
+        lines: value.lines.map((line) => ({
+            sourceLineId: line.sourceLineId,
+            description: line.description,
+            quantity: line.quantity,
+            measurementUnit: line.measurementUnit,
+            unitPriceMinorUnits: line.unitPriceMinorUnits,
+            ...(line.unitPrice === undefined ? {} : { unitPrice: line.unitPrice }),
+            itemKind: line.itemKind,
+            taxTreatment: line.taxTreatment,
+            isLegalTipApplicable: line.isLegalTipApplicable,
+            ...(line.taxIncluded === undefined ? {} : { taxIncluded: line.taxIncluded }),
+            ...(line.group === undefined ? {} : { group: line.group }),
+        })),
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+        delivery: value.delivery === null ? null : decodeFiscalDelivery(value.delivery),
+    };
+    if (value.status === "issued") {
+        return {
+            ...base,
+            status: "issued",
+            eNcf: value.eNcf,
+            issuedAt: value.issuedAt,
+            signedDocument: { sha256: value.signedDocument.sha256 },
+        };
+    }
+    if (value.status === "accepted") {
+        return {
+            ...base,
+            status: "accepted",
+            externalReference: value.externalReference,
+            printedRepresentation: value.printedRepresentation,
+        };
+    }
+    return { ...base, status: value.status };
+}
+function decodeMerchantAccount(value) {
+    return {
+        id: value.id,
+        object: "merchant_account",
+        provider: value.provider,
+        mode: value.mode,
+        ...(value.venueReference === undefined ? {} : { venueReference: value.venueReference }),
+        lifecycle: value.lifecycle,
+        ...(value.credentialVersion === undefined
+            ? {}
+            : { credentialVersion: value.credentialVersion }),
+        readiness: {
+            status: value.readiness.status,
+            blockers: value.readiness.blockers.map(({ code, owner, detail }) => ({
+                code,
+                owner,
+                ...(detail === undefined ? {} : { detail }),
+            })),
+            checks: value.readiness.checks,
+        },
+        capabilities: "capabilities" in value ? value.capabilities : [],
+    };
+}
+function decodeMerchantAccountList(value) {
+    return {
+        object: "list",
+        data: value.data.map(decodeMerchantAccount),
+        hasMore: value.hasMore,
+        nextCursor: value.nextCursor,
+    };
+}
+function decodeWebhookEndpoint(value) {
+    return {
+        id: value.id,
+        object: "webhook_endpoint",
+        url: value.url,
+        enabledEvents: value.enabledEvents,
+        status: value.status,
+        secretCreatedAt: value.secretCreatedAt,
+        previousSecretExpiresAt: value.previousSecretExpiresAt,
+        createdAt: value.createdAt,
+        ...(value.secret === undefined ? {} : { secret: value.secret }),
+    };
+}
+function decodeWebhookEndpointList(value) {
+    return {
+        object: "list",
+        data: value.data.map(decodeWebhookEndpoint),
+        hasMore: value.hasMore,
+        nextCursor: value.nextCursor,
+    };
+}
+function decodeWebhookDeliveryList(value) {
+    return {
+        object: "list",
+        data: value.data,
+        hasMore: value.hasMore,
+        nextCursor: value.nextCursor,
+    };
+}
+function requireIdempotencyKey(idempotencyKey) {
+    if (idempotencyKey.trim() === "") {
+        throw new TypeError("idempotencyKey is required for mutating commands.");
+    }
+    return idempotencyKey;
+}
+function requireMerchantRnc(rnc) {
+    if (!MERCHANT_RNC.test(rnc)) {
+        throw new TypeError("rnc must contain exactly nine digits.");
+    }
+    return rnc;
+}
+function decodeMerchantRncVerification(value) {
+    if (!hasExactKeys(value, ["rnc", "legalName"]) ||
+        typeof value.rnc !== "string" ||
+        !MERCHANT_RNC.test(value.rnc) ||
+        typeof value.legalName !== "string" ||
+        value.legalName.trim() === "" ||
+        value.legalName.length > 256) {
+        throw new PaymentsError({
+            status: 502,
+            code: "unexpected_http_error",
+            title: "Timbro Payments returned an invalid merchant RNC verification response.",
+        });
+    }
+    return { rnc: value.rnc, legalName: value.legalName };
+}
+function requireData(response) {
+    if (response.data !== undefined) {
+        return response.data;
+    }
+    throw httpError(response.response, response.error);
+}
+function requireSuccess(response) {
+    if (!response.response.ok) {
+        throw httpError(response.response, response.error);
+    }
+}
+function problemPointers(problems) {
+    if (!Array.isArray(problems)) {
+        return [];
+    }
+    return problems.flatMap((entry) => {
+        if (typeof entry !== "object" || entry === null) {
+            return [];
+        }
+        const { pointer, code } = entry;
+        return typeof pointer === "string" && typeof code === "string"
+            ? [{ pointer, code: code }]
+            : [];
+    });
+}
+/** `Retry-After` carries either delta-seconds or an IMF-fixdate. */
+function retryAfterSeconds(header) {
+    if (header === null) {
+        return undefined;
+    }
+    const value = header.trim();
+    if (DELTA_SECONDS.test(value)) {
+        return Number(value);
+    }
+    const at = Date.parse(value);
+    return Number.isNaN(at) ? undefined : Math.max(0, Math.ceil((at - Date.now()) / 1000));
+}
+function httpError(response, body) {
+    const problem = typeof body === "object" && body !== null ? body : {};
+    const code = typeof problem.code === "string" ? problem.code : undefined;
+    const title = typeof problem.title === "string" && problem.title !== ""
+        ? problem.title
+        : `Timbro Payments returned HTTP ${response.status}.`;
+    const requestId = response.headers.get("request-id") ?? undefined;
+    const seconds = retryAfterSeconds(response.headers.get("retry-after"));
+    return new PaymentsError({
+        status: response.status,
+        code: code ?? "unexpected_http_error",
+        title,
+        ...(requestId === undefined ? {} : { requestId }),
+        problems: problemPointers(problem.problems),
+        ...(seconds === undefined ? {} : { retryAfterSeconds: seconds }),
+    });
+}
+/** A page that promises more without minting a fresh cursor would walk the same rows for ever. */
+async function* walkCollection(readPage) {
+    const spent = new Set();
+    let cursor;
+    for (;;) {
+        const page = await readPage(cursor);
+        yield* page.data;
+        if (!page.hasMore) {
+            return;
+        }
+        if (page.nextCursor === null || spent.has(page.nextCursor)) {
+            throw new PaymentsError({
+                status: 0,
+                code: "collection_page_not_advancing",
+                title: "Timbro Payments returned a page that promised more rows without advancing.",
+            });
+        }
+        spent.add(page.nextCursor);
+        cursor = page.nextCursor;
+    }
+}
+function transportError(cause) {
+    return new PaymentsError({
+        status: 0,
+        code: "transport_failure",
+        title: "Timbro Payments could not be reached.",
+        cause,
+    });
+}
+async function retrieveArtifact(fetcher, headers, baseUrl, fiscalDocumentId, artifact) {
+    const response = await fetcher(`${baseUrl}/v1/fiscal_documents/${encodeURIComponent(fiscalDocumentId)}/${artifact}`, { headers });
+    if (!response.ok) {
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = undefined;
+        }
+        throw httpError(response, body);
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const digest = response.headers.get("content-digest");
+    if (digest === null || !verifyContentDigest(bytes, digest)) {
+        throw new PaymentsError({
+            status: 503,
+            code: "artifact_digest_mismatch",
+            title: "The fiscal artifact failed Content-Digest verification.",
+        });
+    }
+    return {
+        bytes,
+        mediaType: response.headers.get("content-type") ?? "application/octet-stream",
+        contentDigest: digest,
+    };
+}
+function verifyContentDigest(bytes, header) {
+    const match = CONTENT_DIGEST.exec(header);
+    if (match?.[1] === undefined) {
+        return false;
+    }
+    const expected = Buffer.from(match[1], "base64");
+    const actual = createHash("sha256").update(bytes).digest();
+    return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+function verifyWebhook(command) {
+    const signed = verifySignedWebhookBody(command);
+    if (!isWebhookEvent(signed.payload) || signed.payload.id !== signed.webhookId) {
+        throw new TypeError("Invalid Timbro webhook event.");
+    }
+    return signed.payload;
+}
+function isWebhookEvent(value) {
+    if (!hasExactKeys(value, ["id", "type", "apiVersion", "occurredAt", "data"])) {
+        return false;
+    }
+    if (typeof value.id !== "string" ||
+        !EVENT_ID.test(value.id) ||
+        typeof value.apiVersion !== "string" ||
+        typeof value.occurredAt !== "string" ||
+        Number.isNaN(Date.parse(value.occurredAt)) ||
+        !hasExactKeys(value.data, ["id", "object"]) ||
+        typeof value.data.id !== "string") {
+        return false;
+    }
+    if (value.type === "payment.succeeded" ||
+        value.type === "payment.canceled" ||
+        value.type === "payment.operator_required") {
+        return PAYMENT_ID.test(value.data.id) && value.data.object === "payment";
+    }
+    return ((value.type === "fiscal_document.issued" ||
+        value.type === "fiscal_document.rejected" ||
+        value.type === "fiscal_document.operator_required") &&
+        FISCAL_DOCUMENT_ID.test(value.data.id) &&
+        value.data.object === "fiscal_document");
+}
+function hasExactKeys(value, expected) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const keys = Object.keys(value).sort();
+    const expectedKeys = [...expected].sort();
+    return (keys.length === expectedKeys.length && keys.every((key, index) => key === expectedKeys[index]));
+}
+//# sourceMappingURL=payments-client.js.map