@heymantle/core-api-client 0.1.0

package/dist/index.js

@@ -0,0 +1,1846 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AffiliateCommissionsResource: () => AffiliateCommissionsResource,
+  AffiliatePayoutsResource: () => AffiliatePayoutsResource,
+  AffiliateProgramsResource: () => AffiliateProgramsResource,
+  AffiliateReferralsResource: () => AffiliateReferralsResource,
+  AffiliatesResource: () => AffiliatesResource,
+  AgentsResource: () => AgentsResource,
+  AppsResource: () => AppsResource,
+  BaseResource: () => BaseResource,
+  ChannelsResource: () => ChannelsResource,
+  ChargesResource: () => ChargesResource,
+  CompaniesResource: () => CompaniesResource,
+  ContactsResource: () => ContactsResource,
+  CustomerSegmentsResource: () => CustomerSegmentsResource,
+  CustomersResource: () => CustomersResource,
+  DealActivitiesResource: () => DealActivitiesResource,
+  DealFlowsResource: () => DealFlowsResource,
+  DealsResource: () => DealsResource,
+  DocsResource: () => DocsResource,
+  FlowsResource: () => FlowsResource,
+  MantleAPIError: () => MantleAPIError,
+  MantleAuthenticationError: () => MantleAuthenticationError,
+  MantleCoreClient: () => MantleCoreClient,
+  MantleNotFoundError: () => MantleNotFoundError,
+  MantlePermissionError: () => MantlePermissionError,
+  MantleRateLimitError: () => MantleRateLimitError,
+  MantleValidationError: () => MantleValidationError,
+  MeResource: () => MeResource,
+  MetricsResource: () => MetricsResource,
+  OrganizationResource: () => OrganizationResource,
+  SubscriptionsResource: () => SubscriptionsResource,
+  TasksResource: () => TasksResource,
+  TicketsResource: () => TicketsResource,
+  TransactionsResource: () => TransactionsResource,
+  UsageEventsResource: () => UsageEventsResource,
+  UsersResource: () => UsersResource,
+  WebhooksResource: () => WebhooksResource
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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)) {
+      value.forEach((v) => searchParams.append(key, String(v)));
+    } else if (value !== null && value !== void 0) {
+      searchParams.append(key, String(value));
+    }
+  }
+  return searchParams.toString();
+}
+
+// src/utils/errors.ts
+var MantleAPIError = class _MantleAPIError extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.name = "MantleAPIError";
+    this.statusCode = statusCode;
+    this.details = details;
+    Object.setPrototypeOf(this, _MantleAPIError.prototype);
+  }
+  static fromResponse(response, statusCode) {
+    return new _MantleAPIError(response.error, statusCode, response.details);
+  }
+};
+var MantleAuthenticationError = class _MantleAuthenticationError extends MantleAPIError {
+  constructor(message = "Authentication failed") {
+    super(message, 401);
+    this.name = "MantleAuthenticationError";
+    Object.setPrototypeOf(this, _MantleAuthenticationError.prototype);
+  }
+};
+var MantlePermissionError = class _MantlePermissionError extends MantleAPIError {
+  constructor(message = "Permission denied") {
+    super(message, 403);
+    this.name = "MantlePermissionError";
+    Object.setPrototypeOf(this, _MantlePermissionError.prototype);
+  }
+};
+var MantleNotFoundError = class _MantleNotFoundError extends MantleAPIError {
+  constructor(resource, id) {
+    super(`${resource} with id '${id}' not found`, 404);
+    this.name = "MantleNotFoundError";
+    Object.setPrototypeOf(this, _MantleNotFoundError.prototype);
+  }
+};
+var MantleValidationError = class _MantleValidationError extends MantleAPIError {
+  constructor(message, details) {
+    super(message, 422, details);
+    this.name = "MantleValidationError";
+    Object.setPrototypeOf(this, _MantleValidationError.prototype);
+  }
+};
+var MantleRateLimitError = class _MantleRateLimitError extends MantleAPIError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, 429);
+    this.name = "MantleRateLimitError";
+    this.retryAfter = retryAfter;
+    Object.setPrototypeOf(this, _MantleRateLimitError.prototype);
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get(endpoint, params) {
+    return this.client.get(endpoint, params);
+  }
+  post(endpoint, data) {
+    return this.client.post(endpoint, data);
+  }
+  put(endpoint, data) {
+    return this.client.put(endpoint, data);
+  }
+  _delete(endpoint) {
+    return this.client.delete(endpoint);
+  }
+};
+
+// 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
+    };
+  }
+  /**
+   * Retrieve a single customer by ID
+   */
+  async retrieve(customerId, params) {
+    return this.get(
+      `/customers/${customerId}`,
+      params
+    );
+  }
+  /**
+   * Create a new customer
+   */
+  async create(data) {
+    return this.post("/customers", data);
+  }
+  /**
+   * Update an existing customer
+   */
+  async update(customerId, data) {
+    return this.put(
+      `/customers/${customerId}`,
+      data
+    );
+  }
+  /**
+   * Add tags to a customer
+   */
+  async addTags(customerId, tags) {
+    return this.post(
+      `/customers/${customerId}/addTags`,
+      { tags }
+    );
+  }
+  /**
+   * Remove tags from a customer
+   */
+  async removeTags(customerId, tags) {
+    return this.post(
+      `/customers/${customerId}/removeTags`,
+      { 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
+    };
+  }
+  /**
+   * List account owners for a customer
+   */
+  async listAccountOwners(customerId) {
+    return this.get(
+      `/customers/${customerId}/account_owners`
+    );
+  }
+  /**
+   * Add an account owner to a customer
+   */
+  async addAccountOwner(customerId, data) {
+    return this.post(`/customers/${customerId}/account_owners`, data);
+  }
+  /**
+   * Remove an account owner from a customer
+   */
+  async removeAccountOwner(customerId, ownerId) {
+    return this._delete(
+      `/customers/${customerId}/account_owners/${ownerId}`
+    );
+  }
+  /**
+   * List custom fields
+   */
+  async listCustomFields(params) {
+    return this.get(
+      "/customers/custom_fields",
+      params
+    );
+  }
+  /**
+   * Create a custom field
+   */
+  async createCustomField(data) {
+    return this.post(
+      "/customers/custom_fields",
+      data
+    );
+  }
+  /**
+   * Retrieve a custom field by ID
+   */
+  async retrieveCustomField(fieldId) {
+    return this.get(
+      `/customers/custom_fields/${fieldId}`
+    );
+  }
+  /**
+   * Update a custom field
+   */
+  async updateCustomField(fieldId, data) {
+    return this.put(
+      `/customers/custom_fields/${fieldId}`,
+      data
+    );
+  }
+  /**
+   * Delete a custom field
+   */
+  async deleteCustomField(fieldId) {
+    return this._delete(
+      `/customers/custom_fields/${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
+    };
+  }
+  /**
+   * Retrieve a single contact by ID
+   */
+  async retrieve(contactId) {
+    return this.get(`/contacts/${contactId}`);
+  }
+  /**
+   * Create a new contact
+   */
+  async create(data) {
+    return this.post("/contacts", data);
+  }
+  /**
+   * Update an existing contact
+   */
+  async update(contactId, data) {
+    return this.put(`/contacts/${contactId}`, data);
+  }
+  /**
+   * Delete a contact
+   */
+  async del(contactId) {
+    return this._delete(`/contacts/${contactId}`);
+  }
+  /**
+   * Add tags to a contact
+   */
+  async addTags(contactId, tags) {
+    return this.post(
+      `/contacts/${contactId}/addTags`,
+      { tags }
+    );
+  }
+  /**
+   * Remove tags from a contact
+   */
+  async removeTags(contactId, tags) {
+    return this.post(
+      `/contacts/${contactId}/removeTags`,
+      { tags }
+    );
+  }
+};
+
+// src/resources/subscriptions.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single subscription by ID
+   */
+  async retrieve(subscriptionId) {
+    return this.get(
+      `/subscriptions/${subscriptionId}`
+    );
+  }
+};
+
+// src/resources/usage-events.ts
+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
+    };
+  }
+  /**
+   * Create usage event(s)
+   *
+   * @example
+   * // Single event
+   * await client.usageEvents.create({
+   *   eventName: 'api_call',
+   *   customerId: 'cust_123',
+   *   appId: 'app_456',
+   *   properties: { endpoint: '/users' },
+   * });
+   *
+   * @example
+   * // Multiple events
+   * await client.usageEvents.create({
+   *   events: [
+   *     { eventName: 'api_call', customerId: 'cust_123', appId: 'app_456' },
+   *     { eventName: 'api_call', customerId: 'cust_789', appId: 'app_456' },
+   *   ],
+   * });
+   */
+  async create(data) {
+    return this.post("/usage_events", data);
+  }
+};
+
+// src/resources/apps.ts
+var AppsResource = class extends BaseResource {
+  /**
+   * List all apps
+   */
+  async list(params) {
+    return this.get("/apps", params);
+  }
+  /**
+   * Retrieve a single app by ID
+   */
+  async retrieve(appId) {
+    return this.get(`/apps/${appId}`);
+  }
+  // ========== Plans ==========
+  /**
+   * List plans for an app
+   */
+  async listPlans(appId, params) {
+    return this.get(`/apps/${appId}/plans`, params);
+  }
+  /**
+   * Retrieve a single plan
+   */
+  async retrievePlan(appId, planId) {
+    return this.get(`/apps/${appId}/plans/${planId}`);
+  }
+  /**
+   * Create a new plan for an app
+   */
+  async createPlan(appId, data) {
+    return this.post(`/apps/${appId}/plans`, data);
+  }
+  /**
+   * Update an existing plan
+   */
+  async updatePlan(appId, planId, data) {
+    return this.put(`/apps/${appId}/plans/${planId}`, data);
+  }
+  /**
+   * Archive a plan
+   */
+  async archivePlan(appId, planId) {
+    return this.post(
+      `/apps/${appId}/plans/${planId}/archive`,
+      {}
+    );
+  }
+  /**
+   * Unarchive a plan
+   */
+  async unarchivePlan(appId, planId) {
+    return this.post(
+      `/apps/${appId}/plans/${planId}/unarchive`,
+      {}
+    );
+  }
+  // ========== Features ==========
+  /**
+   * List features for an app
+   */
+  async listFeatures(appId) {
+    return this.get(`/apps/${appId}/plans/features`);
+  }
+  /**
+   * Retrieve a single feature
+   */
+  async retrieveFeature(appId, featureId) {
+    return this.get(
+      `/apps/${appId}/plans/features/${featureId}`
+    );
+  }
+  /**
+   * Create a new feature for an app
+   */
+  async createFeature(appId, data) {
+    return this.post(
+      `/apps/${appId}/plans/features`,
+      data
+    );
+  }
+  /**
+   * Update an existing feature
+   */
+  async updateFeature(appId, featureId, data) {
+    return this.put(
+      `/apps/${appId}/plans/features/${featureId}`,
+      data
+    );
+  }
+  /**
+   * Delete a feature
+   */
+  async deleteFeature(appId, featureId) {
+    return this._delete(
+      `/apps/${appId}/plans/features/${featureId}`
+    );
+  }
+  // ========== Reviews ==========
+  /**
+   * List reviews for an app
+   */
+  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}`);
+  }
+  // ========== 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 }
+    );
+  }
+  // ========== Usage Metrics ==========
+  /**
+   * List usage metrics for an app
+   */
+  async listUsageMetrics(appId) {
+    return this.get(
+      `/apps/${appId}/usage_metrics`
+    );
+  }
+  /**
+   * Retrieve a single usage metric
+   */
+  async retrieveUsageMetric(appId, usageMetricId) {
+    return this.get(
+      `/apps/${appId}/usage_metrics/${usageMetricId}`
+    );
+  }
+  /**
+   * Create a new usage metric for an app
+   */
+  async createUsageMetric(appId, data) {
+    return this.post(
+      `/apps/${appId}/usage_metrics`,
+      data
+    );
+  }
+  /**
+   * Update an existing usage metric
+   */
+  async updateUsageMetric(appId, usageMetricId, data) {
+    return this.put(
+      `/apps/${appId}/usage_metrics/${usageMetricId}`,
+      data
+    );
+  }
+  /**
+   * Delete a usage metric
+   */
+  async deleteUsageMetric(appId, usageMetricId) {
+    return this._delete(
+      `/apps/${appId}/usage_metrics/${usageMetricId}`
+    );
+  }
+  // ========== App Events ==========
+  /**
+   * List 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
+    };
+  }
+};
+
+// 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
+    };
+  }
+  /**
+   * Retrieve a single deal by ID
+   */
+  async retrieve(dealId) {
+    return this.get(`/deals/${dealId}`);
+  }
+  /**
+   * Create a new deal
+   */
+  async create(data) {
+    return this.post("/deals", data);
+  }
+  /**
+   * Update an existing deal
+   */
+  async update(dealId, data) {
+    return this.put(`/deals/${dealId}`, data);
+  }
+  /**
+   * Archive (soft delete) a deal
+   */
+  async del(dealId) {
+    return this._delete(`/deals/${dealId}`);
+  }
+  /**
+   * Get deal activity timeline
+   */
+  async getTimeline(dealId) {
+    const response = await this.get(
+      `/deals/${dealId}/timeline`
+    );
+    return {
+      events: response.events || [],
+      hasNextPage: response.hasNextPage || false,
+      hasPreviousPage: response.hasPreviousPage || false,
+      cursor: response.cursor
+    };
+  }
+  /**
+   * Get deal events
+   */
+  async getEvents(dealId) {
+    return this.get(`/deals/${dealId}/events`);
+  }
+};
+
+// src/resources/deal-flows.ts
+var DealFlowsResource = class extends BaseResource {
+  /**
+   * List all deal flows
+   */
+  async list() {
+    return this.get("/deal_flows");
+  }
+  /**
+   * Retrieve a single deal flow by ID
+   */
+  async retrieve(dealFlowId) {
+    return this.get(`/deal_flows/${dealFlowId}`);
+  }
+  /**
+   * Create a new deal flow
+   */
+  async create(data) {
+    return this.post("/deal_flows", data);
+  }
+  /**
+   * Update an existing deal flow
+   */
+  async update(dealFlowId, data) {
+    return this.put(
+      `/deal_flows/${dealFlowId}`,
+      data
+    );
+  }
+  /**
+   * Delete a deal flow
+   */
+  async del(dealFlowId) {
+    return this._delete(`/deal_flows/${dealFlowId}`);
+  }
+};
+
+// src/resources/deal-activities.ts
+var DealActivitiesResource = class extends BaseResource {
+  /**
+   * List all deal activities
+   */
+  async list() {
+    return this.get("/deal_activities");
+  }
+  /**
+   * Retrieve a single deal activity by ID
+   */
+  async retrieve(dealActivityId) {
+    return this.get(
+      `/deal_activities/${dealActivityId}`
+    );
+  }
+  /**
+   * Create a new deal activity
+   */
+  async create(data) {
+    return this.post("/deal_activities", data);
+  }
+  /**
+   * Update an existing deal activity
+   */
+  async update(dealActivityId, data) {
+    return this.put(
+      `/deal_activities/${dealActivityId}`,
+      data
+    );
+  }
+  /**
+   * Delete a deal activity
+   */
+  async del(dealActivityId) {
+    return this._delete(`/deal_activities/${dealActivityId}`);
+  }
+};
+
+// src/resources/tickets.ts
+var TicketsResource = class extends BaseResource {
+  /**
+   * List tickets with optional filters and pagination
+   */
+  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
+    };
+  }
+  /**
+   * Retrieve a single ticket by ID
+   */
+  async retrieve(ticketId) {
+    return this.get(`/tickets/${ticketId}`);
+  }
+  /**
+   * Create a new ticket
+   */
+  async create(data) {
+    return this.post("/tickets", 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}`);
+  }
+  // ========== Messages ==========
+  /**
+   * List messages for a ticket
+   */
+  async listMessages(ticketId) {
+    return this.get(
+      `/tickets/${ticketId}/messages`
+    );
+  }
+  /**
+   * Retrieve a single message
+   */
+  async retrieveMessage(ticketId, messageId) {
+    return this.get(
+      `/tickets/${ticketId}/messages/${messageId}`
+    );
+  }
+  /**
+   * Create a new message on a ticket
+   */
+  async createMessage(ticketId, data) {
+    return this.post(
+      `/tickets/${ticketId}/messages`,
+      data
+    );
+  }
+  /**
+   * Update a message
+   */
+  async updateMessage(ticketId, messageId, data) {
+    return this.put(
+      `/tickets/${ticketId}/messages/${messageId}`,
+      data
+    );
+  }
+  /**
+   * Delete a message
+   */
+  async deleteMessage(ticketId, messageId) {
+    return this._delete(
+      `/tickets/${ticketId}/messages/${messageId}`
+    );
+  }
+};
+
+// src/resources/channels.ts
+var ChannelsResource = class extends BaseResource {
+  /**
+   * List CX channels
+   */
+  async list(params) {
+    return this.get("/channels", params);
+  }
+  /**
+   * Create a new CX channel
+   */
+  async create(data) {
+    return this.post("/channels", data);
+  }
+};
+
+// src/resources/flows.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single flow by ID
+   */
+  async retrieve(flowId) {
+    return this.get(`/flows/${flowId}`);
+  }
+  /**
+   * Create a new flow
+   */
+  async create(data) {
+    return this.post("/flows", data);
+  }
+  /**
+   * Update an existing flow
+   */
+  async update(flowId, data) {
+    return this.put(`/flows/${flowId}`, data);
+  }
+  /**
+   * Delete a flow
+   */
+  async del(flowId) {
+    return this._delete(`/flows/${flowId}`);
+  }
+};
+
+// src/resources/tasks.ts
+var TasksResource = class extends BaseResource {
+  /**
+   * List tasks with optional filters and pagination
+   */
+  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
+    };
+  }
+  /**
+   * Retrieve a single task by ID
+   */
+  async retrieve(taskId) {
+    return this.get(`/tasks/${taskId}`);
+  }
+  /**
+   * Create a new task
+   */
+  async create(data) {
+    return this.post("/tasks", data);
+  }
+  /**
+   * Update an existing task
+   */
+  async update(taskId, data) {
+    return this.put(`/tasks/${taskId}`, data);
+  }
+  /**
+   * Delete a task
+   */
+  async del(taskId) {
+    return this._delete(`/tasks/${taskId}`);
+  }
+};
+
+// src/resources/webhooks.ts
+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}`);
+  }
+  /**
+   * Create a new webhook
+   */
+  async create(data) {
+    return this.post("/webhooks", data);
+  }
+  /**
+   * Update an existing webhook
+   */
+  async update(webhookId, data) {
+    return this.put(`/webhooks/${webhookId}`, data);
+  }
+  /**
+   * Delete a webhook
+   */
+  async del(webhookId) {
+    return this._delete(`/webhooks/${webhookId}`);
+  }
+};
+
+// src/resources/companies.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single company by ID
+   */
+  async retrieve(companyId) {
+    return this.get(`/companies/${companyId}`);
+  }
+  /**
+   * Create a new company
+   */
+  async create(data) {
+    return this.post("/companies", data);
+  }
+  /**
+   * Update an existing company
+   */
+  async update(companyId, data) {
+    return this.put(`/companies/${companyId}`, data);
+  }
+  /**
+   * Delete a company
+   */
+  async del(companyId) {
+    return this._delete(`/companies/${companyId}`);
+  }
+};
+
+// src/resources/customer-segments.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single customer segment by ID
+   */
+  async retrieve(segmentId) {
+    return this.get(
+      `/customer_segments/${segmentId}`
+    );
+  }
+};
+
+// src/resources/affiliates.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single affiliate by ID
+   */
+  async retrieve(affiliateId) {
+    return this.get(`/affiliates/${affiliateId}`);
+  }
+  /**
+   * Update an existing affiliate
+   */
+  async update(affiliateId, data) {
+    return this.put(
+      `/affiliates/${affiliateId}`,
+      data
+    );
+  }
+};
+
+// src/resources/affiliate-programs.ts
+var AffiliateProgramsResource = class extends BaseResource {
+  /**
+   * List all affiliate programs
+   */
+  async list() {
+    return this.get(
+      "/affiliate_programs"
+    );
+  }
+  /**
+   * Retrieve a single affiliate program by ID
+   */
+  async retrieve(programId) {
+    return this.get(
+      `/affiliate_programs/${programId}`
+    );
+  }
+  /**
+   * Create a new affiliate program
+   */
+  async create(data) {
+    return this.post(
+      "/affiliate_programs",
+      data
+    );
+  }
+  /**
+   * Update an existing affiliate program
+   */
+  async update(programId, data) {
+    return this.put(
+      `/affiliate_programs/${programId}`,
+      data
+    );
+  }
+  /**
+   * Delete an affiliate program
+   */
+  async del(programId) {
+    return this._delete(`/affiliate_programs/${programId}`);
+  }
+};
+
+// src/resources/affiliate-commissions.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single affiliate commission by ID
+   */
+  async retrieve(commissionId) {
+    return this.get(
+      `/affiliate_commissions/${commissionId}`
+    );
+  }
+};
+
+// src/resources/affiliate-payouts.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single affiliate payout by ID
+   */
+  async retrieve(payoutId) {
+    return this.get(
+      `/affiliate_payouts/${payoutId}`
+    );
+  }
+};
+
+// src/resources/affiliate-referrals.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single affiliate referral by ID
+   */
+  async retrieve(referralId) {
+    return this.get(
+      `/affiliate_referrals/${referralId}`
+    );
+  }
+};
+
+// src/resources/charges.ts
+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
+    };
+  }
+};
+
+// src/resources/transactions.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single transaction by ID
+   */
+  async retrieve(transactionId) {
+    return this.get(
+      `/transactions/${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
+    };
+  }
+  /**
+   * Get Annual Recurring Revenue (ARR)
+   */
+  async arr(params) {
+    return this.fetch({
+      metric: "PlatformApp.arr",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get Monthly Recurring Revenue (MRR)
+   */
+  async mrr(params) {
+    return this.fetch({
+      metric: "PlatformApp.mrr",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get active subscriptions count
+   */
+  async activeSubscriptions(params) {
+    return this.fetch({
+      metric: "PlatformApp.activeSubscriptions",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get active installations count
+   */
+  async activeInstalls(params) {
+    return this.fetch({
+      metric: "PlatformApp.activeInstalls",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get net new installations
+   */
+  async netInstalls(params) {
+    return this.fetch({
+      metric: "PlatformApp.netInstalls",
+      dateRange: params.dateRange || "last_30_days",
+      ...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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * Get revenue retention rate
+   */
+  async revenueRetention(params) {
+    return this.fetch({
+      metric: "PlatformApp.revenueRetention",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get net revenue retention rate
+   */
+  async netRevenueRetention(params) {
+    return this.fetch({
+      metric: "PlatformApp.netRevenueRetention",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get net revenue
+   */
+  async netRevenue(params) {
+    return this.fetch({
+      metric: "PlatformApp.netRevenue",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get payout amount
+   */
+  async payout(params) {
+    return this.fetch({
+      metric: "PlatformApp.payout",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+  /**
+   * Get predicted Lifetime Value
+   */
+  async predictedLtv(params) {
+    return this.fetch({
+      metric: "PlatformApp.predictedLtv",
+      dateRange: params.dateRange || "last_30_days",
+      ...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
+    });
+  }
+  /**
+   * Get usage metric data
+   */
+  async usageMetric(params) {
+    return this.fetch({
+      metric: "PlatformApp.usageMetric",
+      dateRange: params.dateRange || "last_30_days",
+      ...params
+    });
+  }
+};
+
+// src/resources/users.ts
+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
+    };
+  }
+  /**
+   * Retrieve a single user by ID
+   */
+  async retrieve(userId) {
+    return this.get(`/users/${userId}`);
+  }
+};
+
+// src/resources/me.ts
+var MeResource = class extends BaseResource {
+  /**
+   * Get current user and organization info
+   */
+  async retrieve() {
+    return this.client.get("/me");
+  }
+};
+
+// src/resources/organization.ts
+var OrganizationResource = class extends BaseResource {
+  /**
+   * Get organization details
+   */
+  async retrieve() {
+    return this.client.get("/organization");
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class extends BaseResource {
+  /**
+   * List support agents
+   */
+  async list() {
+    return this.get("/agents");
+  }
+};
+
+// src/resources/docs.ts
+var DocsResource = class extends BaseResource {
+  // ========== Collections ==========
+  /**
+   * List all doc collections
+   */
+  async listCollections() {
+    return this.get("/docs/collections");
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Update a doc collection
+   */
+  async updateCollection(collectionId, data) {
+    return this.put(
+      `/docs/collections/${collectionId}`,
+      data
+    );
+  }
+  /**
+   * Delete a doc collection
+   */
+  async deleteCollection(collectionId) {
+    return this._delete(`/docs/collections/${collectionId}`);
+  }
+  // ========== Groups ==========
+  /**
+   * List all doc groups
+   */
+  async listGroups() {
+    return this.get("/docs/groups");
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Update a doc group
+   */
+  async updateGroup(groupId, data) {
+    return this.put(`/docs/groups/${groupId}`, data);
+  }
+  /**
+   * Delete a doc group
+   */
+  async deleteGroup(groupId) {
+    return this._delete(`/docs/groups/${groupId}`);
+  }
+  // ========== Pages ==========
+  /**
+   * List doc pages with optional filters
+   */
+  async listPages(params) {
+    const response = await this.get("/docs/pages", params);
+    return {
+      pages: response.pages || [],
+      hasNextPage: response.hasNextPage || false,
+      hasPreviousPage: response.hasPreviousPage || false
+    };
+  }
+  /**
+   * Retrieve a single doc page
+   */
+  async retrievePage(pageId) {
+    return this.get(`/docs/pages/${pageId}`);
+  }
+  /**
+   * Create a new doc page
+   */
+  async createPage(data) {
+    return this.post("/docs/pages", 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`, {});
+  }
+  /**
+   * Delete a doc page
+   */
+  async deletePage(pageId) {
+    return this._delete(`/docs/pages/${pageId}`);
+  }
+  // ========== Tree ==========
+  /**
+   * Get the full documentation tree structure
+   */
+  async getTree() {
+    return this.get("/docs/tree");
+  }
+};
+
+// src/client.ts
+var MantleCoreClient = class {
+  constructor(config) {
+    if (!config.apiKey && !config.accessToken) {
+      throw new Error(
+        "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.customers = new CustomersResource(this);
+    this.contacts = new ContactsResource(this);
+    this.subscriptions = new SubscriptionsResource(this);
+    this.usageEvents = new UsageEventsResource(this);
+    this.apps = new AppsResource(this);
+    this.deals = new DealsResource(this);
+    this.dealFlows = new DealFlowsResource(this);
+    this.dealActivities = new DealActivitiesResource(this);
+    this.tickets = new TicketsResource(this);
+    this.channels = new ChannelsResource(this);
+    this.flows = new FlowsResource(this);
+    this.tasks = new TasksResource(this);
+    this.webhooks = new WebhooksResource(this);
+    this.companies = new CompaniesResource(this);
+    this.customerSegments = new CustomerSegmentsResource(this);
+    this.affiliates = new AffiliatesResource(this);
+    this.affiliatePrograms = new AffiliateProgramsResource(this);
+    this.affiliateCommissions = new AffiliateCommissionsResource(this);
+    this.affiliatePayouts = new AffiliatePayoutsResource(this);
+    this.affiliateReferrals = new AffiliateReferralsResource(this);
+    this.charges = new ChargesResource(this);
+    this.transactions = new TransactionsResource(this);
+    this.metrics = new MetricsResource(this);
+    this.users = new UsersResource(this);
+    this.me = new MeResource(this);
+    this.organization = new OrganizationResource(this);
+    this.agents = new AgentsResource(this);
+    this.docs = new DocsResource(this);
+  }
+  /**
+   * 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) {
+    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);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AffiliateCommissionsResource,
+  AffiliatePayoutsResource,
+  AffiliateProgramsResource,
+  AffiliateReferralsResource,
+  AffiliatesResource,
+  AgentsResource,
+  AppsResource,
+  BaseResource,
+  ChannelsResource,
+  ChargesResource,
+  CompaniesResource,
+  ContactsResource,
+  CustomerSegmentsResource,
+  CustomersResource,
+  DealActivitiesResource,
+  DealFlowsResource,
+  DealsResource,
+  DocsResource,
+  FlowsResource,
+  MantleAPIError,
+  MantleAuthenticationError,
+  MantleCoreClient,
+  MantleNotFoundError,
+  MantlePermissionError,
+  MantleRateLimitError,
+  MantleValidationError,
+  MeResource,
+  MetricsResource,
+  OrganizationResource,
+  SubscriptionsResource,
+  TasksResource,
+  TicketsResource,
+  TransactionsResource,
+  UsageEventsResource,
+  UsersResource,
+  WebhooksResource
+});