@primitivedotdev/sdk 0.2.0

package/dist/types-C6M6oCRS.d.ts

@@ -0,0 +1,817 @@
+//#region src/types.generated.d.ts
+/**
+ * Types for Primitive webhook payloads.
+ *
+ * AUTO-GENERATED - DO NOT EDIT
+ * Run `pnpm generate:types` to regenerate.
+ */
+/**
+ * Result for a single forwarded email detected in the message.
+ *
+ * Use the `type` and `analyzed` fields to narrow the type:
+ * - `type: 'inline'` - Inline forward, always analyzed
+ * - `type: 'attachment'` + `analyzed: true` - Analyzed attachment
+ * - `type: 'attachment'` + `analyzed: false` - Skipped attachment
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ForwardResult".
+ */
+type ForwardResult$1 = (ForwardResultInline$1 | ForwardResultAttachmentAnalyzed$1 | ForwardResultAttachmentSkipped$1);
+/**
+ * Valid webhook version format (YYYY-MM-DD date string). The SDK accepts any valid date-formatted version, not just the current one, for forward and backward compatibility.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "WebhookVersion".
+ */
+
+/**
+ * Webhook payload for the `email.received` event.
+ *
+ * This is delivered to your webhook endpoint when Primitive receives an email matching your domain configuration.
+ */
+interface EmailReceivedEvent$1 {
+  /**
+   * Unique delivery event ID.
+   *
+   * This ID is stable across retries to the same endpoint - use it as your idempotency/dedupe key. Note that the same email delivered to different endpoints will have different event IDs.
+   *
+   * Format: `evt_` prefix followed by a SHA-256 hash (64 hex characters). Example: `evt_a1b2c3d4e5f6...` (68 characters total)
+   */
+  id: string;
+  /**
+   * Event type identifier. Always `"email.received"` for this event type.
+   */
+  event: "email.received";
+  /**
+   * API version in date format (YYYY-MM-DD). Use this to detect version mismatches between webhook and SDK.
+   */
+  version: string;
+  /**
+   * Metadata about this webhook delivery.
+   */
+  delivery: {
+    /**
+     * ID of the webhook endpoint receiving this event. Matches the endpoint ID from your Primitive dashboard.
+     */
+    endpoint_id: string;
+    /**
+     * Delivery attempt number, starting at 1. Increments with each retry if previous attempts failed.
+     */
+    attempt: number;
+    /**
+     * ISO 8601 timestamp (UTC) when this delivery was attempted.
+     */
+    attempted_at: string;
+  };
+  /**
+   * The email that triggered this event.
+   */
+  email: {
+    /**
+     * Unique email ID in Primitive. Use this ID when calling Primitive APIs to reference this email.
+     */
+    id: string;
+    /**
+     * ISO 8601 timestamp (UTC) when Primitive received the email.
+     */
+    received_at: string;
+    /**
+     * SMTP envelope information. This is the "real" sender/recipient info from the SMTP transaction, which may differ from the headers (e.g., BCC recipients).
+     */
+    smtp: {
+      /**
+       * HELO/EHLO hostname from the sending server. Null if not provided during SMTP transaction.
+       */
+      helo: (string | null);
+      /**
+       * SMTP envelope sender (MAIL FROM command). This is the bounce address, which may differ from the From header.
+       */
+      mail_from: string;
+      /**
+       * SMTP envelope recipients (RCPT TO commands). All addresses that received this email in a single delivery.
+       *
+       * @minItems 1
+       */
+      rcpt_to: [string, ...(string)[]];
+    };
+    /**
+     * Parsed email headers. These are extracted from the email content, not the SMTP envelope.
+     */
+    headers: {
+      /**
+       * Message-ID header value. Null if the email had no Message-ID header.
+       */
+      message_id: (string | null);
+      /**
+       * Subject header value. Null if the email had no Subject header.
+       */
+      subject: (string | null);
+      /**
+       * From header value. May include display name: `"John Doe" <john@example.com>`
+       */
+      from: string;
+      /**
+       * To header value. May include multiple addresses or display names.
+       */
+      to: string;
+      /**
+       * Date header value as it appeared in the email. Null if the email had no Date header.
+       */
+      date: (string | null);
+    };
+    /**
+     * Raw email content and download information.
+     */
+    content: {
+      /**
+       * Raw email in RFC 5322 format. May be inline (base64) or download-only depending on size.
+       */
+      raw: (RawContentInline$1 | RawContentDownloadOnly$1);
+      /**
+       * Download information for the raw email. Always present, even if raw content is inline.
+       */
+      download: {
+        /**
+         * HTTPS URL to download the raw email. Returns the email as-is in RFC 5322 format.
+         */
+        url: string;
+        /**
+         * ISO 8601 timestamp (UTC) when this URL expires. Download before this time or the URL will return 403.
+         */
+        expires_at: string;
+      };
+    };
+    /**
+     * Parsed email content (body text, HTML, attachments). Check `status` to determine if parsing succeeded.
+     */
+    parsed: (ParsedDataComplete$1 | ParsedDataFailed$1);
+    analysis: EmailAnalysis$1;
+    auth: EmailAuth$1;
+  };
+}
+/**
+ * Raw email content included inline (base64 encoded).
+ *
+ * When the raw email is small enough (under  {@link  max_inline_bytes } ), it's included directly in the webhook payload for convenience.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "RawContentInline".
+ */
+interface RawContentInline$1 {
+  /**
+   * Discriminant indicating raw content is included inline.
+   */
+  included: true;
+  /**
+   * Encoding used for the data field. Always "base64".
+   */
+  encoding: "base64";
+  /**
+   * Maximum size in bytes for inline inclusion. Emails larger than this threshold require download.
+   */
+  max_inline_bytes: number;
+  /**
+   * Actual size of the raw email in bytes.
+   */
+  size_bytes: number;
+  /**
+   * SHA-256 hash of the raw email content (hex-encoded). Use this to verify integrity after base64 decoding.
+   */
+  sha256: string;
+  /**
+   * Base64-encoded raw email (RFC 5322 format). Decode with `Buffer.from(data, 'base64')` in Node.js.
+   */
+  data: string;
+}
+/**
+ * Raw email content not included (must be downloaded).
+ *
+ * When the raw email exceeds  {@link  max_inline_bytes } , it's not included in the webhook payload. Use the download URL from  {@link  EmailReceivedEvent.email.content.download  }  to fetch it.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "RawContentDownloadOnly".
+ */
+interface RawContentDownloadOnly$1 {
+  /**
+   * Discriminant indicating raw content must be downloaded.
+   */
+  included: false;
+  /**
+   * Reason the content wasn't included inline.
+   */
+  reason_code: "size_exceeded";
+  /**
+   * Maximum size in bytes for inline inclusion. The email exceeded this threshold.
+   */
+  max_inline_bytes: number;
+  /**
+   * Actual size of the raw email in bytes.
+   */
+  size_bytes: number;
+  /**
+   * SHA-256 hash of the raw email content (hex-encoded). Use this to verify integrity after download.
+   */
+  sha256: string;
+}
+/**
+ * Parsed email content when parsing succeeded.
+ *
+ * Use the discriminant `status: "complete"` to narrow from  {@link  ParsedData } .
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ParsedDataComplete".
+ */
+interface ParsedDataComplete$1 {
+  /**
+   * Discriminant indicating successful parsing.
+   */
+  status: "complete";
+  /**
+   * Always null when parsing succeeds.
+   */
+  error: null;
+  /**
+   * Plain text body of the email. Null if the email had no text/plain part.
+   */
+  body_text: (string | null);
+  /**
+   * HTML body of the email. Null if the email had no text/html part.
+   */
+  body_html: (string | null);
+  /**
+   * Parsed Reply-To header addresses. Null if the email had no Reply-To header.
+   */
+  reply_to: (EmailAddress$1[] | null);
+  /**
+   * Parsed CC header addresses. Null if the email had no CC header.
+   */
+  cc: (EmailAddress$1[] | null);
+  /**
+   * Parsed BCC header addresses. Null if the email had no BCC header. Note: BCC is only available for outgoing emails or when explicitly provided.
+   */
+  bcc: (EmailAddress$1[] | null);
+  /**
+   * In-Reply-To header values (Message-IDs of the email(s) being replied to). Null if the email had no In-Reply-To header. Per RFC 5322, this can contain multiple Message-IDs, though typically just one.
+   */
+  in_reply_to: (string[] | null);
+  /**
+   * References header values (Message-IDs of the email thread). Null if the email had no References header.
+   */
+  references: (string[] | null);
+  /**
+   * List of attachments with metadata. Use  {@link  attachments_download_url }  to download the actual files.
+   */
+  attachments: WebhookAttachment$1[];
+  /**
+   * HTTPS URL to download all attachments as a tar.gz archive. Null if the email had no attachments. URL expires - check the expiration before downloading.
+   */
+  attachments_download_url: (string | null);
+}
+/**
+ * A parsed email address with optional display name.
+ *
+ * This structure is used in the `parsed` section of the webhook payload (e.g., `reply_to`, `cc`, `bcc`). For unparsed header strings, see the `headers` section (e.g., `event.email.headers.from`).
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "EmailAddress".
+ */
+interface EmailAddress$1 {
+  /**
+   * The email address portion (e.g., "john@example.com").
+   *
+   * This is the raw value from the email header with no validation applied. May contain unusual but valid formats like quoted local parts.
+   */
+  address: string;
+  /**
+   * The display name portion, if present. Null if the address had no display name.
+   *
+   * May contain any characters including unicode, emoji, or special characters as they appeared in the original email header.
+   */
+  name: (string | null);
+}
+/**
+ * Metadata for an email attachment.
+ *
+ * Attachment content is not included directly in the webhook payload. Use the `attachments_download_url` from  {@link  ParsedDataComplete }  to download all attachments as a tar.gz archive.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "WebhookAttachment".
+ */
+interface WebhookAttachment$1 {
+  /**
+   * Original filename from the email. May be null if the attachment had no filename specified.
+   */
+  filename: (string | null);
+  /**
+   * MIME content type (e.g., "application/pdf", "image/png").
+   */
+  content_type: string;
+  /**
+   * Size of the attachment in bytes.
+   */
+  size_bytes: number;
+  /**
+   * SHA-256 hash of the attachment content (hex-encoded). Use this to verify attachment integrity after download.
+   */
+  sha256: string;
+  /**
+   * Zero-based index of this part in the MIME structure.
+   */
+  part_index: number;
+  /**
+   * Path to this attachment within the downloaded tar.gz archive.
+   */
+  tar_path: string;
+}
+/**
+ * Parsed email content when parsing failed.
+ *
+ * Use the discriminant `status: "failed"` to narrow from  {@link  ParsedData } .
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ParsedDataFailed".
+ */
+interface ParsedDataFailed$1 {
+  /**
+   * Discriminant indicating parsing failed.
+   */
+  status: "failed";
+  error: ParsedError$1;
+  /**
+   * Always null when parsing fails.
+   */
+  body_text: null;
+  /**
+   * Always null when parsing fails.
+   */
+  body_html: null;
+  /**
+   * Always null when parsing fails.
+   */
+  reply_to: null;
+  /**
+   * Always null when parsing fails.
+   */
+  cc: null;
+  /**
+   * Always null when parsing fails.
+   */
+  bcc: null;
+  /**
+   * Always null when parsing fails.
+   */
+  in_reply_to: null;
+  /**
+   * Always null when parsing fails.
+   */
+  references: null;
+  /**
+   * May contain partial attachment metadata even when parsing failed. Useful for debugging or recovering partial data.
+   */
+  attachments: WebhookAttachment$1[];
+  /**
+   * Always null when parsing fails.
+   */
+  attachments_download_url: null;
+}
+/**
+ * Details about why parsing failed.
+ */
+interface ParsedError$1 {
+  /**
+   * Error code indicating the type of failure.
+   * - `PARSE_FAILED`: The email could not be parsed (e.g., malformed MIME)
+   * - `ATTACHMENT_EXTRACTION_FAILED`: Email parsed but attachments couldn't be extracted
+   */
+  code: ("PARSE_FAILED" | "ATTACHMENT_EXTRACTION_FAILED");
+  /**
+   * Human-readable error message describing what went wrong.
+   */
+  message: string;
+  /**
+   * Whether retrying might succeed. If true, the error was transient (e.g., timeout). If false, the email itself is problematic.
+   */
+  retryable: boolean;
+}
+/**
+ * Email analysis and classification results.
+ */
+interface EmailAnalysis$1 {
+  /**
+   * SpamAssassin analysis results.
+   */
+  spamassassin?: {
+    /**
+     * Overall spam score (sum of all rule scores). Higher scores indicate higher likelihood of spam. Unbounded - can be negative (ham) or very high (spam).
+     */
+    score: number;
+  };
+  forward?: ForwardAnalysis$1;
+}
+/**
+ * Forward detection and analysis results.
+ */
+interface ForwardAnalysis$1 {
+  /**
+   * Whether any forwards were detected in the email.
+   */
+  detected: boolean;
+  /**
+   * Analysis results for each detected forward.
+   */
+  results: ForwardResult$1[];
+  /**
+   * Total number of .eml attachments found.
+   */
+  attachments_found: number;
+  /**
+   * Number of .eml attachments that were analyzed.
+   */
+  attachments_analyzed: number;
+  /**
+   * Maximum number of attachments that will be analyzed, or null if unlimited.
+   */
+  attachments_limit: (number | null);
+}
+/**
+ * Result for an inline forward that was detected and analyzed. Inline forwards are always analyzed when forward detection is enabled.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ForwardResultInline".
+ */
+interface ForwardResultInline$1 {
+  type: "inline";
+  /**
+   * Original sender of the forwarded email, if extractable.
+   */
+  original_sender: (ForwardOriginalSender$1 | null);
+  verification: ForwardVerification$1;
+  /**
+   * Human-readable summary of the forward analysis.
+   */
+  summary: string;
+}
+/**
+ * Original sender information extracted from the forwarded email.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ForwardOriginalSender".
+ */
+interface ForwardOriginalSender$1 {
+  /**
+   * Email address of the original sender.
+   */
+  email: string;
+  /**
+   * Domain of the original sender.
+   */
+  domain: string;
+}
+/**
+ * Verification result for the forwarded email.
+ */
+interface ForwardVerification$1 {
+  /**
+   * Overall verdict on whether the forward is authentic.
+   */
+  verdict: ("legit" | "unknown");
+  /**
+   * Confidence level for this verdict.
+   */
+  confidence: ("high" | "medium" | "low");
+  /**
+   * Whether a valid DKIM signature was found that verifies the original sender.
+   */
+  dkim_verified: boolean;
+  /**
+   * Domain of the DKIM signature that verified the forward, if any.
+   */
+  dkim_domain: (string | null);
+  /**
+   * DMARC policy of the original sender's domain.
+   */
+  dmarc_policy: ("reject" | "quarantine" | "none" | null);
+}
+/**
+ * Result for an attachment forward that was analyzed.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ForwardResultAttachmentAnalyzed".
+ */
+interface ForwardResultAttachmentAnalyzed$1 {
+  type: "attachment";
+  /**
+   * Path to the attachment in the attachments tar archive.
+   */
+  attachment_tar_path: string;
+  /**
+   * Original filename of the attachment, if available.
+   */
+  attachment_filename: (string | null);
+  /**
+   * Whether this attachment was analyzed.
+   */
+  analyzed: true;
+  /**
+   * Original sender of the forwarded email, if extractable.
+   */
+  original_sender: (ForwardOriginalSender$1 | null);
+  verification: ForwardVerification1;
+  /**
+   * Human-readable summary of the forward analysis.
+   */
+  summary: string;
+}
+/**
+ * Verification result for the forwarded email.
+ */
+interface ForwardVerification1 {
+  /**
+   * Overall verdict on whether the forward is authentic.
+   */
+  verdict: ("legit" | "unknown");
+  /**
+   * Confidence level for this verdict.
+   */
+  confidence: ("high" | "medium" | "low");
+  /**
+   * Whether a valid DKIM signature was found that verifies the original sender.
+   */
+  dkim_verified: boolean;
+  /**
+   * Domain of the DKIM signature that verified the forward, if any.
+   */
+  dkim_domain: (string | null);
+  /**
+   * DMARC policy of the original sender's domain.
+   */
+  dmarc_policy: ("reject" | "quarantine" | "none" | null);
+}
+/**
+ * Result for an attachment forward that was detected but not analyzed. This occurs when attachment analysis is disabled or the limit was reached.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "ForwardResultAttachmentSkipped".
+ */
+interface ForwardResultAttachmentSkipped$1 {
+  type: "attachment";
+  /**
+   * Path to the attachment in the attachments tar archive.
+   */
+  attachment_tar_path: string;
+  /**
+   * Original filename of the attachment, if available.
+   */
+  attachment_filename: (string | null);
+  /**
+   * Whether this attachment was analyzed.
+   */
+  analyzed: false;
+  /**
+   * Always null when not analyzed.
+   */
+  original_sender: null;
+  /**
+   * Always null when not analyzed.
+   */
+  verification: null;
+  /**
+   * Human-readable summary explaining why analysis was skipped.
+   */
+  summary: string;
+}
+/**
+ * Email authentication results (SPF, DKIM, DMARC).
+ */
+interface EmailAuth$1 {
+  /**
+   * SPF verification result.
+   *
+   * SPF checks if the sending IP is authorized by the envelope sender's domain. "pass" means the IP is authorized; "fail" means it's explicitly not allowed.
+   */
+  spf: ("pass" | "fail" | "softfail" | "neutral" | "none" | "temperror" | "permerror");
+  /**
+   * DMARC verification result.
+   *
+   * DMARC passes if either SPF or DKIM passes AND aligns with the From: domain. "pass" means the email is authenticated according to the sender's policy.
+   */
+  dmarc: ("pass" | "fail" | "none" | "temperror" | "permerror");
+  /**
+   * DMARC policy from the sender's DNS record.
+   *
+   * - `reject`: Domain wants receivers to reject failing emails
+   * - `quarantine`: Domain wants failing emails marked as suspicious
+   * - `none`: Domain is monitoring only (no action requested)
+   * - `null`: No DMARC record found for this domain
+   */
+  dmarcPolicy: ("reject" | "quarantine" | "none" | null);
+  /**
+   * The organizational domain used for DMARC lookups.
+   *
+   * For example, if the From: address is `user@mail.example.com`, the DMARC lookup checks `_dmarc.mail.example.com`, then falls back to `_dmarc.example.com`. This field shows which domain's policy was used.
+   */
+  dmarcFromDomain: (string | null);
+  /**
+   * Whether SPF aligned with the From: domain for DMARC purposes.
+   *
+   * True if the envelope sender domain matches the From: domain (per alignment mode). Optional in self-hosted environments.
+   */
+  dmarcSpfAligned?: boolean;
+  /**
+   * Whether DKIM aligned with the From: domain for DMARC purposes.
+   *
+   * True if at least one DKIM signature's domain matches the From: domain. Optional in self-hosted environments.
+   */
+  dmarcDkimAligned?: boolean;
+  /**
+   * Whether DMARC SPF alignment mode is strict.
+   *
+   * - `true`: Strict alignment required (exact domain match)
+   * - `false`: Relaxed alignment allowed (organizational domain match)
+   * - `null`: No DMARC record found
+   */
+  dmarcSpfStrict: (boolean | null);
+  /**
+   * Whether DMARC DKIM alignment mode is strict.
+   *
+   * - `true`: Strict alignment required (exact domain match)
+   * - `false`: Relaxed alignment allowed (organizational domain match)
+   * - `null`: No DMARC record found
+   */
+  dmarcDkimStrict: (boolean | null);
+  /**
+   * All DKIM signatures found in the email with their verification results.
+   *
+   * May be empty if no DKIM signatures were present.
+   */
+  dkimSignatures: DkimSignature$1[];
+}
+/**
+ * Details about a single DKIM signature found in the email.
+ *
+ * An email may have multiple DKIM signatures (e.g., one from the sending domain and one from the ESP). Each signature is verified independently.
+ *
+ * Fields marked optional (`selector`, `keyBits`, `algo`) may be unavailable in self-hosted environments where the milter provides limited DKIM detail.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "DkimSignature".
+ */
+interface DkimSignature$1 {
+  /**
+   * The domain that signed this DKIM signature (d= tag). This may differ from the From: domain (that's what alignment checks).
+   */
+  domain: string;
+  /**
+   * The DKIM selector used to locate the public key (s= tag). Combined with the domain to form the DNS lookup: `selector._domainkey.domain`
+   *
+   * Optional in self-hosted environments where the milter may not provide selector info.
+   */
+  selector?: (string | null);
+  /**
+   * Verification result for this specific signature.
+   */
+  result: ("pass" | "fail" | "temperror" | "permerror");
+  /**
+   * Whether this signature's domain aligns with the From: domain (for DMARC).
+   *
+   * Alignment can be "strict" (exact match) or "relaxed" (organizational domain match). For example, if From: is `user@sub.example.com` and DKIM is signed by `example.com`:
+   * - Relaxed alignment: true (same organizational domain)
+   * - Strict alignment: false (not exact match)
+   */
+  aligned: boolean;
+  /**
+   * Key size in bits (e.g., 1024, 2048). Null if the key size couldn't be determined.
+   *
+   * Optional in self-hosted environments.
+   */
+  keyBits?: (number | null);
+  /**
+   * Signing algorithm (e.g., "rsa-sha256", "ed25519-sha256").
+   *
+   * Optional in self-hosted environments.
+   */
+  algo?: (string | null);
+} //#endregion
+//#region src/types.d.ts
+
+/**
+ * Webhook payload for the `email.received` event.
+ *
+ * This is delivered to your webhook endpoint when Primitive receives an email matching your domain configuration.
+ *
+ * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
+ * via the `definition` "EmailReceivedEvent".
+ */
+type EmailReceivedEvent = EmailReceivedEvent$1;
+type EventType = EmailReceivedEvent["event"];
+declare const EventType: {
+  readonly EmailReceived: "email.received";
+};
+type RawContent = EmailReceivedEvent["email"]["content"]["raw"];
+type RawContentInline = Extract<RawContent, {
+  included: true;
+}>;
+type RawContentDownloadOnly = Extract<RawContent, {
+  included: false;
+}>;
+type ParsedData = EmailReceivedEvent["email"]["parsed"];
+type ParsedDataComplete = Extract<ParsedData, {
+  status: "complete";
+}>;
+type ParsedDataFailed = Extract<ParsedData, {
+  status: "failed";
+}>;
+type ParsedStatus = ParsedData["status"];
+declare const ParsedStatus: {
+  readonly Complete: "complete";
+  readonly Failed: "failed";
+};
+type ParsedError = ParsedDataFailed["error"];
+type EmailAddress = NonNullable<ParsedDataComplete["reply_to"]>[number];
+type WebhookAttachment = ParsedDataComplete["attachments"][number];
+type EmailAnalysis = EmailReceivedEvent["email"]["analysis"];
+type ForwardAnalysis = NonNullable<EmailAnalysis["forward"]>;
+type ForwardResult = ForwardAnalysis["results"][number];
+type ForwardResultInline = Extract<ForwardResult, {
+  type: "inline";
+}>;
+type ForwardResultAttachmentAnalyzed = Extract<ForwardResult, {
+  type: "attachment";
+  analyzed: true;
+}>;
+type ForwardResultAttachmentSkipped = Extract<ForwardResult, {
+  type: "attachment";
+  analyzed: false;
+}>;
+type ForwardOriginalSender = NonNullable<ForwardResultInline["original_sender"]>;
+type ForwardVerification = NonNullable<ForwardResultInline["verification"]>;
+type ForwardVerdict = ForwardVerification["verdict"];
+declare const ForwardVerdict: {
+  readonly Legit: "legit";
+  readonly Unknown: "unknown";
+};
+type EmailAuth = EmailReceivedEvent["email"]["auth"];
+type DkimSignature = EmailAuth["dkimSignatures"][number];
+type SpfResult = EmailAuth["spf"];
+declare const SpfResult: {
+  readonly Pass: "pass";
+  readonly Fail: "fail";
+  readonly Softfail: "softfail";
+  readonly Neutral: "neutral";
+  readonly None: "none";
+  readonly Temperror: "temperror";
+  readonly Permerror: "permerror";
+};
+type DmarcResult = EmailAuth["dmarc"];
+declare const DmarcResult: {
+  readonly Pass: "pass";
+  readonly Fail: "fail";
+  readonly None: "none";
+  readonly Temperror: "temperror";
+  readonly Permerror: "permerror";
+};
+type DmarcPolicy = EmailAuth["dmarcPolicy"];
+declare const DmarcPolicy: {
+  readonly Reject: "reject";
+  readonly Quarantine: "quarantine";
+  readonly None: "none";
+};
+type DkimResult = DkimSignature["result"];
+declare const DkimResult: {
+  readonly Pass: "pass";
+  readonly Fail: "fail";
+  readonly Temperror: "temperror";
+  readonly Permerror: "permerror";
+};
+type AuthConfidence = ForwardVerification["confidence"];
+declare const AuthConfidence: {
+  readonly High: "high";
+  readonly Medium: "medium";
+  readonly Low: "low";
+};
+type AuthVerdict = "legit" | "suspicious" | "unknown";
+declare const AuthVerdict: {
+  readonly Legit: "legit";
+  readonly Suspicious: "suspicious";
+  readonly Unknown: "unknown";
+};
+interface ValidateEmailAuthResult {
+  verdict: AuthVerdict;
+  confidence: AuthConfidence;
+  reasons: string[];
+}
+declare const unknownEventTypeBrand: unique symbol;
+type UnknownEventType = string & {
+  readonly [unknownEventTypeBrand]: true;
+};
+interface UnknownEvent {
+  event: UnknownEventType;
+  id?: string;
+  version?: string;
+  [key: string]: unknown;
+}
+type KnownWebhookEvent = EmailReceivedEvent;
+type WebhookEvent = KnownWebhookEvent | UnknownEvent;
+
+//#endregion
+export { AuthConfidence as AuthConfidence$1, AuthVerdict as AuthVerdict$1, DkimResult as DkimResult$1, DkimSignature, DmarcPolicy as DmarcPolicy$1, DmarcResult as DmarcResult$1, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType as EventType$1, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict as ForwardVerdict$1, ForwardVerification, KnownWebhookEvent, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus as ParsedStatus$1, RawContent, RawContentDownloadOnly, RawContentInline, SpfResult as SpfResult$1, UnknownEvent, ValidateEmailAuthResult, WebhookAttachment, WebhookEvent };