@heymantle/core-api-client 0.2.0 → 0.2.2

package/dist/index.js

@@ -186,679 +186,601 @@ var BaseResource = class {
   }
 };
 
-// src/resources/customers.ts
-var CustomersResource = class extends BaseResource {
+// src/resources/affiliate-commissions.ts
+var AffiliateCommissionsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/customers", { params: { query: params } }));
-  }
-  async get(customerId) {
-    return this.unwrap(this.api.GET("/customers/{id}", { params: { path: { id: customerId } } }));
-  }
-  async create(data) {
-    return this.unwrap(this.api.POST("/customers", { body: data }));
-  }
-  async update(customerId, data) {
-    return this.unwrap(this.api.PUT("/customers/{id}", { params: { path: { id: customerId } }, body: data }));
-  }
-  async addTags(customerId, tags) {
-    return this.unwrap(this.api.POST("/customers/{id}/addTags", { params: { path: { id: customerId } }, body: { tags } }));
-  }
-  async removeTags(customerId, tags) {
-    return this.unwrap(this.api.POST("/customers/{id}/removeTags", { params: { path: { id: customerId } }, body: { tags } }));
-  }
-  async getTimeline(customerId, params) {
-    return this.unwrap(this.api.GET("/customers/{id}/timeline", { params: { path: { id: customerId }, query: params } }));
-  }
-  async listAccountOwners(customerId) {
-    return this.unwrap(this.api.GET("/customers/{id}/account_owners", { params: { path: { id: customerId } } }));
-  }
-  async addAccountOwner(customerId, data) {
-    return this.unwrap(this.api.POST("/customers/{id}/account_owners", { params: { path: { id: customerId } }, body: data }));
-  }
-  async removeAccountOwner(customerId, ownerId) {
-    return this.unwrap(this.api.DELETE("/customers/{id}/account_owners/{ownerId}", { params: { path: { id: customerId, ownerId } } }));
-  }
-  async listCustomFields(params) {
-    return this.unwrap(this.api.GET("/customers/custom_fields", { params: { query: params } }));
-  }
-  async createCustomField(data) {
-    return this.unwrap(this.api.POST("/customers/custom_fields", { body: data }));
-  }
-  async getCustomField(fieldId) {
-    return this.unwrap(this.api.GET("/customers/custom_fields/{id}", { params: { path: { id: fieldId } } }));
-  }
-  async updateCustomField(fieldId, data) {
-    return this.unwrap(this.api.PUT("/customers/custom_fields/{id}", { params: { path: { id: fieldId } }, body: data }));
+    return this.unwrap(this.api.GET("/affiliate_commissions", { params: { query: params } }));
   }
-  async deleteCustomField(fieldId) {
-    return this.unwrap(this.api.DELETE("/customers/custom_fields/{id}", { params: { path: { id: fieldId } } }));
+  async get(commissionId) {
+    return this.unwrap(this.api.GET("/affiliate_commissions/{id}", { params: { path: { id: commissionId } } }));
   }
 };
 
-// src/resources/contacts.ts
-var ContactsResource = class extends BaseResource {
+// src/resources/affiliate-payouts.ts
+var AffiliatePayoutsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/contacts", { params: { query: params } }));
-  }
-  async get(contactId) {
-    return this.unwrap(this.api.GET("/contacts/{id}", { params: { path: { id: contactId } } }));
+    return this.unwrap(this.api.GET("/affiliate_payouts", { params: { query: params } }));
   }
-  async create(data) {
-    return this.unwrap(this.api.POST("/contacts", { body: data }));
+  async get(payoutId) {
+    return this.unwrap(this.api.GET("/affiliate_payouts/{id}", { params: { path: { id: payoutId } } }));
   }
-  async update(contactId, data) {
-    return this.unwrap(this.api.PUT("/contacts/{id}", { params: { path: { id: contactId } }, body: data }));
+};
+
+// src/resources/affiliate-programs.ts
+var AffiliateProgramsResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/affiliate_programs", { params: { query: params } }));
   }
-  async del(contactId) {
-    return this.unwrap(this.api.DELETE("/contacts/{id}", { params: { path: { id: contactId } } }));
+  async get(programId) {
+    return this.unwrap(this.api.GET("/affiliate_programs/{id}", { params: { path: { id: programId } } }));
   }
-  async addTags(contactId, tags) {
-    return this.unwrap(this.api.POST("/contacts/{id}/addTags", { params: { path: { id: contactId } }, body: { tags } }));
+};
+
+// src/resources/affiliate-referrals.ts
+var AffiliateReferralsResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/affiliate_referrals", { params: { query: params } }));
   }
-  async removeTags(contactId, tags) {
-    return this.unwrap(this.api.POST("/contacts/{id}/removeTags", { params: { path: { id: contactId } }, body: { tags } }));
+  async get(referralId) {
+    return this.unwrap(this.api.GET("/affiliate_referrals/{id}", { params: { path: { id: referralId } } }));
   }
 };
 
-// src/resources/subscriptions.ts
-var SubscriptionsResource = class extends BaseResource {
-  /**
-   * List subscriptions with optional filters and pagination
-   */
+// src/resources/affiliates.ts
+var AffiliatesResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/subscriptions", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/affiliates", { params: { query: params } }));
   }
-  /**
-   * Get a single subscription by ID
-   */
-  async get(subscriptionId) {
-    return this.unwrap(this.api.GET("/subscriptions/{id}", { params: { path: { id: subscriptionId } } }));
+  async get(affiliateId) {
+    return this.unwrap(this.api.GET("/affiliates/{id}", { params: { path: { id: affiliateId } } }));
   }
 };
 
