@sendmailos/sdk 1.2.0 → 1.2.1

package/dist/index.d.ts

@@ -26,6 +26,17 @@ interface SendEmailRequest {
     variables?: Record<string, unknown>;
     /** Email type: "transactional" (default) or "marketing" */
     type?: 'transactional' | 'marketing';
+    /**
+     * Workspace ID (for agency accounts) - use this OR domain
+     * @note Agency accounts MUST specify either workspaceId or domain
+     */
+    workspaceId?: string;
+    /**
+     * Client domain (for agency accounts) - alternative to workspaceId
+     * Used to identify which workspace/client this email belongs to
+     * @note Agency accounts MUST specify either workspaceId or domain
+     */
+    domain?: string;
 }
 interface SendEmailResponse {
     success: boolean;
@@ -42,6 +53,7 @@ interface Subscriber {
     tags?: string[];
     source: string;
     createdAt: string;
+    workspaceId?: string;
     primaryDomain?: {
         id: string;
         domainName: string;
@@ -58,6 +70,10 @@ interface CreateSubscriberRequest {
     tags?: string[];
     /** Associate with a specific domain */
     domainId?: string;
+    /** Workspace ID (for agency accounts) - use this OR domain */
+    workspaceId?: string;
+    /** Client domain (for agency accounts) - alternative to workspaceId */
+    domain?: string;
 }
 interface CreateSubscriberResponse {
     success: boolean;
@@ -68,6 +84,10 @@ interface ListSubscribersRequest {
     limit?: number;
     /** Pagination offset */
     offset?: number;
+    /** Filter by workspace ID (for agency accounts) - use this OR domain */
+    workspaceId?: string;
+    /** Filter by client domain (for agency accounts) - alternative to workspaceId */
+    domain?: string;
 }
 interface ListSubscribersResponse {
     success: boolean;
@@ -93,6 +113,12 @@ interface SendCampaignRequest {
     tags?: string[];
     /** Global template variables */
     variables?: Record<string, unknown>;
+    /** Workspace ID (for agency accounts) - use this OR domain */
+    workspaceId?: string;
+    /** Client domain (for agency accounts) - alternative to workspaceId */
+    domain?: string;
+    /** Filter subscribers by source domains - only send to subscribers who came from these domains */
+    sourceDomains?: string[];
 }
 interface SendCampaignResponse {
     success: boolean;
@@ -106,6 +132,7 @@ interface Domain {
     dkimTokens: string[];
     createdAt: string;
     verifiedAt?: string;
+    workspaceId?: string;
     dnsRecords?: DnsRecord[];
 }
 interface DnsRecord {
@@ -125,16 +152,19 @@ interface ListDomainsResponse {
     success: boolean;
     domains: Domain[];
 }
-type WebhookEventType = 'email.sent' | 'email.delivered' | 'email.opened' | 'email.clicked' | 'email.bounced' | 'email.complained';
+type WebhookEventType = 'email.sent' | 'email.delivered' | 'email.opened' | 'email.clicked' | 'email.bounced' | 'email.complained' | 'subscriber.created' | 'subscriber.updated' | 'subscriber.unsubscribed' | 'campaign.sent' | 'workflow.started' | 'workflow.completed';
 interface WebhookEvent {
     id: string;
     type: WebhookEventType;
     createdAt: string;
     data: {
-        emailId: string;
-        messageId: string;
-        recipient: string;
+        emailId?: string;
+        messageId?: string;
+        recipient?: string;
+        subscriberId?: string;
         campaignId?: string;
+        workflowId?: string;
+        domainId?: string;
         timestamp: string;
         metadata?: Record<string, unknown>;
     };
@@ -144,15 +174,201 @@ interface CreateWebhookRequest {
     url: string;
     /** Events to subscribe to */
     events: WebhookEventType[];
-    /** Signing secret for webhook verification */
+    /** Signing secret for webhook verification (auto-generated if not provided) */
     secret?: string;
+    /** Filter webhook events by domain */
+    domain?: string;
+    /** Filter webhook events by workspace ID */
+    workspace_id?: string;
+}
+interface UpdateWebhookRequest {
+    /** New webhook URL */
+    url?: string;
+    /** New events to subscribe to */
+    events?: WebhookEventType[];
+    /** Enable or disable webhook */
+    active?: boolean;
 }
 interface Webhook {
     id: string;
     url: string;
     events: WebhookEventType[];
+    secret: string;
     active: boolean;
+    domainId?: string;
+    domainName?: string;
+    workspaceId?: string;
     createdAt: string;
+    updatedAt?: string;
+}
+interface WebhookDelivery {
+    id: string;
+    eventType: string;
+    statusCode: number;
+    responseTimeMs: number;
+    error?: string;
+    deliveredAt: string;
+}
+interface WebhookStats {
+    totalDeliveries: number;
+    avgResponseTimeMs: number;
+    successCount: number;
+    failureCount: number;
+}
+interface ListWebhooksResponse {
+    success: boolean;
+    webhooks: Array<Webhook & {
+        lastTriggeredAt?: string;
+        lastStatusCode?: number;
+        totalDeliveries: number;
+    }>;
+}
+interface GetWebhookResponse {
+    success: boolean;
+    webhook: Webhook & {
+        recentDeliveries: WebhookDelivery[];
+        stats: WebhookStats;
+    };
+}
+interface TestWebhookResponse {
+    success: boolean;
+    test: {
+        sent: boolean;
+        statusCode: number;
+        responseTimeMs: number;
+        error?: string;
+    };
+}
+type WorkflowStatus = 'draft' | 'active' | 'paused';
+type WorkflowTriggerType = 'api' | 'subscriber_created' | 'subscriber_tagged' | 'form_submitted' | 'email_opened' | 'email_clicked' | 'custom_event';
+interface WorkflowTrigger {
+    /** Trigger type */
+    type: WorkflowTriggerType;
+    /** Event name (for custom_event type) */
+    event?: string;
+    /** Additional conditions */
+    conditions?: Record<string, unknown>;
+}
+interface WorkflowNode {
+    /** Unique node ID */
+    id: string;
+    /** Node type */
+    type: 'trigger' | 'email' | 'delay' | 'condition' | 'tag' | 'http' | 'wait_for_event' | 'unsubscribe' | 'jump' | 'exit';
+    /** Node position (for UI) */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Node-specific data */
+    data: Record<string, unknown>;
+}
+interface WorkflowEdge {
+    /** Unique edge ID */
+    id: string;
+    /** Source node ID */
+    source: string;
+    /** Target node ID */
+    target: string;
+    /** Source handle (for branching) */
+    sourceHandle?: string;
+    /** Edge label */
+    label?: string;
+}
+interface WorkflowStats {
+    totalRuns: number;
+    activeRuns?: number;
+    completedRuns: number;
+}
+interface Workflow {
+    id: string;
+    name: string;
+    status: WorkflowStatus;
+    domainId?: string;
+    domainName?: string;
+    workspaceId?: string;
+    nodes?: WorkflowNode[];
+    edges?: WorkflowEdge[];
+    triggerConfig?: WorkflowTrigger;
+    createdAt: string;
+    updatedAt: string;
+    stats?: WorkflowStats;
+}
+interface CreateWorkflowRequest {
+    /** Workflow name */
+    name: string;
+    /** Client domain (for multi-brand) - auto-detects workspace */
+    domain?: string;
+    /** Workspace ID (alternative to domain) */
+    workspace_id?: string;
+    /** Trigger configuration */
+    trigger?: WorkflowTrigger;
+}
+interface CreateWorkflowResponse {
+    success: boolean;
+    workflow: {
+        id: string;
+        name: string;
+        status: WorkflowStatus;
+        createdAt: string;
+    };
+}
+interface UpdateWorkflowRequest {
+    /** Workflow name */
+    name?: string;
+    /** Workflow nodes (the steps) */
+    nodes?: WorkflowNode[];
+    /** Workflow edges (connections between nodes) */
+    edges?: WorkflowEdge[];
+    /** Trigger configuration */
+    trigger?: WorkflowTrigger;
+    /** Domain ID */
+    domain_id?: string;
+}
+interface UpdateWorkflowResponse {
+    success: boolean;
+    workflow: {
+        id: string;
+        name: string;
+        status: WorkflowStatus;
+        nodes: WorkflowNode[];
+        edges: WorkflowEdge[];
+        updatedAt: string;
+    };
+}
+interface ListWorkflowsRequest {
+    /** Filter by client domain */
+    domain?: string;
+    /** Filter by workspace ID */
+    workspace_id?: string;
+}
+interface ListWorkflowsResponse {
+    success: boolean;
+    workflows: Workflow[];
+}
+interface GetWorkflowResponse {
+    success: boolean;
+    workflow: Workflow;
+}
+interface TriggerWorkflowRequest {
+    /** Subscriber email */
+    email: string;
+    /** Subscriber ID (if known) */
+    subscriber_id?: string;
+    /** Custom data to pass to the workflow */
+    data?: Record<string, unknown>;
+}
+interface TriggerWorkflowResponse {
+    success: boolean;
+    execution_id: string;
+    subscriber_id: string;
+}
+interface WorkflowStatusResponse {
+    success: boolean;
+    workflow: {
+        id: string;
+        name: string;
+        status: WorkflowStatus;
+    };
 }
 interface ApiError {
     success: false;
@@ -172,6 +388,7 @@ declare class EmailsResource {
      *
      * @example
      * ```ts
+     * // Business account (single-tenant)
      * const result = await client.emails.send({
      *   to: 'user@example.com',
      *   fromName: 'Your Company',
@@ -179,6 +396,16 @@ declare class EmailsResource {
      *   subject: 'Welcome!',
      *   html: '<h1>Hello!</h1>'
      * });
+     *
+     * // Agency account (multi-tenant) - identify client by domain
+     * const result = await agencyClient.emails.send({
+     *   to: 'customer@example.com',
+     *   fromName: 'Pizza Palace',
+     *   fromEmail: 'hello@pizzapalace.com',
+     *   subject: 'Your order is ready!',
+     *   html: '<h1>Order Ready!</h1>',
+     *   domain: 'pizzapalace.com'  // Required for agency accounts
+     * });
      * ```
      */
     send(params: SendEmailRequest): Promise<SendEmailResponse>;
@@ -201,6 +428,10 @@ declare class EmailsResource {
         fromEmail?: string;
         subject?: string;
         variables?: Record<string, unknown>;
+        /** Workspace ID (for agency accounts) */
+        workspaceId?: string;
+        /** Client domain (for agency accounts) */
+        domain?: string;
     }): Promise<SendEmailResponse>;
 }
 
@@ -215,11 +446,20 @@ declare class SubscribersResource {
      *
      * @example
      * ```ts
+     * // Business account
      * const { subscriber } = await client.subscribers.create({
      *   email: 'user@example.com',
      *   firstName: 'John',
      *   tags: ['newsletter', 'premium']
      * });
+     *
+     * // Agency account - subscriber tracked to client domain
+     * const { subscriber } = await agencyClient.subscribers.create({
+     *   email: 'customer@example.com',
+     *   firstName: 'Jane',
+     *   domain: 'pizzapalace.com',  // Required for agency accounts
+     *   tags: ['loyalty-member']
+     * });
      * ```
      */
     create(params: CreateSubscriberRequest): Promise<CreateSubscriberResponse>;
@@ -277,6 +517,7 @@ declare class CampaignsResource {
      *
      * @example
      * ```ts
+     * // Business account
      * const result = await client.campaigns.send({
      *   name: 'January Newsletter',
      *   subject: 'What\'s new this month',
@@ -285,6 +526,17 @@ declare class CampaignsResource {
      *   html: '<h1>Hello {{first_name}}!</h1>',
      *   tags: ['newsletter', 'active']
      * });
+     *
+     * // Agency account - send to specific client's subscribers
+     * const result = await agencyClient.campaigns.send({
+     *   name: 'Pizza Promo',
+     *   subject: 'New menu items!',
+     *   fromName: 'Pizza Palace',
+     *   fromEmail: 'promo@pizzapalace.com',
+     *   html: '<h1>Check out our new menu!</h1>',
+     *   domain: 'pizzapalace.com',           // Filter to this client's subscribers
+     *   sourceDomains: ['pizzapalace.com']   // Only subscribers who signed up on this domain
+     * });
      * ```
      */
     send(params: SendCampaignRequest): Promise<SendCampaignResponse>;
@@ -299,6 +551,12 @@ declare class CampaignsResource {
         fromEmail: string;
         tags?: string[];
         variables?: Record<string, unknown>;
+        /** Workspace ID (for agency accounts) */
+        workspaceId?: string;
+        /** Client domain (for agency accounts) */
+        domain?: string;
+        /** Filter by source domains */
+        sourceDomains?: string[];
     }): Promise<SendCampaignResponse>;
 }
 
@@ -361,7 +619,6 @@ interface Organization {
     onboarding_completed: boolean;
     onboarding_step: string;
     created_at: string;
-    free_credits_limit?: number;
 }
 interface UpdateOrganizationRequest {
     name?: string;
@@ -458,6 +715,69 @@ interface CreateWorkspaceRequest {
     /** Custom settings */
     settings?: Record<string, unknown>;
 }
+interface ProvisionWorkspaceRequest {
+    /** Client/workspace name */
+    name: string;
+    /** Client website URL - used for matching existing workspace */
+    website?: string;
+    /** Client email - used for matching existing workspace */
+    client_email?: string;
+    /** Industry for pre-built templates (used if creating new) */
+    industry?: Industry;
+    /** Logo URL */
+    logo_url?: string;
+    /** Allow client to view reports (default: true) */
+    client_can_view_reports?: boolean;
+    /** Import industry templates automatically (default: true) */
+    import_templates?: boolean;
+    /** Generate a workspace-scoped API key */
+    generate_api_key?: boolean;
+    /** Allowed origins for the generated API key */
+    allowed_origins?: string[];
+    /** Custom settings */
+    settings?: Record<string, unknown>;
+}
+interface ProvisionWorkspaceResponse {
+    workspace: Workspace;
+    /** Whether this is a newly created workspace */
+    is_new: boolean;
+    /** Generated API key (only if generate_api_key was true) */
+    api_key?: string;
+    /** Human-readable message */
+    message: string;
+}
+interface OnboardClientRequest {
+    /** Client domain (e.g., "pizzapalace.com" or "https://pizzapalace.com") */
+    domain: string;
+    /** Client name (optional - derived from domain if not provided) */
+    name?: string;
+    /** Industry for templates (default: "restaurants") */
+    industry?: Industry;
+    /** Client email for notifications */
+    client_email?: string;
+}
+interface OnboardClientResponse {
+    /** Workspace token - USE THIS FOR ALL API CALLS */
+    token: string;
+    /** Workspace ID */
+    workspace_id: string;
+    /** Workspace name */
+    workspace_name: string;
+    /** Normalized domain */
+    domain: string;
+    /** Domain verification status */
+    domain_status: string;
+    /** DNS records to add for domain verification */
+    dns_records: Array<{
+        type: string;
+        name: string;
+        value: string;
+    }>;
+    /** Whether workspace was newly created */
+    is_new: boolean;
+    /** Human-readable message */
+    message: string;
+}
 interface UpdateWorkspaceRequest {
     name?: string;
     industry?: Industry;
@@ -555,6 +875,323 @@ declare class WorkspacesResource {
      * ```
      */
     inviteClient(workspaceId: string, email: string): Promise<Workspace>;
+    /**
+     * Smart workspace provisioning - finds existing or creates new
+     *
+     * This is the recommended method for agency client onboarding.
+     * It will:
+     * 1. Search for existing workspace by website URL or client_email
+     * 2. Return existing workspace if found
+     * 3. Create new workspace with industry templates if not found
+     * 4. Optionally generate a workspace-scoped API key
+     *
+     * @note Only available for agency accounts
+     *
+     * @example
+     * ```ts
+     * // Auto-provision workspace for a new client
+     * const result = await client.workspaces.provision({
+     *   name: 'Pizza Palace',
+     *   website: 'https://pizzapalace.com',
+     *   client_email: 'owner@pizzapalace.com',
+     *   industry: 'restaurants',
+     *   generate_api_key: true
+     * });
+     *
+     * if (result.is_new) {
+     *   console.log('Created new workspace:', result.workspace.id);
+     *   console.log('API Key:', result.api_key);
+     * } else {
+     *   console.log('Found existing workspace:', result.workspace.id);
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Idempotent client setup - safe to call multiple times
+     * const { workspace, is_new } = await client.workspaces.provision({
+     *   name: 'Client Name',
+     *   website: 'https://client.com',
+     *   industry: 'ecommerce'
+     * });
+     * // Always returns the same workspace for the same website
+     * ```
+     */
+    provision(request: ProvisionWorkspaceRequest): Promise<ProvisionWorkspaceResponse>;
+    /**
+     * Alias for provision() - find or create workspace
+     * @see provision
+     */
+    findOrCreate(request: ProvisionWorkspaceRequest): Promise<ProvisionWorkspaceResponse>;
+    /**
+     * Complete client onboarding in ONE call (Agency only)
+     *
+     * This is the simplest way to onboard a new client:
+     * 1. Creates or finds workspace by domain
+     * 2. Registers domain for email verification
+     * 3. Generates workspace token
+     * 4. Returns DNS records + token
+     *
+     * After this, use the returned `token` for all API calls.
+     *
+     * @example
+     * ```ts
+     * // Your SaaS onboards a new restaurant
+     * const result = await agency.workspaces.onboard({
+     *   domain: 'pizzapalace.com',
+     *   industry: 'restaurants'
+     * });
+     *
+     * // Save this token - it's all you need
+     * saveToDatabase(restaurantId, result.token);
+     *
+     * // Show DNS records to restaurant owner
+     * console.log('Add these DNS records:', result.dns_records);
+     *
+     * // Later, use the token directly
+     * const restaurant = new SendMailOS(result.token);
+     * await restaurant.emails.send({ ... });
+     * ```
+     */
+    onboard(request: OnboardClientRequest): Promise<OnboardClientResponse>;
+}
+
+/**
+ * Workflows resource for managing email automation workflows
+ */
+declare class WorkflowsResource {
+    private request;
+    constructor(request: <T>(endpoint: string, options?: RequestInit) => Promise<T>);
+    /**
+     * Create a new workflow
+     *
+     * @example
+     * ```ts
+     * // Create workflow for a specific client (multi-brand)
+     * const result = await platform.workflows.create({
+     *   name: 'Welcome Sequence',
+     *   domain: 'pizzapalace.com',
+     *   trigger: { type: 'subscriber_created' }
+     * });
+     *
+     * // Create workflow (single brand)
+     * const result = await client.workflows.create({
+     *   name: 'Onboarding Flow',
+     *   trigger: { type: 'api' }
+     * });
+     * ```
+     */
+    create(params: CreateWorkflowRequest): Promise<CreateWorkflowResponse>;
+    /**
+     * List all workflows
+     *
+     * @example
+     * ```ts
+     * // List all workflows
+     * const { workflows } = await client.workflows.list();
+     *
+     * // List workflows for a specific client (multi-brand)
+     * const { workflows } = await platform.workflows.list({ domain: 'pizzapalace.com' });
+     * ```
+     */
+    list(params?: ListWorkflowsRequest): Promise<ListWorkflowsResponse>;
+    /**
+     * Get a workflow by ID (includes nodes and edges)
+     *
+     * @example
+     * ```ts
+     * const { workflow } = await client.workflows.get('workflow-uuid');
+     * console.log(workflow.nodes); // The workflow steps
+     * console.log(workflow.edges); // Connections between steps
+     * ```
+     */
+    get(workflowId: string): Promise<GetWorkflowResponse>;
+    /**
+     * Update a workflow (name, nodes, edges, trigger)
+     *
+     * @example
+     * ```ts
+     * // Update workflow name
+     * await client.workflows.update('workflow-uuid', { name: 'New Name' });
+     *
+     * // Update workflow steps
+     * await client.workflows.update('workflow-uuid', {
+     *   nodes: [
+     *     { id: '1', type: 'trigger', data: { triggerType: 'api' } },
+     *     { id: '2', type: 'email', data: { templateId: 'tmpl_xxx', subject: 'Welcome!' } },
+     *     { id: '3', type: 'delay', data: { duration: 3, unit: 'days' } }
+     *   ],
+     *   edges: [
+     *     { id: 'e1', source: '1', target: '2' },
+     *     { id: 'e2', source: '2', target: '3' }
+     *   ]
+     * });
+     * ```
+     */
+    update(workflowId: string, params: UpdateWorkflowRequest): Promise<UpdateWorkflowResponse>;
+    /**
+     * Delete a workflow
+     */
+    delete(workflowId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Activate a workflow (start accepting triggers)
+     *
+     * @example
+     * ```ts
+     * await client.workflows.activate('workflow-uuid');
+     * // Workflow is now active and will process triggers
+     * ```
+     */
+    activate(workflowId: string): Promise<WorkflowStatusResponse>;
+    /**
+     * Pause a workflow (stop accepting new triggers)
+     *
+     * @example
+     * ```ts
+     * await client.workflows.pause('workflow-uuid');
+     * // Workflow is paused - existing executions continue, but no new ones start
+     * ```
+     */
+    pause(workflowId: string): Promise<WorkflowStatusResponse>;
+    /**
+     * Trigger a workflow for a subscriber
+     *
+     * @example
+     * ```ts
+     * // Trigger when a customer signs up
+     * const result = await platform.workflows.trigger('workflow-uuid', {
+     *   email: 'customer@example.com',
+     *   data: {
+     *     firstName: 'John',
+     *     restaurantName: 'Pizza Palace',
+     *     signupSource: 'website'
+     *   }
+     * });
+     *
+     * console.log(result.execution_id); // Track this execution
+     * ```
+     */
+    trigger(workflowId: string, params: TriggerWorkflowRequest): Promise<TriggerWorkflowResponse>;
+    /**
+     * Send a custom event to resume waiting workflows
+     *
+     * Use this when you have workflows waiting for specific events (e.g., "purchase_completed").
+     * All workflows waiting for this event for the given subscriber will resume.
+     *
+     * @example
+     * ```ts
+     * // When a customer completes a purchase
+     * await platform.workflows.sendEvent({
+     *   event: 'purchase_completed',
+     *   email: 'customer@example.com',
+     *   data: { orderTotal: 45.99, orderId: 'ORD-123' }
+     * });
+     *
+     * // Any workflow with a "wait_for_event: purchase_completed" node will resume
+     * ```
+     */
+    sendEvent(params: {
+        event: string;
+        email: string;
+        data?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        processed: number;
+    }>;
+}
+
+/**
+ * Webhooks resource for managing webhook endpoints
+ */
+declare class WebhooksResource {
+    private request;
+    constructor(request: <T>(endpoint: string, options?: RequestInit) => Promise<T>);
+    /**
+     * Create a new webhook endpoint
+     *
+     * @example
+     * ```ts
+     * const webhook = await client.webhooks.create({
+     *   url: 'https://yourserver.com/webhooks',
+     *   events: ['email.sent', 'email.delivered', 'email.opened'],
+     *   secret: 'your-secret-key' // Optional, auto-generated if not provided
+     * });
+     *
+     * console.log('Webhook secret:', webhook.secret);
+     * ```
+     */
+    create(params: CreateWebhookRequest): Promise<{
+        success: boolean;
+        webhook: Webhook;
+    }>;
+    /**
+     * List all webhooks
+     */
+    list(): Promise<ListWebhooksResponse>;
+    /**
+     * Get a webhook by ID with recent delivery history
+     */
+    get(webhookId: string): Promise<GetWebhookResponse>;
+    /**
+     * Update a webhook
+     *
+     * @example
+     * ```ts
+     * // Update webhook URL
+     * await client.webhooks.update('webhook-id', {
+     *   url: 'https://newserver.com/webhooks'
+     * });
+     *
+     * // Add new events
+     * await client.webhooks.update('webhook-id', {
+     *   events: ['email.sent', 'email.delivered', 'email.bounced']
+     * });
+     *
+     * // Disable webhook
+     * await client.webhooks.update('webhook-id', { active: false });
+     * ```
+     */
+    update(webhookId: string, params: UpdateWebhookRequest): Promise<{
+        success: boolean;
+        webhook: Webhook;
+    }>;
+    /**
+     * Delete a webhook
+     */
+    delete(webhookId: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Test a webhook by sending a test event
+     *
+     * @example
+     * ```ts
+     * const result = await client.webhooks.test('webhook-id');
+     * if (result.test.sent) {
+     *   console.log(`Test delivered in ${result.test.responseTimeMs}ms`);
+     * } else {
+     *   console.log('Test failed:', result.test.error);
+     * }
+     * ```
+     */
+    test(webhookId: string): Promise<TestWebhookResponse>;
+    /**
+     * Enable a webhook
+     */
+    enable(webhookId: string): Promise<{
+        success: boolean;
+        webhook: Webhook;
+    }>;
+    /**
+     * Disable a webhook
+     */
+    disable(webhookId: string): Promise<{
+        success: boolean;
+        webhook: Webhook;
+    }>;
 }
 
 /**
@@ -597,6 +1234,10 @@ declare class SendMailOS {
     readonly organization: OrganizationResource;
     /** Workspace management (for agencies) */
     readonly workspaces: WorkspacesResource;
+    /** Workflow automation */
+    readonly workflows: WorkflowsResource;
+    /** Webhook management */
+    readonly webhooks: WebhooksResource;
     constructor(apiKey: string, options?: SendMailOSOptions);
     /**
      * Make an authenticated request to the API
@@ -777,4 +1418,4 @@ declare function constructWebhookEvent<T = unknown>(payload: string, headers: {
     timestamp: string;
 }, secret: string): T;
 
-export { type ApiError, AuthenticationError, type CreateDomainRequest, type CreateDomainResponse, type CreateSubscriberRequest, type CreateSubscriberResponse, type CreateWebhookRequest, type CreateWorkspaceRequest, type DnsRecord, type Domain, INDUSTRIES, type IdentifyTraits, type Industry, type ListDomainsResponse, type ListSubscribersRequest, type ListSubscribersResponse, NotFoundError, type Organization, type OrganizationType, Pixel, type PixelConfig, type PixelOptions, RateLimitError, type SendCampaignRequest, type SendCampaignResponse, type SendEmailRequest, type SendEmailResponse, SendMailOS, SendMailOSError, type SendMailOSOptions, SendmailPixel, type Subscriber, type TrackEventProperties, type TrackProps, type UpdateOrganizationRequest, type UpdateWorkspaceRequest, ValidationError, type VerifyWebhookParams, type Webhook, type WebhookEvent, type WebhookEventType, type Workspace, type WorkspaceStats, constructWebhookEvent, createGlobalPixel, SendMailOS as default, verifyWebhookSignature, verifyWebhookSignatureAsync };
+export { type ApiError, AuthenticationError, type CreateDomainRequest, type CreateDomainResponse, type CreateSubscriberRequest, type CreateSubscriberResponse, type CreateWebhookRequest, type CreateWorkflowRequest, type CreateWorkflowResponse, type CreateWorkspaceRequest, type DnsRecord, type Domain, type GetWorkflowResponse, INDUSTRIES, type IdentifyTraits, type Industry, type ListDomainsResponse, type ListSubscribersRequest, type ListSubscribersResponse, type ListWorkflowsRequest, type ListWorkflowsResponse, NotFoundError, type OnboardClientRequest, type OnboardClientResponse, type Organization, type OrganizationType, Pixel, type PixelConfig, type PixelOptions, type ProvisionWorkspaceRequest, type ProvisionWorkspaceResponse, RateLimitError, type SendCampaignRequest, type SendCampaignResponse, type SendEmailRequest, type SendEmailResponse, SendMailOS, SendMailOSError, type SendMailOSOptions, SendmailPixel, type Subscriber, type TrackEventProperties, type TrackProps, type TriggerWorkflowRequest, type TriggerWorkflowResponse, type UpdateOrganizationRequest, type UpdateWorkflowRequest, type UpdateWorkflowResponse, type UpdateWorkspaceRequest, ValidationError, type VerifyWebhookParams, type Webhook, type WebhookEvent, type WebhookEventType, type Workflow, type WorkflowEdge, type WorkflowNode, type WorkflowStats, type WorkflowStatus, type WorkflowStatusResponse, type WorkflowTrigger, type WorkflowTriggerType, type Workspace, type WorkspaceStats, constructWebhookEvent, createGlobalPixel, SendMailOS as default, verifyWebhookSignature, verifyWebhookSignatureAsync };