@primitivedotdev/sdk 1.7.0 → 1.9.0

package/dist/parser/index.d.ts

@@ -1,4 +1,4 @@
-import { F as WebhookAttachment, l as EmailAddress, w as ParsedDataComplete } from "../types-QT2ss9ho.js";
+import { F as WebhookAttachment, l as EmailAddress, w as ParsedDataComplete } from "../types-BjnIxPED.js";
 import { a as parseFromHeader, i as ValidatedAddress, n as ParseFromHeaderResult, o as parseFromHeaderLoose, r as ParsedAddress, t as ParseFromHeaderFailureReason } from "../address-parser-CA6G7R-h.js";
 
 //#region src/parser/attachment-parser.d.ts

package/dist/{types-QT2ss9ho.d.ts → types-BjnIxPED.d.ts}

@@ -897,6 +897,95 @@ interface DkimSignature$1 {
   algo: (string | null);
 }
 //#endregion
+//#region src/webhook/events.d.ts
+/**
+ * The five first-party email events (subject = an email).
+ */
+declare const EMAIL_EVENT_TYPES: readonly ["email.received", "email.bounced", "email.tls_report", "email.dmarc_report", "email.dmarc_failure"];
+/**
+ * The two x402 settlement-notification events (subject = a payment). Emitted for
+ * both the synthetic API pay flow and the email-native settle path.
+ */
+declare const PAYMENT_EVENT_TYPES: readonly ["payment.settled", "payment.failed"];
+/**
+ * The interaction step events (subject = an interaction). One event per accepted
+ * protocol step, named `interaction.<protocolShort>.<suffix>`.
+ *
+ * The x402 slice covers the payment lifecycle a payee/payer cares about; the ack
+ * slice covers the acknowledgement protocols.
+ */
+declare const INTERACTION_EVENT_TYPES: readonly ["interaction.ack.acked", "interaction.ack.canceled", "interaction.ack.expired", "interaction.ack.received", "interaction.ack.requested", "interaction.x402.challenge", "interaction.x402.declined", "interaction.x402.expired", "interaction.x402.payment", "interaction.x402.rejected", "interaction.x402.settled", "interaction.x402.verify_timeout"];
+/**
+ * The full enumerated catalog of every current webhook event type: the five
+ * email.*, the two payment.*, and every interaction.<protocol>.<suffix>.
+ */
+declare const WEBHOOK_EVENT_TYPES: readonly ["email.received", "email.bounced", "email.tls_report", "email.dmarc_report", "email.dmarc_failure", "payment.settled", "payment.failed", "interaction.ack.acked", "interaction.ack.canceled", "interaction.ack.expired", "interaction.ack.received", "interaction.ack.requested", "interaction.x402.challenge", "interaction.x402.declined", "interaction.x402.expired", "interaction.x402.payment", "interaction.x402.rejected", "interaction.x402.settled", "interaction.x402.verify_timeout"];
+/**
+ * Any current catalog value: every `email.*`, `payment.*`, and
+ * `interaction.x402.*` / `interaction.ack.*` event the platform emits, surfaced
+ * in the `X-Webhook-Event` header. Use this to type a switch over the header.
+ */
+type WebhookEventType = (typeof WEBHOOK_EVENT_TYPES)[number];
+/** True if `eventType` is a known current catalog value. */
+declare function isKnownWebhookEventType(eventType: string | null | undefined): eventType is WebhookEventType;
+/**
+ * Common shape of a `payment.*` webhook body. The stored payload carries the
+ * event name in `type` (not `event`); the parser overlays a canonical `event`
+ * from the header so consumers can branch on a single field.
+ */
+interface PaymentEvent {
+  /** Canonical event name, mirrored from the `X-Webhook-Event` header. */
+  event: "payment.settled" | "payment.failed";
+  /** The event name as carried in the raw stored body. */
+  type?: string;
+  id?: string;
+  created_at?: string;
+  /** The settlement payload as stored; shape is payment-flow specific. */
+  payment?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+/** A `payment.settled` webhook event. */
+interface PaymentSettledEvent extends PaymentEvent {
+  event: "payment.settled";
+}
+/** A `payment.failed` webhook event. */
+interface PaymentFailedEvent extends PaymentEvent {
+  event: "payment.failed";
+}
+/** A single interaction.x402.* event suffix. */
+type InteractionX402Suffix = "challenge" | "payment" | "settled" | "rejected" | "declined" | "expired" | "verify_timeout";
+/**
+ * Common shape of an `interaction.*` webhook body. The stored payload is just
+ * `{ interaction: { ... } }` with no event/type field; the parser overlays a
+ * canonical `event` from the header.
+ */
+interface InteractionEvent {
+  /** Canonical event name, mirrored from the `X-Webhook-Event` header. */
+  event: WebhookEventType;
+  /** The interaction state as stored; shape is protocol/step specific. */
+  interaction?: Record<string, unknown>;
+  id?: string;
+  [key: string]: unknown;
+}
+/** An `interaction.x402.*` event (the x402-over-email lifecycle). */
+interface InteractionX402Event extends InteractionEvent {
+  event: `interaction.x402.${InteractionX402Suffix}`;
+}
+/**
+ * Type guard for the `email.received` event. Confirms the discriminator AND
+ * that the body validates against the canonical schema, so a payload that names
+ * itself `email.received` but is malformed does not narrow.
+ */
+declare function isEmailReceivedEvent(event: unknown): event is EmailReceivedEvent;
+/** Type guard for any `payment.*` event. */
+declare function isPaymentEvent(event: unknown): event is PaymentEvent;
+/** Type guard for the `payment.settled` event. */
+declare function isPaymentSettledEvent(event: unknown): event is PaymentSettledEvent;
+/** Type guard for the `payment.failed` event. */
+declare function isPaymentFailedEvent(event: unknown): event is PaymentFailedEvent;
+/** Type guard for any `interaction.x402.*` event. */
+declare function isInteractionX402Event(event: unknown): event is InteractionX402Event;
+//#endregion
 //#region src/types.d.ts
 type EmailReceivedEvent = EmailReceivedEvent$1;
 type EventType = EmailReceivedEvent["event"];
@@ -1013,7 +1102,13 @@ interface UnknownEvent {
   version?: string;
   [key: string]: unknown;
 }
-type KnownWebhookEvent = EmailReceivedEvent;
+/**
+ * The webhook events the SDK returns as fully typed values. The email.received
+ * body is schema-validated; the payment.* and interaction.x402.* shapes are
+ * keyed off the `X-Webhook-Event` header and surfaced with a canonical `event`
+ * field so consumers can branch on a single discriminator.
+ */
+type KnownWebhookEvent = EmailReceivedEvent | PaymentSettledEvent | PaymentFailedEvent | InteractionX402Event;
 type WebhookEvent = KnownWebhookEvent | UnknownEvent;
 //#endregion
-export { RawContentInline as A, ParsedData as C, ParsedStatus as D, ParsedError as E, WebhookAttachment as F, WebhookEvent as I, TlsReportAnalysis as M, UnknownEvent as N, RawContent as O, ValidateEmailAuthResult as P, KnownWebhookEvent as S, ParsedDataFailed as T, ForwardResultAttachmentAnalyzed as _, DkimSignature as a, ForwardVerdict as b, DmarcResult as c, EmailAuth as d, EmailReceivedEvent as f, ForwardResult as g, ForwardOriginalSender as h, DkimResult as i, SpfResult as j, RawContentDownloadOnly as k, EmailAddress as l, ForwardAnalysis as m, AuthVerdict as n, DmarcPolicy as o, EventType as p, BounceAnalysis as r, DmarcReportAnalysis as s, AuthConfidence as t, EmailAnalysis as u, ForwardResultAttachmentSkipped as v, ParsedDataComplete as w, ForwardVerification as x, ForwardResultInline as y };
+export { isPaymentSettledEvent as $, RawContentInline as A, InteractionX402Event as B, ParsedData as C, ParsedStatus as D, ParsedError as E, WebhookAttachment as F, PaymentSettledEvent as G, PAYMENT_EVENT_TYPES as H, WebhookEvent as I, isEmailReceivedEvent as J, WEBHOOK_EVENT_TYPES as K, EMAIL_EVENT_TYPES as L, TlsReportAnalysis as M, UnknownEvent as N, RawContent as O, ValidateEmailAuthResult as P, isPaymentFailedEvent as Q, INTERACTION_EVENT_TYPES as R, KnownWebhookEvent as S, ParsedDataFailed as T, PaymentEvent as U, InteractionX402Suffix as V, PaymentFailedEvent as W, isKnownWebhookEventType as X, isInteractionX402Event as Y, isPaymentEvent as Z, ForwardResultAttachmentAnalyzed as _, DkimSignature as a, ForwardVerdict as b, DmarcResult as c, EmailAuth as d, EmailReceivedEvent as f, ForwardResult as g, ForwardOriginalSender as h, DkimResult as i, SpfResult as j, RawContentDownloadOnly as k, EmailAddress as l, ForwardAnalysis as m, AuthVerdict as n, DmarcPolicy as o, EventType as p, WebhookEventType as q, BounceAnalysis as r, DmarcReportAnalysis as s, AuthConfidence as t, EmailAnalysis as u, ForwardResultAttachmentSkipped as v, ParsedDataComplete as w, ForwardVerification as x, ForwardResultInline as y, InteractionEvent as z };

package/dist/webhook/index.d.ts

@@ -1,4 +1,4 @@
-import { A as RawContentInline, C as ParsedData, D as ParsedStatus, E as ParsedError, F as WebhookAttachment, I as WebhookEvent, M as TlsReportAnalysis, N as UnknownEvent, O as RawContent, P as ValidateEmailAuthResult, S as KnownWebhookEvent, T as ParsedDataFailed, _ as ForwardResultAttachmentAnalyzed, a as DkimSignature, b as ForwardVerdict, c as DmarcResult, d as EmailAuth, f as EmailReceivedEvent, g as ForwardResult, h as ForwardOriginalSender, i as DkimResult, j as SpfResult, k as RawContentDownloadOnly, l as EmailAddress, m as ForwardAnalysis, n as AuthVerdict, o as DmarcPolicy, p as EventType, r as BounceAnalysis, s as DmarcReportAnalysis, t as AuthConfidence, u as EmailAnalysis, v as ForwardResultAttachmentSkipped, w as ParsedDataComplete, x as ForwardVerification, y as ForwardResultInline } from "../types-QT2ss9ho.js";
-import { _ as buildForwardSubject, a as RawEmailDecodeErrorCode, b as normalizeReceivedEmail, c as WebhookPayloadError, d as WebhookValidationErrorCode, f as WebhookVerificationError, g as ReceivedEmailThread, h as ReceivedEmailAddress, i as RawEmailDecodeError, l as WebhookPayloadErrorCode, m as ReceivedEmail, n as PrimitiveWebhookError, o as VERIFICATION_ERRORS, p as WebhookVerificationErrorCode, r as RAW_EMAIL_ERRORS, s as WebhookErrorCode, t as PAYLOAD_ERRORS, u as WebhookValidationError, v as buildReplySubject, x as parseHeaderAddress, y as formatAddress } from "../errors-DyuAXctD.js";
-import { A as VerifyOptions, C as signStandardWebhooksPayload, D as PRIMITIVE_CONFIRMED_HEADER, E as LEGACY_SIGNATURE_HEADER, F as VerifyDownloadTokenResult, I as generateDownloadToken, L as verifyDownloadToken, M as verifyWebhookSignature, N as GenerateDownloadTokenOptions, O as PRIMITIVE_SIGNATURE_HEADER, P as VerifyDownloadTokenOptions, R as safeValidateEmailReceivedEvent, S as StandardWebhooksVerifyOptions, T as LEGACY_CONFIRMED_HEADER, _ as emailReceivedEventJsonSchema, a as confirmedHeaders, b as STANDARD_WEBHOOK_TIMESTAMP_HEADER, c as handleWebhook, d as isRawIncluded, f as parseWebhookEvent, g as validateEmailAuth, h as WEBHOOK_VERSION, i as WebhookHeaders, j as signWebhookPayload, k as SignResult, l as isDownloadExpired, m as verifyRawEmailDownload, n as HandleWebhookOptions, o as decodeRawEmail, p as receive, r as ReceiveRequestOptions, s as getDownloadTimeRemaining, t as DecodeRawEmailOptions, u as isEmailReceivedEvent, v as STANDARD_WEBHOOK_ID_HEADER, w as verifyStandardWebhooksSignature, x as StandardWebhooksSignResult, y as STANDARD_WEBHOOK_SIGNATURE_HEADER, z as validateEmailReceivedEvent } from "../index-iZWfb98V.js";
-export { AuthConfidence, AuthVerdict, BounceAnalysis, DecodeRawEmailOptions, DkimResult, DkimSignature, DmarcPolicy, DmarcReportAnalysis, DmarcResult, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict, ForwardVerification, GenerateDownloadTokenOptions, HandleWebhookOptions, KnownWebhookEvent, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawContent, RawContentDownloadOnly, RawContentInline, RawEmailDecodeError, RawEmailDecodeErrorCode, ReceiveRequestOptions, ReceivedEmail, ReceivedEmailAddress, ReceivedEmailThread, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SignResult, SpfResult, StandardWebhooksSignResult, StandardWebhooksVerifyOptions, TlsReportAnalysis, UnknownEvent, VERIFICATION_ERRORS, ValidateEmailAuthResult, VerifyDownloadTokenOptions, VerifyDownloadTokenResult, VerifyOptions, WEBHOOK_VERSION, WebhookAttachment, WebhookErrorCode, WebhookEvent, WebhookHeaders, WebhookPayloadError, WebhookPayloadErrorCode, WebhookValidationError, WebhookValidationErrorCode, WebhookVerificationError, WebhookVerificationErrorCode, buildForwardSubject, buildReplySubject, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, formatAddress, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, normalizeReceivedEmail, parseHeaderAddress, parseWebhookEvent, receive, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };
+import { $ as isPaymentSettledEvent, A as RawContentInline, B as InteractionX402Event, C as ParsedData, D as ParsedStatus, E as ParsedError, F as WebhookAttachment, G as PaymentSettledEvent, H as PAYMENT_EVENT_TYPES, I as WebhookEvent, J as isEmailReceivedEvent, K as WEBHOOK_EVENT_TYPES, L as EMAIL_EVENT_TYPES, M as TlsReportAnalysis, N as UnknownEvent, O as RawContent, P as ValidateEmailAuthResult, Q as isPaymentFailedEvent, R as INTERACTION_EVENT_TYPES, S as KnownWebhookEvent, T as ParsedDataFailed, U as PaymentEvent, V as InteractionX402Suffix, W as PaymentFailedEvent, X as isKnownWebhookEventType, Y as isInteractionX402Event, Z as isPaymentEvent, _ as ForwardResultAttachmentAnalyzed, a as DkimSignature, b as ForwardVerdict, c as DmarcResult, d as EmailAuth, f as EmailReceivedEvent, g as ForwardResult, h as ForwardOriginalSender, i as DkimResult, j as SpfResult, k as RawContentDownloadOnly, l as EmailAddress, m as ForwardAnalysis, n as AuthVerdict, o as DmarcPolicy, p as EventType, q as WebhookEventType, r as BounceAnalysis, s as DmarcReportAnalysis, t as AuthConfidence, u as EmailAnalysis, v as ForwardResultAttachmentSkipped, w as ParsedDataComplete, x as ForwardVerification, y as ForwardResultInline, z as InteractionEvent } from "../types-BjnIxPED.js";
+import { _ as buildForwardSubject, a as RawEmailDecodeErrorCode, b as normalizeReceivedEmail, c as WebhookPayloadError, d as WebhookValidationErrorCode, f as WebhookVerificationError, g as ReceivedEmailThread, h as ReceivedEmailAddress, i as RawEmailDecodeError, l as WebhookPayloadErrorCode, m as ReceivedEmail, n as PrimitiveWebhookError, o as VERIFICATION_ERRORS, p as WebhookVerificationErrorCode, r as RAW_EMAIL_ERRORS, s as WebhookErrorCode, t as PAYLOAD_ERRORS, u as WebhookValidationError, v as buildReplySubject, x as parseHeaderAddress, y as formatAddress } from "../errors-bXUNXAlf.js";
+import { A as PRIMITIVE_SIGNATURE_HEADER, B as safeValidateEmailReceivedEvent, C as StandardWebhooksSignResult, D as LEGACY_CONFIRMED_HEADER, E as verifyStandardWebhooksSignature, F as GenerateDownloadTokenOptions, I as VerifyDownloadTokenOptions, L as VerifyDownloadTokenResult, M as VerifyOptions, N as signWebhookPayload, O as LEGACY_SIGNATURE_HEADER, P as verifyWebhookSignature, R as generateDownloadToken, S as STANDARD_WEBHOOK_TIMESTAMP_HEADER, T as signStandardWebhooksPayload, V as validateEmailReceivedEvent, _ as WEBHOOK_VERSION, a as WebhookHeaders, b as STANDARD_WEBHOOK_ID_HEADER, c as getDownloadTimeRemaining, d as handleWebhookEvent, f as isDownloadExpired, g as verifyRawEmailDownload, h as receive, i as WEBHOOK_EVENT_HEADER, j as SignResult, k as PRIMITIVE_CONFIRMED_HEADER, l as getEventHeader, m as parseWebhookEvent, n as HandleWebhookOptions, o as confirmedHeaders, p as isRawIncluded, r as ReceiveRequestOptions, s as decodeRawEmail, t as DecodeRawEmailOptions, u as handleWebhook, v as validateEmailAuth, w as StandardWebhooksVerifyOptions, x as STANDARD_WEBHOOK_SIGNATURE_HEADER, y as emailReceivedEventJsonSchema, z as verifyDownloadToken } from "../index-BDnY9HH-.js";
+export { AuthConfidence, AuthVerdict, BounceAnalysis, DecodeRawEmailOptions, DkimResult, DkimSignature, DmarcPolicy, DmarcReportAnalysis, DmarcResult, EMAIL_EVENT_TYPES, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict, ForwardVerification, GenerateDownloadTokenOptions, HandleWebhookOptions, INTERACTION_EVENT_TYPES, InteractionEvent, InteractionX402Event, InteractionX402Suffix, KnownWebhookEvent, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PAYMENT_EVENT_TYPES, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus, PaymentEvent, PaymentFailedEvent, PaymentSettledEvent, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawContent, RawContentDownloadOnly, RawContentInline, RawEmailDecodeError, RawEmailDecodeErrorCode, ReceiveRequestOptions, ReceivedEmail, ReceivedEmailAddress, ReceivedEmailThread, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SignResult, SpfResult, StandardWebhooksSignResult, StandardWebhooksVerifyOptions, TlsReportAnalysis, UnknownEvent, VERIFICATION_ERRORS, ValidateEmailAuthResult, VerifyDownloadTokenOptions, VerifyDownloadTokenResult, VerifyOptions, WEBHOOK_EVENT_HEADER, WEBHOOK_EVENT_TYPES, WEBHOOK_VERSION, WebhookAttachment, WebhookErrorCode, WebhookEvent, WebhookEventType, WebhookHeaders, WebhookPayloadError, WebhookPayloadErrorCode, WebhookValidationError, WebhookValidationErrorCode, WebhookVerificationError, WebhookVerificationErrorCode, buildForwardSubject, buildReplySubject, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, formatAddress, generateDownloadToken, getDownloadTimeRemaining, getEventHeader, handleWebhook, handleWebhookEvent, isDownloadExpired, isEmailReceivedEvent, isInteractionX402Event, isKnownWebhookEventType, isPaymentEvent, isPaymentFailedEvent, isPaymentSettledEvent, isRawIncluded, normalizeReceivedEmail, parseHeaderAddress, parseWebhookEvent, receive, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };

package/dist/webhook/index.js

@@ -1,3 +1,3 @@
 import { a as VERIFICATION_ERRORS, c as WebhookVerificationError, d as formatAddress, f as normalizeReceivedEmail, i as RawEmailDecodeError, l as buildForwardSubject, n as PrimitiveWebhookError, o as WebhookPayloadError, p as parseHeaderAddress, r as RAW_EMAIL_ERRORS, s as WebhookValidationError, t as PAYLOAD_ERRORS, u as buildReplySubject } from "../errors-BPJGp9I6.js";
-import { A as PRIMITIVE_CONFIRMED_HEADER, C as STANDARD_WEBHOOK_ID_HEADER, D as verifyStandardWebhooksSignature, E as signStandardWebhooksPayload, F as verifyDownloadToken, I as safeValidateEmailReceivedEvent, L as validateEmailReceivedEvent, M as signWebhookPayload, N as verifyWebhookSignature, O as LEGACY_CONFIRMED_HEADER, P as generateDownloadToken, S as emailReceivedEventJsonSchema, T as STANDARD_WEBHOOK_TIMESTAMP_HEADER, _ as DmarcResult, a as isDownloadExpired, b as ParsedStatus, c as parseWebhookEvent, d as WEBHOOK_VERSION, f as validateEmailAuth, g as DmarcPolicy, h as DkimResult, i as handleWebhook, j as PRIMITIVE_SIGNATURE_HEADER, k as LEGACY_SIGNATURE_HEADER, l as receive, m as AuthVerdict, n as decodeRawEmail, o as isEmailReceivedEvent, p as AuthConfidence, r as getDownloadTimeRemaining, s as isRawIncluded, t as confirmedHeaders, u as verifyRawEmailDownload, v as EventType, w as STANDARD_WEBHOOK_SIGNATURE_HEADER, x as SpfResult, y as ForwardVerdict } from "../webhook-CwjCyFv-.js";
-export { AuthConfidence, AuthVerdict, DkimResult, DmarcPolicy, DmarcResult, EventType, ForwardVerdict, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawEmailDecodeError, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SpfResult, VERIFICATION_ERRORS, WEBHOOK_VERSION, WebhookPayloadError, WebhookValidationError, WebhookVerificationError, buildForwardSubject, buildReplySubject, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, formatAddress, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, normalizeReceivedEmail, parseHeaderAddress, parseWebhookEvent, receive, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };
+import { A as LEGACY_CONFIRMED_HEADER, B as isEmailReceivedEvent, C as SpfResult, D as STANDARD_WEBHOOK_TIMESTAMP_HEADER, E as STANDARD_WEBHOOK_SIGNATURE_HEADER, F as verifyWebhookSignature, G as isPaymentSettledEvent, H as isKnownWebhookEventType, I as EMAIL_EVENT_TYPES, J as safeValidateEmailReceivedEvent, K as generateDownloadToken, L as INTERACTION_EVENT_TYPES, M as PRIMITIVE_CONFIRMED_HEADER, N as PRIMITIVE_SIGNATURE_HEADER, O as signStandardWebhooksPayload, P as signWebhookPayload, R as PAYMENT_EVENT_TYPES, S as ParsedStatus, T as STANDARD_WEBHOOK_ID_HEADER, U as isPaymentEvent, V as isInteractionX402Event, W as isPaymentFailedEvent, Y as validateEmailReceivedEvent, _ as DkimResult, a as getEventHeader, b as EventType, c as isDownloadExpired, d as receive, f as verifyRawEmailDownload, g as AuthVerdict, h as AuthConfidence, i as getDownloadTimeRemaining, j as LEGACY_SIGNATURE_HEADER, k as verifyStandardWebhooksSignature, l as isRawIncluded, m as validateEmailAuth, n as confirmedHeaders, o as handleWebhook, p as WEBHOOK_VERSION, q as verifyDownloadToken, r as decodeRawEmail, s as handleWebhookEvent, t as WEBHOOK_EVENT_HEADER, u as parseWebhookEvent, v as DmarcPolicy, w as emailReceivedEventJsonSchema, x as ForwardVerdict, y as DmarcResult, z as WEBHOOK_EVENT_TYPES } from "../webhook-CiIPtegj.js";
+export { AuthConfidence, AuthVerdict, DkimResult, DmarcPolicy, DmarcResult, EMAIL_EVENT_TYPES, EventType, ForwardVerdict, INTERACTION_EVENT_TYPES, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PAYMENT_EVENT_TYPES, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawEmailDecodeError, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SpfResult, VERIFICATION_ERRORS, WEBHOOK_EVENT_HEADER, WEBHOOK_EVENT_TYPES, WEBHOOK_VERSION, WebhookPayloadError, WebhookValidationError, WebhookVerificationError, buildForwardSubject, buildReplySubject, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, formatAddress, generateDownloadToken, getDownloadTimeRemaining, getEventHeader, handleWebhook, handleWebhookEvent, isDownloadExpired, isEmailReceivedEvent, isInteractionX402Event, isKnownWebhookEventType, isPaymentEvent, isPaymentFailedEvent, isPaymentSettledEvent, isRawIncluded, normalizeReceivedEmail, parseHeaderAddress, parseWebhookEvent, receive, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };

package/dist/{webhook-CwjCyFv-.js → webhook-CiIPtegj.js}

@@ -8132,6 +8132,94 @@ function verifyDownloadToken(params) {
 	return { valid: true };
 }
 //#endregion
+//#region src/webhook/events.ts
+/**
+* The five first-party email events (subject = an email).
+*/
+const EMAIL_EVENT_TYPES = [
+	"email.received",
+	"email.bounced",
+	"email.tls_report",
+	"email.dmarc_report",
+	"email.dmarc_failure"
+];
+/**
+* The two x402 settlement-notification events (subject = a payment). Emitted for
+* both the synthetic API pay flow and the email-native settle path.
+*/
+const PAYMENT_EVENT_TYPES = ["payment.settled", "payment.failed"];
+/**
+* The interaction step events (subject = an interaction). One event per accepted
+* protocol step, named `interaction.<protocolShort>.<suffix>`.
+*
+* The x402 slice covers the payment lifecycle a payee/payer cares about; the ack
+* slice covers the acknowledgement protocols.
+*/
+const INTERACTION_EVENT_TYPES = [
+	"interaction.ack.acked",
+	"interaction.ack.canceled",
+	"interaction.ack.expired",
+	"interaction.ack.received",
+	"interaction.ack.requested",
+	"interaction.x402.challenge",
+	"interaction.x402.declined",
+	"interaction.x402.expired",
+	"interaction.x402.payment",
+	"interaction.x402.rejected",
+	"interaction.x402.settled",
+	"interaction.x402.verify_timeout"
+];
+/**
+* The full enumerated catalog of every current webhook event type: the five
+* email.*, the two payment.*, and every interaction.<protocol>.<suffix>.
+*/
+const WEBHOOK_EVENT_TYPES = [
+	...EMAIL_EVENT_TYPES,
+	...PAYMENT_EVENT_TYPES,
+	...INTERACTION_EVENT_TYPES
+];
+const WEBHOOK_EVENT_TYPE_SET = new Set(WEBHOOK_EVENT_TYPES);
+/** True if `eventType` is a known current catalog value. */
+function isKnownWebhookEventType(eventType) {
+	return eventType != null && WEBHOOK_EVENT_TYPE_SET.has(eventType);
+}
+function eventName(event) {
+	if (typeof event !== "object" || event === null) return void 0;
+	const value = event.event;
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Type guard for the `email.received` event. Confirms the discriminator AND
+* that the body validates against the canonical schema, so a payload that names
+* itself `email.received` but is malformed does not narrow.
+*/
+function isEmailReceivedEvent(event) {
+	if (eventName(event) !== "email.received") return false;
+	try {
+		validateEmailReceivedEvent(event);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Type guard for any `payment.*` event. */
+function isPaymentEvent(event) {
+	const name = eventName(event);
+	return name === "payment.settled" || name === "payment.failed";
+}
+/** Type guard for the `payment.settled` event. */
+function isPaymentSettledEvent(event) {
+	return eventName(event) === "payment.settled";
+}
+/** Type guard for the `payment.failed` event. */
+function isPaymentFailedEvent(event) {
+	return eventName(event) === "payment.failed";
+}
+/** Type guard for any `interaction.x402.*` event. */
+function isInteractionX402Event(event) {
+	return eventName(event)?.startsWith("interaction.x402.") ?? false;
+}
+//#endregion
 //#region src/webhook/encoding.ts
 /**
 * Buffer encoding utilities
@@ -10014,40 +10102,52 @@ const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/
 * }
 * ```
 */
-function parseWebhookEvent(input) {
+function parseWebhookEvent(input, eventType) {
 	if (input === null) throw new WebhookPayloadError("PAYLOAD_NULL", "Received null instead of webhook payload", "Check that your request body variable is defined.");
 	if (input === void 0) throw new WebhookPayloadError("PAYLOAD_UNDEFINED", "Received undefined instead of webhook payload", "Make sure you're passing the request body to parseWebhookEvent()");
 	if (Array.isArray(input)) throw new WebhookPayloadError("PAYLOAD_IS_ARRAY", "Received array instead of webhook payload object", "Webhook payloads must be objects, not arrays.");
 	if (typeof input !== "object") throw new WebhookPayloadError("PAYLOAD_WRONG_TYPE", `Received ${typeof input} instead of webhook payload object`, "Webhook payloads must be objects.");
 	const obj = input;
-	if (!("event" in obj) || typeof obj.event !== "string") throw new WebhookPayloadError("PAYLOAD_MISSING_EVENT", "Missing 'event' field in payload", "This doesn't look like a Primitive webhook payload.");
-	switch (obj.event) {
+	const resolvedEvent = typeof eventType === "string" && eventType || (typeof obj.event === "string" ? obj.event : void 0);
+	if (!resolvedEvent) throw new WebhookPayloadError("PAYLOAD_MISSING_EVENT", "Missing event discriminator: no X-Webhook-Event header and no 'event' field in payload", "Pass the X-Webhook-Event header (the canonical discriminator) or call handleWebhookEvent, which reads it for you.");
+	switch (resolvedEvent) {
 		case "email.received": return validateEmailReceivedEvent(input);
-		default: return input;
+		case "payment.settled":
+		case "payment.failed": return {
+			...obj,
+			event: resolvedEvent
+		};
+		default:
+			if (isKnownWebhookEventType(resolvedEvent)) return {
+				...obj,
+				event: resolvedEvent
+			};
+			return {
+				...obj,
+				event: resolvedEvent
+			};
 	}
 }
 /**
-* Type guard to check if a webhook event is an EmailReceivedEvent.
-*
-* @example
-* ```typescript
-* const event = parseWebhookEvent(payload);
-* if (isEmailReceivedEvent(event)) {
-*   // TypeScript knows event is EmailReceivedEvent
-*   console.log(event.email.headers.subject);
-* }
-* ```
+* The header that names the webhook event for ALL event families
+* (`email.*`, `payment.*`, `interaction.*`). It is the primary discriminator
+* the parser keys on, because the stored body is sent verbatim with no envelope.
 */
-function isEmailReceivedEvent(event) {
-	if (typeof event !== "object" || event === null || !("event" in event) || event.event !== "email.received") return false;
-	try {
-		validateEmailReceivedEvent(event);
-		return true;
-	} catch {
-		return false;
-	}
-}
+const WEBHOOK_EVENT_HEADER = "X-Webhook-Event";
 const SIGNATURE_HEADER_NAMES = ["primitive-signature", "mymx-signature"];
+/**
+* Read the `X-Webhook-Event` header value (case-insensitive). Returns null when
+* the header is absent.
+*/
+function getEventHeader(headers) {
+	if (headers instanceof Headers) return headers.get("x-webhook-event");
+	const obj = headers;
+	const key = Object.keys(obj).find((k) => k.toLowerCase() === "x-webhook-event");
+	if (!key) return null;
+	const value = obj[key];
+	if (Array.isArray(value)) return value[0] ?? null;
+	return value ?? null;
+}
 const STANDARD_WEBHOOKS_HEADER_NAMES = [
 	"webhook-signature",
 	"webhook-id",
@@ -10160,7 +10260,7 @@ function getStandardWebhooksHeaders(headers) {
 * });
 * ```
 */
-function handleWebhook(options) {
+function verifyWebhookRequest(options) {
 	const { body, headers, secret, toleranceSeconds } = options;
 	const swHeaders = getStandardWebhooksHeaders(headers);
 	if (swHeaders) verifyStandardWebhooksSignature({
@@ -10177,7 +10277,36 @@ function handleWebhook(options) {
 		secret,
 		toleranceSeconds
 	});
-	return validateEmailReceivedEvent(parseJsonBody(body));
+}
+/**
+* Verify, then parse any webhook event into a typed value.
+*
+* Unlike {@link handleWebhook}, this returns the full {@link WebhookEvent}
+* union, so it handles `payment.*` and `interaction.x402.*` events in addition
+* to `email.*`. The flow is:
+*
+* 1. Verify the signature over the RAW body (works for every event family).
+* 2. Parse the JSON body.
+* 3. Classify on the `X-Webhook-Event` HEADER (the primary discriminator),
+*    returning a typed event for known types and an UnknownEvent for the rest.
+*
+* @example
+* ```typescript
+* const event = handleWebhookEvent({ body, headers, secret });
+* if (isPaymentSettledEvent(event)) {
+*   // typed PaymentSettledEvent
+* } else if (isInteractionX402Event(event)) {
+*   // typed interaction.x402.* event
+* }
+* ```
+*/
+function handleWebhookEvent(options) {
+	verifyWebhookRequest(options);
+	return parseWebhookEvent(parseJsonBody(options.body), getEventHeader(options.headers));
+}
+function handleWebhook(options) {
+	verifyWebhookRequest(options);
+	return validateEmailReceivedEvent(parseJsonBody(options.body));
 }
 function receive(input, options) {
 	if (input instanceof Request) return receiveFromRequest(input, options);
@@ -10364,4 +10493,4 @@ function verifyRawEmailDownload(downloaded, event) {
 	return buffer;
 }
 //#endregion
-export { PRIMITIVE_CONFIRMED_HEADER as A, STANDARD_WEBHOOK_ID_HEADER as C, verifyStandardWebhooksSignature as D, signStandardWebhooksPayload as E, verifyDownloadToken as F, safeValidateEmailReceivedEvent as I, validateEmailReceivedEvent as L, signWebhookPayload as M, verifyWebhookSignature as N, LEGACY_CONFIRMED_HEADER as O, generateDownloadToken as P, emailReceivedEventJsonSchema as S, STANDARD_WEBHOOK_TIMESTAMP_HEADER as T, DmarcResult as _, isDownloadExpired as a, ParsedStatus as b, parseWebhookEvent as c, WEBHOOK_VERSION as d, validateEmailAuth as f, DmarcPolicy as g, DkimResult as h, handleWebhook as i, PRIMITIVE_SIGNATURE_HEADER as j, LEGACY_SIGNATURE_HEADER as k, receive as l, AuthVerdict as m, decodeRawEmail as n, isEmailReceivedEvent as o, AuthConfidence as p, getDownloadTimeRemaining as r, isRawIncluded as s, confirmedHeaders as t, verifyRawEmailDownload as u, EventType as v, STANDARD_WEBHOOK_SIGNATURE_HEADER as w, SpfResult as x, ForwardVerdict as y };
+export { LEGACY_CONFIRMED_HEADER as A, isEmailReceivedEvent as B, SpfResult as C, STANDARD_WEBHOOK_TIMESTAMP_HEADER as D, STANDARD_WEBHOOK_SIGNATURE_HEADER as E, verifyWebhookSignature as F, isPaymentSettledEvent as G, isKnownWebhookEventType as H, EMAIL_EVENT_TYPES as I, safeValidateEmailReceivedEvent as J, generateDownloadToken as K, INTERACTION_EVENT_TYPES as L, PRIMITIVE_CONFIRMED_HEADER as M, PRIMITIVE_SIGNATURE_HEADER as N, signStandardWebhooksPayload as O, signWebhookPayload as P, PAYMENT_EVENT_TYPES as R, ParsedStatus as S, STANDARD_WEBHOOK_ID_HEADER as T, isPaymentEvent as U, isInteractionX402Event as V, isPaymentFailedEvent as W, validateEmailReceivedEvent as Y, DkimResult as _, getEventHeader as a, EventType as b, isDownloadExpired as c, receive as d, verifyRawEmailDownload as f, AuthVerdict as g, AuthConfidence as h, getDownloadTimeRemaining as i, LEGACY_SIGNATURE_HEADER as j, verifyStandardWebhooksSignature as k, isRawIncluded as l, validateEmailAuth as m, confirmedHeaders as n, handleWebhook as o, WEBHOOK_VERSION as p, verifyDownloadToken as q, decodeRawEmail as r, handleWebhookEvent as s, WEBHOOK_EVENT_HEADER as t, parseWebhookEvent as u, DmarcPolicy as v, emailReceivedEventJsonSchema as w, ForwardVerdict as x, DmarcResult as y, WEBHOOK_EVENT_TYPES as z };

package/dist/x402/index.d.ts

@@ -130,6 +130,62 @@ interface X402PaymentPayload {
     };
   };
 }
+/**
+ * The protocol the email-native payment interaction runs (`x402.payment/1`).
+ * The payer's reply carries the `payment` step of this protocol.
+ */
+declare const X402_INTERACTION_PROTOCOL = "x402.payment";
+declare const X402_INTERACTION_PROTOCOL_VERSION = 1;
+/**
+ * The interaction.json envelope for one step of an email-carried interaction.
+ * The payer's `payment` step is sent as an `interaction.json` MIME attachment
+ * in the reply; the platform parses this envelope, validates the step against
+ * the `x402.payment` protocol, and re-verifies the embedded payment.
+ */
+interface InteractionEnvelope<P = unknown> {
+  interaction_version: 1;
+  /** The thread id (`uuid@domain`) the step belongs to. */
+  interaction_id: string;
+  protocol: string;
+  protocol_version: number;
+  /** The protocol step name (e.g. `"payment"`). */
+  step: string;
+  /** This step's id (a fresh UUID). */
+  step_id: string;
+  /** The id of the step this one answers (the challenge step), or null. */
+  prev_step_id: string | null;
+  expires_at: string | null;
+  payload: P;
+}
+/** The `payload` of an `x402.payment` `payment` step: the signed x402 payload. */
+interface X402PaymentStepPayload {
+  payment: X402PaymentPayload;
+}
+/**
+ * A built, signed payment-step envelope plus its canonical JSON bytes. The
+ * caller attaches `json` as the `interaction.json` part of the reply email; the
+ * platform reads `envelope` back from those exact bytes.
+ */
+interface BuiltPaymentStep {
+  envelope: InteractionEnvelope<X402PaymentStepPayload>;
+  /** The canonical interaction.json body (what to attach to the reply). */
+  json: string;
+}
+/**
+ * Build the section-2.3 interaction.json envelope for a `payment` step. Pure: no
+ * I/O. `payment` is the signed exact-EVM payload (from
+ * `buildExactEvmPaymentPayload`); `prevStepId` is the challenge step id this
+ * payment answers, and `stepId` is a fresh UUID for the payment step. Returns
+ * the envelope and its canonical JSON, so the bytes the platform reads back are
+ * exactly the ones produced here.
+ */
+declare function buildPaymentStepEnvelope(params: {
+  /** The thread id (`uuid@domain`). */interactionId: string; /** A fresh UUID identifying this payment step. */
+  stepId: string; /** The challenge step id this payment answers. */
+  prevStepId: string;
+  payment: X402PaymentPayload; /** Optional ISO-8601 step expiry. */
+  expiresAt?: string | null;
+}): BuiltPaymentStep;
 /** Assemble the wire payload from a signed authorization. */
 declare function toPaymentPayload(network: string, auth: TransferAuthorization, signature: Hex): X402PaymentPayload;
 /**
@@ -218,6 +274,33 @@ interface X402Challenge {
   payment_requirements: X402PaymentRequirements;
   expires_at: string;
 }
+/** The nonce binding the payer hashes into the EIP-3009 nonce. */
+interface X402NonceBinding {
+  interaction_id: string;
+  challenge_step_id: string;
+  challenge_nonce: string;
+}
+/**
+ * The challenge details carried inside an email-native challenge: what the
+ * payer needs to sign and pay. Distinct from the synthetic `X402Challenge` in
+ * that it has no top-level `id`/`amount`; everything is in the nested objects.
+ */
+interface X402EmailChallengeDetails {
+  payment_requirements: X402PaymentRequirements;
+  nonce_binding: X402NonceBinding;
+  expires_at: string;
+}
+/**
+ * The result of issuing an email-native challenge (`createEmailChallenge`).
+ * `interaction_id` is the real email thread id (`uuid@domain`) the payment is
+ * bound to. Hand the whole object to the payer; the payer calls
+ * `payEmailChallenge` with it to build the signed payment step.
+ */
+interface X402EmailChallenge {
+  interaction_id: string;
+  challenge_id: string;
+  challenge: X402EmailChallengeDetails;
+}
 interface X402Receipt {
   id: string;
   status: string;
@@ -279,6 +362,34 @@ interface X402ChargeInput {
    */
   idempotencyKey?: string;
 }
+interface X402EmailChargeInput {
+  /** Your sending address (the payee / funds receiver). */
+  from: string;
+  /** The payer's email address the challenge is sent to. */
+  to: string;
+  /**
+   * Amount in token base units (USDC has 6 decimals, so "10000" = 0.01).
+   * Provide exactly one of `amount` or `amountUsdc`.
+   */
+  amount?: string;
+  /**
+   * Amount as human USDC (e.g. "0.01"), converted to base units for you.
+   * Provide exactly one of `amount` or `amountUsdc`.
+   */
+  amountUsdc?: string;
+  /** Defaults to "base-sepolia". */
+  network?: string;
+  description?: string;
+  /** A URL identifying the thing being paid for. */
+  resource?: string;
+  /** Seconds until the challenge expires (default 1h). */
+  expiresIn?: number;
+  /**
+   * Optional idempotency key. Retrying `createEmailChallenge()` with the same
+   * key returns the original challenge without sending a second email.
+   */
+  idempotencyKey?: string;
+}
 declare class X402Error extends Error {
   /** HTTP status, or 0 for a client-side / transport error that never reached the server. */
   readonly status: number;
@@ -305,6 +416,30 @@ declare class X402Client {
   constructor(options?: X402ClientOptions);
   /** Request a payment (payee side). Returns the challenge to hand to the payer. */
   charge(input: X402ChargeInput): Promise<X402Challenge>;
+  /**
+   * Issue a payment challenge over an email thread (payee side). Sends the
+   * challenge as an email from `from` to `to` and binds the payment to that
+   * thread. Returns the challenge (including the real `interaction_id`); deliver
+   * it to the payer, who calls `payEmailChallenge` to build the signed payment.
+   *
+   * Provide exactly one of `amount` (base units) or `amountUsdc` (human USDC).
+   */
+  createEmailChallenge(input: X402EmailChargeInput): Promise<X402EmailChallenge>;
+  /**
+   * Build the signed payment step for an email-native challenge (payer side).
+   * Given a received `X402EmailChallenge` and the caller's signer, this derives
+   * the interaction-bound authorization, signs it locally, and returns the
+   * signed `interaction.json` payment-step envelope plus its canonical JSON
+   * bytes. It does NOT send anything.
+   *
+   * The caller sends `result.json` back as an `interaction.json` attachment on a
+   * reply to the challenge email (e.g. via the SDK's `send` / `reply`); the
+   * platform reads the envelope from those exact bytes, re-derives the bound
+   * nonce, and settles.
+   */
+  payEmailChallenge(challenge: X402EmailChallenge, options: {
+    signer: X402Signer;
+  }): Promise<BuiltPaymentStep>;
   /**
    * Pay a challenge (payer side). Derives the interaction-bound authorization,
    * signs it locally with the caller's key, and submits it for settlement.
@@ -351,4 +486,4 @@ declare class X402Client {
 }
 declare function createX402Client(options?: X402ClientOptions): X402Client;
 //#endregion
-export { DEFAULT_MAX_WINDOW_SEC, NonceBinding, PayoutRegistrationMessageInput, TRANSFER_WITH_AUTHORIZATION_TYPES, TokenDomain, TransferAuthorization, TransferWithAuthorizationTypedData, X402Challenge, X402ChargeInput, X402Client, X402ClientOptions, X402DeclinedPayment, X402Error, X402Network, X402PaymentPayload, X402PaymentRequirements, X402PayoutAddress, X402Receipt, X402Signer, X402SpendPolicy, buildExactEvmPaymentPayload, buildPayoutRegistrationMessage, computePaymentValidityWindow, createX402Client, deriveEip3009Nonce, signInteractionPayment, toPaymentPayload, transferWithAuthorizationTypedData };
+export { BuiltPaymentStep, DEFAULT_MAX_WINDOW_SEC, InteractionEnvelope, NonceBinding, PayoutRegistrationMessageInput, TRANSFER_WITH_AUTHORIZATION_TYPES, TokenDomain, TransferAuthorization, TransferWithAuthorizationTypedData, X402Challenge, X402ChargeInput, X402Client, X402ClientOptions, X402DeclinedPayment, X402EmailChallenge, X402EmailChallengeDetails, X402EmailChargeInput, X402Error, X402Network, X402NonceBinding, X402PaymentPayload, X402PaymentRequirements, X402PaymentStepPayload, X402PayoutAddress, X402Receipt, X402Signer, X402SpendPolicy, X402_INTERACTION_PROTOCOL, X402_INTERACTION_PROTOCOL_VERSION, buildExactEvmPaymentPayload, buildPaymentStepEnvelope, buildPayoutRegistrationMessage, computePaymentValidityWindow, createX402Client, deriveEip3009Nonce, signInteractionPayment, toPaymentPayload, transferWithAuthorizationTypedData };