@stackshift-cloud/sdk 0.1.1 → 0.1.2

package/dist/client.js

@@ -1,11 +1,17 @@
 import { AssetsClient } from './assets.js';
+import { MailClient } from './mail.js';
 import { ProjectsClient } from './projects.js';
 const defaultBaseUrl = 'https://api.stackshift.cloud/api/v1';
+const defaultMailBaseUrl = 'https://api.stackshift.cloud/v1';
+const defaultCdnBaseUrl = 'https://cdn.stackshift.cloud';
 export class StackShift {
     apiKey;
     baseUrl;
+    mailBaseUrl;
+    cdnBaseUrl;
     projects;
     assets;
+    mail;
     fetcher;
     constructor(options = {}) {
         const apiKey = options.apiKey ?? env('STACKSHIFT_API_KEY');
@@ -14,13 +20,22 @@ export class StackShift {
         }
         this.apiKey = apiKey;
         this.baseUrl = (options.baseUrl ?? defaultBaseUrl).replace(/\/$/, '');
+        this.mailBaseUrl = (options.mailBaseUrl ?? defaultMailBaseUrl).replace(/\/$/, '');
+        this.cdnBaseUrl = (options.cdnBaseUrl ?? defaultCdnBaseUrl).replace(/\/$/, '');
         this.fetcher = options.fetch ?? fetch;
         this.projects = new ProjectsClient(this);
         this.assets = new AssetsClient(this);
+        this.mail = new MailClient(this);
     }
     async request(path, init = {}) {
+        return this.requestFrom(this.baseUrl, path, init);
+    }
+    async mailRequest(path, init = {}) {
+        return this.requestFrom(this.mailBaseUrl, path, init);
+    }
+    async requestFrom(baseUrl, path, init) {
         const isFormData = typeof FormData !== 'undefined' && init.body instanceof FormData;
-        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+        const response = await this.fetcher(`${baseUrl}${path}`, {
             method: init.method ?? 'GET',
             headers: stripUndefined({
                 Authorization: `Bearer ${this.apiKey}`,
@@ -32,7 +47,8 @@ export class StackShift {
         const raw = await response.text();
         const parsed = raw ? JSON.parse(raw) : null;
         if (!response.ok) {
-            throw new Error(parsed?.message ?? parsed?.error ?? `StackShift API request failed with ${response.status}`);
+            const apiError = parsed?.error && typeof parsed.error === 'object' ? parsed.error : undefined;
+            throw new StackShiftAPIError(apiError?.message ?? parsed?.message ?? parsed?.error ?? `StackShift API request failed with ${response.status}`, response.status, apiError?.code, apiError?.details);
         }
         if (parsed && typeof parsed === 'object' && 'success' in parsed && 'data' in parsed) {
             return parsed.data;
@@ -40,6 +56,18 @@ export class StackShift {
         return parsed;
     }
 }
+export class StackShiftAPIError extends Error {
+    status;
+    code;
+    details;
+    constructor(message, status, code, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = 'StackShiftAPIError';
+    }
+}
 function env(key) {
     const maybeProcess = globalThis.process;
     return maybeProcess?.env?.[key];

package/dist/index.d.ts

@@ -1,4 +1,11 @@
-export { StackShift } from './client.js';
-export { AssetsClient } from './assets.js';
+export { StackShift, StackShiftAPIError } from './client.js';
+export { AssetsClient, assetTransformOptions, assetTransformPresets, assetTransformSpec, getAssetTransformPreset } from './assets.js';
+export { MailBouncesClient, MailClient, MailDomainsClient, MailEventsClient, MailLimitsClient, MailMessagesClient, MailScheduledClient, MailBatchClient, MailInboundClient, MailAnalyticsClient, MailOtpChallengesClient, MailOtpClient, MailReputationClient, MailReputationEventsClient, MailSuppressionsClient, MailTemplatesClient, MailWebhooksClient, } from './mail.js';
 export { ProjectsClient } from './projects.js';
-export type { Asset, AssetListOptions, AssetListResult, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetUploadOptions, AssetVisibility, JsonValue, Project, ProjectListOptions, StackShiftOptions, } from './types.js';
+export type { Asset, AssetAIAnnotation, AssetAIInfo, AssetCollection, AssetListOptions, AssetListResult, AssetModerationResult, AssetSavedSearch, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTranscript, AssetTransformOptions, AssetTransformPreset, AssetTransformPresetCategory, AssetUploadOptions, AssetVisibility, AssetVersion, JsonValue, MailAddress, MailAddressInput, MailDnsRecord, MailDomain, MailDomainListResult, MailDomainStatus, MailIdempotencyStatus, MailLog, MailMessage, MailMessageListOptions, MailMessageListResult, MailMessageSummary, MailRecordStatus, MailSendAttempt, MailSendInput, MailSendResponse, MailStatus, Project, ProjectListOptions, StackShiftOptions, } from './types.js';
+export type { MailBounce, MailBounceListOptions, MailBounceListResult, MailBounceType, MailSuppression, MailSuppressionCreateInput, MailSuppressionListOptions, MailSuppressionListResult, MailSuppressionReason, MailSuppressionSource, } from './mail-phase4-types.js';
+export type { MailOtpChallenge, MailOtpChallengeListOptions, MailOtpChallengeListResult, MailOtpSendInput, MailOtpSendResponse, MailOtpStatus, MailOtpVerifyInput, MailOtpVerifyResponse, } from './mail-otp-types.js';
+export type { MailSendTemplateInput, MailSendTemplateResponse, MailTemplate, MailTemplateCreateInput, MailTemplateDetail, MailTemplateListOptions, MailTemplateListResult, MailTemplatePreview, MailTemplatePreviewInput, MailTemplateStatus, MailTemplateTestSendInput, MailTemplateTestSendResponse, MailTemplateUpdateInput, MailTemplateVersion, } from './mail-template-types.js';
+export type { MailEvent, MailEventListOptions, MailEventListResult, MailEventType, MailTimelineItem, MailWebhook, MailWebhookCreateInput, MailWebhookCreateResponse, MailWebhookDelivery, MailWebhookDeliveryAttempt, MailWebhookDeliveryDetail, MailWebhookDeliveryListOptions, MailWebhookListOptions, MailWebhookListResult, MailWebhookUpdateInput, } from './mail-webhook-types.js';
+export type { MailDomainReputation, MailLimits, MailManualReviewStatus, MailReputation, MailReputationEvent, MailReputationEventListOptions, MailReputationEventListResult, MailReputationEventSeverity, MailReputationStatus, MailReputationTier, MailReputationWorkspace, } from './mail-reputation-types.js';
+export type { MailAnalytics, MailAnalyticsInput, MailAttachmentInput, MailBatch, MailBatchSendInput, MailBatchTemplateInput, MailInboundDomain, MailInboundMessage, MailScheduledCreateInput, MailScheduledMessage, } from './mail-advanced-types.js';

package/dist/index.js

@@ -1,3 +1,4 @@
-export { StackShift } from './client.js';
-export { AssetsClient } from './assets.js';
+export { StackShift, StackShiftAPIError } from './client.js';
+export { AssetsClient, assetTransformOptions, assetTransformPresets, assetTransformSpec, getAssetTransformPreset } from './assets.js';
+export { MailBouncesClient, MailClient, MailDomainsClient, MailEventsClient, MailLimitsClient, MailMessagesClient, MailScheduledClient, MailBatchClient, MailInboundClient, MailAnalyticsClient, MailOtpChallengesClient, MailOtpClient, MailReputationClient, MailReputationEventsClient, MailSuppressionsClient, MailTemplatesClient, MailWebhooksClient, } from './mail.js';
 export { ProjectsClient } from './projects.js';

package/dist/mail-advanced-types.d.ts

@@ -0,0 +1,83 @@
+import type { JsonValue, MailAddress, MailAddressInput, MailSendInput, MailSendResponse } from './types.js';
+import type { MailSendTemplateInput } from './mail-template-types.js';
+export interface MailAttachmentInput {
+    assetId?: string;
+    uploadId?: string;
+    filename: string;
+    contentType?: string;
+}
+export interface MailScheduledCreateInput {
+    sendAt: string;
+    message?: MailSendInput;
+    template?: string;
+    versionId?: string;
+    to?: MailAddressInput;
+    from?: string | MailAddress;
+    data?: Record<string, JsonValue>;
+    idempotencyKey?: string;
+    attachments?: MailAttachmentInput[];
+}
+export interface MailScheduledMessage {
+    id: string;
+    status: 'scheduled' | 'queued' | 'sent' | 'canceled' | 'failed';
+    sendAt: string;
+    messageId?: string | null;
+    createdAt?: string;
+    canceledAt?: string | null;
+    sentAt?: string | null;
+}
+export interface MailBatchSendInput {
+    from: string | MailAddress;
+    messages: MailSendInput[];
+}
+export interface MailBatchTemplateInput {
+    template: string;
+    versionId?: string;
+    from: string | MailAddress;
+    recipients: Array<{
+        to: MailAddressInput;
+        data?: Record<string, JsonValue>;
+        idempotencyKey?: string;
+    }>;
+}
+export interface MailBatch {
+    id: string;
+    status: 'queued' | 'processing' | 'completed' | 'failed';
+    messageCount: number;
+}
+export interface MailInboundDomain {
+    id: string;
+    domain: string;
+    status: 'pending' | 'verified' | 'disabled';
+    records?: Array<{
+        type: string;
+        name: string;
+        value: string;
+        required: boolean;
+    }>;
+}
+export interface MailInboundMessage {
+    id: string;
+    fromEmail: string;
+    toEmails: string[];
+    ccEmails?: string[] | null;
+    subject?: string | null;
+    text?: string | null;
+    html?: string | null;
+    rawRef?: string | null;
+    receivedAt: string;
+}
+export interface MailAnalyticsInput {
+    range?: '24h' | '7d' | '30d' | '90d' | string;
+    from?: string;
+    to?: string;
+    interval?: 'hour' | 'day';
+    domain?: string;
+    template?: string;
+    event?: string;
+}
+export interface MailAnalytics {
+    summary: Record<string, number>;
+    series: Array<Record<string, number | string>>;
+}
+export type { MailSendResponse, MailSendTemplateInput };

package/dist/mail-advanced-types.js

@@ -0,0 +1 @@
+export {};

package/dist/mail-advanced.d.ts

@@ -0,0 +1,45 @@
+import type { StackShift } from './client.js';
+import type { MailAnalytics, MailAnalyticsInput, MailBatch, MailBatchSendInput, MailBatchTemplateInput, MailInboundDomain, MailInboundMessage, MailScheduledCreateInput, MailScheduledMessage } from './mail-advanced-types.js';
+export declare class MailScheduledClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailScheduledCreateInput): Promise<MailScheduledMessage>;
+    list(): Promise<{
+        data: MailScheduledMessage[];
+    }>;
+    get(id: string): Promise<MailScheduledMessage>;
+    cancel(id: string): Promise<MailScheduledMessage>;
+}
+export declare class MailBatchClient {
+    private readonly client;
+    constructor(client: StackShift);
+    send(input: MailBatchSendInput): Promise<MailBatch>;
+    sendTemplate(input: MailBatchTemplateInput): Promise<MailBatch>;
+}
+export declare class MailInboundClient {
+    readonly domains: MailInboundDomainsClient;
+    readonly messages: MailInboundMessagesClient;
+    constructor(client: StackShift);
+}
+export declare class MailInboundDomainsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(domain: string): Promise<MailInboundDomain>;
+    list(): Promise<{
+        data: MailInboundDomain[];
+    }>;
+    verify(id: string): Promise<MailInboundDomain>;
+}
+export declare class MailInboundMessagesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    list(): Promise<{
+        data: MailInboundMessage[];
+    }>;
+    get(id: string): Promise<MailInboundMessage>;
+}
+export declare class MailAnalyticsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    get(input?: MailAnalyticsInput): Promise<MailAnalytics>;
+}

package/dist/mail-advanced.js

@@ -0,0 +1,88 @@
+export class MailScheduledClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/scheduled', { method: 'POST', body: input });
+    }
+    list() {
+        return this.client.mailRequest('/mail/scheduled');
+    }
+    get(id) {
+        return this.client.mailRequest(`/mail/scheduled/${encodeURIComponent(id)}`);
+    }
+    cancel(id) {
+        return this.client.mailRequest(`/mail/scheduled/${encodeURIComponent(id)}/cancel`, { method: 'POST' });
+    }
+}
+export class MailBatchClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    send(input) {
+        return this.client.mailRequest('/mail/batch', { method: 'POST', body: input });
+    }
+    sendTemplate(input) {
+        return this.client.mailRequest('/mail/batch-template', { method: 'POST', body: input });
+    }
+}
+export class MailInboundClient {
+    domains;
+    messages;
+    constructor(client) {
+        this.domains = new MailInboundDomainsClient(client);
+        this.messages = new MailInboundMessagesClient(client);
+    }
+}
+export class MailInboundDomainsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(domain) {
+        return this.client.mailRequest('/mail/inbound/domains', { method: 'POST', body: { domain } });
+    }
+    list() {
+        return this.client.mailRequest('/mail/inbound/domains');
+    }
+    verify(id) {
+        return this.client.mailRequest(`/mail/inbound/domains/${encodeURIComponent(id)}/verify`, { method: 'POST' });
+    }
+}
+export class MailInboundMessagesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list() {
+        return this.client.mailRequest('/mail/inbound/messages');
+    }
+    get(id) {
+        return this.client.mailRequest(`/mail/inbound/messages/${encodeURIComponent(id)}`);
+    }
+}
+export class MailAnalyticsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    get(input = {}) {
+        const query = new URLSearchParams();
+        append(query, 'range', input.range);
+        append(query, 'from', input.from);
+        append(query, 'to', input.to);
+        append(query, 'interval', input.interval);
+        append(query, 'domain', input.domain);
+        append(query, 'template', input.template);
+        append(query, 'event', input.event);
+        const suffix = query.toString();
+        return this.client.mailRequest(`/mail/analytics${suffix ? `?${suffix}` : ''}`);
+    }
+}
+function append(target, key, value) {
+    if (value !== undefined && value !== null && value !== '') {
+        target.append(key, String(value));
+    }
+}

