@sendmailos/sdk 1.1.1 → 1.2.1

package/dist/index.mjs

@@ -54,9 +54,10 @@ var EmailsResource = class {
   }
   /**
    * Send a transactional email
-   * 
+   *
    * @example
    * ```ts
+   * // Business account (single-tenant)
    * const result = await client.emails.send({
    *   to: 'user@example.com',
    *   fromName: 'Your Company',
@@ -64,6 +65,16 @@ var EmailsResource = class {
    *   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
+   * });
    * ```
    */
   async send(params) {
@@ -77,13 +88,15 @@ var EmailsResource = class {
         from_name: params.fromName,
         from_email: params.fromEmail,
         variables: params.variables,
-        type: params.type || "transactional"
+        type: params.type || "transactional",
+        workspace_id: params.workspaceId,
+        domain: params.domain
       })
     });
   }
   /**
    * Send email using a template
-   * 
+   *
    * @example
    * ```ts
    * const result = await client.emails.sendTemplate({
@@ -101,7 +114,9 @@ var EmailsResource = class {
       fromName: params.fromName,
       fromEmail: params.fromEmail,
       variables: params.variables,
-      type: "transactional"
+      type: "transactional",
+      workspaceId: params.workspaceId,
+      domain: params.domain
     });
   }
 };
@@ -113,14 +128,23 @@ var SubscribersResource = class {
   }
   /**
    * Create or update a subscriber (upsert)
-   * 
+   *
    * @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']
+   * });
    * ```
    */
   async create(params) {
@@ -131,7 +155,10 @@ var SubscribersResource = class {
         first_name: params.firstName,
         last_name: params.lastName,
         tags: params.tags,
-        domain_id: params.domainId
+        domain_id: params.domainId,
+        workspace_id: params.workspaceId,
+        domain: params.domain
+        // Alternative to workspace_id
       })
     });
   }
@@ -150,6 +177,8 @@ var SubscribersResource = class {
     const searchParams = new URLSearchParams();
     if (params.limit) searchParams.set("limit", String(params.limit));
     if (params.offset) searchParams.set("offset", String(params.offset));
+    if (params.workspaceId) searchParams.set("workspace_id", params.workspaceId);
+    if (params.domain) searchParams.set("domain", params.domain);
     const query = searchParams.toString();
     const endpoint = query ? `/subscribers?${query}` : "/subscribers";
     return this.request(endpoint, {
@@ -221,9 +250,10 @@ var CampaignsResource = class {
   }
   /**
    * Send a campaign to subscribers
-   * 
+   *
    * @example
    * ```ts
+   * // Business account
    * const result = await client.campaigns.send({
    *   name: 'January Newsletter',
    *   subject: 'What\'s new this month',
@@ -232,6 +262,17 @@ var CampaignsResource = class {
    *   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
+   * });
    * ```
    */
   async send(params) {
@@ -245,7 +286,10 @@ var CampaignsResource = class {
         html: params.html,
         templateId: params.templateId,
         tags: params.tags,
-        variables: params.variables
+        variables: params.variables,
+        workspace_id: params.workspaceId,
+        domain: params.domain,
+        sourceDomains: params.sourceDomains
       })
     });
   }
@@ -260,7 +304,10 @@ var CampaignsResource = class {
       fromEmail: params.fromEmail,
       templateId: params.templateId,
       tags: params.tags,
-      variables: params.variables
+      variables: params.variables,
+      workspaceId: params.workspaceId,
+      domain: params.domain,
+      sourceDomains: params.sourceDomains
     });
   }
 };
@@ -325,10 +372,633 @@ var DomainsResource = class {
   }
 };
 
