@heymantle/core-api-client 0.1.27 → 0.2.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -26,6 +36,7 @@ __export(index_exports, {
   AffiliateReferralsResource: () => AffiliateReferralsResource,
   AffiliatesResource: () => AffiliatesResource,
   AgentsResource: () => AgentsResource,
+  AiAgentRunsResource: () => AiAgentRunsResource,
   AppsResource: () => AppsResource,
   BaseResource: () => BaseResource,
   ChannelsResource: () => ChannelsResource,
@@ -39,8 +50,12 @@ __export(index_exports, {
   DealFlowsResource: () => DealFlowsResource,
   DealsResource: () => DealsResource,
   DocsResource: () => DocsResource,
+  EmailUnsubscribeGroupsResource: () => EmailUnsubscribeGroupsResource,
   EntitiesResource: () => EntitiesResource,
+  FlowExtensionsResource: () => FlowExtensionsResource,
   FlowsResource: () => FlowsResource,
+  JournalEntriesResource: () => JournalEntriesResource,
+  ListsResource: () => ListsResource,
   MantleAPIError: () => MantleAPIError,
   MantleAuthenticationError: () => MantleAuthenticationError,
   MantleCoreClient: () => MantleCoreClient,
@@ -49,13 +64,14 @@ __export(index_exports, {
   MantleRateLimitError: () => MantleRateLimitError,
   MantleValidationError: () => MantleValidationError,
   MeResource: () => MeResource,
+  MeetingsResource: () => MeetingsResource,
   MetricsResource: () => MetricsResource,
-  MiddlewareManager: () => MiddlewareManager,
   OrganizationResource: () => OrganizationResource,
   SubscriptionsResource: () => SubscriptionsResource,
   SyncedEmailsResource: () => SyncedEmailsResource,
   TasksResource: () => TasksResource,
   TicketsResource: () => TicketsResource,
+  TimelineCommentsResource: () => TimelineCommentsResource,
   TransactionsResource: () => TransactionsResource,
   UsageEventsResource: () => UsageEventsResource,
   UsersResource: () => UsersResource,
@@ -65,136 +81,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/middleware/manager.ts
-var MiddlewareManager = class {
-  constructor() {
-    this.middlewares = [];
-  }
-  /**
-   * Register a middleware function
-   *
-   * @param middleware - The middleware function to register
-   * @param options - Optional configuration
-   * @returns this for chaining
-   */
-  use(middleware, options = {}) {
-    const registered = {
-      fn: middleware,
-      name: options.name ?? `middleware_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-      priority: options.priority ?? 100
-    };
-    this.middlewares.push(registered);
-    this.middlewares.sort((a, b) => a.priority - b.priority);
-    return this;
-  }
-  /**
-   * Remove a middleware by name
-   *
-   * @param name - The name of the middleware to remove
-   * @returns true if removed, false if not found
-   */
-  remove(name) {
-    const index = this.middlewares.findIndex((m) => m.name === name);
-    if (index !== -1) {
-      this.middlewares.splice(index, 1);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get all registered middleware names
-   */
-  list() {
-    return this.middlewares.map((m) => m.name);
-  }
-  /**
-   * Check if any middleware is registered
-   */
-  hasMiddleware() {
-    return this.middlewares.length > 0;
-  }
-  /**
-   * Execute the middleware chain with retry support
-   *
-   * @param ctx - The middleware context
-   * @param coreHandler - The core request handler to call at the end of the chain
-   * @returns The response from the core handler
-   */
-  async execute(ctx, coreHandler) {
-    const maxAttempts = ctx.maxRetries + 1;
-    let attempts = 0;
-    while (attempts < maxAttempts) {
-      ctx.retryCount = attempts;
-      ctx.retry = false;
-      ctx.error = void 0;
-      try {
-        await this.runChain(ctx, coreHandler);
-        if (!ctx.retry) {
-          return ctx.response;
-        }
-        attempts++;
-      } catch (error) {
-        if (!ctx.retry || attempts >= maxAttempts - 1) {
-          throw error;
-        }
-        attempts++;
-      }
-    }
-    throw ctx.error ?? new Error("Max retries exceeded");
-  }
-  /**
-   * Run the middleware chain (onion model)
-   */
-  async runChain(ctx, coreHandler) {
-    let index = -1;
-    const dispatch = async (i) => {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      if (i < this.middlewares.length) {
-        const middleware = this.middlewares[i];
-        await middleware.fn(ctx, () => dispatch(i + 1));
-      } else {
-        try {
-          ctx.response = await coreHandler();
-        } catch (error) {
-          ctx.error = error;
-          throw error;
-        }
-      }
-    };
-    await dispatch(0);
-  }
-};
-
-// src/utils/sanitize.ts
-function sanitizeObject(obj) {
-  if (!obj || typeof obj !== "object") {
-    return obj;
-  }
-  const sanitized = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value !== void 0) {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}
-function toQueryString(params) {
-  const sanitized = sanitizeObject(params);
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(sanitized)) {
-    if (Array.isArray(value)) {
-      if (value.length > 0) {
-        searchParams.append(key, value.map(String).join(","));
-      }
-    } else if (value !== null && value !== void 0) {
-      searchParams.append(key, String(value));
-    }
-  }
-  return searchParams.toString();
-}
+// src/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"));
 
 // src/utils/errors.ts
 var MantleAPIError = class _MantleAPIError extends Error {
@@ -251,218 +139,124 @@ var BaseResource = class {
   constructor(client) {
     this.client = client;
   }
-  get(endpoint, params) {
-    return this.client.get(endpoint, params);
+  get api() {
+    return this.client._api;
   }
-  post(endpoint, data) {
-    return this.client.post(endpoint, data);
+  /**
+   * Access the API client without path type-checking.
+   * Used for endpoints not yet in the OpenAPI spec.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get untypedApi() {
+    return this.client._api;
   }
-  put(endpoint, data) {
-    return this.client.put(endpoint, data);
+  /**
+   * Unwraps an openapi-fetch response, throwing typed errors on failure.
+   */
+  async unwrap(promise) {
+    const { data, error, response } = await promise;
+    if (error !== void 0) {
+      throw this.createError(response, error);
+    }
+    return data;
   }
-  _delete(endpoint) {
-    return this.client.delete(endpoint);
+  createError(response, error) {
+    const err = error;
+    const message = (typeof err?.error === "string" ? err.error : null) || `API request failed: ${response.status}`;
+    const details = typeof err?.details === "string" ? err.details : void 0;
+    switch (response.status) {
+      case 401:
+        return new MantleAuthenticationError(message);
+      case 403:
+        return new MantlePermissionError(message);
+      case 404:
+        return new MantleAPIError(message, 404, details);
+      case 422:
+        return new MantleValidationError(message, details);
+      case 429: {
+        const retryAfter = response.headers.get("Retry-After");
+        return new MantleRateLimitError(
+          message,
+          retryAfter ? parseInt(retryAfter, 10) : void 0
+        );
+      }
+      default:
+        return new MantleAPIError(message, response.status, details);
+    }
   }
 };
 
 // src/resources/customers.ts
 var CustomersResource = class extends BaseResource {
-  /**
-   * List customers with optional filters and pagination
-   */
   async list(params) {
-    const response = await this.get("/customers", params);
-    return {
-      customers: response.customers || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/customers", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single customer by ID
-   */
-  async retrieve(customerId, params) {
-    return this.get(
-      `/customers/${customerId}`,
-      params
-    );
+  async get(customerId) {
+    return this.unwrap(this.api.GET("/customers/{id}", { params: { path: { id: customerId } } }));
   }
-  /**
-   * Create a new customer
-   */
   async create(data) {
-    return this.post("/customers", data);
+    return this.unwrap(this.api.POST("/customers", { body: data }));
   }
-  /**
-   * Update an existing customer
-   */
   async update(customerId, data) {
-    return this.put(
-      `/customers/${customerId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/customers/{id}", { params: { path: { id: customerId } }, body: data }));
   }
-  /**
-   * Add tags to a customer
-   */
   async addTags(customerId, tags) {
-    return this.post(
-      `/customers/${customerId}/addTags`,
-      { tags }
-    );
+    return this.unwrap(this.api.POST("/customers/{id}/addTags", { params: { path: { id: customerId } }, body: { tags } }));
   }
-  /**
-   * Remove tags from a customer
-   */
   async removeTags(customerId, tags) {
-    return this.post(
-      `/customers/${customerId}/removeTags`,
-      { tags }
-    );
+    return this.unwrap(this.api.POST("/customers/{id}/removeTags", { params: { path: { id: customerId } }, body: { tags } }));
   }
-  /**
-   * Get customer activity timeline
-   */
   async getTimeline(customerId, params) {
-    const response = await this.get(
-      `/customers/${customerId}/timeline`,
-      { limit: 25, ...params }
-    );
-    return {
-      events: response.events || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/customers/{id}/timeline", { params: { path: { id: customerId }, query: params } }));
   }
-  /**
-   * List account owners for a customer
-   */
   async listAccountOwners(customerId) {
-    return this.get(
-      `/customers/${customerId}/account_owners`
-    );
+    return this.unwrap(this.api.GET("/customers/{id}/account_owners", { params: { path: { id: customerId } } }));
   }
-  /**
-   * Add an account owner to a customer
-   */
   async addAccountOwner(customerId, data) {
-    return this.post(`/customers/${customerId}/account_owners`, data);
+    return this.unwrap(this.api.POST("/customers/{id}/account_owners", { params: { path: { id: customerId } }, body: data }));
   }
-  /**
-   * Remove an account owner from a customer
-   */
   async removeAccountOwner(customerId, ownerId) {
-    return this._delete(
-      `/customers/${customerId}/account_owners/${ownerId}`
-    );
+    return this.unwrap(this.api.DELETE("/customers/{id}/account_owners/{ownerId}", { params: { path: { id: customerId, ownerId } } }));
   }
-  /**
-   * List custom fields
-   */
   async listCustomFields(params) {
-    return this.get(
-      "/customers/custom_fields",
-      params
-    );
+    return this.unwrap(this.api.GET("/customers/custom_fields", { params: { query: params } }));
   }
-  /**
-   * Create a custom field
-   */
   async createCustomField(data) {
-    return this.post(
-      "/customers/custom_fields",
-      data
-    );
+    return this.unwrap(this.api.POST("/customers/custom_fields", { body: data }));
   }
-  /**
-   * Retrieve a custom field by ID
-   */
-  async retrieveCustomField(fieldId) {
-    return this.get(
-      `/customers/custom_fields/${fieldId}`
-    );
+  async getCustomField(fieldId) {
+    return this.unwrap(this.api.GET("/customers/custom_fields/{id}", { params: { path: { id: fieldId } } }));
   }
-  /**
-   * Update a custom field
-   */
   async updateCustomField(fieldId, data) {
-    return this.put(
-      `/customers/custom_fields/${fieldId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/customers/custom_fields/{id}", { params: { path: { id: fieldId } }, body: data }));
   }
-  /**
-   * Delete a custom field
-   */
   async deleteCustomField(fieldId) {
-    return this._delete(
-      `/customers/custom_fields/${fieldId}`
-    );
+    return this.unwrap(this.api.DELETE("/customers/custom_fields/{id}", { params: { path: { id: fieldId } } }));
   }
 };
 
 // src/resources/contacts.ts
 var ContactsResource = class extends BaseResource {
-  /**
-   * List contacts with optional filters and pagination
-   */
   async list(params) {
-    const response = await this.get("/contacts", params);
-    return {
-      contacts: response.contacts || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/contacts", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single contact by ID
-   */
-  async retrieve(contactId) {
-    return this.get(`/contacts/${contactId}`);
+  async get(contactId) {
+    return this.unwrap(this.api.GET("/contacts/{id}", { params: { path: { id: contactId } } }));
   }
-  /**
-   * Create or update a contact.
-   * If a contact with the same email exists in the organization, it will be updated.
-   * Otherwise, a new contact will be created.
-   * @returns The contact and a boolean indicating if it was newly created
-   */
   async create(data) {
-    return this.post("/contacts", data);
+    return this.unwrap(this.api.POST("/contacts", { body: data }));
   }
-  /**
-   * Update an existing contact
-   */
   async update(contactId, data) {
-    return this.put(`/contacts/${contactId}`, data);
+    return this.unwrap(this.api.PUT("/contacts/{id}", { params: { path: { id: contactId } }, body: data }));
   }
-  /**
-   * Delete a contact
-   */
   async del(contactId) {
-    return this._delete(`/contacts/${contactId}`);
+    return this.unwrap(this.api.DELETE("/contacts/{id}", { params: { path: { id: contactId } } }));
   }
-  /**
-   * Add tags to a contact
-   */
   async addTags(contactId, tags) {
-    return this.post(
-      `/contacts/${contactId}/addTags`,
-      { tags }
-    );
+    return this.unwrap(this.api.POST("/contacts/{id}/addTags", { params: { path: { id: contactId } }, body: { tags } }));
   }
-  /**
-   * Remove tags from a contact
-   */
   async removeTags(contactId, tags) {
-    return this.post(
-      `/contacts/${contactId}/removeTags`,
-      { tags }
-    );
+    return this.unwrap(this.api.POST("/contacts/{id}/removeTags", { params: { path: { id: contactId } }, body: { tags } }));
   }
 };
 
@@ -472,25 +266,13 @@ var SubscriptionsResource = class extends BaseResource {
    * List subscriptions with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/subscriptions",
-      params
-    );
-    return {
-      subscriptions: response.subscriptions || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/subscriptions", { params: { query: params } }));
   }
   /**
-   * Retrieve a single subscription by ID
+   * Get a single subscription by ID
    */
-  async retrieve(subscriptionId) {
-    return this.get(
-      `/subscriptions/${subscriptionId}`
-    );
+  async get(subscriptionId) {
+    return this.unwrap(this.api.GET("/subscriptions/{id}", { params: { path: { id: subscriptionId } } }));
   }
 };
 
@@ -500,18 +282,7 @@ var UsageEventsResource = class extends BaseResource {
    * List usage events with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/usage_events",
-      params
-    );
-    return {
-      usageEvents: response.usageEvents || response.events || [],
-      events: response.events,
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/usage_events", { params: { query: params } }));
   }
   /**
    * Create usage event(s)
@@ -535,549 +306,212 @@ var UsageEventsResource = class extends BaseResource {
    * });
    */
   async create(data) {
-    return this.post("/usage_events", data);
+    return this.unwrap(this.api.POST("/usage_events", { body: data }));
   }
 };
 
 // src/resources/apps.ts
 var AppsResource = class extends BaseResource {
-  /**
-   * List all apps
-   */
+  // Apps
   async list(params) {
-    return this.get("/apps", params);
+    return this.unwrap(this.api.GET("/apps", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single app by ID
-   */
-  async retrieve(appId) {
-    return this.get(`/apps/${appId}`);
+  async get(appId) {
+    return this.unwrap(this.api.GET("/apps/{id}", { params: { path: { id: appId } } }));
   }
-  // ========== Plans ==========
-  /**
-   * List plans for an app
-   */
+  // Plans
   async listPlans(appId, params) {
-    return this.get(`/apps/${appId}/plans`, params);
+    return this.unwrap(this.api.GET("/apps/{id}/plans", { params: { path: { id: appId }, query: params } }));
   }
-  /**
-   * Retrieve a single plan
-   */
-  async retrievePlan(appId, planId) {
-    return this.get(`/apps/${appId}/plans/${planId}`);
+  async getPlan(appId, planId) {
+    return this.unwrap(this.api.GET("/apps/{id}/plans/{planId}", { params: { path: { id: appId, planId } } }));
   }
-  /**
-   * Create a new plan for an app
-   */
   async createPlan(appId, data) {
-    return this.post(`/apps/${appId}/plans`, data);
+    return this.unwrap(this.api.POST("/apps/{id}/plans", { params: { path: { id: appId } }, body: data }));
   }
-  /**
-   * Update an existing plan
-   */
   async updatePlan(appId, planId, data) {
-    return this.put(`/apps/${appId}/plans/${planId}`, data);
+    return this.unwrap(this.api.PUT("/apps/{id}/plans/{planId}", { params: { path: { id: appId, planId } }, body: data }));
   }
-  /**
-   * Archive a plan
-   */
   async archivePlan(appId, planId) {
-    return this.post(
-      `/apps/${appId}/plans/${planId}/archive`,
-      {}
-    );
+    return this.unwrap(this.api.PUT("/apps/{id}/plans/{planId}/archive", { params: { path: { id: appId, planId } } }));
   }
-  /**
-   * Unarchive a plan
-   */
   async unarchivePlan(appId, planId) {
-    return this.post(
-      `/apps/${appId}/plans/${planId}/unarchive`,
-      {}
-    );
+    return this.unwrap(this.api.PUT("/apps/{id}/plans/{planId}/unarchive", { params: { path: { id: appId, planId } } }));
   }
-  // ========== Features ==========
-  /**
-   * List features for an app
-   */
+  // Features
   async listFeatures(appId) {
-    return this.get(`/apps/${appId}/plans/features`);
+    return this.unwrap(this.api.GET("/apps/{appId}/plans/features", { params: { path: { appId } } }));
   }
-  /**
-   * Retrieve a single feature
-   */
-  async retrieveFeature(appId, featureId) {
-    return this.get(
-      `/apps/${appId}/plans/features/${featureId}`
-    );
+  async getFeature(appId, featureId) {
+    return this.unwrap(this.api.GET("/apps/{appId}/plans/features/{featureId}", { params: { path: { appId, featureId } } }));
   }
-  /**
-   * Create a new feature for an app
-   */
   async createFeature(appId, data) {
-    return this.post(
-      `/apps/${appId}/plans/features`,
-      data
-    );
+    return this.unwrap(this.api.POST("/apps/{appId}/plans/features", { params: { path: { appId } }, body: data }));
   }
-  /**
-   * Update an existing feature
-   */
   async updateFeature(appId, featureId, data) {
-    return this.put(
-      `/apps/${appId}/plans/features/${featureId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/apps/{appId}/plans/features/{featureId}", { params: { path: { appId, featureId } }, body: data }));
   }
-  /**
-   * Delete a feature
-   */
   async deleteFeature(appId, featureId) {
-    return this._delete(
-      `/apps/${appId}/plans/features/${featureId}`
-    );
+    return this.unwrap(this.api.DELETE("/apps/{appId}/plans/features/{featureId}", { params: { path: { appId, featureId } } }));
   }
-  // ========== Reviews ==========
-  /**
-   * List reviews for an app
-   */
+  // Reviews
   async listReviews(appId) {
-    return this.get(`/apps/${appId}/reviews`);
-  }
-  /**
-   * Retrieve a single review
-   */
-  async retrieveReview(appId, reviewId) {
-    return this.get(`/apps/${appId}/reviews/${reviewId}`);
-  }
-  /**
-   * Create a new review for an app
-   */
-  async createReview(appId, data) {
-    return this.post(`/apps/${appId}/reviews`, data);
-  }
-  /**
-   * Update an existing review
-   */
-  async updateReview(appId, reviewId, data) {
-    return this.put(
-      `/apps/${appId}/reviews/${reviewId}`,
-      data
-    );
-  }
-  /**
-   * Delete a review
-   */
-  async deleteReview(appId, reviewId) {
-    return this._delete(`/apps/${appId}/reviews/${reviewId}`);
+    return this.unwrap(this.api.GET("/apps/{id}/reviews", { params: { path: { id: appId } } }));
   }
-  // ========== Usage Event Metadata ==========
-  /**
-   * Get usage event names for an app
-   */
-  async listEventNames(appId) {
-    return this.get(
-      `/apps/${appId}/usage_events/event_names`
-    );
-  }
-  /**
-   * Get property keys for a specific event name
-   */
-  async listPropertyKeys(appId, eventName) {
-    return this.get(
-      `/apps/${appId}/usage_events/property_keys`,
-      { eventName }
-    );
+  async getReview(appId, reviewId) {
+    return this.unwrap(this.api.GET("/apps/{id}/reviews/{reviewId}", { params: { path: { id: appId, reviewId } } }));
   }
-  // ========== Usage Metrics ==========
-  /**
-   * List usage metrics for an app
-   */
+  // Usage Metrics
   async listUsageMetrics(appId) {
-    return this.get(
-      `/apps/${appId}/usage_metrics`
-    );
+    return this.unwrap(this.api.GET("/apps/{id}/usage_metrics", { params: { path: { id: appId } } }));
   }
-  /**
-   * Retrieve a single usage metric
-   */
-  async retrieveUsageMetric(appId, usageMetricId) {
-    return this.get(
-      `/apps/${appId}/usage_metrics/${usageMetricId}`
-    );
+  async getUsageMetric(appId, usageMetricId) {
+    return this.unwrap(this.api.GET("/apps/{id}/usage_metrics/{usageMetricId}", { params: { path: { id: appId, usageMetricId } } }));
   }
-  /**
-   * Create a new usage metric for an app
-   */
   async createUsageMetric(appId, data) {
-    return this.post(
-      `/apps/${appId}/usage_metrics`,
-      data
-    );
+    return this.unwrap(this.api.POST("/apps/{id}/usage_metrics", { params: { path: { id: appId } }, body: data }));
   }
-  /**
-   * Update an existing usage metric
-   */
   async updateUsageMetric(appId, usageMetricId, data) {
-    return this.put(
-      `/apps/${appId}/usage_metrics/${usageMetricId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/apps/{id}/usage_metrics/{usageMetricId}", { params: { path: { id: appId, usageMetricId } }, body: data }));
   }
-  /**
-   * Delete a usage metric
-   */
   async deleteUsageMetric(appId, usageMetricId) {
-    return this._delete(
-      `/apps/${appId}/usage_metrics/${usageMetricId}`
-    );
+    return this.unwrap(this.api.DELETE("/apps/{id}/usage_metrics/{usageMetricId}", { params: { path: { id: appId, usageMetricId } } }));
   }
-  // ========== App Events ==========
-  /**
-   * List app events
-   */
+  // App Events
   async listAppEvents(appId, params) {
-    const response = await this.get(
-      `/apps/${appId}/app_events`,
-      params
-    );
-    return {
-      appEvents: response.appEvents || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/apps/{id}/app_events", { params: { path: { id: appId }, query: params } }));
+  }
+  async getAppEvent(appId, appEventId) {
+    return this.unwrap(this.api.GET("/apps/{id}/app_events/{appEventId}", { params: { path: { id: appId, appEventId } } }));
+  }
+  async createAppEvent(appId, data) {
+    return this.unwrap(this.api.POST("/apps/{id}/app_events", { params: { path: { id: appId } }, body: data }));
   }
 };
 
 // src/resources/deals.ts
 var DealsResource = class extends BaseResource {
-  /**
-   * List deals with optional filters and pagination
-   */
   async list(params) {
-    const response = await this.get("/deals", params);
-    return {
-      deals: response.deals || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/deals", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single deal by ID
-   */
-  async retrieve(dealId) {
-    return this.get(`/deals/${dealId}`);
+  async get(dealId) {
+    return this.unwrap(this.api.GET("/deals/{id}", { params: { path: { id: dealId } } }));
   }
-  /**
-   * Create a new deal
-   *
-   * **Linking a Customer:**
-   * There are three ways to associate a customer with a deal (use only one):
-   *
-   * 1. `customerId` - Link to an existing customer by ID
-   * 2. `customer` - Create or update a customer inline. Matches existing customers
-   *    by `domain` or `shopifyDomain`. If no match, creates a new customer.
-   * 3. `domain` and/or `shopifyDomain` - Find an existing customer by domain,
-   *    or create a minimal customer record if not found.
-   *
-   * If `domain` or `shopifyDomain` are provided alongside `customerId` or `customer`,
-   * they will be used to update the customer's domain fields only if not already set.
-   *
-   * **Linking Contacts:**
-   * There are two ways to associate contacts with a deal (use only one):
-   *
-   * 1. `contactIds` - Link to existing contacts by their IDs
-   * 2. `contacts` - Create or update contacts inline. Matches existing contacts
-   *    by email. Contacts are automatically linked to both the customer and the deal.
-   *
-   * @example
-   * // Using an existing customer
-   * await client.deals.create({ name: 'Deal', customerId: 'cust_123', dealFlowId: '...', dealStageId: '...' });
-   *
-   * // Creating a customer inline
-   * await client.deals.create({
-   *   name: 'Deal',
-   *   customer: { name: 'Acme Corp', domain: 'acme.com', email: 'info@acme.com' },
-   *   contacts: [{ email: 'john@acme.com', name: 'John Doe', jobTitle: 'CEO' }],
-   *   dealFlowId: '...',
-   *   dealStageId: '...',
-   * });
-   *
-   * // Using domain to find/create customer
-   * await client.deals.create({ name: 'Deal', shopifyDomain: 'acme.myshopify.com', dealFlowId: '...', dealStageId: '...' });
-   */
   async create(data) {
-    return this.post("/deals", data);
+    return this.unwrap(this.api.POST("/deals", { body: data }));
   }
-  /**
-   * Update an existing deal
-   *
-   * **Updating Customer Association:**
-   * There are three ways to change or update the customer (use only one):
-   *
-   * 1. `customerId` - Change to a different existing customer
-   * 2. `customer` - Update the linked customer inline, or create/link a new one.
-   *    Matches existing customers by `domain` or `shopifyDomain`.
-   * 3. `domain` and/or `shopifyDomain` - Find a different customer by domain,
-   *    or create a minimal customer record if not found.
-   *
-   * If `domain` or `shopifyDomain` are provided alongside `customerId` or `customer`,
-   * they will be used to update the customer's domain fields only if not already set.
-   *
-   * **Updating Contacts:**
-   * There are two ways to update contacts (use only one):
-   *
-   * 1. `contactIds` - Replace deal contacts with the specified contact IDs
-   * 2. `contacts` - Create or update contacts inline. Matches existing contacts
-   *    by email. Contacts are automatically linked to both the customer and the deal.
-   *
-   * @example
-   * // Update customer's domain if not set
-   * await client.deals.update('deal_123', { customerId: 'cust_456', domain: 'newdomain.com' });
-   *
-   * // Update customer and contacts inline
-   * await client.deals.update('deal_123', {
-   *   customer: { name: 'Updated Name', domain: 'acme.com' },
-   *   contacts: [{ email: 'new@acme.com', name: 'New Contact' }],
-   * });
-   */
   async update(dealId, data) {
-    return this.put(`/deals/${dealId}`, data);
+    return this.unwrap(this.api.PUT("/deals/{id}", { params: { path: { id: dealId } }, body: data }));
   }
-  /**
-   * Archive (soft delete) a deal
-   */
   async del(dealId) {
-    return this._delete(`/deals/${dealId}`);
+    return this.unwrap(this.api.DELETE("/deals/{id}", { params: { path: { id: dealId } } }));
   }
-  /**
-   * Get deal activity timeline
-   */
   async timeline(dealId) {
-    const response = await this.get(
-      `/deals/${dealId}/timeline`
-    );
-    return {
-      events: response.events || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/deals/{id}/timeline", { params: { path: { id: dealId } } }));
   }
-  /**
-   * List deal events
-   */
   async listEvents(dealId) {
-    const response = await this.get(
-      `/deals/${dealId}/events`
-    );
-    return {
-      events: response.events || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/deals/{id}/events", { params: { path: { id: dealId } } }));
   }
-  /**
-   * Create a deal event
-   *
-   * Creates an event on a deal. If `dealStageId` is provided, the deal will
-   * progress to that stage. If `dealActivityId` is provided and the activity
-   * is configured for a future stage, the deal will automatically progress.
-   *
-   * @example
-   * // Create a simple note
-   * await client.deals.createEvent('deal_123', { notes: 'Follow-up call completed' });
-   *
-   * // Create an event and progress to a new stage
-   * await client.deals.createEvent('deal_123', {
-   *   dealStageId: 'stage_456',
-   *   notes: 'Moving to negotiation phase',
-   * });
-   */
   async createEvent(dealId, data) {
-    return this.post(`/deals/${dealId}/events`, data);
+    return this.unwrap(this.api.POST("/deals/{id}/events", { params: { path: { id: dealId } }, body: data }));
   }
 };
 
 // src/resources/deal-flows.ts
 var DealFlowsResource = class extends BaseResource {
-  /**
-   * List all deal flows
-   */
-  async list() {
-    return this.get("/deal_flows");
+  async list(params) {
+    return this.unwrap(this.api.GET("/deal_flows", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single deal flow by ID
-   */
-  async retrieve(dealFlowId) {
-    return this.get(`/deal_flows/${dealFlowId}`);
+  async get(dealFlowId) {
+    return this.unwrap(this.api.GET("/deal_flows/{id}", { params: { path: { id: dealFlowId } } }));
   }
-  /**
-   * Create a new deal flow
-   */
   async create(data) {
-    return this.post("/deal_flows", data);
+    return this.unwrap(this.api.POST("/deal_flows", { body: data }));
   }
-  /**
-   * Update an existing deal flow
-   */
   async update(dealFlowId, data) {
-    return this.put(
-      `/deal_flows/${dealFlowId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/deal_flows/{id}", { params: { path: { id: dealFlowId } }, body: data }));
   }
-  /**
-   * Delete a deal flow
-   */
   async del(dealFlowId) {
-    return this._delete(`/deal_flows/${dealFlowId}`);
+    return this.unwrap(this.api.DELETE("/deal_flows/{id}", { params: { path: { id: dealFlowId } } }));
   }
 };
 
 // src/resources/deal-activities.ts
 var DealActivitiesResource = class extends BaseResource {
-  /**
-   * List all deal activities
-   */
-  async list() {
-    return this.get("/deal_activities");
+  async list(params) {
+    return this.unwrap(this.api.GET("/deal_activities", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single deal activity by ID
-   */
-  async retrieve(dealActivityId) {
-    return this.get(
-      `/deal_activities/${dealActivityId}`
-    );
+  async get(dealActivityId) {
+    return this.unwrap(this.api.GET("/deal_activities/{id}", { params: { path: { id: dealActivityId } } }));
   }
-  /**
-   * Create a new deal activity
-   */
   async create(data) {
-    return this.post("/deal_activities", data);
+    return this.unwrap(this.api.POST("/deal_activities", { body: data }));
   }
-  /**
-   * Update an existing deal activity
-   */
   async update(dealActivityId, data) {
-    return this.put(
-      `/deal_activities/${dealActivityId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/deal_activities/{id}", { params: { path: { id: dealActivityId } }, body: data }));
   }
-  /**
-   * Delete a deal activity
-   */
   async del(dealActivityId) {
-    return this._delete(`/deal_activities/${dealActivityId}`);
+    return this.unwrap(this.api.DELETE("/deal_activities/{id}", { params: { path: { id: dealActivityId } } }));
   }
 };
 
 // src/resources/tickets.ts
 var TicketsResource = class extends BaseResource {
-  /**
-   * List tickets with optional filters and pagination
-   */
+  // Tickets
   async list(params) {
-    const response = await this.get("/tickets", params);
-    return {
-      tickets: response.tickets || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/tickets", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single ticket by ID
-   */
-  async retrieve(ticketId) {
-    return this.get(`/tickets/${ticketId}`);
+  async get(ticketId) {
+    return this.unwrap(this.api.GET("/tickets/{id}", { params: { path: { id: ticketId } } }));
   }
-  /**
-   * Create a new ticket
-   */
   async create(data) {
-    return this.post("/tickets", data);
+    return this.unwrap(this.api.POST("/tickets", { body: data }));
   }
-  /**
-   * Update an existing ticket
-   */
   async update(ticketId, data) {
-    return this.put(`/tickets/${ticketId}`, data);
-  }
-  /**
-   * Delete a ticket
-   */
-  async del(ticketId) {
-    return this._delete(`/tickets/${ticketId}`);
+    return this.unwrap(this.api.PUT("/tickets/{id}", { params: { path: { id: ticketId } }, body: data }));
   }
-  // ========== Messages ==========
-  /**
-   * List messages for a ticket
-   */
-  async listMessages(ticketId) {
-    return this.get(
-      `/tickets/${ticketId}/messages`
-    );
+  // Messages
+  async listMessages(ticketId, params) {
+    return this.unwrap(this.api.GET("/tickets/{id}/messages", { params: { path: { id: ticketId }, query: params } }));
   }
-  /**
-   * Retrieve a single message
-   */
-  async retrieveMessage(ticketId, messageId) {
-    return this.get(
-      `/tickets/${ticketId}/messages/${messageId}`
-    );
+  async getMessage(ticketId, messageId) {
+    return this.unwrap(this.api.GET("/tickets/{id}/messages/{messageId}", { params: { path: { id: ticketId, messageId } } }));
   }
-  /**
-   * Create a new message on a ticket
-   */
   async createMessage(ticketId, data) {
-    return this.post(
-      `/tickets/${ticketId}/messages`,
-      data
-    );
+    return this.unwrap(this.api.POST("/tickets/{id}/messages", { params: { path: { id: ticketId } }, body: data }));
   }
-  /**
-   * Update a message
-   */
-  async updateMessage(ticketId, messageId, data) {
-    return this.put(
-      `/tickets/${ticketId}/messages/${messageId}`,
-      data
-    );
+  async updateMessage(ticketId, data) {
+    return this.unwrap(this.api.PUT("/tickets/{id}/messages", { params: { path: { id: ticketId } }, body: data }));
   }
-  /**
-   * Delete a message
-   */
-  async deleteMessage(ticketId, messageId) {
-    return this._delete(
-      `/tickets/${ticketId}/messages/${messageId}`
-    );
+  // Events
+  async listEvents(ticketId, params) {
+    return this.unwrap(this.api.GET("/tickets/{id}/events", { params: { path: { id: ticketId }, query: params } }));
+  }
+  async createEvent(ticketId, data) {
+    return this.unwrap(this.api.POST("/tickets/{id}/events", { params: { path: { id: ticketId } }, body: data }));
+  }
+  // Loops
+  async listLoops(ticketId) {
+    return this.unwrap(this.api.GET("/tickets/{id}/loops", { params: { path: { id: ticketId } } }));
+  }
+  async getLoop(ticketId, loopId) {
+    return this.unwrap(this.api.GET("/tickets/{id}/loops/{loopId}", { params: { path: { id: ticketId, loopId } } }));
   }
 };
 
 // src/resources/channels.ts
 var ChannelsResource = class extends BaseResource {
   /**
-   * List CX channels
+   * List CX channels with optional filters
    */
   async list(params) {
-    return this.get("/channels", params);
+    return this.unwrap(this.api.GET("/channels", { params: { query: params } }));
   }
   /**
    * Create a new CX channel
    */
   async create(data) {
-    return this.post("/channels", data);
+    return this.unwrap(this.api.POST("/channels", { body: data }));
   }
 };
 
@@ -1087,113 +521,67 @@ var FlowsResource = class extends BaseResource {
    * List flows with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get("/flows", params);
-    return {
-      flows: response.flows || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/flows", { params: { query: params } }));
   }
   /**
-   * Retrieve a single flow by ID
+   * Get a single flow by ID
    */
-  async retrieve(flowId) {
-    return this.get(`/flows/${flowId}`);
+  async get(flowId) {
+    return this.unwrap(this.api.GET("/flows/{id}", { params: { path: { id: flowId } } }));
   }
   /**
    * Create a new flow
    */
   async create(data) {
-    return this.post("/flows", data);
+    return this.unwrap(this.api.POST("/flows", { body: data }));
   }
   /**
    * Update an existing flow
    */
   async update(flowId, data) {
-    return this.put(`/flows/${flowId}`, data);
+    return this.unwrap(this.api.PATCH("/flows/{id}", { params: { path: { id: flowId } }, body: data }));
   }
   /**
    * Delete a flow
    */
   async del(flowId) {
-    return this._delete(`/flows/${flowId}`);
+    return this.unwrap(this.api.DELETE("/flows/{id}", { params: { path: { id: flowId } } }));
   }
 };
 
 // src/resources/tasks.ts
 var TasksResource = class extends BaseResource {
-  /**
-   * List tasks with optional filters and pagination
-   */
+  // Tasks
   async list(params) {
-    const response = await this.get("/tasks", params);
-    return {
-      tasks: response.tasks || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/tasks", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single task by ID
-   */
-  async retrieve(taskId) {
-    return this.get(`/tasks/${taskId}`);
+  async get(taskId) {
+    return this.unwrap(this.api.GET("/tasks/{id}", { params: { path: { id: taskId } } }));
   }
-  /**
-   * Create a new task
-   */
   async create(data) {
-    return this.post("/tasks", data);
+    return this.unwrap(this.api.POST("/tasks", { body: data }));
   }
-  /**
-   * Update an existing task
-   */
   async update(taskId, data) {
-    return this.put(`/tasks/${taskId}`, data);
+    return this.unwrap(this.api.PUT("/tasks/{id}", { params: { path: { id: taskId } }, body: data }));
   }
-  /**
-   * Delete a task
-   */
   async del(taskId) {
-    return this._delete(`/tasks/${taskId}`);
+    return this.unwrap(this.api.DELETE("/tasks/{id}", { params: { path: { id: taskId } } }));
   }
-  // ========== Todo Items ==========
-  /**
-   * List todo items for a task
-   */
+  // Todo Items
   async listTodoItems(taskId) {
-    return this.get(`/tasks/${taskId}/todo-items`);
+    return this.unwrap(this.api.GET("/tasks/{id}/todo-items", { params: { path: { id: taskId } } }));
   }
-  /**
-   * Retrieve a single todo item
-   */
-  async retrieveTodoItem(taskId, itemId) {
-    return this.get(`/tasks/${taskId}/todo-items/${itemId}`);
+  async getTodoItem(taskId, itemId) {
+    return this.unwrap(this.api.GET("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } } }));
   }
-  /**
-   * Create a todo item for a task
-   */
   async createTodoItem(taskId, data) {
-    return this.post(`/tasks/${taskId}/todo-items`, data);
+    return this.unwrap(this.api.POST("/tasks/{id}/todo-items", { params: { path: { id: taskId } }, body: data }));
   }
-  /**
-   * Update a todo item
-   */
   async updateTodoItem(taskId, itemId, data) {
-    return this.put(
-      `/tasks/${taskId}/todo-items/${itemId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } }, body: data }));
   }
-  /**
-   * Delete a todo item
-   */
   async deleteTodoItem(taskId, itemId) {
-    return this._delete(`/tasks/${taskId}/todo-items/${itemId}`);
+    return this.unwrap(this.api.DELETE("/tasks/{id}/todo-items/{itemId}", { params: { path: { id: taskId, itemId } } }));
   }
 };
 
@@ -1203,36 +591,25 @@ var WebhooksResource = class extends BaseResource {
    * List all webhooks
    */
   async list() {
-    const response = await this.get("/webhooks");
-    return {
-      webhooks: response.webhooks || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false
-    };
-  }
-  /**
-   * Retrieve a single webhook by ID
-   */
-  async retrieve(webhookId) {
-    return this.get(`/webhooks/${webhookId}`);
+    return this.unwrap(this.api.GET("/webhooks"));
   }
   /**
    * Create a new webhook
    */
   async create(data) {
-    return this.post("/webhooks", data);
+    return this.unwrap(this.api.POST("/webhooks", { body: data }));
   }
   /**
    * Update an existing webhook
    */
   async update(webhookId, data) {
-    return this.put(`/webhooks/${webhookId}`, data);
+    return this.unwrap(this.api.PUT("/webhooks/{id}", { params: { path: { id: webhookId } }, body: data }));
   }
   /**
    * Delete a webhook
    */
   async del(webhookId) {
-    return this._delete(`/webhooks/${webhookId}`);
+    return this.unwrap(this.api.DELETE("/webhooks/{id}", { params: { path: { id: webhookId } } }));
   }
 };
 
@@ -1242,37 +619,31 @@ var CompaniesResource = class extends BaseResource {
    * List companies with optional pagination
    */
   async list(params) {
-    const response = await this.get("/companies", params);
-    return {
-      companies: response.companies || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/companies", { params: { query: params } }));
   }
   /**
-   * Retrieve a single company by ID
+   * Get a single company by ID
    */
-  async retrieve(companyId) {
-    return this.get(`/companies/${companyId}`);
+  async get(companyId) {
+    return this.unwrap(this.api.GET("/companies/{id}", { params: { path: { id: companyId } } }));
   }
   /**
    * Create a new company
    */
   async create(data) {
-    return this.post("/companies", data);
+    return this.unwrap(this.api.POST("/companies", { body: data }));
   }
   /**
    * Update an existing company
    */
   async update(companyId, data) {
-    return this.put(`/companies/${companyId}`, data);
+    return this.unwrap(this.api.PUT("/companies/{id}", { params: { path: { id: companyId } }, body: data }));
   }
   /**
    * Delete a company
    */
   async del(companyId) {
-    return this._delete(`/companies/${companyId}`);
+    return this.unwrap(this.api.DELETE("/companies/{id}", { params: { path: { id: companyId } } }));
   }
 };
 
@@ -1282,24 +653,13 @@ var CustomerSegmentsResource = class extends BaseResource {
    * List public customer segments with optional pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/customer_segments",
-      params
-    );
-    return {
-      customerSegments: response.customerSegments || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/customer_segments", { params: { query: params } }));
   }
   /**
-   * Retrieve a single customer segment by ID
+   * Get a single customer segment by ID
    */
-  async retrieve(segmentId) {
-    return this.get(
-      `/customer_segments/${segmentId}`
-    );
+  async get(segmentId) {
+    return this.unwrap(this.api.GET("/customer_segments/{id}", { params: { path: { id: segmentId } } }));
   }
 };
 
@@ -1309,75 +669,57 @@ var AffiliatesResource = class extends BaseResource {
    * List affiliates with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/affiliates",
-      params
-    );
-    return {
-      affiliates: response.affiliates || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/affiliates", { params: { query: params } }));
   }
   /**
-   * Retrieve a single affiliate by ID
+   * Get a single affiliate by ID
    */
-  async retrieve(affiliateId) {
-    return this.get(`/affiliates/${affiliateId}`);
+  async get(affiliateId) {
+    return this.unwrap(this.api.GET("/affiliates/{id}", { params: { path: { id: affiliateId } } }));
   }
   /**
    * Update an existing affiliate
+   * Note: PUT not in OpenAPI spec but kept for backwards compatibility
    */
   async update(affiliateId, data) {
-    return this.put(
-      `/affiliates/${affiliateId}`,
-      data
-    );
+    return this.unwrap(this.untypedApi.PUT("/affiliates/{id}", { params: { path: { id: affiliateId } }, body: data }));
   }
 };
 
 // src/resources/affiliate-programs.ts
 var AffiliateProgramsResource = class extends BaseResource {
   /**
-   * List all affiliate programs
+   * List affiliate programs with optional filters and pagination
    */
-  async list() {
-    return this.get(
-      "/affiliate_programs"
-    );
+  async list(params) {
+    return this.unwrap(this.api.GET("/affiliate_programs", { params: { query: params } }));
   }
   /**
-   * Retrieve a single affiliate program by ID
+   * Get a single affiliate program by ID
    */
-  async retrieve(programId) {
-    return this.get(
-      `/affiliate_programs/${programId}`
-    );
+  async get(programId) {
+    return this.unwrap(this.api.GET("/affiliate_programs/{id}", { params: { path: { id: programId } } }));
   }
   /**
    * Create a new affiliate program
+   * Note: POST not yet in OpenAPI spec
    */
   async create(data) {
-    return this.post(
-      "/affiliate_programs",
-      data
-    );
+    return this.unwrap(this.untypedApi.POST("/affiliate_programs", { body: data }));
   }
   /**
    * Update an existing affiliate program
+   * Note: PUT not yet in OpenAPI spec
    */
   async update(programId, data) {
-    return this.put(
-      `/affiliate_programs/${programId}`,
-      data
-    );
+    return this.unwrap(this.untypedApi.PUT("/affiliate_programs/{id}", { params: { path: { id: programId } }, body: data }));
   }
   /**
    * Delete an affiliate program
+   * Note: DELETE not yet in OpenAPI spec
    */
   async del(programId) {
-    return this._delete(`/affiliate_programs/${programId}`);
+    return this.unwrap(this.untypedApi.DELETE("/affiliate_programs/{id}", { params: { path: { id: programId } } }));
   }
 };
 
@@ -1387,24 +729,13 @@ var AffiliateCommissionsResource = class extends BaseResource {
    * List affiliate commissions with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/affiliate_commissions",
-      params
-    );
-    return {
-      commissions: response.commissions || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/affiliate_commissions", { params: { query: params } }));
   }
   /**
-   * Retrieve a single affiliate commission by ID
+   * Get a single affiliate commission by ID
    */
-  async retrieve(commissionId) {
-    return this.get(
-      `/affiliate_commissions/${commissionId}`
-    );
+  async get(commissionId) {
+    return this.unwrap(this.api.GET("/affiliate_commissions/{id}", { params: { path: { id: commissionId } } }));
   }
 };
 
@@ -1414,24 +745,13 @@ var AffiliatePayoutsResource = class extends BaseResource {
    * List affiliate payouts with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/affiliate_payouts",
-      params
-    );
-    return {
-      payouts: response.payouts || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/affiliate_payouts", { params: { query: params } }));
   }
   /**
-   * Retrieve a single affiliate payout by ID
+   * Get a single affiliate payout by ID
    */
-  async retrieve(payoutId) {
-    return this.get(
-      `/affiliate_payouts/${payoutId}`
-    );
+  async get(payoutId) {
+    return this.unwrap(this.api.GET("/affiliate_payouts/{id}", { params: { path: { id: payoutId } } }));
   }
 };
 
@@ -1441,24 +761,13 @@ var AffiliateReferralsResource = class extends BaseResource {
    * List affiliate referrals with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/affiliate_referrals",
-      params
-    );
-    return {
-      referrals: response.referrals || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/affiliate_referrals", { params: { query: params } }));
   }
   /**
-   * Retrieve a single affiliate referral by ID
+   * Get a single affiliate referral by ID
    */
-  async retrieve(referralId) {
-    return this.get(
-      `/affiliate_referrals/${referralId}`
-    );
+  async get(referralId) {
+    return this.unwrap(this.api.GET("/affiliate_referrals/{id}", { params: { path: { id: referralId } } }));
   }
 };
 
@@ -1468,14 +777,7 @@ var ChargesResource = class extends BaseResource {
    * List charges with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get("/charges", params);
-    return {
-      charges: response.charges || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/charges", { params: { query: params } }));
   }
 };
 
@@ -1485,227 +787,62 @@ var TransactionsResource = class extends BaseResource {
    * List transactions with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/transactions",
-      params
-    );
-    return {
-      transactions: response.transactions || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/transactions", { params: { query: params } }));
   }
   /**
-   * Retrieve a single transaction by ID
+   * Get a single transaction by ID
    */
-  async retrieve(transactionId) {
-    return this.get(
-      `/transactions/${transactionId}`
-    );
+  async get(transactionId) {
+    return this.unwrap(this.api.GET("/transactions/{id}", { params: { path: { id: transactionId } } }));
   }
 };
 
 // src/resources/metrics.ts
 var MetricsResource = class extends BaseResource {
-  /**
-   * Fetch metrics with custom parameters
-   */
-  async fetch(params) {
-    const response = await this.client.get("/metrics", {
-      ...params,
-      includes: params.includes || ["includeTotal"],
-      appEventsForMrr: params.appEventsForMrr ?? true
-    });
-    const data = Array.isArray(response) ? response : [];
-    const first = data[0];
-    return {
-      data,
-      total: first?.total,
-      startingTotal: first?.startingTotal,
-      change: first?.change,
-      changePercentage: first?.changePercentage,
-      formattedTotal: first?.formattedTotal,
-      formattedChange: first?.formattedChange,
-      formattedChangePercentage: first?.formattedChangePercentage
-    };
+  async mrr(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/mrr", { params: { query: params } }));
   }
-  /**
-   * Get Annual Recurring Revenue (ARR)
-   */
   async arr(params) {
-    return this.fetch({
-      metric: "PlatformApp.arr",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/arr", { params: { query: params } }));
   }
-  /**
-   * Get Monthly Recurring Revenue (MRR)
-   */
-  async mrr(params) {
-    return this.fetch({
-      metric: "PlatformApp.mrr",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+  async arpu(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/arpu", { params: { query: params } }));
   }
-  /**
-   * Get active subscriptions count
-   */
   async activeSubscriptions(params) {
-    return this.fetch({
-      metric: "PlatformApp.activeSubscriptions",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/activeSubscriptions", { params: { query: params } }));
   }
-  /**
-   * Get active installations count
-   */
   async activeInstalls(params) {
-    return this.fetch({
-      metric: "PlatformApp.activeInstalls",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/activeInstalls", { params: { query: params } }));
   }
-  /**
-   * Get net new installations
-   */
   async netInstalls(params) {
-    return this.fetch({
-      metric: "PlatformApp.netInstalls",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/netInstalls", { params: { query: params } }));
   }
-  /**
-   * Get Average Revenue Per User (ARPU)
-   */
-  async arpu(params) {
-    return this.fetch({
-      metric: "PlatformApp.arpu",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
-  }
-  /**
-   * Get Lifetime Value (LTV)
-   */
-  async ltv(params) {
-    return this.fetch({
-      metric: "PlatformApp.ltv",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+  async logoChurn(params) {
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/logoChurn", { params: { query: params } }));
   }
-  /**
-   * Get revenue churn rate
-   */
   async revenueChurn(params) {
-    return this.fetch({
-      metric: "PlatformApp.revenueChurn",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
-  }
-  /**
-   * Get logo (customer) churn rate
-   */
-  async logoChurn(params) {
-    return this.fetch({
-      metric: "PlatformApp.logoChurn",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/revenueChurn", { params: { query: params } }));
   }
-  /**
-   * Get revenue retention rate
-   */
   async revenueRetention(params) {
-    return this.fetch({
-      metric: "PlatformApp.revenueRetention",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/revenueRetention", { params: { query: params } }));
   }
-  /**
-   * Get net revenue retention rate
-   */
   async netRevenueRetention(params) {
-    return this.fetch({
-      metric: "PlatformApp.netRevenueRetention",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/netRevenueRetention", { params: { query: params } }));
   }
-  /**
-   * Get net revenue
-   */
   async netRevenue(params) {
-    return this.fetch({
-      metric: "PlatformApp.netRevenue",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/netRevenue", { params: { query: params } }));
   }
-  /**
-   * Get payout amount
-   */
   async payout(params) {
-    return this.fetch({
-      metric: "PlatformApp.payout",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/payout", { params: { query: params } }));
   }
-  /**
-   * Get predicted Lifetime Value
-   */
   async predictedLtv(params) {
-    return this.fetch({
-      metric: "PlatformApp.predictedLtv",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/predictedLtv", { params: { query: params } }));
   }
-  /**
-   * Get charges
-   */
-  async charges(params) {
-    return this.fetch({
-      metric: "PlatformApp.charges",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
-  }
-  /**
-   * Get usage event metrics
-   */
   async usageEvent(params) {
-    return this.fetch({
-      metric: "PlatformApp.usageEvent",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/usageEvent", { params: { query: params } }));
   }
-  /**
-   * Get usage metric data
-   */
   async usageMetric(params) {
-    return this.fetch({
-      metric: "PlatformApp.usageMetric",
-      dateRange: params.dateRange || "last_30_days",
-      ...params
-    });
-  }
-  /**
-   * Get key sales metrics
-   */
-  async sales(params) {
-    return this.get("/metrics/sales", params);
+    return this.unwrap(this.api.GET("/api/core/v1/metrics/usageMetric", { params: { query: params } }));
   }
 };
 
@@ -1715,29 +852,20 @@ var UsersResource = class extends BaseResource {
    * List organization users with optional pagination
    */
   async list(params) {
-    const response = await this.get("/users", params);
-    return {
-      users: response.users || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/users", { params: { query: params } }));
   }
   /**
-   * Retrieve a single user by ID
+   * Get a single user by ID
    */
-  async retrieve(userId) {
-    return this.get(`/users/${userId}`);
+  async get(userId) {
+    return this.unwrap(this.api.GET("/users/{id}", { params: { path: { id: userId } } }));
   }
 };
 
 // src/resources/me.ts
 var MeResource = class extends BaseResource {
-  /**
-   * Get current user and organization info
-   */
-  async retrieve() {
-    return this.client.get("/me");
+  async get() {
+    return this.unwrap(this.untypedApi.GET("/me", {}));
   }
 };
 
@@ -1746,206 +874,77 @@ var OrganizationResource = class extends BaseResource {
   /**
    * Get organization details
    */
-  async retrieve() {
-    return this.client.get("/organization");
+  async get() {
+    return this.unwrap(this.api.GET("/organization"));
   }
 };
 
 // src/resources/agents.ts
 var AgentsResource = class extends BaseResource {
-  /**
-   * List support agents
-   */
   async list() {
-    return this.get("/agents");
+    return this.unwrap(this.untypedApi.GET("/agents", {}));
   }
-  /**
-   * Retrieve a specific agent by ID
-   */
-  async retrieve(agentId) {
-    return this.get(`/agents/${agentId}`);
+  async get(agentId) {
+    return this.unwrap(this.untypedApi.GET("/agents/{id}", { params: { path: { id: agentId } } }));
   }
-  /**
-   * Create a new agent
-   */
   async create(params) {
-    return this.post("/agents", params);
+    return this.unwrap(this.untypedApi.POST("/agents", { body: params }));
   }
-  /**
-   * Find an existing agent by email, or create one if not found.
-   * This is useful for sync operations where you want to ensure
-   * an agent exists without duplicating.
-   *
-   * @param params - Agent data (email required, name optional)
-   * @returns The existing or newly created agent
-   */
   async findOrCreate(params) {
-    try {
-      return await this.create(params);
-    } catch (error) {
-      if (error instanceof MantleAPIError && error.statusCode === 409) {
-        const { agents } = await this.list();
-        const existingAgent = agents.find(
-          (agent) => agent.email.toLowerCase() === params.email.toLowerCase()
-        );
-        if (existingAgent) {
-          return { agent: existingAgent };
-        }
-      }
-      throw error;
-    }
+    return this.unwrap(this.untypedApi.POST("/agents/find_or_create", { body: params }));
   }
 };
 
 // src/resources/docs.ts
 var DocsResource = class extends BaseResource {
-  // ========== Collections ==========
-  /**
-   * List all doc collections
-   */
-  async listCollections() {
-    return this.get("/docs/collections");
+  // Collections
+  async listCollections(params) {
+    return this.unwrap(this.api.GET("/docs/collections", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single doc collection
-   */
-  async retrieveCollection(collectionId) {
-    return this.get(
-      `/docs/collections/${collectionId}`
-    );
-  }
-  /**
-   * Create a new doc collection
-   */
   async createCollection(data) {
-    return this.post("/docs/collections", data);
+    return this.unwrap(this.api.POST("/docs/collections", { body: data }));
   }
-  /**
-   * Update a doc collection
-   */
   async updateCollection(collectionId, data) {
-    return this.put(
-      `/docs/collections/${collectionId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/docs/collections/{collection_id}", { params: { path: { collection_id: collectionId } }, body: data }));
   }
-  /**
-   * Delete a doc collection
-   */
   async deleteCollection(collectionId) {
-    return this._delete(`/docs/collections/${collectionId}`);
+    return this.unwrap(this.api.DELETE("/docs/collections/{collection_id}", { params: { path: { collection_id: collectionId } } }));
   }
-  // ========== Groups ==========
-  /**
-   * List all doc groups
-   */
-  async listGroups() {
-    return this.get("/docs/groups");
+  // Groups
+  async listGroups(params) {
+    return this.unwrap(this.api.GET("/docs/groups", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single doc group
-   */
-  async retrieveGroup(groupId) {
-    return this.get(`/docs/groups/${groupId}`);
-  }
-  /**
-   * Create a new doc group
-   */
   async createGroup(data) {
-    return this.post("/docs/groups", data);
+    return this.unwrap(this.api.POST("/docs/groups", { body: data }));
   }
-  /**
-   * Update a doc group
-   */
   async updateGroup(groupId, data) {
-    return this.put(`/docs/groups/${groupId}`, data);
+    return this.unwrap(this.api.PUT("/docs/groups/{group_id}", { params: { path: { group_id: groupId } }, body: data }));
   }
-  /**
-   * Delete a doc group
-   */
   async deleteGroup(groupId) {
-    return this._delete(`/docs/groups/${groupId}`);
+    return this.unwrap(this.api.DELETE("/docs/groups/{group_id}", { params: { path: { group_id: groupId } } }));
   }
-  // ========== Pages ==========
-  /**
-   * List doc pages with optional filters
-   */
+  // Pages
   async listPages(params) {
-    const response = await this.get("/docs/pages", params);
-    return {
-      pages: response.pages || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false
-    };
+    return this.unwrap(this.api.GET("/docs/pages", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single doc page
-   */
-  async retrievePage(pageId) {
-    return this.get(`/docs/pages/${pageId}`);
+  async getPage(pageId) {
+    return this.unwrap(this.api.GET("/docs/pages/{page_id}", { params: { path: { page_id: pageId } } }));
   }
-  /**
-   * Create a new doc page
-   */
   async createPage(data) {
-    return this.post("/docs/pages", data);
+    return this.unwrap(this.api.POST("/docs/pages", { body: data }));
   }
-  /**
-   * Update a doc page
-   */
   async updatePage(pageId, data) {
-    return this.put(`/docs/pages/${pageId}`, data);
-  }
-  /**
-   * Publish a doc page
-   */
-  async publishPage(pageId) {
-    return this.post(`/docs/pages/${pageId}/publish`, {});
-  }
-  /**
-   * Archive a doc page
-   */
-  async archivePage(pageId) {
-    return this.post(`/docs/pages/${pageId}/archive`, {});
+    return this.unwrap(this.api.PUT("/docs/pages/{page_id}", { params: { path: { page_id: pageId } }, body: data }));
   }
-  /**
-   * Delete a doc page
-   */
   async deletePage(pageId) {
-    return this._delete(`/docs/pages/${pageId}`);
+    return this.unwrap(this.api.DELETE("/docs/pages/{page_id}", { params: { path: { page_id: pageId } } }));
   }
-  // ========== Tree ==========
-  /**
-   * Get the full documentation tree structure
-   */
-  async getTree() {
-    return this.get("/docs/tree");
-  }
-  // ========== Repositories ==========
-  /**
-   * List all doc repositories
-   */
+  // Repositories
   async listRepositories(params) {
-    const response = await this.get(
-      "/docs/repositories",
-      params
-    );
-    return {
-      repositories: response.repositories || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/docs/repositories", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single doc repository
-   */
-  async retrieveRepository(repositoryId, params) {
-    return this.get(
-      `/docs/repositories/${repositoryId}`,
-      params
-    );
+  async getRepository(repositoryId, params) {
+    return this.unwrap(this.api.GET("/docs/repositories/{id}", { params: { path: { id: repositoryId }, query: params } }));
   }
 };
 
@@ -1956,50 +955,17 @@ var EntitiesResource = class extends BaseResource {
    * Returns entities with a _type discriminator field
    */
   async search(params) {
-    const response = await this.get("/entities", params);
-    return {
-      entities: response.entities || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/entities", { params: { query: params } }));
   }
 };
 
 // src/resources/custom-data.ts
 var CustomDataResource = class extends BaseResource {
-  /**
-   * Set custom data on a resource.
-   * This will create or update the value for the given key.
-   *
-   * @param params - The custom data parameters
-   */
-  async set(params) {
-    await this.put("/custom_data", params);
+  async set(data) {
+    return this.unwrap(this.api.PUT("/custom_data", { body: data }));
   }
-  /**
-   * Get custom data from a resource.
-   *
-   * @param params - Parameters identifying the custom data to retrieve
-   * @returns The custom data value
-   */
   async getValue(params) {
-    const { resourceType, resourceId, key } = params;
-    return this.get(
-      `/custom_data/${resourceType}/${resourceId}/${encodeURIComponent(key)}`
-    );
-  }
-  /**
-   * Delete custom data from a resource.
-   *
-   * @param params - Parameters identifying the custom data to delete
-   */
-  async del(params) {
-    const { resourceType, resourceId, key } = params;
-    await this._delete(
-      `/custom_data/${resourceType}/${resourceId}/${encodeURIComponent(key)}`
-    );
+    return this.unwrap(this.api.GET("/custom_data", { params: { query: params } }));
   }
 };
 
@@ -2009,130 +975,56 @@ var TimelineCommentsResource = class extends BaseResource {
    * List timeline comments with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/timeline_comments",
-      params
-    );
-    return {
-      timelineComments: response.timelineComments || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/timeline_comments", { params: { query: params } }));
   }
   /**
-   * Retrieve a single timeline comment by ID
+   * Get a single timeline comment by ID
    */
-  async retrieve(id) {
-    return this.get(
-      `/timeline_comments/${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.post("/timeline_comments", data);
+    return this.unwrap(this.api.POST("/timeline_comments", { body: data }));
   }
   /**
    * Update an existing timeline comment
    */
   async update(id, data) {
-    return this.put(
-      `/timeline_comments/${id}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/timeline_comments/{id}", { params: { path: { id } }, body: data }));
   }
   /**
    * Delete a timeline comment
    */
-  async del(id) {
-    return this._delete(`/timeline_comments/${id}`);
+  async del(id, data) {
+    return this.unwrap(this.api.DELETE("/timeline_comments/{id}", { params: { path: { id } }, body: data }));
   }
 };
 
 // src/resources/lists.ts
 var ListsResource = class extends BaseResource {
-  /**
-   * List all lists
-   *
-   * @param params - Optional list parameters
-   * @returns Paginated list of lists
-   */
   async list(params) {
-    const response = await this.get("/lists", params);
-    return {
-      lists: response.lists || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total
-    };
+    return this.unwrap(this.api.GET("/lists", { params: { query: params } }));
   }
-  /**
-   * Retrieve a specific list with its entities
-   *
-   * @param listId - The ID of the list
-   * @param params - Optional parameters to filter entities
-   * @returns The list with its entities
-   */
-  async retrieve(listId, params) {
-    const response = await this.get(`/lists/${listId}`, params);
-    return {
-      list: response.list,
-      entities: response.entities || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total
-    };
+  async get(listId) {
+    return this.unwrap(this.api.GET("/lists/{id}", { params: { path: { id: listId } } }));
   }
-  /**
-   * Create a new list
-   *
-   * @param data - List creation parameters
-   * @returns The created list
-   */
   async create(data) {
-    return this.post("/lists", data);
+    return this.unwrap(this.api.POST("/lists", { body: data }));
   }
-  /**
-   * Update an existing list
-   *
-   * @param listId - The ID of the list to update
-   * @param data - List update parameters
-   * @returns The updated list
-   */
   async update(listId, data) {
-    return this.put(`/lists/${listId}`, data);
+    return this.unwrap(this.api.PUT("/lists/{id}", { params: { path: { id: listId } }, body: data }));
   }
-  /**
-   * Delete a list
-   *
-   * @param listId - The ID of the list to delete
-   * @returns Delete confirmation
-   */
   async del(listId) {
-    return this._delete(`/lists/${listId}`);
+    return this.unwrap(this.api.DELETE("/lists/{id}", { params: { path: { id: listId } } }));
   }
-  /**
-   * Add customers and/or contacts to a list
-   *
-   * @param listId - The ID of the list
-   * @param data - IDs of customers and/or contacts to add
-   * @returns Count of added and skipped entities
-   */
   async addEntities(listId, data) {
-    return this.post(`/lists/${listId}/add`, data);
+    return this.unwrap(this.api.POST("/lists/{id}/add", { params: { path: { id: listId } }, body: data }));
   }
-  /**
-   * Remove customers and/or contacts from a list
-   *
-   * @param listId - The ID of the list
-   * @param data - IDs of customers and/or contacts to remove
-   * @returns Count of removed entities
-   */
   async removeEntities(listId, data) {
-    return this.post(`/lists/${listId}/remove`, data);
+    return this.unwrap(this.api.POST("/lists/{id}/remove", { params: { path: { id: listId } }, body: data }));
   }
 };
 
@@ -2142,727 +1034,172 @@ var JournalEntriesResource = class extends BaseResource {
    * List journal entries with optional filters and pagination
    */
   async list(params) {
-    const response = await this.get(
-      "/journal_entries",
-      params
-    );
-    return {
-      journalEntries: response.journalEntries || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/journal_entries", { params: { query: params } }));
   }
   /**
-   * Retrieve a single journal entry by ID
+   * Get a single journal entry by ID
    */
-  async retrieve(entryId) {
-    return this.get(
-      `/journal_entries/${entryId}`
-    );
+  async get(entryId, params) {
+    return this.unwrap(this.api.GET("/journal_entries/{id}", { params: { path: { id: entryId }, query: params } }));
   }
   /**
    * Create a new journal entry
    */
   async create(data) {
-    return this.post("/journal_entries", data);
+    return this.unwrap(this.api.POST("/journal_entries", { body: data }));
   }
   /**
    * Update an existing journal entry
    */
   async update(entryId, data) {
-    return this.put(
-      `/journal_entries/${entryId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/journal_entries/{id}", { params: { path: { id: entryId } }, body: data }));
   }
   /**
    * Delete a journal entry
    */
   async del(entryId) {
-    return this._delete(`/journal_entries/${entryId}`);
+    return this.unwrap(this.api.DELETE("/journal_entries/{id}", { params: { path: { id: entryId } } }));
   }
 };
 
 // src/resources/email-unsubscribe-groups.ts
 var EmailUnsubscribeGroupsResource = class extends BaseResource {
-  /**
-   * List all email unsubscribe groups
-   */
   async list(params) {
-    const response = await this.get(
-      "/email/unsubscribe_groups",
-      params
-    );
-    return {
-      unsubscribeGroups: response.unsubscribeGroups || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/email/unsubscribe_groups", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single unsubscribe group
-   */
-  async retrieve(groupId) {
-    return this.get(
-      `/email/unsubscribe_groups/${groupId}`
-    );
-  }
-  // ========== Members ==========
-  /**
-   * List members of an unsubscribe group
-   */
   async listMembers(groupId, params) {
-    const response = await this.get(
-      `/email/unsubscribe_groups/${groupId}/members`,
-      params
-    );
-    return {
-      members: response.members || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
+    return this.unwrap(this.api.GET("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId }, query: params } }));
   }
-  /**
-   * Add members to an unsubscribe group by email addresses
-   */
   async addMembers(groupId, data) {
-    return this.post(
-      `/email/unsubscribe_groups/${groupId}/members`,
-      data
-    );
+    return this.unwrap(this.api.POST("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId } }, body: data }));
   }
-  /**
-   * Remove members from an unsubscribe group by email addresses
-   */
   async removeMembers(groupId, data) {
-    return this._delete(
-      `/email/unsubscribe_groups/${groupId}/members?emails=${encodeURIComponent(data.emails.join(","))}`
-    );
+    return this.unwrap(this.api.DELETE("/email/unsubscribe_groups/{id}/members", { params: { path: { id: groupId } }, body: data }));
   }
-  /**
-   * Remove a single member from an unsubscribe group by member ID
-   */
   async removeMember(groupId, memberId) {
-    return this._delete(
-      `/email/unsubscribe_groups/${groupId}/members/${memberId}`
-    );
+    return this.unwrap(this.api.DELETE("/email/unsubscribe_groups/{id}/members/{member_id}", { params: { path: { id: groupId, member_id: memberId } } }));
   }
 };
 
 // src/resources/flow-extensions.ts
 var FlowExtensionsResource = class extends BaseResource {
-  // ========== Actions ==========
-  /**
-   * List flow extension actions
-   */
+  // Actions
   async listActions(params) {
-    const response = await this.get(
-      "/flow/extensions/actions",
-      params
-    );
-    return {
-      actions: response.actions || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      cursor: response.cursor
-    };
-  }
-  /**
-   * Retrieve a single flow extension action
-   */
-  async retrieveAction(actionId) {
-    return this.get(
-      `/flow/extensions/actions/${actionId}`
-    );
+    return this.unwrap(this.api.GET("/flow/extensions/actions", { params: { query: params } }));
   }
-  /**
-   * Create a new flow extension action
-   */
   async createAction(data) {
-    return this.post(
-      "/flow/extensions/actions",
-      data
-    );
+    return this.unwrap(this.api.POST("/flow/extensions/actions", { body: data }));
   }
-  /**
-   * Update an existing flow extension action
-   */
   async updateAction(actionId, data) {
-    return this.put(
-      `/flow/extensions/actions/${actionId}`,
-      data
-    );
+    return this.unwrap(this.api.PUT("/flow/extensions/actions/{id}", { params: { path: { id: actionId } }, body: data }));
   }
-  /**
-   * Delete a flow extension action
-   */
   async deleteAction(actionId) {
-    return this._delete(
-      `/flow/extensions/actions/${actionId}`
-    );
+    return this.unwrap(this.api.DELETE("/flow/extensions/actions/{id}", { params: { path: { id: actionId } } }));
   }
-  // ========== Action Runs ==========
-  /**
-   * Update a flow action run status
-   * Used to report completion or failure of async action execution
-   */
+  // Action Runs
   async updateActionRun(runId, data) {
-    return this.put(`/flow/actions/runs/${runId}`, data);
+    return this.unwrap(this.api.PUT("/flow/actions/runs/{id}", { params: { path: { id: runId } }, body: data }));
+  }
+  // Triggers
+  async listTriggers() {
+    return this.unwrap(this.api.GET("/flow/extensions/triggers"));
+  }
+  async getTrigger(handle) {
+    return this.unwrap(this.api.GET("/flow/extensions/triggers/{handle}", { params: { path: { handle } } }));
+  }
+  async createTrigger(data) {
+    return this.unwrap(this.api.POST("/flow/extensions/triggers", { body: data }));
+  }
+  async updateTrigger(handle, data) {
+    return this.unwrap(this.api.PUT("/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 } } }));
+  }
+  async fireTrigger(handle, data) {
+    return this.unwrap(this.api.POST("/flow/extensions/triggers/{handle}/fire", { params: { path: { handle } }, body: data }));
   }
 };
 
 // src/resources/ai-agent-runs.ts
 var AiAgentRunsResource = class extends BaseResource {
-  /**
-   * Create a new AI agent run
-   * Returns 202 Accepted as the run executes asynchronously
-   * Poll the retrieve endpoint to check for completion
-   */
   async create(agentId, data) {
-    return this.post(
-      `/ai/agents/${agentId}/runs`,
-      data || {}
-    );
+    return this.unwrap(this.api.POST("/ai/agents/{agentId}/runs", { params: { path: { agentId } }, body: data }));
   }
-  /**
-   * Retrieve the status and results of an AI agent run
-   * Use this to poll for completion after creating a run
-   */
-  async retrieve(agentId, runId) {
-    return this.get(
-      `/ai/agents/${agentId}/runs/${runId}`
-    );
+  async get(agentId, runId) {
+    return this.unwrap(this.api.GET("/ai/agents/{agentId}/runs/{runId}", { params: { path: { agentId, runId } } }));
   }
   /**
-   * Create a run and poll until completion
-   * Convenience method that handles the async polling pattern
-   *
-   * @param agentId - The ID of the AI agent
-   * @param data - Optional parameters for the run
-   * @param options - Polling options
-   * @returns The completed agent run
+   * Create an agent run and poll until it completes or errors.
    */
   async createAndWait(agentId, data, options) {
-    const timeout = options?.timeout ?? 6e4;
-    const pollInterval = options?.pollInterval ?? 1e3;
-    const startTime = Date.now();
-    const { run } = await this.create(agentId, data);
-    while (Date.now() - startTime < timeout) {
-      const { run: currentRun } = await this.retrieve(agentId, run.id);
-      if (currentRun.status === "completed" || currentRun.status === "error") {
-        return currentRun;
+    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 ${run.id} did not complete within ${timeout}ms timeout`
-    );
+    throw new Error(`Agent run timed out after ${timeout}ms`);
   }
 };
 
 // src/resources/meetings.ts
 var MeetingsResource = class extends BaseResource {
-  /**
-   * List meetings with optional filters and pagination
-   *
-   * @param params - Filter and pagination parameters
-   * @returns Paginated list of meetings
-   *
-   * @example
-   * ```typescript
-   * // List all meetings
-   * const { meetings } = await client.meetings.list();
-   *
-   * // List meetings for a specific deal
-   * const { meetings } = await client.meetings.list({ dealId: 'deal_123' });
-   *
-   * // List meetings from Google Meet
-   * const { meetings } = await client.meetings.list({ platform: 'google_meet' });
-   * ```
-   */
   async list(params) {
-    const response = await this.get("/meetings", params);
-    return {
-      meetings: response.meetings || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      page: response.page,
-      totalPages: response.totalPages
-    };
+    return this.unwrap(this.api.GET("/meetings", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single meeting by ID with full transcript and attendee data
-   *
-   * @param meetingId - The meeting ID
-   * @returns The meeting with all related data
-   *
-   * @example
-   * ```typescript
-   * const { meeting } = await client.meetings.retrieve('meeting_123');
-   * console.log(meeting.transcript?.fullText);
-   * ```
-   */
-  async retrieve(meetingId) {
-    return this.get(`/meetings/${meetingId}`);
+  async get(meetingId) {
+    return this.unwrap(this.api.GET("/meetings/{id}", { params: { path: { id: meetingId } } }));
   }
-  /**
-   * Create a new meeting
-   *
-   * Typically called when a recording starts in the browser extension.
-   * The meeting can be created with optional transcript and attendee data,
-   * or these can be added later via transcription.
-   *
-   * @param data - Meeting creation parameters
-   * @returns The created meeting
-   *
-   * @example
-   * ```typescript
-   * // Create meeting when recording starts
-   * const meeting = await client.meetings.create({
-   *   meetingData: {
-   *     platform: 'zoom',
-   *     title: 'Weekly Sync',
-   *     meetingUrl: 'https://zoom.us/j/123456789',
-   *     startTime: new Date().toISOString(),
-   *     recordingStatus: 'pending',
-   *   }
-   * });
-   *
-   * // Create meeting with transcript (from local transcription)
-   * const meeting = await client.meetings.create({
-   *   meetingData: { ... },
-   *   transcript: {
-   *     fullText: 'Hello, this is the transcript...',
-   *     utterances: [
-   *       { attendeeId: 'A', text: 'Hello', startTime: 0, endTime: 500 },
-   *     ],
-   *   },
-   *   attendees: [
-   *     { externalId: 'A', name: 'John Doe', email: 'john@example.com' },
-   *   ],
-   * });
-   * ```
-   */
   async create(data) {
-    return this.post("/meetings", data);
+    return this.unwrap(this.api.POST("/meetings", { body: data }));
   }
-  /**
-   * Update an existing meeting
-   *
-   * @param meetingId - The meeting ID
-   * @param data - Fields to update
-   * @returns The updated meeting
-   *
-   * @example
-   * ```typescript
-   * // Update meeting title and link to a deal
-   * const meeting = await client.meetings.update('meeting_123', {
-   *   title: 'Updated Meeting Title',
-   *   dealId: 'deal_456',
-   * });
-   * ```
-   */
   async update(meetingId, data) {
-    return this.put(`/meetings/${meetingId}`, data);
+    return this.unwrap(this.api.PUT("/meetings/{id}", { params: { path: { id: meetingId } }, body: data }));
   }
-  /**
-   * Archive (soft delete) a meeting
-   *
-   * @param meetingId - The meeting ID
-   * @returns Success response
-   *
-   * @example
-   * ```typescript
-   * await client.meetings.del('meeting_123');
-   * ```
-   */
   async del(meetingId) {
-    return this._delete(`/meetings/${meetingId}`);
-  }
-  /**
-   * Get a signed URL to upload a meeting recording
-   *
-   * Returns a pre-signed S3 URL that can be used to upload the recording
-   * directly from the client. After uploading, call `startTranscription`
-   * to begin server-side transcription.
-   *
-   * @param meetingId - The meeting ID
-   * @param filename - Optional filename (default: "recording.webm")
-   * @returns Upload URL and recording key
-   *
-   * @example
-   * ```typescript
-   * const { uploadUrl, recordingKey } = await client.meetings.getUploadUrl('meeting_123');
-   *
-   * // Upload the recording blob directly to S3
-   * const response = await fetch(uploadUrl, {
-   *   method: 'PUT',
-   *   body: recordingBlob,
-   *   headers: { 'Content-Type': 'audio/webm' },
-   * });
-   *
-   * // Then start transcription
-   * await client.meetings.startTranscription('meeting_123', { recordingKey });
-   * ```
-   */
-  async getUploadUrl(meetingId, filename) {
-    return this.post(
-      `/meetings/${meetingId}/transcribe/upload`,
-      filename ? { filename } : {}
-    );
-  }
-  /**
-   * Start server-side transcription for a meeting
-   *
-   * The recording must first be uploaded using the URL from `getUploadUrl`.
-   * Transcription is processed asynchronously - poll `getTranscriptionStatus`
-   * or retrieve the meeting to check for completion.
-   *
-   * @param meetingId - The meeting ID
-   * @param params - Transcription parameters including the recording key
-   * @returns The meeting with pending transcription status
-   *
-   * @example
-   * ```typescript
-   * // Start transcription after uploading
-   * const meeting = await client.meetings.startTranscription('meeting_123', {
-   *   recordingKey: 'meeting-recordings/org-id/meeting-123/uuid/recording.webm',
-   * });
-   *
-   * // meeting.recordingStatus will be 'pending' or 'processing'
-   * ```
-   */
-  async startTranscription(meetingId, params) {
-    return this.post(`/meetings/${meetingId}/transcribe`, params);
-  }
-  /**
-   * Get the current transcription status for a meeting
-   *
-   * Use this to poll for transcription completion after calling
-   * `startTranscription`.
-   *
-   * @param meetingId - The meeting ID
-   * @returns Current transcription status
-   *
-   * @example
-   * ```typescript
-   * // Poll for completion
-   * const poll = async () => {
-   *   const status = await client.meetings.getTranscriptionStatus('meeting_123');
-   *
-   *   if (status.recordingStatus === 'ready') {
-   *     // Transcription complete - fetch the full meeting
-   *     const meeting = await client.meetings.retrieve('meeting_123');
-   *     return meeting;
-   *   }
-   *
-   *   if (status.recordingStatus === 'failed') {
-   *     throw new Error('Transcription failed');
-   *   }
-   *
-   *   // Still processing - wait and retry
-   *   await new Promise(r => setTimeout(r, 5000));
-   *   return poll();
-   * };
-   * ```
-   */
-  async getTranscriptionStatus(meetingId) {
-    return this.get(
-      `/meetings/${meetingId}/transcribe`
-    );
-  }
-  /**
-   * Update a meeting attendee
-   *
-   * Updates attendee details such as name or links the attendee to a Mantle contact.
-   * This is useful for speaker identification in transcripts.
-   *
-   * @param meetingId - The meeting ID
-   * @param attendeeId - The attendee ID (or externalId if useExternalId option is set)
-   * @param data - Fields to update
-   * @param options - Additional options
-   * @param options.useExternalId - If true, treat attendeeId as the externalId (e.g., "A", "B" from browser extension)
-   * @returns The updated attendee
-   *
-   * @example
-   * ```typescript
-   * // Update attendee name by server ID
-   * const { attendee } = await client.meetings.updateAttendee(
-   *   'meeting_123',
-   *   'attendee_456',
-   *   { name: 'John Doe' }
-   * );
-   *
-   * // Update attendee name by external ID (e.g., from browser extension)
-   * const { attendee } = await client.meetings.updateAttendee(
-   *   'meeting_123',
-   *   'A',
-   *   { name: 'John Doe' },
-   *   { useExternalId: true }
-   * );
-   *
-   * // Link attendee to a contact
-   * const { attendee } = await client.meetings.updateAttendee(
-   *   'meeting_123',
-   *   'attendee_456',
-   *   { contactId: 'contact_789' }
-   * );
-   * ```
-   */
-  async updateAttendee(meetingId, attendeeId, data, options) {
-    const queryParams = options?.useExternalId ? "?useExternalId=true" : "";
-    return this.put(
-      `/meetings/${meetingId}/attendees/${attendeeId}${queryParams}`,
-      data
-    );
-  }
-  /**
-   * Get a signed URL to stream/download the meeting recording
-   *
-   * Returns a temporary signed URL that can be used to play or download
-   * the meeting recording. URLs expire after 1 hour.
-   *
-   * @param meetingId - The meeting ID
-   * @returns Signed URL and expiration info
-   *
-   * @example
-   * ```typescript
-   * const { recordingUrl, expiresIn } = await client.meetings.getRecordingUrl('meeting_123');
-   *
-   * // Use the URL in an audio/video element
-   * audioElement.src = recordingUrl;
-   * ```
-   */
-  async getRecordingUrl(meetingId) {
-    return this.get(
-      `/meetings/${meetingId}/recording-url`
-    );
-  }
-  /**
-   * Accept an AI-generated task suggestion
-   *
-   * Creates a real Task from the suggestion. Optional overrides allow
-   * modifying the title, description, priority, due date, or assignee
-   * before creating the task.
-   *
-   * @param meetingId - The meeting ID
-   * @param suggestionId - The task suggestion ID
-   * @param overrides - Optional fields to override on the created task
-   * @returns The created task and updated suggestion
-   *
-   * @example
-   * ```typescript
-   * // Accept a suggestion as-is
-   * const { task, suggestion } = await client.meetings.acceptTaskSuggestion(
-   *   'meeting_123',
-   *   'suggestion_456'
-   * );
-   *
-   * // Accept with overrides
-   * const { task } = await client.meetings.acceptTaskSuggestion(
-   *   'meeting_123',
-   *   'suggestion_456',
-   *   { title: 'Custom title', priority: 'high' }
-   * );
-   * ```
-   */
-  async acceptTaskSuggestion(meetingId, suggestionId, overrides) {
-    return this.post(
-      `/meetings/${meetingId}/task-suggestions/${suggestionId}/accept`,
-      overrides || {}
-    );
-  }
-  /**
-   * Dismiss an AI-generated task suggestion
-   *
-   * Marks the suggestion as dismissed so it no longer appears as pending.
-   *
-   * @param meetingId - The meeting ID
-   * @param suggestionId - The task suggestion ID
-   * @returns Success response
-   *
-   * @example
-   * ```typescript
-   * await client.meetings.dismissTaskSuggestion('meeting_123', 'suggestion_456');
-   * ```
-   */
-  async dismissTaskSuggestion(meetingId, suggestionId) {
-    return this.post(
-      `/meetings/${meetingId}/task-suggestions/${suggestionId}/dismiss`
-    );
+    return this.unwrap(this.api.DELETE("/meetings/{id}", { params: { path: { id: meetingId } } }));
   }
 };
 
 // src/resources/synced-emails.ts
 var SyncedEmailsResource = class extends BaseResource {
-  /**
-   * List synced email threads with optional filters and pagination
-   *
-   * @param params - Filter and pagination parameters
-   * @returns Paginated list of synced email threads
-   *
-   * @example
-   * ```typescript
-   * // List all synced emails
-   * const { syncedEmails } = await client.syncedEmails.list();
-   *
-   * // List synced emails for a specific customer
-   * const { syncedEmails } = await client.syncedEmails.list({ customerId: 'cust_123' });
-   *
-   * // List Gmail synced emails
-   * const { syncedEmails } = await client.syncedEmails.list({ source: 'gmail' });
-   * ```
-   */
   async list(params) {
-    const response = await this.get("/synced_emails", params);
-    return {
-      syncedEmails: response.syncedEmails || [],
-      hasNextPage: response.hasNextPage || false,
-      hasPreviousPage: response.hasPreviousPage || false,
-      total: response.total,
-      page: response.page,
-      totalPages: response.totalPages
-    };
+    return this.unwrap(this.untypedApi.GET("/synced_emails", { params: { query: params } }));
   }
-  /**
-   * Retrieve a single synced email thread by ID with all messages
-   *
-   * @param syncedEmailId - The synced email thread ID
-   * @returns The synced email with all messages
-   *
-   * @example
-   * ```typescript
-   * const syncedEmail = await client.syncedEmails.retrieve('se_123');
-   * console.log(syncedEmail.messages?.length);
-   * ```
-   */
-  async retrieve(syncedEmailId) {
-    return this.get(`/synced_emails/${syncedEmailId}`);
+  async get(syncedEmailId) {
+    return this.unwrap(this.untypedApi.GET("/synced_emails/{id}", { params: { path: { id: syncedEmailId } } }));
   }
-  /**
-   * Create or sync a synced email thread
-   *
-   * If `emailData.externalId` is provided, performs an upsert: updates the
-   * existing thread and adds new messages if a thread with that externalId
-   * already exists. Otherwise creates a new thread.
-   *
-   * @param data - Email thread and messages data
-   * @returns The created or updated synced email thread
-   *
-   * @example
-   * ```typescript
-   * // Create a new thread (or upsert if externalId matches)
-   * const syncedEmail = await client.syncedEmails.create({
-   *   emailData: {
-   *     externalId: 'gmail-thread-123',
-   *     subject: 'Sales Discussion',
-   *     source: 'gmail',
-   *   },
-   *   messages: [
-   *     {
-   *       externalId: 'msg-1',
-   *       fromEmail: 'prospect@example.com',
-   *       subject: 'Sales Discussion',
-   *       bodyText: 'Interested in your product...',
-   *       date: new Date().toISOString(),
-   *       isInbound: true,
-   *     },
-   *   ],
-   * });
-   * ```
-   */
   async create(data) {
-    return this.post("/synced_emails", data);
+    return this.unwrap(this.untypedApi.POST("/synced_emails", { body: data }));
   }
-  /**
-   * Update synced email thread metadata
-   *
-   * @param syncedEmailId - The synced email thread ID
-   * @param data - Fields to update
-   * @returns The updated synced email thread
-   *
-   * @example
-   * ```typescript
-   * // Link email to a deal
-   * const syncedEmail = await client.syncedEmails.update('se_123', {
-   *   dealId: 'deal_456',
-   * });
-   * ```
-   */
   async update(syncedEmailId, data) {
-    return this.put(`/synced_emails/${syncedEmailId}`, data);
+    return this.unwrap(this.untypedApi.PUT("/synced_emails/{id}", { params: { path: { id: syncedEmailId } }, body: data }));
   }
-  /**
-   * Archive (soft delete) a synced email thread
-   *
-   * @param syncedEmailId - The synced email thread ID
-   * @returns Success response
-   *
-   * @example
-   * ```typescript
-   * await client.syncedEmails.del('se_123');
-   * ```
-   */
   async del(syncedEmailId) {
-    return this._delete(`/synced_emails/${syncedEmailId}`);
+    return this.unwrap(this.untypedApi.DELETE("/synced_emails/{id}", { params: { path: { id: syncedEmailId } } }));
   }
-  /**
-   * Add messages to an existing synced email thread
-   *
-   * @param syncedEmailId - The synced email thread ID
-   * @param data - Messages to add
-   * @returns The synced email thread with all messages
-   *
-   * @example
-   * ```typescript
-   * const syncedEmail = await client.syncedEmails.addMessages('se_123', {
-   *   messages: [
-   *     {
-   *       externalId: 'msg-2',
-   *       fromEmail: 'you@company.com',
-   *       toEmails: ['prospect@example.com'],
-   *       subject: 'Re: Sales Discussion',
-   *       bodyText: 'Thanks for your interest...',
-   *       date: new Date().toISOString(),
-   *       isInbound: false,
-   *     },
-   *   ],
-   * });
-   * ```
-   */
   async addMessages(syncedEmailId, data) {
-    return this.post(
-      `/synced_emails/${syncedEmailId}/messages`,
-      data
-    );
+    return this.unwrap(this.untypedApi.POST("/synced_emails/{id}/messages", { params: { path: { id: syncedEmailId } }, body: data }));
   }
-  /**
-   * Get messages for a synced email thread
-   *
-   * @param syncedEmailId - The synced email thread ID
-   * @returns List of messages in the thread
-   *
-   * @example
-   * ```typescript
-   * const { messages } = await client.syncedEmails.getMessages('se_123');
-   * ```
-   */
   async getMessages(syncedEmailId) {
-    return this.get(
-      `/synced_emails/${syncedEmailId}/messages`
-    );
+    return this.unwrap(this.untypedApi.GET("/synced_emails/{id}/messages", { params: { path: { id: syncedEmailId } } }));
   }
 };
 
 // src/client.ts
+function createTimeoutSignal(ms) {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), ms);
+  return controller.signal;
+}
 var MantleCoreClient = class {
   constructor(config) {
     if (!config.apiKey && !config.accessToken) {
@@ -2870,18 +1207,35 @@ var MantleCoreClient = class {
         "MantleCoreClient requires either apiKey or accessToken"
       );
     }
-    this.baseURL = config.baseURL || "https://api.heymantle.com/v1";
     this.apiKey = config.apiKey;
     this.accessToken = config.accessToken;
-    this.timeout = config.timeout || 3e4;
-    this.middlewareManager = new MiddlewareManager();
+    const timeoutMs = config.timeout ?? 3e4;
+    this._api = (0, import_openapi_fetch.default)({
+      baseUrl: config.baseURL || "https://api.heymantle.com/v1",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this._api.use({
+      onRequest: ({ request }) => {
+        const token = this.accessToken || this.apiKey;
+        if (token) {
+          request.headers.set("Authorization", `Bearer ${token}`);
+        }
+        return request;
+      }
+    });
+    if (timeoutMs > 0) {
+      this._api.use({
+        onRequest: ({ request }) => {
+          const signal = typeof AbortSignal !== "undefined" && "timeout" in AbortSignal ? AbortSignal.timeout(timeoutMs) : createTimeoutSignal(timeoutMs);
+          return new Request(request, { signal });
+        }
+      });
+    }
     if (config.middleware) {
       for (const mw of config.middleware) {
-        if (Array.isArray(mw)) {
-          this.middlewareManager.use(mw[0], mw[1]);
-        } else {
-          this.middlewareManager.use(mw);
-        }
+        this._api.use(mw);
       }
     }
     this.customers = new CustomersResource(this);
@@ -2924,39 +1278,21 @@ var MantleCoreClient = class {
     this.syncedEmails = new SyncedEmailsResource(this);
   }
   /**
-   * Register a middleware function
-   *
-   * @param middleware - The middleware function to register
-   * @param options - Optional configuration (name, priority)
-   * @returns this for chaining
-   *
-   * @example
-   * ```typescript
-   * client.use(async (ctx, next) => {
-   *   console.log('Request:', ctx.request.url);
-   *   await next();
-   *   console.log('Response:', ctx.response?.status);
-   * });
-   * ```
+   * Register an openapi-fetch middleware
    */
-  use(middleware, options) {
-    this.middlewareManager.use(middleware, options);
+  use(middleware) {
+    this._api.use(middleware);
     return this;
   }
   /**
-   * Remove a middleware by name
-   *
-   * @param name - The name of the middleware to remove
-   * @returns true if removed, false if not found
+   * Remove a registered middleware
    */
-  removeMiddleware(name) {
-    return this.middlewareManager.remove(name);
+  eject(middleware) {
+    this._api.eject(middleware);
+    return this;
   }
   /**
    * Update authentication credentials
-   * Useful for middleware that needs to refresh tokens
-   *
-   * @param credentials - New credentials to set
    */
   updateAuth(credentials) {
     if (credentials.apiKey !== void 0) {
@@ -2966,234 +1302,43 @@ var MantleCoreClient = class {
       this.accessToken = credentials.accessToken;
     }
   }
-  /**
-   * Performs a GET request to the API
-   */
-  async get(endpoint, params) {
-    const sanitizedParams = params ? sanitizeObject(params) : {};
-    const query = toQueryString(sanitizedParams);
-    const url = query ? `${endpoint}?${query}` : endpoint;
-    return this.makeRequest(url, { method: "GET" });
-  }
-  /**
-   * Performs a POST request to the API
-   */
-  async post(endpoint, data) {
-    const sanitizedData = data ? sanitizeObject(data) : {};
-    return this.makeRequest(endpoint, {
-      method: "POST",
-      body: JSON.stringify(sanitizedData)
-    });
-  }
-  /**
-   * Performs a PUT request to the API
-   */
-  async put(endpoint, data) {
-    const sanitizedData = data ? sanitizeObject(data) : {};
-    return this.makeRequest(endpoint, {
-      method: "PUT",
-      body: JSON.stringify(sanitizedData)
-    });
-  }
-  /**
-   * Performs a DELETE request to the API
-   */
-  async delete(endpoint) {
-    return this.makeRequest(endpoint, { method: "DELETE" });
-  }
-  /**
-   * Makes an HTTP request to the API
-   */
-  async makeRequest(endpoint, options) {
-    if (this.middlewareManager.hasMiddleware()) {
-      return this.makeRequestWithMiddleware(endpoint, options);
-    }
-    return this.executeRequest(endpoint, options);
-  }
-  /**
-   * Execute request through middleware chain
-   */
-  async makeRequestWithMiddleware(endpoint, options) {
-    const request = {
-      url: `${this.baseURL}${endpoint}`,
-      method: options.method,
-      headers: {
-        Authorization: this.getAuthHeader(),
-        "Content-Type": "application/json",
-        ...options.headers
-      },
-      body: options.body,
-      endpoint
-    };
-    const ctx = {
-      request,
-      retry: false,
-      retryCount: 0,
-      maxRetries: 3,
-      updateAuth: (credentials) => this.updateAuth(credentials)
-    };
-    const coreHandler = async () => {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-      try {
-        const response2 = await fetch(ctx.request.url, {
-          method: ctx.request.method,
-          body: ctx.request.body,
-          headers: ctx.request.headers,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (!response2.ok) {
-          await this.handleErrorResponse(response2);
-        }
-        const text = await response2.text();
-        const data = text ? JSON.parse(text) : {};
-        return {
-          data,
-          status: response2.status,
-          headers: response2.headers
-        };
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (error instanceof MantleAPIError) {
-          throw error;
-        }
-        if (error instanceof Error && error.name === "AbortError") {
-          throw new MantleAPIError("Request timeout", 408);
-        }
-        throw new MantleAPIError(
-          error instanceof Error ? error.message : "Unknown error occurred",
-          500
-        );
-      }
-    };
-    const response = await this.middlewareManager.execute(ctx, coreHandler);
-    return response.data;
-  }
-  /**
-   * Direct request execution (no middleware)
-   */
-  async executeRequest(endpoint, options) {
-    const authHeader = this.getAuthHeader();
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(`${this.baseURL}${endpoint}`, {
-        method: options.method,
-        body: options.body,
-        headers: {
-          Authorization: authHeader,
-          "Content-Type": "application/json",
-          ...options.headers
-        },
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-      const text = await response.text();
-      if (!text) {
-        return {};
-      }
-      return JSON.parse(text);
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof MantleAPIError) {
-        throw error;
-      }
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new MantleAPIError("Request timeout", 408);
-      }
-      throw new MantleAPIError(
-        error instanceof Error ? error.message : "Unknown error occurred",
-        500
-      );
-    }
-  }
-  /**
-   * Gets the authorization header value
-   */
-  getAuthHeader() {
-    if (this.accessToken) {
-      return `Bearer ${this.accessToken}`;
-    }
-    if (this.apiKey) {
-      return `Bearer ${this.apiKey}`;
-    }
-    throw new MantleAuthenticationError(
-      "Authentication not configured. Please set up API key or OAuth."
-    );
-  }
-  /**
-   * Handles error responses from the API
-   */
-  async handleErrorResponse(response) {
-    let errorData = {};
-    try {
-      const text = await response.text();
-      if (text) {
-        errorData = JSON.parse(text);
-      }
-    } catch {
-    }
-    const message = errorData.error || `API request failed: ${response.status}`;
-    switch (response.status) {
-      case 401:
-        throw new MantleAuthenticationError(message);
-      case 403:
-        throw new MantlePermissionError(message);
-      case 404:
-        throw new MantleAPIError(message, 404, errorData.details);
-      case 422:
-        throw new MantleValidationError(message, errorData.details);
-      case 429: {
-        const retryAfter = response.headers.get("Retry-After");
-        throw new MantleRateLimitError(
-          message,
-          retryAfter ? parseInt(retryAfter, 10) : void 0
-        );
-      }
-      default:
-        throw new MantleAPIError(message, response.status, errorData.details);
-    }
-  }
 };
 
 // src/middleware/auth-refresh.ts
 function createAuthRefreshMiddleware(options) {
   const {
     refreshToken,
+    updateAuth,
     onRefreshSuccess,
     onRefreshFailed,
     maxRefreshAttempts = 1
   } = options;
   let refreshAttempts = 0;
-  return async (ctx, next) => {
-    try {
-      await next();
-    } catch (error) {
-      if (!(error instanceof MantleAuthenticationError)) {
-        throw error;
-      }
+  return {
+    async onResponse({ request, response }) {
+      if (response.status !== 401) return void 0;
       if (refreshAttempts >= maxRefreshAttempts) {
         refreshAttempts = 0;
-        throw error;
+        return void 0;
       }
       refreshAttempts++;
       try {
         const newToken = await refreshToken();
-        ctx.updateAuth({ accessToken: newToken });
-        ctx.request.headers.Authorization = `Bearer ${newToken}`;
+        updateAuth(newToken);
         onRefreshSuccess?.(newToken);
-        ctx.retry = true;
         refreshAttempts = 0;
+        const headers = new Headers(request.headers);
+        headers.set("Authorization", `Bearer ${newToken}`);
+        return fetch(new Request(request.url, {
+          method: request.method,
+          headers,
+          body: request.body,
+          signal: request.signal
+        }));
       } catch (refreshError) {
         refreshAttempts = 0;
         onRefreshFailed?.(refreshError);
-        throw new MantleAuthenticationError(
-          "Authentication failed. Please re-authenticate."
-        );
+        return void 0;
       }
     }
   };
@@ -3208,69 +1353,52 @@ var RateLimiter = class {
     this.burstWindowMs = options.burstWindowMs;
     this.throttleThreshold = options.throttleThreshold;
   }
-  /**
-   * Prune timestamps older than the burst window
-   */
   prune() {
-    const now = Date.now();
-    const cutoff = now - this.burstWindowMs;
+    const cutoff = Date.now() - this.burstWindowMs;
     this.timestamps = this.timestamps.filter((ts) => ts > cutoff);
   }
-  /**
-   * Get current usage statistics
-   */
   getUsage() {
     this.prune();
-    const now = Date.now();
-    const oneMinuteAgo = now - 6e4;
+    const oneMinuteAgo = Date.now() - 6e4;
     const minuteUsage = this.timestamps.filter((ts) => ts > oneMinuteAgo).length;
-    const burstUsage = this.timestamps.length;
-    return { minuteUsage, burstUsage };
+    return { minuteUsage, burstUsage: this.timestamps.length };
   }
-  /**
-   * Calculate the delay needed before the next request can be made
-   * Returns 0 if no delay is needed
-   */
   getDelay() {
     const { minuteUsage, burstUsage } = this.getUsage();
     const minuteThreshold = Math.floor(this.requestsPerMinute * this.throttleThreshold);
     const burstThreshold = Math.floor(this.burstLimit * this.throttleThreshold);
+    const now = Date.now();
     if (minuteUsage >= minuteThreshold) {
-      const now = Date.now();
       const oneMinuteAgo = now - 6e4;
-      const oldestInMinute = this.timestamps.find((ts) => ts > oneMinuteAgo);
-      if (oldestInMinute) {
-        const delay = oldestInMinute + 6e4 - now;
-        if (delay > 0) {
-          return delay;
-        }
+      const oldest = this.timestamps.find((ts) => ts > oneMinuteAgo);
+      if (oldest) {
+        const delay = oldest + 6e4 - now;
+        if (delay > 0) return delay;
       }
     }
     if (burstUsage >= burstThreshold) {
-      const now = Date.now();
       const burstCutoff = now - this.burstWindowMs;
-      const oldestInBurst = this.timestamps.find((ts) => ts > burstCutoff);
-      if (oldestInBurst) {
-        const delay = oldestInBurst + this.burstWindowMs - now;
-        if (delay > 0) {
-          return delay;
-        }
+      const oldest = this.timestamps.find((ts) => ts > burstCutoff);
+      if (oldest) {
+        const delay = oldest + this.burstWindowMs - now;
+        if (delay > 0) return delay;
       }
     }
     return 0;
   }
-  /**
-   * Record a request timestamp
-   */
   recordRequest() {
     this.timestamps.push(Date.now());
   }
 };
-function calculateRetryDelay(retryAfter, retryCount, options) {
+function calculateRetryDelay(retryAfterHeader, retryCount, options) {
+  if (retryAfterHeader) {
+    const retryAfter = parseInt(retryAfterHeader, 10);
+    if (!isNaN(retryAfter) && retryAfter > 0) {
+      return retryAfter * 1e3;
+    }
+  }
   let delay;
-  if (retryAfter !== void 0 && retryAfter > 0) {
-    return retryAfter * 1e3;
-  } else if (options.exponentialBackoff) {
+  if (options.exponentialBackoff) {
     delay = options.baseDelay * Math.pow(2, retryCount);
   } else {
     delay = options.baseDelay;
@@ -3294,37 +1422,42 @@ function createRateLimitMiddleware(options = {}) {
     burstWindowMs = 3e5,
     throttleThreshold = 0.9
   } = options;
-  const rateLimiter = enableThrottle ? new RateLimiter({
-    requestsPerMinute,
-    burstLimit,
-    burstWindowMs,
-    throttleThreshold
-  }) : null;
-  return async (ctx, next) => {
-    if (rateLimiter) {
-      const delay = rateLimiter.getDelay();
-      if (delay > 0) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-    try {
-      await next();
-      rateLimiter?.recordRequest();
-    } catch (error) {
-      rateLimiter?.recordRequest();
-      if (enableRetry && error instanceof MantleRateLimitError) {
-        if (ctx.retryCount < maxRetries) {
-          const delay = calculateRetryDelay(error.retryAfter, ctx.retryCount, {
-            baseDelay,
-            exponentialBackoff,
-            jitter
-          });
+  const rateLimiter = enableThrottle ? new RateLimiter({ requestsPerMinute, burstLimit, burstWindowMs, throttleThreshold }) : null;
+  let retryCount = 0;
+  return {
+    async onRequest({ request }) {
+      if (rateLimiter) {
+        const delay = rateLimiter.getDelay();
+        if (delay > 0) {
           await new Promise((resolve) => setTimeout(resolve, delay));
-          ctx.retry = true;
-          return;
         }
       }
-      throw error;
+      return request;
+    },
+    async onResponse({ request, response }) {
+      rateLimiter?.recordRequest();
+      if (response.status !== 429 || !enableRetry) return void 0;
+      if (retryCount >= maxRetries) {
+        retryCount = 0;
+        return void 0;
+      }
+      const delay = calculateRetryDelay(
+        response.headers.get("Retry-After"),
+        retryCount,
+        { baseDelay, exponentialBackoff, jitter }
+      );
+      retryCount++;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      const retryResponse = await fetch(new Request(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: request.signal
+      }));
+      if (retryResponse.status !== 429) {
+        retryCount = 0;
+      }
+      return retryResponse;
     }
   };
 }
@@ -3336,6 +1469,7 @@ function createRateLimitMiddleware(options = {}) {
   AffiliateReferralsResource,
   AffiliatesResource,
   AgentsResource,
+  AiAgentRunsResource,
   AppsResource,
   BaseResource,
   ChannelsResource,
@@ -3349,8 +1483,12 @@ function createRateLimitMiddleware(options = {}) {
   DealFlowsResource,
   DealsResource,
   DocsResource,
+  EmailUnsubscribeGroupsResource,
   EntitiesResource,
+  FlowExtensionsResource,
   FlowsResource,
+  JournalEntriesResource,
+  ListsResource,
   MantleAPIError,
   MantleAuthenticationError,
   MantleCoreClient,
@@ -3359,13 +1497,14 @@ function createRateLimitMiddleware(options = {}) {
   MantleRateLimitError,
   MantleValidationError,
   MeResource,
+  MeetingsResource,
   MetricsResource,
-  MiddlewareManager,
   OrganizationResource,
   SubscriptionsResource,
   SyncedEmailsResource,
   TasksResource,
   TicketsResource,
+  TimelineCommentsResource,
   TransactionsResource,
   UsageEventsResource,
   UsersResource,