package/dist/mail-events-webhooks.d.ts

@@ -0,0 +1,43 @@
+import type { StackShift } from './client.js';
+import type { MailEvent, MailEventListOptions, MailEventListResult, MailTimelineItem, MailWebhook, MailWebhookCreateInput, MailWebhookCreateResponse, MailWebhookDelivery, MailWebhookDeliveryDetail, MailWebhookDeliveryListOptions, MailWebhookListOptions, MailWebhookListResult, MailWebhookUpdateInput } from './mail-webhook-types.js';
+export declare class MailEventsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    list(options?: MailEventListOptions): Promise<MailEventListResult>;
+    get(eventId: string): Promise<MailEvent>;
+}
+export declare class MailWebhooksClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailWebhookCreateInput): Promise<MailWebhookCreateResponse>;
+    list(options?: MailWebhookListOptions): Promise<MailWebhookListResult>;
+    get(webhookId: string): Promise<MailWebhook>;
+    update(webhookId: string, input: MailWebhookUpdateInput): Promise<MailWebhook>;
+    rotateSecret(webhookId: string): Promise<{
+        secret: string;
+    }>;
+    delete(webhookId: string): Promise<void>;
+    deliveries(webhookId: string, options?: MailWebhookDeliveryListOptions): Promise<{
+        data: MailWebhookDelivery[];
+        nextCursor?: string | null;
+    }>;
+    getDelivery(deliveryId: string): Promise<MailWebhookDeliveryDetail>;
+    retryDelivery(deliveryId: string): Promise<MailWebhookDelivery>;
+    verifySignature(input: {
+        rawBody: string | Uint8Array;
+        signatureHeader?: string | null;
+        timestampHeader?: string | null;
+        secret: string;
+        toleranceSeconds?: number;
+    }): boolean;
+}
+export declare function verifyWebhookSignature(input: {
+    rawBody: string | Uint8Array;
+    signatureHeader?: string | null;
+    timestampHeader?: string | null;
+    secret: string;
+    toleranceSeconds?: number;
+}): boolean;
+export declare function timeline(client: StackShift, messageId: string): Promise<{
+    data: MailTimelineItem[];
+}>;