-// src/resources/usage-events.ts
-var UsageEventsResource = class extends BaseResource {
-  /**
-   * List usage events with optional filters and pagination
-   */
-  async list(params) {
-    return this.unwrap(this.api.GET("/usage_events", { params: { query: params } }));
+// src/resources/ai-agent-runs.ts
+var AiAgentRunsResource = class extends BaseResource {
+  async create(agentId, data) {
+    return this.unwrap(this.api.POST("/ai/agents/{agentId}/runs", { params: { path: { agentId } }, body: data }));
+  }
+  async get(agentId, runId) {
+    return this.unwrap(this.api.GET("/ai/agents/{agentId}/runs/{runId}", { params: { path: { agentId, runId } } }));
   }
   /**
-   * Create usage event(s)
-   *
-   * @example
-   * // Single event
-   * await client.usageEvents.create({
-   *   eventName: 'api_call',
-   *   customerId: 'cust_123',
-   *   appId: 'app_456',
-   *   properties: { endpoint: '/users' },
-   * });
-   *
-   * @example
-   * // Multiple events
-   * await client.usageEvents.create({
-   *   events: [
-   *     { eventName: 'api_call', customerId: 'cust_123', appId: 'app_456' },
-   *     { eventName: 'api_call', customerId: 'cust_789', appId: 'app_456' },
-   *   ],
-   * });
+   * Create an agent run and poll until it reaches a terminal status.
    */
-  async create(data) {
-    return this.unwrap(this.api.POST("/usage_events", { body: data }));
+  async createAndWait(agentId, data, options) {
+    const { timeout = 3e5, pollInterval = 2e3 } = options ?? {};
+    const result = await this.create(agentId, data);
+    const run = result.run;
+    if (!run?.id) throw new Error("Agent run ID not returned");
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const response = await this.get(agentId, run.id);
+      const agentRun = response.run;
+      if (agentRun.status === "completed" || agentRun.status === "error") return agentRun;
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Agent run timed out after ${timeout}ms`);
   }
 };
 
 // src/resources/apps.ts
 var AppsResource = class extends BaseResource {
-  // Apps
   async list(params) {
     return this.unwrap(this.api.GET("/apps", { params: { query: params } }));
   }
+  async analyze(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{id}/analyze", { params: { path: { id: appId } }, body: data }));
+  }
   async get(appId) {
     return this.unwrap(this.api.GET("/apps/{id}", { params: { path: { id: appId } } }));
   }
-  // Plans
-  async listPlans(appId, params) {
-    return this.unwrap(this.api.GET("/apps/{id}/plans", { params: { path: { id: appId }, query: params } }));
-  }
   async getPlan(appId, planId) {
     return this.unwrap(this.api.GET("/apps/{id}/plans/{planId}", { params: { path: { id: appId, planId } } }));
   }
-  async createPlan(appId, data) {
-    return this.unwrap(this.api.POST("/apps/{id}/plans", { params: { path: { id: appId } }, body: data }));
-  }
   async updatePlan(appId, planId, data) {
     return this.unwrap(this.api.PUT("/apps/{id}/plans/{planId}", { params: { path: { id: appId, planId } }, body: data }));
   }
+  async getAppEvent(appId, appEventId) {
+    return this.unwrap(this.api.GET("/apps/{id}/app_events/{appEventId}", { params: { path: { id: appId, appEventId } } }));
+  }
+  async listAppEvents(appId, params) {
+    return this.unwrap(this.api.GET("/apps/{id}/app_events", { params: { path: { id: appId }, query: params } }));
+  }
+  async createAppEvent(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{id}/app_events", { params: { path: { id: appId } }, body: data }));
+  }
+  async getChecklist(appId, checklistId) {
+    return this.unwrap(this.api.GET("/apps/{appId}/checklists/{checklistId}", { params: { path: { appId, checklistId } } }));
+  }
+  async updateChecklist(appId, checklistId, data) {
+    return this.unwrap(this.api.PUT("/apps/{appId}/checklists/{checklistId}", { params: { path: { appId, checklistId } }, body: data }));
+  }
+  async deleteChecklist(appId, checklistId) {
+    return this.unwrap(this.api.DELETE("/apps/{appId}/checklists/{checklistId}", { params: { path: { appId, checklistId } } }));
+  }
+  async listChecklists(appId) {
+    return this.unwrap(this.api.GET("/apps/{appId}/checklists", { params: { path: { appId } } }));
+  }
+  async createChecklist(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{appId}/checklists", { params: { path: { appId } }, body: data }));
+  }
   async archivePlan(appId, planId) {
     return this.unwrap(this.api.PUT("/apps/{id}/plans/{planId}/archive", { params: { path: { id: appId, planId } } }));
   }
   async unarchivePlan(appId, planId) {
     return this.unwrap(this.api.PUT("/apps/{id}/plans/{planId}/unarchive", { params: { path: { id: appId, planId } } }));
   }
-  // Features
-  async listFeatures(appId) {
-    return this.unwrap(this.api.GET("/apps/{appId}/plans/features", { params: { path: { appId } } }));
-  }
   async getFeature(appId, featureId) {
     return this.unwrap(this.api.GET("/apps/{appId}/plans/features/{featureId}", { params: { path: { appId, featureId } } }));
   }
-  async createFeature(appId, data) {
-    return this.unwrap(this.api.POST("/apps/{appId}/plans/features", { params: { path: { appId } }, body: data }));
-  }
   async updateFeature(appId, featureId, data) {
     return this.unwrap(this.api.PUT("/apps/{appId}/plans/features/{featureId}", { params: { path: { appId, featureId } }, body: data }));
   }
   async deleteFeature(appId, featureId) {
     return this.unwrap(this.api.DELETE("/apps/{appId}/plans/features/{featureId}", { params: { path: { appId, featureId } } }));
   }
-  // Reviews
-  async listReviews(appId) {
-    return this.unwrap(this.api.GET("/apps/{id}/reviews", { params: { path: { id: appId } } }));
+  async listFeatures(appId) {
+    return this.unwrap(this.api.GET("/apps/{appId}/plans/features", { params: { path: { appId } } }));
+  }
+  async createFeature(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{appId}/plans/features", { params: { path: { appId } }, body: data }));
+  }
+  async listPlans(appId, params) {
+    return this.unwrap(this.api.GET("/apps/{id}/plans", { params: { path: { id: appId }, query: params } }));
+  }
+  async createPlan(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{id}/plans", { params: { path: { id: appId } }, body: data }));
   }
   async getReview(appId, reviewId) {
     return this.unwrap(this.api.GET("/apps/{id}/reviews/{reviewId}", { params: { path: { id: appId, reviewId } } }));
   }
-  // Usage Metrics
-  async listUsageMetrics(appId) {
-    return this.unwrap(this.api.GET("/apps/{id}/usage_metrics", { params: { path: { id: appId } } }));
+  async listReviews(appId, params) {
+    return this.unwrap(this.api.GET("/apps/{id}/reviews", { params: { path: { id: appId }, query: params } }));
+  }
+  async getSkill(appId, skillId, params) {
+    return this.unwrap(this.api.GET("/apps/{id}/skills/{skillId}", { params: { path: { id: appId, skillId }, query: params } }));
+  }
+  async createSkill(appId, skillId, data) {
+    return this.unwrap(this.api.POST("/apps/{id}/skills/{skillId}", { params: { path: { id: appId, skillId } }, body: data }));
   }
   async getUsageMetric(appId, usageMetricId) {
     return this.unwrap(this.api.GET("/apps/{id}/usage_metrics/{usageMetricId}", { params: { path: { id: appId, usageMetricId } } }));
   }
-  async createUsageMetric(appId, data) {
-    return this.unwrap(this.api.POST("/apps/{id}/usage_metrics", { params: { path: { id: appId } }, body: data }));
-  }
   async updateUsageMetric(appId, usageMetricId, data) {
     return this.unwrap(this.api.PUT("/apps/{id}/usage_metrics/{usageMetricId}", { params: { path: { id: appId, usageMetricId } }, body: data }));
   }
   async deleteUsageMetric(appId, usageMetricId) {
     return this.unwrap(this.api.DELETE("/apps/{id}/usage_metrics/{usageMetricId}", { params: { path: { id: appId, usageMetricId } } }));
   }
-  // App Events
-  async listAppEvents(appId, params) {
-    return this.unwrap(this.api.GET("/apps/{id}/app_events", { params: { path: { id: appId }, query: params } }));
+  async listUsageMetrics(appId) {
+    return this.unwrap(this.api.GET("/apps/{id}/usage_metrics", { params: { path: { id: appId } } }));
   }
-  async getAppEvent(appId, appEventId) {
-    return this.unwrap(this.api.GET("/apps/{id}/app_events/{appEventId}", { params: { path: { id: appId, appEventId } } }));
+  async createUsageMetric(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{id}/usage_metrics", { params: { path: { id: appId } }, body: data }));
   }
-  async createAppEvent(appId, data) {
-    return this.unwrap(this.api.POST("/apps/{id}/app_events", { params: { path: { id: appId } }, body: data }));
+};
+
+// src/resources/assistant.ts
+var AssistantResource = class extends BaseResource {
+  async getConversation(conversationId) {
+    return this.unwrap(this.api.GET("/assistant/conversations/{id}", { params: { path: { id: conversationId } } }));
   }
 };
 
-// src/resources/deals.ts
-var DealsResource = class extends BaseResource {
+// src/resources/channels.ts
+var ChannelsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/deals", { params: { query: params } }));
-  }
-  async get(dealId) {
-    return this.unwrap(this.api.GET("/deals/{id}", { params: { path: { id: dealId } } }));
+    return this.unwrap(this.api.GET("/channels", { params: { query: params } }));
   }
   async create(data) {
-    return this.unwrap(this.api.POST("/deals", { body: data }));
-  }
-  async update(dealId, data) {
-    return this.unwrap(this.api.PUT("/deals/{id}", { params: { path: { id: dealId } }, body: data }));
-  }
-  async del(dealId) {
-    return this.unwrap(this.api.DELETE("/deals/{id}", { params: { path: { id: dealId } } }));
-  }
-  async timeline(dealId) {
-    return this.unwrap(this.api.GET("/deals/{id}/timeline", { params: { path: { id: dealId } } }));
-  }
-  async listEvents(dealId) {
-    return this.unwrap(this.api.GET("/deals/{id}/events", { params: { path: { id: dealId } } }));
-  }
-  async createEvent(dealId, data) {
-    return this.unwrap(this.api.POST("/deals/{id}/events", { params: { path: { id: dealId } }, body: data }));
+    return this.unwrap(this.api.POST("/channels", { body: data }));
   }
 };
 
-// src/resources/deal-flows.ts
-var DealFlowsResource = class extends BaseResource {
+// src/resources/charges.ts
+var ChargesResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/deal_flows", { params: { query: params } }));
-  }
-  async get(dealFlowId) {
-    return this.unwrap(this.api.GET("/deal_flows/{id}", { params: { path: { id: dealFlowId } } }));
-  }
-  async create(data) {
-    return this.unwrap(this.api.POST("/deal_flows", { body: data }));
-  }
-  async update(dealFlowId, data) {
-    return this.unwrap(this.api.PUT("/deal_flows/{id}", { params: { path: { id: dealFlowId } }, body: data }));
-  }
-  async del(dealFlowId) {
-    return this.unwrap(this.api.DELETE("/deal_flows/{id}", { params: { path: { id: dealFlowId } } }));
+    return this.unwrap(this.api.GET("/charges", { params: { query: params } }));
   }
 };
 
-// src/resources/deal-activities.ts
-var DealActivitiesResource = class extends BaseResource {
+// src/resources/companies.ts
+var CompaniesResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/deal_activities", { params: { query: params } }));
-  }
-  async get(dealActivityId) {
-    return this.unwrap(this.api.GET("/deal_activities/{id}", { params: { path: { id: dealActivityId } } }));
+    return this.unwrap(this.api.GET("/companies", { params: { query: params } }));
   }
   async create(data) {
-    return this.unwrap(this.api.POST("/deal_activities", { body: data }));
+    return this.unwrap(this.api.POST("/companies", { body: data }));
   }
-  async update(dealActivityId, data) {
-    return this.unwrap(this.api.PUT("/deal_activities/{id}", { params: { path: { id: dealActivityId } }, body: data }));
+  async get(companyId) {
+    return this.unwrap(this.api.GET("/companies/{id}", { params: { path: { id: companyId } } }));
+  }
+  async update(companyId, data) {
+    return this.unwrap(this.api.PUT("/companies/{id}", { params: { path: { id: companyId } }, body: data }));
   }
-  async del(dealActivityId) {
-    return this.unwrap(this.api.DELETE("/deal_activities/{id}", { params: { path: { id: dealActivityId } } }));
+  async del(companyId) {
+    return this.unwrap(this.api.DELETE("/companies/{id}", { params: { path: { id: companyId } } }));
   }
 };
 
-// src/resources/tickets.ts
-var TicketsResource = class extends BaseResource {
-  // Tickets
+// src/resources/contacts.ts
+var ContactsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/tickets", { params: { query: params } }));
-  }
-  async get(ticketId) {
-    return this.unwrap(this.api.GET("/tickets/{id}", { params: { path: { id: ticketId } } }));
+    return this.unwrap(this.api.GET("/contacts", { params: { query: params } }));
   }
   async create(data) {
-    return this.unwrap(this.api.POST("/tickets", { body: data }));
-  }
-  async update(ticketId, data) {
-    return this.unwrap(this.api.PUT("/tickets/{id}", { params: { path: { id: ticketId } }, body: data }));
-  }
-  // Messages
-  async listMessages(ticketId, params) {
-    return this.unwrap(this.api.GET("/tickets/{id}/messages", { params: { path: { id: ticketId }, query: params } }));
+    return this.unwrap(this.api.POST("/contacts", { body: data }));
   }
-  async getMessage(ticketId, messageId) {
-    return this.unwrap(this.api.GET("/tickets/{id}/messages/{messageId}", { params: { path: { id: ticketId, messageId } } }));
+  async addTags(contactId, data) {
+    return this.unwrap(this.api.POST("/contacts/{id}/addTags", { params: { path: { id: contactId } }, body: data }));
   }
-  async createMessage(ticketId, data) {
-    return this.unwrap(this.api.POST("/tickets/{id}/messages", { params: { path: { id: ticketId } }, body: data }));
+  async get(contactId) {
+    return this.unwrap(this.api.GET("/contacts/{id}", { params: { path: { id: contactId } } }));
   }
-  async updateMessage(ticketId, data) {
-    return this.unwrap(this.api.PUT("/tickets/{id}/messages", { params: { path: { id: ticketId } }, body: data }));
+  async update(contactId, data) {
+    return this.unwrap(this.api.PUT("/contacts/{id}", { params: { path: { id: contactId } }, body: data }));
   }
-  // Events
-  async listEvents(ticketId, params) {
-    return this.unwrap(this.api.GET("/tickets/{id}/events", { params: { path: { id: ticketId }, query: params } }));
+  async del(contactId) {
+    return this.unwrap(this.api.DELETE("/contacts/{id}", { params: { path: { id: contactId } } }));
   }
-  async createEvent(ticketId, data) {
-    return this.unwrap(this.api.POST("/tickets/{id}/events", { params: { path: { id: ticketId } }, body: data }));
+  async removeTags(contactId, data) {
+    return this.unwrap(this.api.POST("/contacts/{id}/removeTags", { params: { path: { id: contactId } }, body: data }));
   }
-  // Loops
-  async listLoops(ticketId) {
-    return this.unwrap(this.api.GET("/tickets/{id}/loops", { params: { path: { id: ticketId } } }));
+};
+
+// src/resources/custom-data.ts
+var CustomDataResource = class extends BaseResource {
+  async getValue(params) {
+    return this.unwrap(this.api.GET("/custom_data", { params: { query: params } }));
   }
-  async getLoop(ticketId, loopId) {
-    return this.unwrap(this.api.GET("/tickets/{id}/loops/{loopId}", { params: { path: { id: ticketId, loopId } } }));
+  async set(data) {
+    return this.unwrap(this.api.PUT("/custom_data", { body: data }));
   }
 };
 
-// src/resources/channels.ts
-var ChannelsResource = class extends BaseResource {
-  /**
-   * List CX channels with optional filters
-   */
+// src/resources/customer-segments.ts
+var CustomerSegmentsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/channels", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/customer_segments", { params: { query: params } }));
   }
-  /**
-   * Create a new CX channel
-   */
-  async create(data) {
-    return this.unwrap(this.api.POST("/channels", { body: data }));
+  async get(segmentId) {
+    return this.unwrap(this.api.GET("/customer_segments/{id}", { params: { path: { id: segmentId } } }));
   }
 };
 
-// src/resources/flows.ts
-var FlowsResource = class extends BaseResource {
-  /**
-   * List flows with optional filters and pagination
-   */
+// src/resources/customers.ts
+var CustomersResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/flows", { params: { query: params } }));
-  }
-  /**
-   * Get a single flow by ID
-   */
-  async get(flowId) {
-    return this.unwrap(this.api.GET("/flows/{id}", { params: { path: { id: flowId } } }));
+    return this.unwrap(this.api.GET("/customers", { params: { query: params } }));
   }
-  /**
-   * Create a new flow
-   */
   async create(data) {
-    return this.unwrap(this.api.POST("/flows", { body: data }));
+    return this.unwrap(this.api.POST("/customers", { body: data }));
   }
-  /**
-   * Update an existing flow
-   */
-  async update(flowId, data) {
-    return this.unwrap(this.api.PATCH("/flows/{id}", { params: { path: { id: flowId } }, body: data }));
+  async listCustomFields(params) {
+    return this.unwrap(this.api.GET("/customers/custom_fields", { params: { query: params } }));
   }
-  /**
-   * Delete a flow
-   */
-  async del(flowId) {
-    return this.unwrap(this.api.DELETE("/flows/{id}", { params: { path: { id: flowId } } }));
+  async createCustomField(data) {
+    return this.unwrap(this.api.POST("/customers/custom_fields", { body: data }));
   }
-};
-
-// src/resources/tasks.ts
-var TasksResource = class extends BaseResource {
-  // Tasks
-  async list(params) {
-    return this.unwrap(this.api.GET("/tasks", { params: { query: params } }));
+  async updateAccountOwner(customerId, ownerId, data) {
+    return this.unwrap(this.api.PUT("/customers/{id}/account_owners/{ownerId}", { params: { path: { id: customerId, ownerId } }, body: data }));
   }
-  async get(taskId) {
-    return this.unwrap(this.api.GET("/tasks/{id}", { params: { path: { id: taskId } } }));
+  async deleteAccountOwner(customerId, ownerId) {
+    return this.unwrap(this.api.DELETE("/customers/{id}/account_owners/{ownerId}", { params: { path: { id: customerId, ownerId } } }));
   }
-  async create(data) {
-    return this.unwrap(this.api.POST("/tasks", { body: data }));
+  async addTags(customerId, data) {
+    return this.unwrap(this.api.POST("/customers/{id}/addTags", { params: { path: { id: customerId } }, body: data }));
   }
-  async update(taskId, data) {
-    return this.unwrap(this.api.PUT("/tasks/{id}", { params: { path: { id: taskId } }, body: data }));
+  async get(customerId) {
+    return this.unwrap(this.api.GET("/customers/{id}", { params: { path: { id: customerId } } }));
   }
-  async del(taskId) {
-    return this.unwrap(this.api.DELETE("/tasks/{id}", { params: { path: { id: taskId } } }));
+  async update(customerId, data) {
+    return this.unwrap(this.api.PUT("/customers/{id}", { params: { path: { id: customerId } }, body: data }));
   }
-  // Todo Items
-  async listTodoItems(taskId) {
-    return this.unwrap(this.api.GET("/tasks/{id}/todo-items", { params: { path: { id: taskId } } }));
+  async removeTags(customerId, data) {
+    return this.unwrap(this.api.POST("/customers/{id}/removeTags", { params: { path: { id: customerId } }, body: data }));
   }
-  async getTodoItem(taskId, itemId) {
-    return this.unwrap(this.api.GET("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } } }));
+  async getTimeline(customerId, params) {
+    return this.unwrap(this.api.GET("/customers/{id}/timeline", { params: { path: { id: customerId }, query: params } }));
   }
-  async createTodoItem(taskId, data) {
-    return this.unwrap(this.api.POST("/tasks/{id}/todo-items", { params: { path: { id: taskId } }, body: data }));
+  async listAccountOwners(customerId) {
+    return this.unwrap(this.api.GET("/customers/{id}/account_owners", { params: { path: { id: customerId } } }));
   }
-  async updateTodoItem(taskId, itemId, data) {
-    return this.unwrap(this.api.PUT("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } }, body: data }));
+  async createAccountOwner(customerId, data) {
+    return this.unwrap(this.api.POST("/customers/{id}/account_owners", { params: { path: { id: customerId } }, body: data }));
   }
-  async deleteTodoItem(taskId, itemId) {
-    return this.unwrap(this.api.DELETE("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } } }));
+  async getCustomField(customerId) {
+    return this.unwrap(this.api.GET("/customers/custom_fields/{id}", { params: { path: { id: customerId } } }));
+  }
+  async updateCustomField(customerId, data) {
+    return this.unwrap(this.api.PUT("/customers/custom_fields/{id}", { params: { path: { id: customerId } }, body: data }));
+  }
+  async deleteCustomField(customerId) {
+    return this.unwrap(this.api.DELETE("/customers/custom_fields/{id}", { params: { path: { id: customerId } } }));
   }
 };
 
-// src/resources/webhooks.ts
-var WebhooksResource = class extends BaseResource {
-  /**
-   * List all webhooks
-   */
-  async list() {
-    return this.unwrap(this.api.GET("/webhooks"));
+// src/resources/deal-activities.ts
+var DealActivitiesResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/deal_activities", { params: { query: params } }));
   }
-  /**
-   * Create a new webhook
-   */
   async create(data) {
-    return this.unwrap(this.api.POST("/webhooks", { body: data }));
+    return this.unwrap(this.api.POST("/deal_activities", { body: data }));
   }
-  /**
-   * Update an existing webhook
-   */
-  async update(webhookId, data) {
-    return this.unwrap(this.api.PUT("/webhooks/{id}", { params: { path: { id: webhookId } }, body: data }));
+  async get(activityId) {
+    return this.unwrap(this.api.GET("/deal_activities/{id}", { params: { path: { id: activityId } } }));
   }
-  /**
-   * Delete a webhook
-   */
-  async del(webhookId) {
-    return this.unwrap(this.api.DELETE("/webhooks/{id}", { params: { path: { id: webhookId } } }));
+  async update(activityId, data) {
+    return this.unwrap(this.api.PUT("/deal_activities/{id}", { params: { path: { id: activityId } }, body: data }));
+  }
+  async del(activityId) {
+    return this.unwrap(this.api.DELETE("/deal_activities/{id}", { params: { path: { id: activityId } } }));
   }
 };
 
-// src/resources/companies.ts
-var CompaniesResource = class extends BaseResource {
-  /**
-   * List companies with optional pagination
-   */
+// src/resources/deal-flows.ts
+var DealFlowsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/companies", { params: { query: params } }));
-  }
-  /**
-   * Get a single company by ID
-   */
-  async get(companyId) {
-    return this.unwrap(this.api.GET("/companies/{id}", { params: { path: { id: companyId } } }));
+    return this.unwrap(this.api.GET("/deal_flows", { params: { query: params } }));
   }
-  /**
-   * Create a new company
-   */
   async create(data) {
-    return this.unwrap(this.api.POST("/companies", { body: data }));
+    return this.unwrap(this.api.POST("/deal_flows", { body: data }));
   }
-  /**
-   * Update an existing company
-   */
-  async update(companyId, data) {
-    return this.unwrap(this.api.PUT("/companies/{id}", { params: { path: { id: companyId } }, body: data }));
+  async get(dealFlowId) {
+    return this.unwrap(this.api.GET("/deal_flows/{id}", { params: { path: { id: dealFlowId } } }));
   }
-  /**
-   * Delete a company
-   */
-  async del(companyId) {
-    return this.unwrap(this.api.DELETE("/companies/{id}", { params: { path: { id: companyId } } }));
+  async update(dealFlowId, data) {
+    return this.unwrap(this.api.PUT("/deal_flows/{id}", { params: { path: { id: dealFlowId } }, body: data }));
+  }
+  async del(dealFlowId) {
+    return this.unwrap(this.api.DELETE("/deal_flows/{id}", { params: { path: { id: dealFlowId } } }));
   }
 };
 
-// src/resources/customer-segments.ts
-var CustomerSegmentsResource = class extends BaseResource {
-  /**
-   * List public customer segments with optional pagination
-   */
+// src/resources/deals.ts
+var DealsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/customer_segments", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/deals", { params: { query: params } }));
   }
-  /**
-   * Get a single customer segment by ID
-   */
-  async get(segmentId) {
-    return this.unwrap(this.api.GET("/customer_segments/{id}", { params: { path: { id: segmentId } } }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/deals", { body: data }));
+  }
+  async listEvents(dealId, params) {
+    return this.unwrap(this.api.GET("/deals/{id}/events", { params: { path: { id: dealId }, query: params } }));
+  }
+  async createEvent(dealId, data) {
+    return this.unwrap(this.api.POST("/deals/{id}/events", { params: { path: { id: dealId } }, body: data }));
+  }
+  async get(dealId) {
+    return this.unwrap(this.api.GET("/deals/{id}", { params: { path: { id: dealId } } }));
+  }
+  async update(dealId, data) {
+    return this.unwrap(this.api.PUT("/deals/{id}", { params: { path: { id: dealId } }, body: data }));
+  }
+  async del(dealId) {
+    return this.unwrap(this.api.DELETE("/deals/{id}", { params: { path: { id: dealId } } }));
+  }
+  async getTimeline(dealId, params) {
+    return this.unwrap(this.api.GET("/deals/{id}/timeline", { params: { path: { id: dealId }, query: params } }));
   }
 };
 
-// src/resources/affiliates.ts
-var AffiliatesResource = class extends BaseResource {
-  /**
-   * List affiliates with optional filters and pagination
-   */
-  async list(params) {
-    return this.unwrap(this.api.GET("/affiliates", { params: { query: params } }));
+// src/resources/docs.ts
+var DocsResource = class extends BaseResource {
+  async listCollections(params) {
+    return this.unwrap(this.api.GET("/docs/collections", { params: { query: params } }));
   }
-  /**
-   * Get a single affiliate by ID
-   */
-  async get(affiliateId) {
-    return this.unwrap(this.api.GET("/affiliates/{id}", { params: { path: { id: affiliateId } } }));
+  async createCollection(data) {
+    return this.unwrap(this.api.POST("/docs/collections", { body: data }));
   }
-  /**
-   * Update an existing affiliate
-   * Note: PUT not in OpenAPI spec but kept for backwards compatibility
-   */
-  async update(affiliateId, data) {
-    return this.unwrap(this.untypedApi.PUT("/affiliates/{id}", { params: { path: { id: affiliateId } }, body: data }));
+  async listGroups(params) {
+    return this.unwrap(this.api.GET("/docs/groups", { params: { query: params } }));
+  }
+  async createGroup(data) {
+    return this.unwrap(this.api.POST("/docs/groups", { body: data }));
+  }
+  async listPages(params) {
+    return this.unwrap(this.api.GET("/docs/pages", { params: { query: params } }));
+  }
+  async createPage(data) {
+    return this.unwrap(this.api.POST("/docs/pages", { body: data }));
+  }
+  async listRepositories(params) {
+    return this.unwrap(this.api.GET("/docs/repositories", { params: { query: params } }));
+  }
+  async updateCollection(collectionId, data) {
+    return this.unwrap(this.api.PUT("/docs/collections/{collection_id}", { params: { path: { collection_id: collectionId } }, body: data }));
+  }
+  async deleteCollection(collectionId) {
+    return this.unwrap(this.api.DELETE("/docs/collections/{collection_id}", { params: { path: { collection_id: collectionId } } }));
+  }
+  async updateGroup(groupId, data) {
+    return this.unwrap(this.api.PUT("/docs/groups/{group_id}", { params: { path: { group_id: groupId } }, body: data }));
+  }
+  async deleteGroup(groupId) {
+    return this.unwrap(this.api.DELETE("/docs/groups/{group_id}", { params: { path: { group_id: groupId } } }));
+  }
+  async getPage(pageId, params) {
+    return this.unwrap(this.api.GET("/docs/pages/{page_id}", { params: { path: { page_id: pageId }, query: params } }));
+  }
+  async updatePage(pageId, data) {
+    return this.unwrap(this.api.PUT("/docs/pages/{page_id}", { params: { path: { page_id: pageId } }, body: data }));
+  }
+  async deletePage(pageId) {
+    return this.unwrap(this.api.DELETE("/docs/pages/{page_id}", { params: { path: { page_id: pageId } } }));
+  }
+  async getRepository(docId, params) {
+    return this.unwrap(this.api.GET("/docs/repositories/{id}", { params: { path: { id: docId }, query: params } }));
   }
 };
 
-// src/resources/affiliate-programs.ts
-var AffiliateProgramsResource = class extends BaseResource {
-  /**
-   * List affiliate programs with optional filters and pagination
-   */
-  async list(params) {
-    return this.unwrap(this.api.GET("/affiliate_programs", { params: { query: params } }));
+// src/resources/email-unsubscribe-groups.ts
+var EmailUnsubscribeGroupsResource = class extends BaseResource {
+  async list() {
+    return this.unwrap(this.api.GET("/email/unsubscribe_groups"));
   }
-  /**
-   * Get a single affiliate program by ID
-   */
-  async get(programId) {
-    return this.unwrap(this.api.GET("/affiliate_programs/{id}", { params: { path: { id: programId } } }));
+  async deleteMemberDelete(groupId, memberId) {
+    return this.unwrap(this.api.DELETE("/email/unsubscribe_groups/{id}/members/{member_id}", { params: { path: { id: groupId, member_id: memberId } } }));
   }
-  /**
-   * Create a new affiliate program
-   * Note: POST not yet in OpenAPI spec
-   */
-  async create(data) {
-    return this.unwrap(this.untypedApi.POST("/affiliate_programs", { body: data }));
+  async listMembers(groupId) {
+    return this.unwrap(this.api.GET("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId } } }));
   }
-  /**
-   * Update an existing affiliate program
-   * Note: PUT not yet in OpenAPI spec
-   */
-  async update(programId, data) {
-    return this.unwrap(this.untypedApi.PUT("/affiliate_programs/{id}", { params: { path: { id: programId } }, body: data }));
+  async createMember(groupId, data) {
+    return this.unwrap(this.api.POST("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId } }, body: data }));
   }
-  /**
-   * Delete an affiliate program
-   * Note: DELETE not yet in OpenAPI spec
-   */
-  async del(programId) {
-    return this.unwrap(this.untypedApi.DELETE("/affiliate_programs/{id}", { params: { path: { id: programId } } }));
+};
+
+// src/resources/entities.ts
+var EntitiesResource = class extends BaseResource {
+  async search(params) {
+    return this.unwrap(this.api.GET("/entities", { params: { query: params } }));
   }
 };
 
-// src/resources/affiliate-commissions.ts
-var AffiliateCommissionsResource = class extends BaseResource {
-  /**
-   * List affiliate commissions with optional filters and pagination
-   */
-  async list(params) {
-    return this.unwrap(this.api.GET("/affiliate_commissions", { params: { query: params } }));
+// src/resources/flow-extensions.ts
+var FlowExtensionsResource = class extends BaseResource {
+  async listActions() {
+    return this.unwrap(this.api.GET("/flow/extensions/actions"));
   }
-  /**
-   * Get a single affiliate commission by ID
-   */
-  async get(commissionId) {
-    return this.unwrap(this.api.GET("/affiliate_commissions/{id}", { params: { path: { id: commissionId } } }));
+  async createAction(data) {
+    return this.unwrap(this.api.POST("/flow/extensions/actions", { body: data }));
+  }
+  async listTriggers() {
+    return this.unwrap(this.api.GET("/flow/extensions/triggers"));
+  }
+  async createTriggerPost(data) {
+    return this.unwrap(this.api.POST("/flow/extensions/triggers", { body: data }));
+  }
+  async validateSchema(data) {
+    return this.unwrap(this.api.POST("/flow/extensions/triggers/validate-schema", { body: data }));
+  }
+  async updateRun(extensionId, data) {
+    return this.unwrap(this.api.PUT("/flow/actions/runs/{id}", { params: { path: { id: extensionId } }, body: data }));
+  }
+  async fireTrigger(handle, data) {
+    return this.unwrap(this.api.POST("/flow/extensions/triggers/{handle}/fire", { params: { path: { handle } }, body: data }));
+  }
+  async updateAction(extensionId, data) {
+    return this.unwrap(this.api.PUT("/flow/extensions/actions/{id}", { params: { path: { id: extensionId } }, body: data }));
+  }
+  async deleteAction(extensionId) {
+    return this.unwrap(this.api.DELETE("/flow/extensions/actions/{id}", { params: { path: { id: extensionId } } }));
+  }
+  async getTrigger(handle) {
+    return this.unwrap(this.api.GET("/flow/extensions/triggers/{handle}", { params: { path: { handle } } }));
+  }
+  async replaceTrigger(handle, data) {
+    return this.unwrap(this.api.PUT("/flow/extensions/triggers/{handle}", { params: { path: { handle } }, body: data }));
+  }
+  async updateTrigger(handle, data) {
+    return this.unwrap(this.api.PATCH("/flow/extensions/triggers/{handle}", { params: { path: { handle } }, body: data }));
+  }
+  async deleteTrigger(handle) {
+    return this.unwrap(this.api.DELETE("/flow/extensions/triggers/{handle}", { params: { path: { handle } } }));
   }
 };
 
-// src/resources/affiliate-payouts.ts
-var AffiliatePayoutsResource = class extends BaseResource {
-  /**
-   * List affiliate payouts with optional filters and pagination
-   */
+// src/resources/flows.ts
+var FlowsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/affiliate_payouts", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/flows", { params: { query: params } }));
   }
-  /**
-   * Get a single affiliate payout by ID
-   */
-  async get(payoutId) {
-    return this.unwrap(this.api.GET("/affiliate_payouts/{id}", { params: { path: { id: payoutId } } }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/flows", { body: data }));
   }
-};
-
-// src/resources/affiliate-referrals.ts
-var AffiliateReferralsResource = class extends BaseResource {
-  /**
-   * List affiliate referrals with optional filters and pagination
-   */
-  async list(params) {
-    return this.unwrap(this.api.GET("/affiliate_referrals", { params: { query: params } }));
+  async get(flowId) {
+    return this.unwrap(this.api.GET("/flows/{id}", { params: { path: { id: flowId } } }));
   }
-  /**
-   * Get a single affiliate referral by ID
-   */
-  async get(referralId) {
-    return this.unwrap(this.api.GET("/affiliate_referrals/{id}", { params: { path: { id: referralId } } }));
+  async update(flowId, data) {
+    return this.unwrap(this.api.PATCH("/flows/{id}", { params: { path: { id: flowId } }, body: data }));
+  }
+  async del(flowId) {
+    return this.unwrap(this.api.DELETE("/flows/{id}", { params: { path: { id: flowId } } }));
   }
 };
 
-// src/resources/charges.ts
-var ChargesResource = class extends BaseResource {
-  /**
-   * List charges with optional filters and pagination
-   */
+// src/resources/journal-entries.ts
+var JournalEntriesResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/charges", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/journal_entries", { params: { query: params } }));
+  }
+  async create(data) {
+    return this.unwrap(this.api.POST("/journal_entries", { body: data }));
+  }
+  async get(entryId, params) {
+    return this.unwrap(this.api.GET("/journal_entries/{id}", { params: { path: { id: entryId }, query: params } }));
+  }
+  async update(entryId, data) {
+    return this.unwrap(this.api.PUT("/journal_entries/{id}", { params: { path: { id: entryId } }, body: data }));
+  }
+  async del(entryId) {
+    return this.unwrap(this.api.DELETE("/journal_entries/{id}", { params: { path: { id: entryId } } }));
   }
 };
 
-// src/resources/transactions.ts
-var TransactionsResource = class extends BaseResource {
-  /**
-   * List transactions with optional filters and pagination
-   */
+// src/resources/lists.ts
+var ListsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/transactions", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/lists", { params: { query: params } }));
   }
-  /**
-   * Get a single transaction by ID
-   */
-  async get(transactionId) {
-    return this.unwrap(this.api.GET("/transactions/{id}", { params: { path: { id: transactionId } } }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/lists", { body: data }));
   }
-};
-
-// src/resources/metrics.ts
-var MetricsResource = class extends BaseResource {
-  async mrr(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/mrr", { params: { query: params } }));
+  async add(listId, data) {
+    return this.unwrap(this.api.POST("/lists/{id}/add", { params: { path: { id: listId } }, body: data }));
   }
-  async arr(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/arr", { params: { query: params } }));
+  async get(listId, params) {
+    return this.unwrap(this.api.GET("/lists/{id}", { params: { path: { id: listId }, query: params } }));
   }
-  async arpu(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/arpu", { params: { query: params } }));
+  async update(listId, data) {
+    return this.unwrap(this.api.PUT("/lists/{id}", { params: { path: { id: listId } }, body: data }));
   }
-  async activeSubscriptions(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/activeSubscriptions", { params: { query: params } }));
+  async del(listId) {
+    return this.unwrap(this.api.DELETE("/lists/{id}", { params: { path: { id: listId } } }));
   }
-  async activeInstalls(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/activeInstalls", { params: { query: params } }));
+  async remove(listId, data) {
+    return this.unwrap(this.api.POST("/lists/{id}/remove", { params: { path: { id: listId } }, body: data }));
   }
-  async netInstalls(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/netInstalls", { params: { query: params } }));
+};
+
+// src/resources/meetings.ts
+var MeetingsResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/meetings", { params: { query: params } }));
   }
-  async logoChurn(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/logoChurn", { params: { query: params } }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/meetings", { body: data }));
   }
-  async revenueChurn(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/revenueChurn", { params: { query: params } }));
+  async getRecordingUrl(meetingId) {
+    return this.unwrap(this.api.GET("/meetings/{id}/recording-url", { params: { path: { id: meetingId } } }));
   }
-  async revenueRetention(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/revenueRetention", { params: { query: params } }));
+  async acceptTaskSuggestion(meetingId, suggestionId, data) {
+    return this.unwrap(this.api.POST("/meetings/{id}/task-suggestions/{suggestionId}/accept", { params: { path: { id: meetingId, suggestionId } }, body: data }));
   }
-  async netRevenueRetention(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/netRevenueRetention", { params: { query: params } }));
+  async dismissTaskSuggestion(meetingId, suggestionId) {
+    return this.unwrap(this.api.POST("/meetings/{id}/task-suggestions/{suggestionId}/dismiss", { params: { path: { id: meetingId, suggestionId } } }));
   }
-  async netRevenue(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/netRevenue", { params: { query: params } }));
+  async updateAttendee(meetingId, attendeeId, data) {
+    return this.unwrap(this.api.PUT("/meetings/{id}/attendees/{attendeeId}", { params: { path: { id: meetingId, attendeeId } }, body: data }));
   }
-  async payout(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/payout", { params: { query: params } }));
+  async transcribeGet(meetingId) {
+    return this.unwrap(this.api.GET("/meetings/{id}/transcribe", { params: { path: { id: meetingId } } }));
   }
-  async predictedLtv(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/predictedLtv", { params: { query: params } }));
+  async transcribePost(meetingId, data) {
+    return this.unwrap(this.api.POST("/meetings/{id}/transcribe", { params: { path: { id: meetingId } }, body: data }));
   }
-  async usageEvent(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/usageEvent", { params: { query: params } }));
+  async transcribeUpload(meetingId, data) {
+    return this.unwrap(this.api.POST("/meetings/{id}/transcribe/upload", { params: { path: { id: meetingId } }, body: data }));
   }
-  async usageMetric(params) {
-    return this.unwrap(this.api.GET("/api/core/v1/metrics/usageMetric", { params: { query: params } }));
+  async get(meetingId) {
+    return this.unwrap(this.api.GET("/meetings/{id}", { params: { path: { id: meetingId } } }));
   }
-};
-
-// src/resources/users.ts
-var UsersResource = class extends BaseResource {
-  /**
-   * List organization users with optional pagination
-   */
-  async list(params) {
-    return this.unwrap(this.api.GET("/users", { params: { query: params } }));
+  async update(meetingId, data) {
+    return this.unwrap(this.api.PUT("/meetings/{id}", { params: { path: { id: meetingId } }, body: data }));
   }
-  /**
-   * Get a single user by ID
-   */
-  async get(userId) {
-    return this.unwrap(this.api.GET("/users/{id}", { params: { path: { id: userId } } }));
+  async del(meetingId) {
+    return this.unwrap(this.api.DELETE("/meetings/{id}", { params: { path: { id: meetingId } } }));
   }
 };
 
@@ -869,328 +791,255 @@ var MeResource = class extends BaseResource {
   }
 };
 
-// src/resources/organization.ts
-var OrganizationResource = class extends BaseResource {
-  /**
-   * Get organization details
-   */
-  async get() {
-    return this.unwrap(this.api.GET("/organization"));
-  }
-};
-
-// src/resources/agents.ts
-var AgentsResource = class extends BaseResource {
-  async list() {
-    return this.unwrap(this.untypedApi.GET("/agents", {}));
-  }
-  async get(agentId) {
-    return this.unwrap(this.untypedApi.GET("/agents/{id}", { params: { path: { id: agentId } } }));
-  }
-  async create(params) {
-    return this.unwrap(this.untypedApi.POST("/agents", { body: params }));
-  }
-  async findOrCreate(params) {
-    return this.unwrap(this.untypedApi.POST("/agents/find_or_create", { body: params }));
-  }
-};
-
-// src/resources/docs.ts
-var DocsResource = class extends BaseResource {
-  // Collections
-  async listCollections(params) {
-    return this.unwrap(this.api.GET("/docs/collections", { params: { query: params } }));
+// src/resources/metrics.ts
+var MetricsResource = class extends BaseResource {
+  async sales(params) {
+    return this.unwrap(this.api.GET("/metrics/sales", { params: { query: params } }));
   }
-  async createCollection(data) {
-    return this.unwrap(this.api.POST("/docs/collections", { body: data }));
+  async activeInstalls(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/activeInstalls", { params: { query: params } }));
   }
-  async updateCollection(collectionId, data) {
-    return this.unwrap(this.api.PUT("/docs/collections/{collection_id}", { params: { path: { collection_id: collectionId } }, body: data }));
+  async activeSubscriptions(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/activeSubscriptions", { params: { query: params } }));
   }
-  async deleteCollection(collectionId) {
-    return this.unwrap(this.api.DELETE("/docs/collections/{collection_id}", { params: { path: { collection_id: collectionId } } }));
+  async arpu(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/arpu", { params: { query: params } }));
   }
-  // Groups
-  async listGroups(params) {
-    return this.unwrap(this.api.GET("/docs/groups", { params: { query: params } }));
+  async arr(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/arr", { params: { query: params } }));
   }
-  async createGroup(data) {
-    return this.unwrap(this.api.POST("/docs/groups", { body: data }));
+  async logoChurn(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/logoChurn", { params: { query: params } }));
   }
-  async updateGroup(groupId, data) {
-    return this.unwrap(this.api.PUT("/docs/groups/{group_id}", { params: { path: { group_id: groupId } }, body: data }));
+  async mrr(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/mrr", { params: { query: params } }));
   }
-  async deleteGroup(groupId) {
-    return this.unwrap(this.api.DELETE("/docs/groups/{group_id}", { params: { path: { group_id: groupId } } }));
+  async netInstalls(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/netInstalls", { params: { query: params } }));
   }
-  // Pages
-  async listPages(params) {
-    return this.unwrap(this.api.GET("/docs/pages", { params: { query: params } }));
+  async netRevenue(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/netRevenue", { params: { query: params } }));
   }
-  async getPage(pageId) {
-    return this.unwrap(this.api.GET("/docs/pages/{page_id}", { params: { path: { page_id: pageId } } }));
+  async netRevenueRetention(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/netRevenueRetention", { params: { query: params } }));
   }
-  async createPage(data) {
-    return this.unwrap(this.api.POST("/docs/pages", { body: data }));
+  async payout(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/payout", { params: { query: params } }));
   }
-  async updatePage(pageId, data) {
-    return this.unwrap(this.api.PUT("/docs/pages/{page_id}", { params: { path: { page_id: pageId } }, body: data }));
+  async predictedLtv(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/predictedLtv", { params: { query: params } }));
   }
-  async deletePage(pageId) {
-    return this.unwrap(this.api.DELETE("/docs/pages/{page_id}", { params: { path: { page_id: pageId } } }));
+  async revenueChurn(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/revenueChurn", { params: { query: params } }));
   }
-  // Repositories
-  async listRepositories(params) {
-    return this.unwrap(this.api.GET("/docs/repositories", { params: { query: params } }));
+  async revenueRetention(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/revenueRetention", { params: { query: params } }));
   }
-  async getRepository(repositoryId, params) {
-    return this.unwrap(this.api.GET("/docs/repositories/{id}", { params: { path: { id: repositoryId }, query: params } }));
+  async usageEvent(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/usageEvent", { params: { query: params } }));
   }
-};
-
-// src/resources/entities.ts
-var EntitiesResource = class extends BaseResource {
-  /**
-   * Search across contacts and customers
-   * Returns entities with a _type discriminator field
-   */
-  async search(params) {
-    return this.unwrap(this.api.GET("/entities", { params: { query: params } }));
+  async usageMetric(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/usageMetric", { params: { query: params } }));
   }
 };
 
-// src/resources/custom-data.ts
-var CustomDataResource = class extends BaseResource {
-  async set(data) {
-    return this.unwrap(this.api.PUT("/custom_data", { body: data }));
-  }
-  async getValue(params) {
-    return this.unwrap(this.api.GET("/custom_data", { params: { query: params } }));
+// src/resources/organization.ts
+var OrganizationResource = class extends BaseResource {
+  async list() {
+    return this.unwrap(this.api.GET("/organization"));
   }
 };
 
-// src/resources/timelineComments.ts
-var TimelineCommentsResource = class extends BaseResource {
-  /**
-   * List timeline comments with optional filters and pagination
-   */
+// src/resources/subscriptions.ts
+var SubscriptionsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/timeline_comments", { params: { query: params } }));
-  }
-  /**
-   * Get a single timeline comment by ID
-   */
-  async get(id) {
-    return this.unwrap(this.api.GET("/timeline_comments/{id}", { params: { path: { id } } }));
-  }
-  /**
-   * Create a new timeline comment
-   */
-  async create(data) {
-    return this.unwrap(this.api.POST("/timeline_comments", { body: data }));
-  }
-  /**
-   * Update an existing timeline comment
-   */
-  async update(id, data) {
-    return this.unwrap(this.api.PUT("/timeline_comments/{id}", { params: { path: { id } }, body: data }));
+    return this.unwrap(this.api.GET("/subscriptions", { params: { query: params } }));
   }
-  /**
-   * Delete a timeline comment
-   */
-  async del(id, data) {
-    return this.unwrap(this.api.DELETE("/timeline_comments/{id}", { params: { path: { id } }, body: data }));
+  async get(subscriptionId) {
+    return this.unwrap(this.api.GET("/subscriptions/{id}", { params: { path: { id: subscriptionId } } }));
   }
 };
 
-// src/resources/lists.ts
-var ListsResource = class extends BaseResource {
+// src/resources/synced-emails.ts
+var SyncedEmailsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/lists", { params: { query: params } }));
-  }
-  async get(listId) {
-    return this.unwrap(this.api.GET("/lists/{id}", { params: { path: { id: listId } } }));
+    return this.unwrap(this.api.GET("/synced_emails", { params: { query: params } }));
   }
   async create(data) {
-    return this.unwrap(this.api.POST("/lists", { body: data }));
+    return this.unwrap(this.api.POST("/synced_emails", { body: data }));
   }
-  async update(listId, data) {
-    return this.unwrap(this.api.PUT("/lists/{id}", { params: { path: { id: listId } }, body: data }));
+  async listMessages(syncedEmailId) {
+    return this.unwrap(this.api.GET("/synced_emails/{id}/messages", { params: { path: { id: syncedEmailId } } }));
   }
-  async del(listId) {
-    return this.unwrap(this.api.DELETE("/lists/{id}", { params: { path: { id: listId } } }));
+  async createMessage(syncedEmailId, data) {
+    return this.unwrap(this.api.POST("/synced_emails/{id}/messages", { params: { path: { id: syncedEmailId } }, body: data }));
   }
-  async addEntities(listId, data) {
-    return this.unwrap(this.api.POST("/lists/{id}/add", { params: { path: { id: listId } }, body: data }));
+  async get(syncedEmailId) {
+    return this.unwrap(this.api.GET("/synced_emails/{id}", { params: { path: { id: syncedEmailId } } }));
   }
-  async removeEntities(listId, data) {
-    return this.unwrap(this.api.POST("/lists/{id}/remove", { params: { path: { id: listId } }, body: data }));
+  async update(syncedEmailId, data) {
+    return this.unwrap(this.api.PUT("/synced_emails/{id}", { params: { path: { id: syncedEmailId } }, body: data }));
+  }
+  async del(syncedEmailId) {
+    return this.unwrap(this.api.DELETE("/synced_emails/{id}", { params: { path: { id: syncedEmailId } } }));
   }
 };
 
-// src/resources/journal-entries.ts
-var JournalEntriesResource = class extends BaseResource {
-  /**
-   * List journal entries with optional filters and pagination
-   */
+// src/resources/tasks.ts
+var TasksResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/journal_entries", { params: { query: params } }));
-  }
-  /**
-   * Get a single journal entry by ID
-   */
-  async get(entryId, params) {
-    return this.unwrap(this.api.GET("/journal_entries/{id}", { params: { path: { id: entryId }, query: params } }));
+    return this.unwrap(this.api.GET("/tasks", { params: { query: params } }));
   }
-  /**
-   * Create a new journal entry
-   */
   async create(data) {
-    return this.unwrap(this.api.POST("/journal_entries", { body: data }));
+    return this.unwrap(this.api.POST("/tasks", { body: data }));
   }
-  /**
-   * Update an existing journal entry
-   */
-  async update(entryId, data) {
-    return this.unwrap(this.api.PUT("/journal_entries/{id}", { params: { path: { id: entryId } }, body: data }));
+  async get(taskId) {
+    return this.unwrap(this.api.GET("/tasks/{id}", { params: { path: { id: taskId } } }));
   }
-  /**
-   * Delete a journal entry
-   */
-  async del(entryId) {
-    return this.unwrap(this.api.DELETE("/journal_entries/{id}", { params: { path: { id: entryId } } }));
+  async update(taskId, data) {
+    return this.unwrap(this.api.PUT("/tasks/{id}", { params: { path: { id: taskId } }, body: data }));
   }
-};
-
-// src/resources/email-unsubscribe-groups.ts
-var EmailUnsubscribeGroupsResource = class extends BaseResource {
-  async list(params) {
-    return this.unwrap(this.api.GET("/email/unsubscribe_groups", { params: { query: params } }));
+  async del(taskId) {
+    return this.unwrap(this.api.DELETE("/tasks/{id}", { params: { path: { id: taskId } } }));
   }
-  async listMembers(groupId, params) {
-    return this.unwrap(this.api.GET("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId }, query: params } }));
+  async getTodoItem(taskId, itemId) {
+    return this.unwrap(this.api.GET("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } } }));
   }
-  async addMembers(groupId, data) {
-    return this.unwrap(this.api.POST("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId } }, body: data }));
+  async updateTodoItem(taskId, itemId, data) {
+    return this.unwrap(this.api.PUT("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } }, body: data }));
+  }
+  async deleteTodoItem(taskId, itemId) {
+    return this.unwrap(this.api.DELETE("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } } }));
   }
-  async removeMembers(groupId, data) {
-    return this.unwrap(this.api.DELETE("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId } }, body: data }));
+  async getTodoItems(taskId) {
+    return this.unwrap(this.api.GET("/tasks/{id}/todo-items", { params: { path: { id: taskId } } }));
   }
-  async removeMember(groupId, memberId) {
-    return this.unwrap(this.api.DELETE("/email/unsubscribe_groups/{id}/members/{member_id}", { params: { path: { id: groupId, member_id: memberId } } }));
+  async createTodoItems(taskId, data) {
+    return this.unwrap(this.api.POST("/tasks/{id}/todo-items", { params: { path: { id: taskId } }, body: data }));
   }
 };
 
-// src/resources/flow-extensions.ts
-var FlowExtensionsResource = class extends BaseResource {
-  // Actions
-  async listActions(params) {
-    return this.unwrap(this.api.GET("/flow/extensions/actions", { params: { query: params } }));
+// src/resources/tickets.ts
+var TicketsResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/tickets", { params: { query: params } }));
   }
-  async createAction(data) {
-    return this.unwrap(this.api.POST("/flow/extensions/actions", { body: data }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/tickets", { body: data }));
   }
-  async updateAction(actionId, data) {
-    return this.unwrap(this.api.PUT("/flow/extensions/actions/{id}", { params: { path: { id: actionId } }, body: data }));
+  async listEvents(ticketId, params) {
+    return this.unwrap(this.api.GET("/tickets/{id}/events", { params: { path: { id: ticketId }, query: params } }));
   }
-  async deleteAction(actionId) {
-    return this.unwrap(this.api.DELETE("/flow/extensions/actions/{id}", { params: { path: { id: actionId } } }));
+  async createEvent(ticketId, data) {
+    return this.unwrap(this.api.POST("/tickets/{id}/events", { params: { path: { id: ticketId } }, body: data }));
   }
-  // Action Runs
-  async updateActionRun(runId, data) {
-    return this.unwrap(this.api.PUT("/flow/actions/runs/{id}", { params: { path: { id: runId } }, body: data }));
+  async updateEvent(ticketId, data) {
+    return this.unwrap(this.api.PUT("/tickets/{id}/events", { params: { path: { id: ticketId } }, body: data }));
   }
-  // Triggers
-  async listTriggers() {
-    return this.unwrap(this.api.GET("/flow/extensions/triggers"));
+  async getLoop(ticketId, loopId) {
+    return this.unwrap(this.api.GET("/tickets/{id}/loops/{loopId}", { params: { path: { id: ticketId, loopId } } }));
   }
-  async getTrigger(handle) {
-    return this.unwrap(this.api.GET("/flow/extensions/triggers/{handle}", { params: { path: { handle } } }));
+  async listLoops(ticketId, params) {
+    return this.unwrap(this.api.GET("/tickets/{id}/loops", { params: { path: { id: ticketId }, query: params } }));
   }
-  async createTrigger(data) {
-    return this.unwrap(this.api.POST("/flow/extensions/triggers", { body: data }));
+  async getMessage(ticketId, messageId) {
+    return this.unwrap(this.api.GET("/tickets/{id}/messages/{messageId}", { params: { path: { id: ticketId, messageId } } }));
   }
-  async updateTrigger(handle, data) {
-    return this.unwrap(this.api.PUT("/flow/extensions/triggers/{handle}", { params: { path: { handle } }, body: data }));
+  async listMessages(ticketId, params) {
+    return this.unwrap(this.api.GET("/tickets/{id}/messages", { params: { path: { id: ticketId }, query: params } }));
   }
-  async deleteTrigger(handle) {
-    return this.unwrap(this.api.DELETE("/flow/extensions/triggers/{handle}", { params: { path: { handle } } }));
+  async createMessage(ticketId, data) {
+    return this.unwrap(this.api.POST("/tickets/{id}/messages", { params: { path: { id: ticketId } }, body: data }));
   }
-  async fireTrigger(handle, data) {
-    return this.unwrap(this.api.POST("/flow/extensions/triggers/{handle}/fire", { params: { path: { handle } }, body: data }));
+  async updateMessage(ticketId, data) {
+    return this.unwrap(this.api.PUT("/tickets/{id}/messages", { params: { path: { id: ticketId } }, body: data }));
+  }
+  async get(ticketId) {
+    return this.unwrap(this.api.GET("/tickets/{id}", { params: { path: { id: ticketId } } }));
+  }
+  async update(ticketId, data) {
+    return this.unwrap(this.api.PUT("/tickets/{id}", { params: { path: { id: ticketId } }, body: data }));
   }
 };
 
-// src/resources/ai-agent-runs.ts
-var AiAgentRunsResource = class extends BaseResource {
-  async create(agentId, data) {
-    return this.unwrap(this.api.POST("/ai/agents/{agentId}/runs", { params: { path: { agentId } }, body: data }));
+// src/resources/timeline-comments.ts
+var TimelineCommentsResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/timeline_comments", { params: { query: params } }));
   }
-  async get(agentId, runId) {
-    return this.unwrap(this.api.GET("/ai/agents/{agentId}/runs/{runId}", { params: { path: { agentId, runId } } }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/timeline_comments", { body: data }));
   }
-  /**
-   * Create an agent run and poll until it completes or errors.
-   */
-  async createAndWait(agentId, data, options) {
-    const { timeout = 3e5, pollInterval = 2e3 } = options || {};
-    const result = await this.create(agentId, data);
-    const run = result.run;
-    if (!run?.id) throw new Error("Agent run ID not returned");
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      const response = await this.get(agentId, run.id);
-      const agentRun = response.run;
-      if (agentRun.status === "completed" || agentRun.status === "error") {
-        return agentRun;
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-    throw new Error(`Agent run timed out after ${timeout}ms`);
+  async get(commentId) {
+    return this.unwrap(this.api.GET("/timeline_comments/{id}", { params: { path: { id: commentId } } }));
+  }
+  async update(commentId, data) {
+    return this.unwrap(this.api.PUT("/timeline_comments/{id}", { params: { path: { id: commentId } }, body: data }));
+  }
+  async del(commentId, params) {
+    return this.unwrap(this.api.DELETE("/timeline_comments/{id}", { params: { path: { id: commentId }, query: params } }));
   }
 };
 
-// src/resources/meetings.ts
-var MeetingsResource = class extends BaseResource {
+// src/resources/transactions.ts
+var TransactionsResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.api.GET("/meetings", { params: { query: params } }));
-  }
-  async get(meetingId) {
-    return this.unwrap(this.api.GET("/meetings/{id}", { params: { path: { id: meetingId } } }));
+    return this.unwrap(this.api.GET("/transactions", { params: { query: params } }));
   }
-  async create(data) {
-    return this.unwrap(this.api.POST("/meetings", { body: data }));
+  async get(transactionId) {
+    return this.unwrap(this.api.GET("/transactions/{id}", { params: { path: { id: transactionId } } }));
   }
-  async update(meetingId, data) {
-    return this.unwrap(this.api.PUT("/meetings/{id}", { params: { path: { id: meetingId } }, body: data }));
+};
+
+// src/resources/usage-events.ts
+var UsageEventsResource = class extends BaseResource {
+  async list(params) {
+    return this.unwrap(this.api.GET("/usage_events", { params: { query: params } }));
   }
-  async del(meetingId) {
-    return this.unwrap(this.api.DELETE("/meetings/{id}", { params: { path: { id: meetingId } } }));
+  async create(data) {
+    return this.unwrap(this.api.POST("/usage_events", { body: data }));
   }
 };
 
-// src/resources/synced-emails.ts
-var SyncedEmailsResource = class extends BaseResource {
+// src/resources/users.ts
+var UsersResource = class extends BaseResource {
   async list(params) {
-    return this.unwrap(this.untypedApi.GET("/synced_emails", { params: { query: params } }));
+    return this.unwrap(this.api.GET("/users", { params: { query: params } }));
   }
-  async get(syncedEmailId) {
-    return this.unwrap(this.untypedApi.GET("/synced_emails/{id}", { params: { path: { id: syncedEmailId } } }));
+  async get(userId) {
+    return this.unwrap(this.api.GET("/users/{id}", { params: { path: { id: userId } } }));
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class extends BaseResource {
+  async list() {
+    return this.unwrap(this.api.GET("/webhooks"));
   }
   async create(data) {
-    return this.unwrap(this.untypedApi.POST("/synced_emails", { body: data }));
+    return this.unwrap(this.api.POST("/webhooks", { body: data }));
   }
-  async update(syncedEmailId, data) {
-    return this.unwrap(this.untypedApi.PUT("/synced_emails/{id}", { params: { path: { id: syncedEmailId } }, body: data }));
+  async update(webhookId, data) {
+    return this.unwrap(this.api.PUT("/webhooks/{id}", { params: { path: { id: webhookId } }, body: data }));
   }
-  async del(syncedEmailId) {
-    return this.unwrap(this.untypedApi.DELETE("/synced_emails/{id}", { params: { path: { id: syncedEmailId } } }));
+  async del(webhookId) {
+    return this.unwrap(this.api.DELETE("/webhooks/{id}", { params: { path: { id: webhookId } } }));
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class extends BaseResource {
+  async list() {
+    return this.unwrap(this.untypedApi.GET("/agents", {}));
+  }
+  async get(agentId) {
+    return this.unwrap(this.untypedApi.GET("/agents/{id}", { params: { path: { id: agentId } } }));
   }
-  async addMessages(syncedEmailId, data) {
-    return this.unwrap(this.untypedApi.POST("/synced_emails/{id}/messages", { params: { path: { id: syncedEmailId } }, body: data }));
+  async create(params) {
+    return this.unwrap(this.untypedApi.POST("/agents", { body: params }));
   }
-  async getMessages(syncedEmailId) {
-    return this.unwrap(this.untypedApi.GET("/synced_emails/{id}/messages", { params: { path: { id: syncedEmailId } } }));
+  async findOrCreate(params) {
+    return this.unwrap(this.untypedApi.POST("/agents/find_or_create", { body: params }));
   }
 };
 
@@ -1201,10 +1050,11 @@ function createTimeoutSignal(ms) {
   return controller.signal;
 }
 var MantleCoreClient = class {
+  // @generated-resource-properties-end
   constructor(config) {
-    if (!config.apiKey && !config.accessToken) {
+    if (!config.apiKey && !config.accessToken && !config.fetch) {
       throw new Error(
-        "MantleCoreClient requires either apiKey or accessToken"
+        "MantleCoreClient requires either apiKey, accessToken, or a custom fetch function"
       );
     }
     this.apiKey = config.apiKey;
@@ -1214,7 +1064,8 @@ var MantleCoreClient = class {
       baseUrl: config.baseURL || "https://api.heymantle.com/v1",
       headers: {
         "Content-Type": "application/json"
-      }
+      },
+      ...config.fetch ? { fetch: config.fetch } : {}
     });
     this._api.use({
       onRequest: ({ request }) => {
@@ -1238,44 +1089,45 @@ var MantleCoreClient = class {
         this._api.use(mw);
       }
     }
-    this.customers = new CustomersResource(this);
-    this.contacts = new ContactsResource(this);
-    this.subscriptions = new SubscriptionsResource(this);
-    this.usageEvents = new UsageEventsResource(this);
-    this.apps = new AppsResource(this);
-    this.deals = new DealsResource(this);
-    this.dealFlows = new DealFlowsResource(this);
-    this.dealActivities = new DealActivitiesResource(this);
-    this.tickets = new TicketsResource(this);
-    this.channels = new ChannelsResource(this);
-    this.flows = new FlowsResource(this);
-    this.tasks = new TasksResource(this);
-    this.webhooks = new WebhooksResource(this);
-    this.companies = new CompaniesResource(this);
-    this.customerSegments = new CustomerSegmentsResource(this);
-    this.affiliates = new AffiliatesResource(this);
-    this.affiliatePrograms = new AffiliateProgramsResource(this);
     this.affiliateCommissions = new AffiliateCommissionsResource(this);
     this.affiliatePayouts = new AffiliatePayoutsResource(this);
+    this.affiliatePrograms = new AffiliateProgramsResource(this);
     this.affiliateReferrals = new AffiliateReferralsResource(this);
+    this.affiliates = new AffiliatesResource(this);
+    this.aiAgentRuns = new AiAgentRunsResource(this);
+    this.apps = new AppsResource(this);
+    this.assistant = new AssistantResource(this);
+    this.channels = new ChannelsResource(this);
     this.charges = new ChargesResource(this);
-    this.transactions = new TransactionsResource(this);
-    this.metrics = new MetricsResource(this);
-    this.users = new UsersResource(this);
-    this.me = new MeResource(this);
-    this.organization = new OrganizationResource(this);
-    this.agents = new AgentsResource(this);
-    this.docs = new DocsResource(this);
-    this.entities = new EntitiesResource(this);
+    this.companies = new CompaniesResource(this);
+    this.contacts = new ContactsResource(this);
     this.customData = new CustomDataResource(this);
-    this.timelineComments = new TimelineCommentsResource(this);
-    this.lists = new ListsResource(this);
-    this.journalEntries = new JournalEntriesResource(this);
+    this.customerSegments = new CustomerSegmentsResource(this);
+    this.customers = new CustomersResource(this);
+    this.dealActivities = new DealActivitiesResource(this);
+    this.dealFlows = new DealFlowsResource(this);
+    this.deals = new DealsResource(this);
+    this.docs = new DocsResource(this);
     this.emailUnsubscribeGroups = new EmailUnsubscribeGroupsResource(this);
+    this.entities = new EntitiesResource(this);
     this.flowExtensions = new FlowExtensionsResource(this);
-    this.aiAgentRuns = new AiAgentRunsResource(this);
+    this.flows = new FlowsResource(this);
+    this.journalEntries = new JournalEntriesResource(this);
+    this.lists = new ListsResource(this);
     this.meetings = new MeetingsResource(this);
+    this.me = new MeResource(this);
+    this.metrics = new MetricsResource(this);
+    this.organization = new OrganizationResource(this);
+    this.subscriptions = new SubscriptionsResource(this);
     this.syncedEmails = new SyncedEmailsResource(this);
+    this.tasks = new TasksResource(this);
+    this.tickets = new TicketsResource(this);
+    this.timelineComments = new TimelineCommentsResource(this);
+    this.transactions = new TransactionsResource(this);
+    this.usageEvents = new UsageEventsResource(this);
+    this.users = new UsersResource(this);
+    this.webhooks = new WebhooksResource(this);
+    this.agents = new AgentsResource(this);
   }
   /**
    * Register an openapi-fetch middleware