+// src/resources/organization.ts
+var OrganizationResource = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Get current organization details
+   */
+  async get() {
+    const response = await this.request("/organization", {
+      method: "GET"
+    });
+    return response.organization;
+  }
+  /**
+   * Update organization settings
+   */
+  async update(updates) {
+    const response = await this.request("/organization", {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+    return response.organization;
+  }
+  /**
+   * Set organization industries (during onboarding)
+   *
+   * @example
+   * ```ts
+   * await client.organization.setIndustries(['ecommerce', 'saas']);
+   * ```
+   */
+  async setIndustries(industries) {
+    return this.update({ industries });
+  }
+  /**
+   * Convert to agency account (enables workspaces)
+   *
+   * @example
+   * ```ts
+   * await client.organization.convertToAgency();
+   * // Now you can create client workspaces
+   * await client.workspaces.create({ name: 'Client A', industry: 'ecommerce' });
+   * ```
+   */
+  async convertToAgency() {
+    return this.update({ org_type: "agency" });
+  }
+  /**
+   * Complete onboarding
+   */
+  async completeOnboarding() {
+    return this.update({ onboarding_completed: true });
+  }
+};
+var INDUSTRIES = {
+  hotels: "Hotels & Hospitality",
+  restaurants: "Restaurants & Food Service",
+  gyms: "Gyms & Fitness",
+  travel_agencies: "Travel Agencies",
+  real_estate: "Real Estate",
+  schools: "Schools & Education",
+  ecommerce: "E-commerce",
+  dentists: "Dentists",
+  car_dealerships: "Car Dealerships",
+  events: "Events & Entertainment",
+  beauty_salons: "Beauty Salons",
+  law_firms: "Law Firms",
+  nonprofits: "Non-Profits",
+  saas: "SaaS & Software",
+  recruitment: "Recruitment & HR",
+  insurance: "Insurance",
+  online_courses: "Online Courses",
+  municipalities: "Government & Municipalities",
+  personal_trainers: "Personal Trainers",
+  influencers: "Influencers & Creators",
+  doctors_clinics: "Doctors & Clinics",
+  nightclubs: "Nightclubs & Bars",
+  coworking: "Coworking Spaces",
+  wedding_planners: "Wedding Planners",
+  art_galleries: "Art Galleries",
+  car_rentals: "Car Rentals",
+  podcasters: "Podcasters",
+  consultants: "Consultants",
+  bakeries: "Bakeries",
+  veterinarians: "Veterinarians",
+  airbnb_hosts: "Airbnb Hosts",
+  accountants: "Accountants",
+  developers: "Developers",
+  musicians: "Musicians & Bands",
+  spas: "Spas & Wellness",
+  bookstores: "Bookstores",
+  cleaning_services: "Cleaning Services",
+  churches: "Churches & Religious",
+  graphic_designers: "Graphic Designers",
+  coffee_shops: "Coffee Shops",
+  florists: "Florists",
+  political: "Political Campaigns",
+  libraries: "Libraries",
+  taxis_limos: "Taxis & Limos",
+  home_inspectors: "Home Inspectors",
+  photographers: "Photographers",
+  universities: "Universities",
+  fashion: "Fashion Brands",
+  nutritionists: "Nutritionists",
+  startups: "Startups",
+  other: "Other"
+};
+
+// src/resources/workspaces.ts
+var WorkspacesResource = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * List all workspaces (clients)
+   * @note Only available for agency accounts
+   *
+   * @example
+   * ```ts
+   * const { workspaces } = await client.workspaces.list();
+   * for (const ws of workspaces) {
+   *   console.log(`${ws.name}: ${ws.stats?.subscribers} subscribers`);
+   * }
+   * ```
+   */
+  async list() {
+    const response = await this.request("/workspaces", {
+      method: "GET"
+    });
+    return { workspaces: response.workspaces, total: response.total };
+  }
+  /**
+   * Create a new workspace (client)
+   * @note Only available for agency accounts
+   *
+   * @example
+   * ```ts
+   * const workspace = await client.workspaces.create({
+   *   name: 'Pizza Palace',
+   *   industry: 'restaurants',
+   *   import_templates: true  // Auto-import restaurant templates
+   * });
+   * ```
+   */
+  async create(workspace) {
+    const response = await this.request("/workspaces", {
+      method: "POST",
+      body: JSON.stringify(workspace)
+    });
+    return response.workspace;
+  }
+  /**
+   * Get a workspace by ID with detailed stats
+   *
+   * @example
+   * ```ts
+   * const workspace = await client.workspaces.get('ws_123');
+   * console.log('Active subscribers:', workspace.stats.active_subscribers);
+   * ```
+   */
+  async get(workspaceId) {
+    const response = await this.request(`/workspaces/${workspaceId}`, {
+      method: "GET"
+    });
+    return response.workspace;
+  }
+  /**
+   * Update a workspace
+   *
+   * @example
+   * ```ts
+   * await client.workspaces.update('ws_123', {
+   *   name: 'Pizza Palace - Main Location',
+   *   client_can_view_reports: true
+   * });
+   * ```
+   */
+  async update(workspaceId, updates) {
+    const response = await this.request(`/workspaces/${workspaceId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+    return response.workspace;
+  }
+  /**
+   * Delete a workspace
+   * @warning This will delete all associated data (subscribers, campaigns, etc.)
+   *
+   * @example
+   * ```ts
+   * await client.workspaces.delete('ws_123');
+   * ```
+   */
+  async delete(workspaceId) {
+    const response = await this.request(`/workspaces/${workspaceId}`, {
+      method: "DELETE"
+    });
+    return { message: response.message };
+  }
+  /**
+   * Activate a workspace
+   */
+  async activate(workspaceId) {
+    return this.update(workspaceId, { is_active: true });
+  }
+  /**
+   * Deactivate a workspace
+   */
+  async deactivate(workspaceId) {
+    return this.update(workspaceId, { is_active: false });
+  }
+  /**
+   * Invite client to view reports
+   *
+   * @example
+   * ```ts
+   * await client.workspaces.inviteClient('ws_123', 'owner@pizzapalace.com');
+   * // Client receives email with portal access
+   * ```
+   */
+  async inviteClient(workspaceId, email) {
+    return this.update(workspaceId, {
+      client_email: email,
+      client_can_view_reports: true
+    });
+  }
+  /**
+   * 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
+   * ```
+   */
+  async provision(request) {
+    const response = await this.request("/workspaces/provision", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    return {
+      workspace: response.workspace,
+      is_new: response.is_new,
+      api_key: response.api_key,
+      message: response.message
+    };
+  }
+  /**
+   * Alias for provision() - find or create workspace
+   * @see provision
+   */
+  async findOrCreate(request) {
+    return this.provision(request);
+  }
+  /**
+   * 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({ ... });
+   * ```
+   */
+  async onboard(request) {
+    const response = await this.request("/workspaces/onboard", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    return {
+      token: response.token,
+      workspace_id: response.workspace_id,
+      workspace_name: response.workspace_name,
+      domain: response.domain,
+      domain_status: response.domain_status,
+      dns_records: response.dns_records,
+      is_new: response.is_new,
+      message: response.message
+    };
+  }
+};
+
+// src/resources/workflows.ts
+var WorkflowsResource = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * 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' }
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("/workflows", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * 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' });
+   * ```
+   */
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.domain) searchParams.set("domain", params.domain);
+    if (params.workspace_id) searchParams.set("workspace_id", params.workspace_id);
+    const query = searchParams.toString();
+    const endpoint = query ? `/workflows?${query}` : "/workflows";
+    return this.request(endpoint, {
+      method: "GET"
+    });
+  }
+  /**
+   * 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
+   * ```
+   */
+  async get(workflowId) {
+    return this.request(`/workflows/${workflowId}`, {
+      method: "GET"
+    });
+  }
+  /**
+   * 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' }
+   *   ]
+   * });
+   * ```
+   */
+  async update(workflowId, params) {
+    return this.request(`/workflows/${workflowId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete a workflow
+   */
+  async delete(workflowId) {
+    return this.request(`/workflows/${workflowId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Activate a workflow (start accepting triggers)
+   *
+   * @example
+   * ```ts
+   * await client.workflows.activate('workflow-uuid');
+   * // Workflow is now active and will process triggers
+   * ```
+   */
+  async activate(workflowId) {
+    return this.request(`/workflows/${workflowId}/activate`, {
+      method: "POST"
+    });
+  }
+  /**
+   * 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
+   * ```
+   */
+  async pause(workflowId) {
+    return this.request(`/workflows/${workflowId}/pause`, {
+      method: "POST"
+    });
+  }
+  /**
+   * 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
+   * ```
+   */
+  async trigger(workflowId, params) {
+    return this.request(`/webhooks/${workflowId}`, {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * 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
+   * ```
+   */
+  async sendEvent(params) {
+    return this.request("/events", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * 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);
+   * ```
+   */
+  async create(params) {
+    return this.request("/webhooks", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * List all webhooks
+   */
+  async list() {
+    return this.request("/webhooks", {
+      method: "GET"
+    });
+  }
+  /**
+   * Get a webhook by ID with recent delivery history
+   */
+  async get(webhookId) {
+    return this.request(`/webhooks/${webhookId}`, {
+      method: "GET"
+    });
+  }
+  /**
+   * 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 });
+   * ```
+   */
+  async update(webhookId, params) {
+    return this.request(`/webhooks/${webhookId}`, {
+      method: "PATCH",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete a webhook
+   */
+  async delete(webhookId) {
+    return this.request(`/webhooks/${webhookId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * 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);
+   * }
+   * ```
+   */
+  async test(webhookId) {
+    return this.request(`/webhooks/${webhookId}/test`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Enable a webhook
+   */
+  async enable(webhookId) {
+    return this.update(webhookId, { active: true });
+  }
+  /**
+   * Disable a webhook
+   */
+  async disable(webhookId) {
+    return this.update(webhookId, { active: false });
+  }
+};
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.sendmailos.com/api/v1";
 var DEFAULT_TIMEOUT = 3e4;
-var SDK_VERSION = "1.0.0";
+var SDK_VERSION = "1.2.0";
 var SendMailOS = class {
   constructor(apiKey, options = {}) {
     if (!apiKey) {
@@ -353,6 +1023,10 @@ var SendMailOS = class {
     this.subscribers = new SubscribersResource(boundRequest);
     this.campaigns = new CampaignsResource(boundRequest);
     this.domains = new DomainsResource(boundRequest);
+    this.organization = new OrganizationResource(boundRequest);
+    this.workspaces = new WorkspacesResource(boundRequest);
+    this.workflows = new WorkflowsResource(boundRequest);
+    this.webhooks = new WebhooksResource(boundRequest);
   }
   /**
    * Make an authenticated request to the API
@@ -896,6 +1570,6 @@ function constructWebhookEvent(payload, headers, secret) {
   return JSON.parse(payload);
 }
 
-export { AuthenticationError, NotFoundError, Pixel, RateLimitError, SendMailOS, SendMailOSError, SendmailPixel, ValidationError, constructWebhookEvent, createGlobalPixel, SendMailOS as default, verifyWebhookSignature, verifyWebhookSignatureAsync };
+export { AuthenticationError, INDUSTRIES, NotFoundError, Pixel, RateLimitError, SendMailOS, SendMailOSError, SendmailPixel, ValidationError, constructWebhookEvent, createGlobalPixel, SendMailOS as default, verifyWebhookSignature, verifyWebhookSignatureAsync };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map