@agentisend/sdk-node 0.5.0 → 0.5.2

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { ApiKey, AutomationRun, ReceivedAttachment, ReceivedEmail, ReceivedThread, SentAttachment, RequestLogEntry, EventDefinition, EventFieldType, ApiKeyPermission, BatchItemResult, CreatedApiKey, CreatedWebhookEndpoint, DeadLetter, Deleted, Domain, DomainRegion, DomainSetup, LegacyDomainRegion, Email, EventType, Limit, LimitPeriod, ListEmailsQuery, ListQuery, MetricsQuery, ExplainReport, Page, PreflightReport, ReplayResult, ContactTopic, SendEmailPayload, ServiceStatus, SuppressionBatchItem, AuditEntry, TeamInvite, TeamMember, Topic, BillingPlan, TrustStanding, WebhookEndpoint } from './types.js';
+import type { ApiKey, BroadcastClickedLinksQuery, BroadcastRecipientsQuery, EngagementList, AutomationConnection, AutomationGraphStep, AutomationRun, ReceivedAttachment, ReceivedEmail, ReceivedThread, SentAttachment, RequestLogEntry, EventDefinition, EventFieldType, ApiKeyPermission, BatchItemResult, CreatedApiKey, CreatedWebhookEndpoint, DeadLetter, Deleted, Domain, DomainCapabilities, DomainClaim, DomainRegion, DomainSetup, LegacyDomainRegion, Email, EventType, Limit, LimitPeriod, ListEmailsQuery, ListQuery, MetricsQuery, ExplainReport, Page, PreflightReport, ReplayResult, ContactTopic, SendEmailPayload, TemplateCreatePayload, ServiceStatus, SuppressionBatchItem, AuditEntry, TeamInvite, TeamMember, Topic, BillingPlan, TrustStanding, WebhookEndpoint } from './types.js';
 export declare const DEFAULT_BASE_URL = "https://api.agentisend.com";
 export interface FetchResponse {
     status: number;
@@ -85,15 +85,28 @@ export declare class AgentiSend {
         }>;
         get: (id: string) => Promise<Email>;
         list: (query?: ListEmailsQuery) => Promise<Page<Email>>;
-        /** Alias of GET /metrics. start_date and end_date name since and until. */
+        /**
+         * Account-level email metrics in Resend's shape: totals for a range, or
+         * rows by period, domain, email or broadcast. since/until answer in the
+         * GET /metrics shape instead. Lists are sent comma-separated.
+         */
         metrics: (query?: MetricsQuery) => Promise<Record<string, unknown>>;
         /** M5.10 — what this email carried, after it was sent. */
         attachments: (id: string) => Promise<Page<SentAttachment>>;
-        /** Stop a scheduled or queued email. Sent mail is history, not cancellable. */
-        cancel: (id: string, options?: RequestOptions) => Promise<{
+        /**
+         * A link anyone can open to read one sent or received email, with no
+         * sign-in. `expires_in` is a duration such as "10m", "2 hours" or "1 day";
+         * the default and the most is 48 hours.
+         */
+        share: (id: string, payload?: {
+            expires_in?: string;
+        }, options?: RequestOptions) => Promise<{
+            object: "email";
             id: string;
-            status: string;
+            url: string;
         }>;
+        /** Stop a scheduled or queued email. Sent mail is history, not cancellable. Answers with the cancelled email. */
+        cancel: (id: string, options?: RequestOptions) => Promise<Email>;
         /** Delete a sent email and its events for good. A scheduled one must be cancelled first. */
         remove: (id: string, options?: RequestOptions) => Promise<{
             id: string;
@@ -188,6 +201,17 @@ export declare class AgentiSend {
         }>;
     };
     readonly domains: {
+        /** Whether create would accept this name, and the refusal it would give. Creates nothing. */
+        check: (name: string) => Promise<{
+            name: string;
+            can_add: boolean;
+            blocklist: "listed" | "clean" | "unknown";
+            problems: Array<{
+                code: string;
+                message: string;
+                fix: string;
+            }>;
+        }>;
         create: (payload: {
             name: string;
             region?: DomainRegion | LegacyDomainRegion;
@@ -197,18 +221,54 @@ export declare class AgentiSend {
             open_tracking?: boolean;
             click_tracking?: boolean;
             tls_mode?: "opportunistic" | "enforced";
+            /** Sending defaults to enabled, receiving to disabled. At least one must be enabled. */
+            capabilities?: DomainCapabilities;
         }, options?: RequestOptions) => Promise<Domain>;
         list: (query?: ListQuery) => Promise<Page<Domain>>;
         get: (id: string) => Promise<Domain>;
         /** One-shot DNS sheet: zone file, copy-paste commands, provider. */
         setup: (id: string) => Promise<DomainSetup>;
+        /** A page the person who owns DNS can open. No sign-in. Lasts 7 days. A new call replaces it. */
+        setupLink: (id: string, options?: RequestOptions) => Promise<{
+            url: string;
+            expires_at: string;
+        }>;
+        /** Withdraw the live setup link. The page stops opening. */
+        revokeSetupLink: (id: string, options?: RequestOptions) => Promise<{
+            revoked: true;
+        }>;
         verify: (id: string, options?: RequestOptions) => Promise<Domain>;
+        /** Who may write to this domain: allow and block rules, newest first. */
+        listInboundRules: (id: string, query?: ListQuery & {
+            kind?: "allow" | "block";
+        }) => Promise<Page<Record<string, unknown>>>;
+        /** One rule: an address, a bare domain, or *@sub.example.com. Block wins over allow. */
+        addInboundRule: (id: string, payload: {
+            kind: "allow" | "block";
+            pattern: string;
+            note?: string;
+        }, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        addInboundRules: (id: string, payload: {
+            kind: "allow" | "block";
+            patterns: string[];
+            note?: string;
+        }, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        removeInboundRules: (id: string, payload: {
+            ids?: string[];
+            kind?: "allow" | "block";
+            patterns?: string[];
+        }, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        removeInboundRule: (id: string, ruleId: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
         /** A8 + P3b: click/open tracking, TLS mode, or a new tracking_subdomain. Never removed. */
         update: (id: string, payload: {
             click_tracking?: boolean;
             open_tracking?: boolean;
             tracking_subdomain?: string;
             tls_mode?: "opportunistic" | "enforced";
+            /** monitor labels received mail. hold keeps a review message until release. */
+            inbound_hold_mode?: "monitor" | "hold";
+            /** Name one or both; the other keeps its value. At least one stays enabled. */
+            capabilities?: DomainCapabilities;
         }, options?: RequestOptions) => Promise<Domain>;
         delete: (id: string, options?: RequestOptions) => Promise<Deleted>;
         /**
@@ -231,6 +291,25 @@ export declare class AgentiSend {
         events: (id: string, query?: ListQuery) => Promise<Page<Record<string, unknown>>>;
         /** Alias of setup: detects the DNS provider and returns the exact records to add. */
         connect: (id: string) => Promise<DomainSetup>;
+        /**
+         * Start a claim for a domain another account has verified. Publish the TXT
+         * `record` it returns, then `verifyClaim`. Nothing moves until the safety
+         * checks pass.
+         */
+        claim: (payload: {
+            name: string;
+            region?: DomainRegion | LegacyDomainRegion;
+            tracking?: boolean;
+            tracking_subdomain?: string;
+            return_path_subdomain?: string;
+            open_tracking?: boolean;
+            click_tracking?: boolean;
+            tls_mode?: "opportunistic" | "enforced";
+        }, options?: RequestOptions) => Promise<DomainClaim>;
+        /** The latest claim for the placeholder domain a claim created. Poll it until `completed`. */
+        getClaim: (domainId: string) => Promise<DomainClaim>;
+        /** Check the claim's TXT record and, when it is there, run the ownership checks and move the domain. */
+        verifyClaim: (domainId: string, options?: RequestOptions) => Promise<DomainClaim>;
     };
     readonly webhooks: {
         create: (payload: {
@@ -273,6 +352,24 @@ export declare class AgentiSend {
             rotated_at: string;
             previous_secret_expires_at: string;
         }>;
+        /** The same rotation on Resend's path. */
+        rotateSigningSecret: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /** What was sent to this endpoint: pending, attempting, success or failed. */
+        listEvents: (id: string, query?: {
+            limit?: number;
+            after?: string;
+        }) => Promise<Page<Record<string, unknown>>>;
+        getEvent: (id: string, eventId: string) => Promise<Record<string, unknown>>;
+        /** Each attempt to deliver one event, with the status code and body the endpoint answered. */
+        listEventAttempts: (id: string, eventId: string, query?: {
+            limit?: number;
+            after?: string;
+        }) => Promise<Page<Record<string, unknown>>>;
+        /** Send one event to the endpoint again, as a new delivery marked as a replay. */
+        replayEvent: (id: string, eventId: string, options?: RequestOptions) => Promise<{
+            object: string;
+            id: string;
+        }>;
     };
     readonly limits: {
         list: (query?: ListQuery) => Promise<Page<Limit>>;
@@ -326,8 +423,11 @@ export declare class AgentiSend {
             from?: string;
             since?: string;
             until?: string;
+            held?: boolean;
         }) => Promise<Page<ReceivedEmail>>;
         get: (id: string) => Promise<ReceivedEmail>;
+        /** How many messages each domain's sender rules refused. */
+        refusals: () => Promise<Record<string, unknown>>;
         /** Delete one received email for good. */
         remove: (id: string, options?: RequestOptions) => Promise<{
             id: string;
@@ -355,6 +455,8 @@ export declare class AgentiSend {
         attachment: (id: string, attachmentId: string) => Promise<Uint8Array>;
         /** The message exactly as it arrived, headers and all. */
         raw: (id: string) => Promise<string>;
+        /** Release a held message. The arrival webhook fires once. */
+        release: (id: string, reason: string, options?: RequestOptions) => Promise<ReceivedEmail>;
     };
     /**
      * M5.7 — the custom-event registry. Declaring an event's fields turns a
@@ -368,6 +470,17 @@ export declare class AgentiSend {
         }, options?: RequestOptions) => Promise<{
             fired: number;
         }>;
+        /** Resend's form: one event for one contact, by contact_id or email. */
+        send: (payload: {
+            event: string;
+            contact_id?: string;
+            email?: string;
+            payload?: Record<string, unknown>;
+        }, options?: RequestOptions) => Promise<{
+            object: "event";
+            event: string;
+            fired: number;
+        }>;
         list: (query?: ListQuery) => Promise<Page<EventDefinition>>;
         get: (id: string) => Promise<EventDefinition>;
         update: (id: string, payload: {
@@ -379,19 +492,53 @@ export declare class AgentiSend {
     };
     /** M5.6 — what an automation actually did, after it did it. */
     readonly automations: {
+        /**
+         * Linear: `{ name, trigger, steps }` with steps of kind email, webhook or
+         * ab_split. Graph (Resend's shape): `{ name, status?, steps, connections }`
+         * with steps `{ key, type, config }`.
+         */
         create: (payload: {
             name: string;
+            status?: "enabled" | "disabled";
             trigger: Record<string, unknown>;
             steps: Record<string, unknown>[];
+        } | {
+            name: string;
+            status?: "enabled" | "disabled";
+            steps: AutomationGraphStep[];
+            connections: AutomationConnection[];
         }, options?: RequestOptions) => Promise<Record<string, unknown>>;
-        list: (query?: ListQuery) => Promise<Page<Record<string, unknown>>>;
+        list: (query?: ListQuery & {
+            status?: "enabled" | "disabled";
+        }) => Promise<Page<Record<string, unknown>>>;
         get: (id: string) => Promise<Record<string, unknown>>;
         update: (id: string, payload: Record<string, unknown>, options?: RequestOptions) => Promise<Record<string, unknown>>;
         enable: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
         disable: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
         versions: (id: string) => Promise<Page<Record<string, unknown>>>;
+        /** Copy an automation, disabled. Edit the copy, enable it, then stop the original. */
+        duplicate: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /**
+         * No new runs start; runs in progress finish as they started.
+         * `cancelRuns: true` cancels those as well.
+         */
+        stop: (id: string, query?: {
+            cancelRuns?: boolean;
+        }, options?: RequestOptions) => Promise<{
+            object: "automation";
+            id: string;
+            status: "disabled";
+            runs_cancelled: number;
+        }>;
+        /** Delete an automation; runs in progress are cancelled first. */
+        remove: (id: string, options?: RequestOptions) => Promise<{
+            object: "automation";
+            id: string;
+            deleted: true;
+        }>;
+        /** `status` is one value or a comma-separated list. */
         runs: (automationId: string, query?: ListQuery & {
-            status?: "running" | "succeeded" | "failed";
+            status?: AutomationRun["status"] | string;
         }) => Promise<Page<AutomationRun>>;
         run: (automationId: string, runId: string) => Promise<AutomationRun>;
     };
@@ -426,17 +573,38 @@ export declare class AgentiSend {
         }, options?: RequestOptions) => Promise<{
             data: Record<string, unknown>[];
         }>;
-        /** CSV in `csv`. Finishes in this response. `on_conflict` defaults to skip. */
+        /**
+         * CSV in `csv`. Finishes in this response; read it back with imports.get.
+         * `column_map` is Resend's, a field on the left and a CSV column on the right.
+         * `on_conflict` defaults to skip.
+         */
         importCsv: (payload: {
             csv: string;
-            column_map?: Record<string, string>;
+            column_map?: Record<string, unknown>;
             on_conflict?: "skip" | "upsert";
+            segments?: Array<{
+                id: string;
+            }>;
+            topics?: Array<{
+                id: string;
+                subscription: "opt_in" | "opt_out";
+            }>;
         }, options?: RequestOptions) => Promise<Record<string, unknown>>;
-        /** Segments whose rules include this contact. The id may be an email. */
+        /** Past contact imports, newest first. */
+        imports: {
+            list: (query?: {
+                status?: "queued" | "in_progress" | "completed" | "failed";
+                limit?: number;
+                after?: string;
+                before?: string;
+            }) => Promise<Page<Record<string, unknown>>>;
+            get: (id: string) => Promise<Record<string, unknown>>;
+        };
+        /** Segments this contact is in: rule matches and direct additions. The id may be an email. */
         segments: (id: string) => Promise<Page<Record<string, unknown>>>;
-        /** Refused: membership is the segment's rules. Names PATCH /segments/:id. */
+        /** Add a contact to a segment. It stays in until removed, whatever the rules say. */
         addSegment: (id: string, segmentId: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
-        /** Refused: membership is the segment's rules. Names PATCH /segments/:id. */
+        /** Remove a contact that was added to a segment. One in it only by its rules is refused. */
         removeSegment: (id: string, segmentId: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
         /** Lift a marketing unsubscribe after the person opts back in. */
         resubscribe: (id: string, payload: {
@@ -444,16 +612,49 @@ export declare class AgentiSend {
             consent_at: string;
         }, options?: RequestOptions) => Promise<Record<string, unknown>>;
     };
-    /** Property names and types already stored on the account. */
+    /** Declared properties with their fallback_value, and the names contacts already hold. */
     readonly contactProperties: {
         list: () => Promise<Page<Record<string, unknown>>>;
         get: (id: string) => Promise<Record<string, unknown>>;
+        /** Declare a property. type is string or number; fallback_value fills in for a contact with none. */
+        create: (payload: {
+            key: string;
+            type: "string" | "number";
+            fallback_value?: string | number | null;
+        }, options?: RequestOptions) => Promise<{
+            object: "contact_property";
+            id: string;
+        }>;
+        /** Change the fallback_value. The key and type cannot change. */
+        update: (id: string, payload: {
+            fallback_value: string | number | null;
+        }, options?: RequestOptions) => Promise<{
+            object: "contact_property";
+            id: string;
+        }>;
+        /** Remove a declared property. Values contacts hold under its key stay on them. */
+        delete: (id: string, options?: RequestOptions) => Promise<{
+            object: "contact_property";
+            id: string;
+            deleted: true;
+        }>;
     };
     /**
-     * The same contact list, at the paths the official SDK uses when a call
-     * names an audience. This account has one contact list.
+     * Audiences are segments. createContact adds the contact to that segment.
+     * listContacts returns that segment's members.
      */
     readonly audiences: {
+        create: (payload: {
+            name: string;
+        }, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        list: (query?: ListQuery) => Promise<Page<Record<string, unknown>>>;
+        get: (id: string) => Promise<Record<string, unknown>>;
+        delete: (id: string, options?: RequestOptions) => Promise<Deleted>;
+        /** Contacts in this audience (the segment's members). */
+        contacts: (id: string, query?: ListQuery & {
+            email?: string;
+        }) => Promise<Page<Record<string, unknown>>>;
+        members: (id: string) => Promise<Page<Record<string, unknown>>>;
         createContact: (audienceId: string, payload: {
             email: string;
             properties?: Record<string, unknown>;
@@ -467,6 +668,12 @@ export declare class AgentiSend {
     };
     readonly broadcasts: {
         create: (payload: Record<string, unknown>, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        /** Delete a draft. A scheduled or sent broadcast is refused; archive it instead. */
+        delete: (id: string, options?: RequestOptions) => Promise<{
+            object: "broadcast";
+            id: string;
+            deleted: boolean;
+        }>;
         list: (query?: ListQuery) => Promise<Page<Record<string, unknown>>>;
         get: (id: string) => Promise<Record<string, unknown>>;
         /** Sent, delivered, opened, clicked, bounced, complained and unsubscribed. A test send is not included. */
@@ -490,6 +697,14 @@ export declare class AgentiSend {
         /** Archive, not delete: a sent broadcast is history worth keeping (F14). */
         archive: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
         messages: (id: string, query?: ListQuery) => Promise<Page<Record<string, unknown>>>;
+        /**
+         * Who the broadcast reached and what they did, for one event `type`
+         * (Resend: list-broadcast-recipients). Rows page with opaque `id` cursors
+         * through `after` and `before`.
+         */
+        recipients: (id: string, query: BroadcastRecipientsQuery) => Promise<EngagementList<Record<string, unknown>>>;
+        /** Every link clicked in the broadcast, most clicked first, with total and unique clicks. */
+        clickedLinks: (id: string, query?: BroadcastClickedLinksQuery) => Promise<EngagementList<Record<string, unknown>>>;
         /** Cancel a scheduled broadcast, or stop one that is still sending. Mail already handed off is not pulled back. A scheduled broadcast returns to draft. */
         cancel: (id: string, options?: RequestOptions) => Promise<Record<string, unknown>>;
         /** Copy a broadcast into a new draft: the message, segment, reply_to, preview_text and topic_id. No schedule, sends or history. */
@@ -497,13 +712,14 @@ export declare class AgentiSend {
             name?: string;
         }, options?: RequestOptions) => Promise<Record<string, unknown>>;
     };
+    /**
+     * Templates. Wherever a method takes `id`, the template's alias works too
+     * (Resend: "The Template ID or alias"). Editing a published template opens
+     * a draft from its live version; the live version keeps sending until
+     * `publish`.
+     */
     readonly templates: {
-        create: (payload: {
-            name: string;
-            subject: string;
-            content: unknown;
-            variables?: unknown[];
-        }, options?: RequestOptions) => Promise<Record<string, unknown>>;
+        create: (payload: TemplateCreatePayload, options?: RequestOptions) => Promise<Record<string, unknown>>;
         list: (query?: ListQuery) => Promise<Page<Record<string, unknown>>>;
         get: (id: string) => Promise<Record<string, unknown>>;
         update: (id: string, payload: Record<string, unknown>, options?: RequestOptions) => Promise<Record<string, unknown>>;
@@ -573,11 +789,6 @@ export declare class AgentiSend {
         get: (id: string) => Promise<Record<string, unknown>>;
         update: (id: string, payload: Record<string, unknown>, options?: RequestOptions) => Promise<Record<string, unknown>>;
         delete: (id: string, options?: RequestOptions) => Promise<Deleted>;
-        /** The account contact list. An audience id on this path does not select a second list. */
-        contacts: (id: string, query?: ListQuery & {
-            email?: string;
-        }) => Promise<Page<Record<string, unknown>>>;
-        members: (id: string) => Promise<Page<Record<string, unknown>>>;
     };
     /**
      * M4.9 — this account's own history. `action` takes a family (`api_key`) or
@@ -670,7 +881,7 @@ export declare class AgentiSend {
      */
     readonly dnsCheck: (domain: string) => Promise<Record<string, unknown>>;
     /** Send, delivery and engagement figures with a daily series, over a window. */
-    readonly metrics: (query?: MetricsQuery & {
+    readonly metrics: (query?: Pick<MetricsQuery, "since" | "until" | "start_date" | "end_date"> & {
         group_by?: string;
         event?: "sent" | "delivered" | "bounced" | "complained" | "opened" | "clicked";
         domain?: string;
@@ -766,6 +977,15 @@ export declare class AgentiSend {
         plan: () => Promise<BillingPlan>;
         /** Plan, usage against each published limit, and what the next tier changes. Buying stays in the console. */
         get: () => Promise<Record<string, unknown>>;
+        /** This account's invoices and one-time receipts, newest first. */
+        invoices: (query?: {
+            limit?: number;
+            starting_after?: string;
+        }) => Promise<Record<string, unknown>>;
+        /** Unpaid invoices, oldest first, and the total still due. */
+        openInvoices: () => Promise<Record<string, unknown>>;
+        /** Record that this key's account opened an invoice or its PDF. */
+        invoiceOpened: (id: string, action: "view" | "pdf", options?: RequestOptions) => Promise<Record<string, unknown>>;
     };
 }
 export {};