package/dist/mail-events-webhooks.js

@@ -0,0 +1,194 @@
+export class MailEventsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options = {}) {
+        const query = queryString(options);
+        return this.client.mailRequest(`/mail/events${query}`);
+    }
+    get(eventId) {
+        return this.client.mailRequest(`/mail/events/${encodeURIComponent(eventId)}`);
+    }
+}
+export class MailWebhooksClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/webhooks', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/webhooks${queryString(options)}`);
+    }
+    get(webhookId) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}`);
+    }
+    update(webhookId, input) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}`, {
+            method: 'PATCH',
+            body: input,
+        });
+    }
+    rotateSecret(webhookId) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}/rotate-secret`, {
+            method: 'POST',
+        });
+    }
+    delete(webhookId) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}`, {
+            method: 'DELETE',
+        });
+    }
+    deliveries(webhookId, options = {}) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}/deliveries${queryString(options)}`);
+    }
+    getDelivery(deliveryId) {
+        return this.client.mailRequest(`/mail/webhook-deliveries/${encodeURIComponent(deliveryId)}`);
+    }
+    retryDelivery(deliveryId) {
+        return this.client.mailRequest(`/mail/webhook-deliveries/${encodeURIComponent(deliveryId)}/retry`, {
+            method: 'POST',
+        });
+    }
+    verifySignature(input) {
+        return verifyWebhookSignature(input);
+    }
+}
+export function verifyWebhookSignature(input) {
+    const timestamp = Number(input.timestampHeader);
+    if (!Number.isFinite(timestamp))
+        return false;
+    const tolerance = input.toleranceSeconds ?? 300;
+    if (tolerance > 0 && Math.abs(Date.now() / 1000 - timestamp) > tolerance)
+        return false;
+    const expected = hex(hmacSha256(utf8(`${timestamp}.`), bytes(input.rawBody), utf8(input.secret)));
+    const actual = signatureValue(input.signatureHeader ?? '');
+    if (!actual || actual.length !== expected.length)
+        return false;
+    return constantTimeEqual(actual, expected);
+}
+export function timeline(client, messageId) {
+    return client.mailRequest(`/mail/messages/${encodeURIComponent(messageId)}/timeline`);
+}
+function queryString(options) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(options)) {
+        if (value !== undefined && value !== null && value !== '') {
+            query.append(key, String(value));
+        }
+    }
+    const suffix = query.toString();
+    return suffix ? `?${suffix}` : '';
+}
+function signatureValue(header) {
+    return header.split(',').map((part) => part.trim()).find((part) => part.startsWith('v1='))?.slice(3) ?? '';
+}
+function hmacSha256(prefix, body, key) {
+    let normalized = key;
+    if (normalized.length > 64)
+        normalized = sha256(normalized);
+    const inner = new Uint8Array(64);
+    const outer = new Uint8Array(64);
+    inner.fill(0x36);
+    outer.fill(0x5c);
+    for (let i = 0; i < normalized.length; i += 1) {
+        inner[i] ^= normalized[i];
+        outer[i] ^= normalized[i];
+    }
+    return sha256(concat(outer, sha256(concat(inner, prefix, body))));
+}
+function sha256(message) {
+    const k = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
+    let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+    const padded = pad(message);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let i = 0; i < 16; i += 1)
+            w[i] = read32(padded, offset + i * 4);
+        for (let i = 16; i < 64; i += 1)
+            w[i] = (sigma1(w[i - 2]) + w[i - 7] + sigma0(w[i - 15]) + w[i - 16]) >>> 0;
+        let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+        for (let i = 0; i < 64; i += 1) {
+            const t1 = (h + capsigma1(e) + ch(e, f, g) + k[i] + w[i]) >>> 0;
+            const t2 = (capsigma0(a) + maj(a, b, c)) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h0 = (h0 + a) >>> 0;
+        h1 = (h1 + b) >>> 0;
+        h2 = (h2 + c) >>> 0;
+        h3 = (h3 + d) >>> 0;
+        h4 = (h4 + e) >>> 0;
+        h5 = (h5 + f) >>> 0;
+        h6 = (h6 + g) >>> 0;
+        h7 = (h7 + h) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    [h0, h1, h2, h3, h4, h5, h6, h7].forEach((value, i) => write32(out, i * 4, value));
+    return out;
+}
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+const ch = (x, y, z) => (x & y) ^ (~x & z);
+const maj = (x, y, z) => (x & y) ^ (x & z) ^ (y & z);
+const capsigma0 = (x) => rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
+const capsigma1 = (x) => rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
+const sigma0 = (x) => rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3);
+const sigma1 = (x) => rotr(x, 17) ^ rotr(x, 19) ^ (x >>> 10);
+const utf8 = (value) => new TextEncoder().encode(value);
+const bytes = (value) => (typeof value === 'string' ? utf8(value) : value);
+const concat = (...arrays) => {
+    const out = new Uint8Array(arrays.reduce((sum, item) => sum + item.length, 0));
+    let offset = 0;
+    for (const item of arrays) {
+        out.set(item, offset);
+        offset += item.length;
+    }
+    return out;
+};
+function pad(message) {
+    const length = (((message.length + 9 + 63) >> 6) << 6);
+    const out = new Uint8Array(length);
+    out.set(message);
+    out[message.length] = 0x80;
+    const bitLength = message.length * 8;
+    write32(out, length - 4, bitLength >>> 0);
+    write32(out, length - 8, Math.floor(bitLength / 0x100000000));
+    return out;
+}
+const read32 = (data, offset) => ((data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]) >>> 0;
+function write32(data, offset, value) {
+    data[offset] = value >>> 24;
+    data[offset + 1] = value >>> 16;
+    data[offset + 2] = value >>> 8;
+    data[offset + 3] = value;
+}
+function hex(data) {
+    return Array.from(data, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function constantTimeEqual(a, b) {
+    let diff = 0;
+    for (let i = 0; i < a.length; i += 1)
+        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    return diff === 0;
+}

package/dist/mail-otp-types.d.ts

@@ -0,0 +1,63 @@
+import type { JsonValue } from './types.js';
+export type MailOtpStatus = 'pending' | 'verified' | 'expired' | 'failed' | 'canceled';
+export interface MailOtpSendInput {
+    to: string;
+    purpose: string;
+    from?: string;
+    expiresIn?: string;
+    codeLength?: number;
+    metadata?: Record<string, JsonValue>;
+    idempotencyKey?: string;
+    subject?: string;
+    brandName?: string;
+}
+export interface MailOtpVerifyInput {
+    to?: string;
+    purpose?: string;
+    challengeId?: string;
+    code: string;
+}
+export interface MailOtpChallengeListOptions {
+    to?: string;
+    purpose?: string;
+    status?: MailOtpStatus;
+    limit?: number;
+    cursor?: string;
+}
+export interface MailOtpChallenge {
+    id: string;
+    to: string;
+    purpose: string;
+    status: MailOtpStatus;
+    attempts: number;
+    maxAttempts: number;
+    attemptsRemaining?: number;
+    expiresAt: string;
+    resendAvailableAt?: string;
+    messageId?: string | null;
+    metadata?: Record<string, JsonValue> | null;
+    createdAt: string;
+    verifiedAt?: string | null;
+    failedAt?: string | null;
+    canceledAt?: string | null;
+}
+export interface MailOtpChallengeListResult {
+    data: MailOtpChallenge[];
+    nextCursor?: string | null;
+}
+export interface MailOtpSendResponse {
+    id: string;
+    to: string;
+    purpose: string;
+    status: MailOtpStatus;
+    expiresAt: string;
+    attemptsRemaining: number;
+    resendAvailableAt: string;
+    messageId?: string | null;
+    idempotencyStatus?: 'created' | 'reused';
+}
+export interface MailOtpVerifyResponse {
+    verified: boolean;
+    challengeId: string;
+    status: MailOtpStatus;
+}

package/dist/mail-otp-types.js

@@ -0,0 +1 @@
+export {};

package/dist/mail-phase4-types.d.ts

@@ -0,0 +1,49 @@
+import type { JsonValue } from './types.js';
+export type MailBounceType = 'hard' | 'soft' | 'unknown';
+export type MailSuppressionReason = 'hard_bounce' | 'complaint' | 'manual' | 'repeated_soft_bounce' | 'blocked' | 'unsubscribe';
+export type MailSuppressionSource = 'bounce_processor' | 'user' | 'system' | 'future_complaint_processor';
+export interface MailSuppression {
+    id: string;
+    email: string;
+    reason: MailSuppressionReason;
+    source: MailSuppressionSource;
+    messageId?: string | null;
+    createdAt: string;
+    expiresAt?: string | null;
+}
+export interface MailSuppressionListOptions {
+    email?: string;
+    reason?: MailSuppressionReason;
+    limit?: number;
+    cursor?: string;
+}
+export interface MailSuppressionCreateInput {
+    email: string;
+    reason?: 'manual' | 'blocked';
+    metadata?: JsonValue;
+}
+export interface MailSuppressionListResult {
+    data: MailSuppression[];
+    nextCursor?: string | null;
+}
+export interface MailBounce {
+    id: string;
+    messageId?: string | null;
+    recipientEmail: string;
+    bounceType: MailBounceType;
+    reason: string;
+    smtpStatusCode?: string | null;
+    diagnosticCode?: string | null;
+    receivedAt: string;
+}
+export interface MailBounceListOptions {
+    email?: string;
+    type?: MailBounceType;
+    messageId?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface MailBounceListResult {
+    data: MailBounce[];
+    nextCursor?: string | null;
+}

package/dist/mail-phase4-types.js

@@ -0,0 +1 @@
+export {};