@masonlandcattle/servicetitan-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3167 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/client.ts
+import axios from "axios";
+import Bottleneck from "bottleneck";
+import qs from "qs";
+var ServiceTitanClient = class {
+  constructor(opts = {}) {
+    this.token = null;
+    this.tokenExpiry = null;
+    this.refreshing = null;
+    const env = opts.environment || process.env.ENVIRONMENT || "production";
+    const authUrl = opts.authUrl || (env === "production" ? "https://auth.servicetitan.io/connect/token" : "https://auth-integration.servicetitan.io/connect/token");
+    const apiBaseUrl = opts.apiBaseUrl || (env === "production" ? "https://api.servicetitan.io" : "https://api-integration.servicetitan.io");
+    const defaults = {
+      tenantId: opts.tenantId || process.env.TENANT_ID || "",
+      appKey: opts.appKey || process.env.APP_KEY || "",
+      clientId: opts.clientId || process.env.CLIENT_ID || "",
+      clientSecret: opts.clientSecret || process.env.SECRET_KEY || "",
+      environment: env,
+      authUrl,
+      apiBaseUrl,
+      timeoutMs: opts.timeoutMs ?? 3e4,
+      retries: opts.retries ?? 3,
+      retryInitialDelayMs: opts.retryInitialDelayMs ?? 1e3,
+      maxConcurrent: opts.maxConcurrent ?? 5,
+      minTimeMs: opts.minTimeMs ?? 100,
+      logger: opts.logger || console
+    };
+    if (!defaults.tenantId || !defaults.appKey || !defaults.clientId || !defaults.clientSecret) {
+      throw new Error("Missing required configuration: TENANT_ID, APP_KEY, CLIENT_ID, SECRET_KEY");
+    }
+    this.options = defaults;
+    this.limiter = new Bottleneck({
+      maxConcurrent: this.options.maxConcurrent,
+      minTime: this.options.minTimeMs
+    });
+    this.axiosInstance = axios.create({
+      baseURL: this.options.apiBaseUrl,
+      timeout: this.options.timeoutMs,
+      headers: {
+        "ST-App-Key": this.options.appKey,
+        "Content-Type": "application/json"
+      }
+    });
+    this.axiosInstance.interceptors.request.use((config) => {
+      if (this.token) {
+        config.headers = config.headers || {};
+        config.headers["Authorization"] = `Bearer ${this.token}`;
+      }
+      return config;
+    });
+    this.axiosInstance.interceptors.response.use(
+      (resp) => resp,
+      async (error) => {
+        const original = error.config;
+        if (error.response?.status === 401 && !original._retry) {
+          original._retry = true;
+          await this.refreshToken();
+          return this.axiosInstance(original);
+        }
+        throw error;
+      }
+    );
+  }
+  async refreshToken() {
+    if (this.refreshing) return this.refreshing;
+    this.refreshing = (async () => {
+      await this.authenticate();
+    })().finally(() => {
+      this.refreshing = null;
+    });
+    return this.refreshing;
+  }
+  async authenticate() {
+    if (this.token && this.tokenExpiry && Date.now() < this.tokenExpiry) {
+      return this.token;
+    }
+    const body = qs.stringify({
+      grant_type: "client_credentials",
+      client_id: this.options.clientId,
+      client_secret: this.options.clientSecret
+    });
+    try {
+      const resp = await axios.post(this.options.authUrl, body, {
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        timeout: this.options.timeoutMs
+      });
+      this.token = String(resp.data.access_token);
+      const expiresIn = Number(resp.data.expires_in || 900);
+      this.tokenExpiry = Date.now() + expiresIn * 1e3 - 5e3;
+      return this.token;
+    } catch (err) {
+      this.options.logger.error?.("ServiceTitan auth failed", err.response?.status, err.response?.data || err.message);
+      throw err;
+    }
+  }
+  async delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  computeBackoff(base, attempt) {
+    const exp = base * Math.pow(2, attempt);
+    const jitter = Math.random() * base;
+    return Math.min(3e4, exp + jitter);
+  }
+  isRetryable(error) {
+    if (!error) return true;
+    const status = error.response?.status;
+    if (!status) return true;
+    if (status === 429) return true;
+    if (status >= 500) return true;
+    return false;
+  }
+  async schedule(fn) {
+    return this.limiter.schedule(fn);
+  }
+  async request(method, endpoint, options = {}) {
+    await this.authenticate();
+    const { params, data, headers, retries } = options;
+    const maxRetries = retries ?? this.options.retries;
+    let attempt = 0;
+    while (true) {
+      try {
+        const result = await this.schedule(async () => {
+          const resp = await this.axiosInstance.request({ method, url: endpoint, params, data, headers });
+          return resp.data;
+        });
+        return result;
+      } catch (error) {
+        this.options.logger.warn?.("ServiceTitan API error", error.response?.status, error.response?.data || error.message);
+        if (attempt >= maxRetries || !this.isRetryable(error)) {
+          throw error.response?.data || error;
+        }
+        let delayMs = this.computeBackoff(this.options.retryInitialDelayMs, attempt);
+        const retryAfter = error.response?.headers?.["retry-after"];
+        if (retryAfter) {
+          const parsed = Number(retryAfter);
+          if (!Number.isNaN(parsed)) delayMs = Math.max(delayMs, parsed * 1e3);
+        }
+        await this.delay(delayMs);
+        attempt += 1;
+      }
+    }
+  }
+  buildPath(options) {
+    const version = options.version || "v2";
+    const tenant = options.tenantScoped !== false ? `/tenant/${this.options.tenantId}` : "";
+    const idSeg = options.idOrSubpath ? `/${String(options.idOrSubpath).replace(/^\/+/, "")}` : "";
+    return `/${options.category}/${version}${tenant}/${options.subject}${idSeg}`;
+  }
+  async getAll(path, params = {}, pageSize = 200) {
+    const aggregated = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const resp = await this.request("get", path, {
+        params: { ...params, page, pageSize }
+      });
+      aggregated.push(...resp.data || []);
+      hasMore = Boolean(resp.hasMore);
+      page += 1;
+    }
+    return aggregated;
+  }
+};
+function createClientFromEnv(overrides = {}) {
+  return new ServiceTitanClient(overrides);
+}
+
+// src/resources/accounting/index.ts
+var accounting_exports = {};
+__export(accounting_exports, {
+  createAdjustmentInvoice: () => createAdjustmentInvoice,
+  createGlAccount: () => createGlAccount,
+  deleteInvoiceItem: () => deleteInvoiceItem,
+  exportInventoryBills: () => exportInventoryBills,
+  getAllInventoryBills: () => getAllInventoryBills,
+  getAllInvoices: () => getAllInvoices,
+  getAllJournalEntries: () => getAllJournalEntries,
+  getAllPaymentTerms: () => getAllPaymentTerms,
+  getAllPaymentTypes: () => getAllPaymentTypes,
+  getAllPayments: () => getAllPayments,
+  getAllTaxZones: () => getAllTaxZones,
+  getGlAccount: () => getGlAccount,
+  getInventoryBillCustomFieldTypes: () => getInventoryBillCustomFieldTypes,
+  getInvoiceCustomFieldTypes: () => getInvoiceCustomFieldTypes,
+  getJournalEntriesSummary: () => getJournalEntriesSummary,
+  getJournalEntryDetails: () => getJournalEntryDetails,
+  getPaymentCustomFieldTypes: () => getPaymentCustomFieldTypes,
+  getPaymentTermModel: () => getPaymentTermModel,
+  getPaymentType: () => getPaymentType,
+  listApCredits: () => listApCredits,
+  listApPayments: () => listApPayments,
+  listGlAccountTypes: () => listGlAccountTypes,
+  listGlAccounts: () => listGlAccounts,
+  listInventoryBills: () => listInventoryBills,
+  listInvoices: () => listInvoices,
+  listJournalEntries: () => listJournalEntries,
+  listPaymentTerms: () => listPaymentTerms,
+  listPaymentTypes: () => listPaymentTypes,
+  listPayments: () => listPayments,
+  listTaxZones: () => listTaxZones,
+  markApCreditsAsExported: () => markApCreditsAsExported,
+  markApPaymentsAsExported: () => markApPaymentsAsExported,
+  markInventoryBillsAsExported: () => markInventoryBillsAsExported,
+  markInvoicesAsExported: () => markInvoicesAsExported,
+  syncUpdateJournalEntries: () => syncUpdateJournalEntries,
+  updateGlAccount: () => updateGlAccount,
+  updateInventoryBillCustomFields: () => updateInventoryBillCustomFields,
+  updateInvoice: () => updateInvoice,
+  updateInvoiceCustomFields: () => updateInvoiceCustomFields,
+  updateInvoiceItems: () => updateInvoiceItems,
+  updateJournalEntry: () => updateJournalEntry,
+  updatePayment: () => updatePayment,
+  updatePaymentCustomFields: () => updatePaymentCustomFields,
+  updatePaymentStatus: () => updatePaymentStatus
+});
+
+// src/resources/accounting/invoices.ts
+async function listInvoices(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "invoices" });
+  return client.request("get", path, { params });
+}
+async function getAllInvoices(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "invoices" });
+  return client.getAll(path, params, pageSize);
+}
+async function createAdjustmentInvoice(client, data) {
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: "adjustment" });
+  return client.request("post", path, { data });
+}
+async function getInvoiceCustomFieldTypes(client) {
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: "custom-field-types" });
+  return client.request("get", path);
+}
+async function updateInvoiceCustomFields(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: `${id}/custom-fields` });
+  return client.request("post", path, { data });
+}
+async function markInvoicesAsExported(client, ids) {
+  if (!ids?.length) throw new Error("ids are required");
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: "mark-as-exported" });
+  return client.request("post", path, { data: { ids } });
+}
+async function updateInvoice(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function updateInvoiceItems(client, id, items) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: `${id}/items` });
+  return client.request("put", path, { data: items });
+}
+async function deleteInvoiceItem(client, invoiceId, itemId) {
+  if (!invoiceId || !itemId) throw new Error("invoiceId and itemId are required");
+  const path = client.buildPath({ category: "accounting", subject: "invoices", idOrSubpath: `${invoiceId}/items/${itemId}` });
+  return client.request("delete", path);
+}
+
+// src/resources/accounting/inventory-bills.ts
+async function listInventoryBills(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "inventory-bills" });
+  return client.request("get", path, { params });
+}
+async function getAllInventoryBills(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "inventory-bills" });
+  return client.getAll(path, params, pageSize);
+}
+async function exportInventoryBills(client, data) {
+  const path = client.buildPath({ category: "accounting", subject: "inventory-bills", idOrSubpath: "export" });
+  return client.request("post", path, { data });
+}
+async function getInventoryBillCustomFieldTypes(client) {
+  const path = client.buildPath({ category: "accounting", subject: "inventory-bills", idOrSubpath: "custom-field-types" });
+  return client.request("get", path);
+}
+async function updateInventoryBillCustomFields(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "inventory-bills", idOrSubpath: `${id}/custom-fields` });
+  return client.request("post", path, { data });
+}
+async function markInventoryBillsAsExported(client, ids) {
+  if (!ids?.length) throw new Error("ids are required");
+  const path = client.buildPath({ category: "accounting", subject: "inventory-bills", idOrSubpath: "mark-as-exported" });
+  return client.request("post", path, { data: { ids } });
+}
+
+// src/resources/accounting/journal-entries.ts
+async function listJournalEntries(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "journal-entries" });
+  return client.request("get", path, { params });
+}
+async function getAllJournalEntries(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "journal-entries" });
+  return client.getAll(path, params, pageSize);
+}
+async function getJournalEntryDetails(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "journal-entries", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function getJournalEntriesSummary(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "journal-entries", idOrSubpath: "summary" });
+  return client.request("get", path, { params });
+}
+async function updateJournalEntry(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "journal-entries", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function syncUpdateJournalEntries(client, data) {
+  const path = client.buildPath({ category: "accounting", subject: "journal-entries", idOrSubpath: "sync-update" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/accounting/payment-terms.ts
+async function listPaymentTerms(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "payment-terms" });
+  return client.request("get", path, { params });
+}
+async function getAllPaymentTerms(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "payment-terms" });
+  return client.getAll(path, params, pageSize);
+}
+async function getPaymentTermModel(client) {
+  const path = client.buildPath({ category: "accounting", subject: "payment-terms", idOrSubpath: "model" });
+  return client.request("get", path);
+}
+
+// src/resources/accounting/payment-types.ts
+async function listPaymentTypes(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "payment-types" });
+  return client.request("get", path, { params });
+}
+async function getAllPaymentTypes(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "payment-types" });
+  return client.getAll(path, params, pageSize);
+}
+async function getPaymentType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "payment-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/accounting/payments.ts
+async function listPayments(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "payments" });
+  return client.request("get", path, { params });
+}
+async function getAllPayments(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "payments" });
+  return client.getAll(path, params, pageSize);
+}
+async function updatePaymentCustomFields(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "payments", idOrSubpath: `${id}/custom-fields` });
+  return client.request("post", path, { data });
+}
+async function getPaymentCustomFieldTypes(client) {
+  const path = client.buildPath({ category: "accounting", subject: "payments", idOrSubpath: "custom-field-types" });
+  return client.request("get", path);
+}
+async function updatePaymentStatus(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "payments", idOrSubpath: `${id}/status` });
+  return client.request("post", path, { data });
+}
+async function updatePayment(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "payments", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/accounting/tax-zones.ts
+async function listTaxZones(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "tax-zones" });
+  return client.request("get", path, { params });
+}
+async function getAllTaxZones(client, params = {}, pageSize = 200) {
+  const path = client.buildPath({ category: "accounting", subject: "tax-zones" });
+  return client.getAll(path, params, pageSize);
+}
+
+// src/resources/accounting/ap-credits.ts
+async function listApCredits(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "ap-credits" });
+  return client.request("get", path, { params });
+}
+async function markApCreditsAsExported(client, ids) {
+  if (!ids?.length) throw new Error("ids are required");
+  const path = client.buildPath({ category: "accounting", subject: "ap-credits", idOrSubpath: "mark-as-exported" });
+  return client.request("post", path, { data: { ids } });
+}
+
+// src/resources/accounting/ap-payments.ts
+async function listApPayments(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "ap-payments" });
+  return client.request("get", path, { params });
+}
+async function markApPaymentsAsExported(client, ids) {
+  if (!ids?.length) throw new Error("ids are required");
+  const path = client.buildPath({ category: "accounting", subject: "ap-payments", idOrSubpath: "mark-as-exported" });
+  return client.request("post", path, { data: { ids } });
+}
+
+// src/resources/accounting/gl-accounts.ts
+async function listGlAccounts(client, params = {}) {
+  const path = client.buildPath({ category: "accounting", subject: "gl-accounts" });
+  return client.request("get", path, { params });
+}
+async function getGlAccount(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "gl-accounts", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function createGlAccount(client, data) {
+  const path = client.buildPath({ category: "accounting", subject: "gl-accounts" });
+  return client.request("post", path, { data });
+}
+async function updateGlAccount(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "accounting", subject: "gl-accounts", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function listGlAccountTypes(client) {
+  const path = client.buildPath({ category: "accounting", subject: "gl-account-types" });
+  return client.request("get", path);
+}
+
+// src/resources/crm/index.ts
+var crm_exports = {};
+__export(crm_exports, {
+  addTagsBulk: () => addTagsBulk,
+  createBooking: () => createBooking,
+  createBookingContact: () => createBookingContact,
+  createBookingProviderTag: () => createBookingProviderTag,
+  createContact: () => createContact,
+  createContactMethod: () => createContactMethod,
+  createContactRelationship: () => createContactRelationship,
+  createCustomer: () => createCustomer,
+  createCustomerContact: () => createCustomerContact,
+  createCustomerNote: () => createCustomerNote,
+  createCustomerTag: () => createCustomerTag,
+  createLead: () => createLead,
+  createLeadFollowUp: () => createLeadFollowUp,
+  createLeadNote: () => createLeadNote,
+  createLocation: () => createLocation,
+  createLocationContact: () => createLocationContact,
+  createLocationNote: () => createLocationNote,
+  createLocationTag: () => createLocationTag,
+  createProviderBooking: () => createProviderBooking,
+  createProviderBookingContact: () => createProviderBookingContact,
+  deleteBookingProviderTag: () => deleteBookingProviderTag,
+  deleteContact: () => deleteContact,
+  deleteContactMethod: () => deleteContactMethod,
+  deleteContactRelationship: () => deleteContactRelationship,
+  deleteCustomerContact: () => deleteCustomerContact,
+  deleteCustomerNote: () => deleteCustomerNote,
+  deleteCustomerTag: () => deleteCustomerTag,
+  deleteLocationContact: () => deleteLocationContact,
+  deleteLocationNote: () => deleteLocationNote,
+  deleteLocationTag: () => deleteLocationTag,
+  deleteProviderBookingContact: () => deleteProviderBookingContact,
+  dismissLead: () => dismissLead,
+  exportBookings: () => exportBookings,
+  exportCustomerContacts: () => exportCustomerContacts,
+  exportCustomers: () => exportCustomers,
+  exportLeads: () => exportLeads,
+  exportLocationContacts: () => exportLocationContacts,
+  exportLocations: () => exportLocations,
+  getBooking: () => getBooking,
+  getBookingContacts: () => getBookingContacts,
+  getBookingProviderTag: () => getBookingProviderTag,
+  getContact: () => getContact,
+  getContactByRelationshipId: () => getContactByRelationshipId,
+  getContactMethod: () => getContactMethod,
+  getContactMethodPreference: () => getContactMethodPreference,
+  getContactRelationshipList: () => getContactRelationshipList,
+  getContactsPreferenceMetadataList: () => getContactsPreferenceMetadataList,
+  getCustomer: () => getCustomer,
+  getCustomerContactList: () => getCustomerContactList,
+  getCustomerCustomFieldTypes: () => getCustomerCustomFieldTypes,
+  getCustomerNotes: () => getCustomerNotes,
+  getLead: () => getLead,
+  getLeadNotes: () => getLeadNotes,
+  getLocation: () => getLocation,
+  getLocationContactList: () => getLocationContactList,
+  getLocationCustomFieldTypes: () => getLocationCustomFieldTypes,
+  getLocationNotes: () => getLocationNotes,
+  getModifiedContactsList: () => getModifiedContactsList,
+  getProviderBooking: () => getProviderBooking,
+  getProviderBookingContact: () => getProviderBookingContact,
+  getProviderBookingContacts: () => getProviderBookingContacts,
+  listBookingProviderTags: () => listBookingProviderTags,
+  listBookings: () => listBookings,
+  listContactMethodPreferences: () => listContactMethodPreferences,
+  listContactMethods: () => listContactMethods,
+  listContacts: () => listContacts,
+  listCustomers: () => listCustomers,
+  listLeads: () => listLeads,
+  listLocations: () => listLocations,
+  listProviderBookings: () => listProviderBookings,
+  removeTagsBulk: () => removeTagsBulk,
+  replaceContact: () => replaceContact,
+  searchContactMethods: () => searchContactMethods,
+  submitLeadForm: () => submitLeadForm,
+  updateBooking: () => updateBooking,
+  updateBookingProviderTag: () => updateBookingProviderTag,
+  updateContact: () => updateContact,
+  updateContactMethod: () => updateContactMethod,
+  updateContactMethodPreference: () => updateContactMethodPreference,
+  updateCustomer: () => updateCustomer,
+  updateCustomerContact: () => updateCustomerContact,
+  updateLead: () => updateLead,
+  updateLocation: () => updateLocation,
+  updateLocationContact: () => updateLocationContact,
+  updateProviderBooking: () => updateProviderBooking,
+  updateProviderBookingContact: () => updateProviderBookingContact,
+  upsertContactMethod: () => upsertContactMethod
+});
+
+// src/resources/crm/bulk-tags.ts
+async function addTagsBulk(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "bulk-tags", idOrSubpath: "add-tags" });
+  return client.request("post", path, { data });
+}
+async function removeTagsBulk(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "bulk-tags", idOrSubpath: "remove-tags" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/crm/contact-methods.ts
+async function listContactMethods(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "contact-methods" });
+  return client.request("get", path, { params });
+}
+async function createContactMethod(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "contact-methods" });
+  return client.request("post", path, { data });
+}
+async function updateContactMethod(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contact-methods", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function upsertContactMethod(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "contact-methods", idOrSubpath: "upsert" });
+  return client.request("post", path, { data });
+}
+async function getContactMethod(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contact-methods", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function deleteContactMethod(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contact-methods", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/crm/contact-preferences.ts
+async function listContactMethodPreferences(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "contact-preferences" });
+  return client.request("get", path, { params });
+}
+async function getContactMethodPreference(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contact-preferences", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateContactMethodPreference(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contact-preferences", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/crm/contacts.ts
+async function listContacts(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "contacts" });
+  return client.request("get", path, { params });
+}
+async function createContact(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "contacts" });
+  return client.request("post", path, { data });
+}
+async function updateContact(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function replaceContact(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function getContact(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function deleteContact(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+async function searchContactMethods(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: "contact-methods:search" });
+  return client.request("get", path, { params });
+}
+async function getContactsPreferenceMetadataList(client) {
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: "preference-metadata" });
+  return client.request("get", path);
+}
+async function getContactByRelationshipId(client, relationshipId) {
+  if (!relationshipId) throw new Error("relationshipId is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: `relationships/${relationshipId}` });
+  return client.request("get", path);
+}
+async function getContactRelationshipList(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: `${id}/relationships` });
+  return client.request("get", path);
+}
+async function deleteContactRelationship(client, id, relationshipId) {
+  if (!id || !relationshipId) throw new Error("id and relationshipId are required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: `${id}/relationships/${relationshipId}` });
+  return client.request("delete", path);
+}
+async function createContactRelationship(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "contacts", idOrSubpath: `${id}/relationships` });
+  return client.request("post", path, { data });
+}
+
+// src/resources/crm/customers.ts
+async function listCustomers(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "customers" });
+  return client.request("get", path, { params });
+}
+async function createCustomer(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "customers" });
+  return client.request("post", path, { data });
+}
+async function updateCustomer(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function getCustomer(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function getModifiedContactsList(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/modified-contacts` });
+  return client.request("get", path);
+}
+async function getCustomerCustomFieldTypes(client) {
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: "custom-field-types" });
+  return client.request("get", path);
+}
+async function getCustomerContactList(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/contacts` });
+  return client.request("get", path);
+}
+async function createCustomerContact(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/contacts` });
+  return client.request("post", path, { data });
+}
+async function updateCustomerContact(client, id, contactId, data) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/contacts/${contactId}` });
+  return client.request("put", path, { data });
+}
+async function deleteCustomerContact(client, id, contactId) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/contacts/${contactId}` });
+  return client.request("delete", path);
+}
+async function getCustomerNotes(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/notes` });
+  return client.request("get", path);
+}
+async function createCustomerNote(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/notes` });
+  return client.request("post", path, { data });
+}
+async function deleteCustomerNote(client, id, noteId) {
+  if (!id || !noteId) throw new Error("id and noteId are required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/notes/${noteId}` });
+  return client.request("delete", path);
+}
+async function createCustomerTag(client, id, tagId) {
+  if (!id || !tagId) throw new Error("id and tagId are required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/tags/${tagId}` });
+  return client.request("post", path);
+}
+async function deleteCustomerTag(client, id, tagId) {
+  if (!id || !tagId) throw new Error("id and tagId are required");
+  const path = client.buildPath({ category: "crm", subject: "customers", idOrSubpath: `${id}/tags/${tagId}` });
+  return client.request("delete", path);
+}
+
+// src/resources/crm/leads.ts
+async function listLeads(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "leads" });
+  return client.request("get", path, { params });
+}
+async function createLead(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "leads" });
+  return client.request("post", path, { data });
+}
+async function submitLeadForm(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: "submit" });
+  return client.request("post", path, { data });
+}
+async function updateLead(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function getLead(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function dismissLead(client, id, data = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: `${id}/dismiss` });
+  return client.request("post", path, { data });
+}
+async function createLeadFollowUp(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: `${id}/follow-ups` });
+  return client.request("post", path, { data });
+}
+async function getLeadNotes(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: `${id}/notes` });
+  return client.request("get", path);
+}
+async function createLeadNote(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "leads", idOrSubpath: `${id}/notes` });
+  return client.request("post", path, { data });
+}
+
+// src/resources/crm/locations.ts
+async function listLocations(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "locations" });
+  return client.request("get", path, { params });
+}
+async function createLocation(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "locations" });
+  return client.request("post", path, { data });
+}
+async function updateLocation(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function getLocation(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function getLocationContactList(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/contacts` });
+  return client.request("get", path);
+}
+async function createLocationContact(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/contacts` });
+  return client.request("post", path, { data });
+}
+async function updateLocationContact(client, id, contactId, data) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/contacts/${contactId}` });
+  return client.request("put", path, { data });
+}
+async function deleteLocationContact(client, id, contactId) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/contacts/${contactId}` });
+  return client.request("delete", path);
+}
+async function getLocationCustomFieldTypes(client) {
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: "custom-field-types" });
+  return client.request("get", path);
+}
+async function getLocationNotes(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/notes` });
+  return client.request("get", path);
+}
+async function createLocationNote(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/notes` });
+  return client.request("post", path, { data });
+}
+async function deleteLocationNote(client, id, noteId) {
+  if (!id || !noteId) throw new Error("id and noteId are required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/notes/${noteId}` });
+  return client.request("delete", path);
+}
+async function createLocationTag(client, id, tagId) {
+  if (!id || !tagId) throw new Error("id and tagId are required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/tags/${tagId}` });
+  return client.request("post", path);
+}
+async function deleteLocationTag(client, id, tagId) {
+  if (!id || !tagId) throw new Error("id and tagId are required");
+  const path = client.buildPath({ category: "crm", subject: "locations", idOrSubpath: `${id}/tags/${tagId}` });
+  return client.request("delete", path);
+}
+
+// src/resources/crm/export.ts
+async function exportBookings(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "export", idOrSubpath: "bookings" });
+  return client.request("get", path, { params });
+}
+async function exportCustomers(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "export", idOrSubpath: "customers" });
+  return client.request("get", path, { params });
+}
+async function exportCustomerContacts(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "export", idOrSubpath: "customers/contacts" });
+  return client.request("get", path, { params });
+}
+async function exportLeads(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "export", idOrSubpath: "leads" });
+  return client.request("get", path, { params });
+}
+async function exportLocations(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "export", idOrSubpath: "locations" });
+  return client.request("get", path, { params });
+}
+async function exportLocationContacts(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "export", idOrSubpath: "locations/contacts" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/crm/booking-provider-tags.ts
+async function listBookingProviderTags(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "booking-provider-tags" });
+  return client.request("get", path, { params });
+}
+async function createBookingProviderTag(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "booking-provider-tags" });
+  return client.request("post", path, { data });
+}
+async function getBookingProviderTag(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "booking-provider-tags", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateBookingProviderTag(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "booking-provider-tags", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function deleteBookingProviderTag(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "booking-provider-tags", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/crm/bookings.ts
+async function listBookings(client, params = {}) {
+  const path = client.buildPath({ category: "crm", subject: "bookings" });
+  return client.request("get", path, { params });
+}
+async function createBooking(client, data) {
+  const path = client.buildPath({ category: "crm", subject: "bookings" });
+  return client.request("post", path, { data });
+}
+async function getBooking(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "bookings", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateBooking(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "bookings", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function getBookingContacts(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "bookings", idOrSubpath: `${id}/contacts` });
+  return client.request("get", path, { params });
+}
+async function createBookingContact(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "crm", subject: "bookings", idOrSubpath: `${id}/contacts` });
+  return client.request("post", path, { data });
+}
+function buildProviderPath(client, provider, idOrSubpath) {
+  const sub = idOrSubpath ? `/${String(idOrSubpath).replace(/^\/+/, "")}` : "";
+  return client.buildPath({ category: "crm", subject: `${provider}/bookings${sub}`, tenantScoped: false });
+}
+async function listProviderBookings(client, provider, params = {}) {
+  const path = buildProviderPath(client, provider);
+  return client.request("get", path, { params });
+}
+async function createProviderBooking(client, provider, data) {
+  const path = buildProviderPath(client, provider);
+  return client.request("post", path, { data });
+}
+async function getProviderBooking(client, provider, id) {
+  if (!id) throw new Error("id is required");
+  const path = buildProviderPath(client, provider, String(id));
+  return client.request("get", path);
+}
+async function updateProviderBooking(client, provider, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = buildProviderPath(client, provider, String(id));
+  return client.request("patch", path, { data });
+}
+async function getProviderBookingContacts(client, provider, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = buildProviderPath(client, provider, `${id}/contacts`);
+  return client.request("get", path, { params });
+}
+async function createProviderBookingContact(client, provider, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = buildProviderPath(client, provider, `${id}/contacts`);
+  return client.request("post", path, { data });
+}
+async function getProviderBookingContact(client, provider, id, contactId) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = buildProviderPath(client, provider, `${id}/contacts/${contactId}`);
+  return client.request("get", path);
+}
+async function updateProviderBookingContact(client, provider, id, contactId, data) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = buildProviderPath(client, provider, `${id}/contacts/${contactId}`);
+  return client.request("patch", path, { data });
+}
+async function deleteProviderBookingContact(client, provider, id, contactId) {
+  if (!id || !contactId) throw new Error("id and contactId are required");
+  const path = buildProviderPath(client, provider, `${id}/contacts/${contactId}`);
+  return client.request("delete", path);
+}
+
+// src/resources/dispatch/index.ts
+var dispatch_exports = {};
+__export(dispatch_exports, {
+  activateArrivalWindow: () => activateArrivalWindow,
+  assignTechnicians: () => assignTechnicians,
+  bulkDeleteTechnicianShifts: () => bulkDeleteTechnicianShifts,
+  createArrivalWindow: () => createArrivalWindow,
+  createBusinessHour: () => createBusinessHour,
+  createGpsPing: () => createGpsPing,
+  createNonJobAppointment: () => createNonJobAppointment,
+  createTeam: () => createTeam,
+  createTechnicianShift: () => createTechnicianShift,
+  createZone: () => createZone,
+  deleteNonJobAppointment: () => deleteNonJobAppointment,
+  deleteTechnicianShift: () => deleteTechnicianShift,
+  deleteZone: () => deleteZone,
+  exportAppointmentAssignments: () => exportAppointmentAssignments,
+  getArrivalWindow: () => getArrivalWindow,
+  getArrivalWindowsConfiguration: () => getArrivalWindowsConfiguration,
+  getCapacity: () => getCapacity,
+  getNonJobAppointment: () => getNonJobAppointment,
+  getTeam: () => getTeam,
+  getTechnicianShift: () => getTechnicianShift,
+  getTechnicianTracking: () => getTechnicianTracking,
+  getZone: () => getZone,
+  listAppointmentAssignments: () => listAppointmentAssignments,
+  listArrivalWindows: () => listArrivalWindows,
+  listBusinessHours: () => listBusinessHours,
+  listGpsPings: () => listGpsPings,
+  listNonJobAppointments: () => listNonJobAppointments,
+  listTeams: () => listTeams,
+  listTechnicianShifts: () => listTechnicianShifts,
+  listZones: () => listZones,
+  unassignTechnicians: () => unassignTechnicians,
+  updateArrivalWindow: () => updateArrivalWindow,
+  updateArrivalWindowsConfiguration: () => updateArrivalWindowsConfiguration,
+  updateNonJobAppointment: () => updateNonJobAppointment,
+  updateTeam: () => updateTeam,
+  updateTechnicianShift: () => updateTechnicianShift,
+  updateZone: () => updateZone
+});
+
+// src/resources/dispatch/export.ts
+async function exportAppointmentAssignments(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "export", idOrSubpath: "appointment-assignments" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/dispatch/appointment-assignments.ts
+async function listAppointmentAssignments(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "appointment-assignments" });
+  return client.request("get", path, { params });
+}
+async function assignTechnicians(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "appointment-assignments", idOrSubpath: "assign-technicians" });
+  return client.request("post", path, { data });
+}
+async function unassignTechnicians(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "appointment-assignments", idOrSubpath: "unassign-technicians" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/dispatch/arrival-windows.ts
+async function listArrivalWindows(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows" });
+  return client.request("get", path, { params });
+}
+async function createArrivalWindow(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows" });
+  return client.request("post", path, { data });
+}
+async function getArrivalWindow(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateArrivalWindow(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function getArrivalWindowsConfiguration(client) {
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows", idOrSubpath: "configuration" });
+  return client.request("get", path);
+}
+async function updateArrivalWindowsConfiguration(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows", idOrSubpath: "configuration" });
+  return client.request("put", path, { data });
+}
+async function activateArrivalWindow(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "arrival-windows", idOrSubpath: `${id}/activated` });
+  return client.request("post", path);
+}
+
+// src/resources/dispatch/business-hours.ts
+async function listBusinessHours(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "business-hours" });
+  return client.request("get", path, { params });
+}
+async function createBusinessHour(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "business-hours" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/dispatch/capacity.ts
+async function getCapacity(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "capacity" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/dispatch/gps.ts
+function buildGpsProviderPath(client, provider) {
+  return client.buildPath({ category: "dispatch", subject: `${provider}/gps-pings`, tenantScoped: false });
+}
+async function listGpsPings(client, provider, params = {}) {
+  const path = buildGpsProviderPath(client, provider);
+  return client.request("get", path, { params });
+}
+async function createGpsPing(client, provider, data) {
+  const path = buildGpsProviderPath(client, provider);
+  return client.request("post", path, { data });
+}
+
+// src/resources/dispatch/non-job-appointments.ts
+async function listNonJobAppointments(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "non-job-appointments" });
+  return client.request("get", path, { params });
+}
+async function createNonJobAppointment(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "non-job-appointments" });
+  return client.request("post", path, { data });
+}
+async function getNonJobAppointment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "non-job-appointments", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateNonJobAppointment(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "non-job-appointments", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function deleteNonJobAppointment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "non-job-appointments", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/dispatch/teams.ts
+async function listTeams(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "teams" });
+  return client.request("get", path, { params });
+}
+async function createTeam(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "teams" });
+  return client.request("post", path, { data });
+}
+async function getTeam(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "teams", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateTeam(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "teams", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+
+// src/resources/dispatch/technician-shifts.ts
+async function listTechnicianShifts(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "technician-shifts" });
+  return client.request("get", path, { params });
+}
+async function createTechnicianShift(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "technician-shifts" });
+  return client.request("post", path, { data });
+}
+async function bulkDeleteTechnicianShifts(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "technician-shifts", idOrSubpath: "bulk-delete" });
+  return client.request("post", path, { data });
+}
+async function getTechnicianShift(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "technician-shifts", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateTechnicianShift(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "technician-shifts", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function deleteTechnicianShift(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "technician-shifts", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/dispatch/technician-tracking.ts
+async function getTechnicianTracking(client, params) {
+  const path = client.buildPath({ category: "dispatch", subject: "technician-tracking" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/dispatch/zones.ts
+async function listZones(client, params = {}) {
+  const path = client.buildPath({ category: "dispatch", subject: "zones" });
+  return client.request("get", path, { params });
+}
+async function createZone(client, data) {
+  const path = client.buildPath({ category: "dispatch", subject: "zones" });
+  return client.request("post", path, { data });
+}
+async function getZone(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "zones", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateZone(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "zones", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+async function deleteZone(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "dispatch", subject: "zones", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/equipment-systems/index.ts
+var equipment_systems_exports = {};
+__export(equipment_systems_exports, {
+  createInstalledEquipment: () => createInstalledEquipment,
+  createInstalledEquipmentAttachment: () => createInstalledEquipmentAttachment,
+  exportInstalledEquipment: () => exportInstalledEquipment,
+  getInstalledEquipment: () => getInstalledEquipment,
+  listInstalledEquipment: () => listInstalledEquipment,
+  listInstalledEquipmentAttachments: () => listInstalledEquipmentAttachments,
+  listInstalledEquipmentCustomFieldTypes: () => listInstalledEquipmentCustomFieldTypes,
+  updateInstalledEquipment: () => updateInstalledEquipment
+});
+
+// src/resources/equipment-systems/export.ts
+async function exportInstalledEquipment(client, params = {}) {
+  const path = client.buildPath({ category: "equipment-systems", subject: "export", idOrSubpath: "installed-equipment" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/equipment-systems/installed-equipment.ts
+async function listInstalledEquipment(client, params = {}) {
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment" });
+  return client.request("get", path, { params });
+}
+async function createInstalledEquipment(client, data) {
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment" });
+  return client.request("post", path, { data });
+}
+async function listInstalledEquipmentAttachments(client, params = {}) {
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment", idOrSubpath: "attachments" });
+  return client.request("get", path, { params });
+}
+async function createInstalledEquipmentAttachment(client, data) {
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment", idOrSubpath: "attachments" });
+  return client.request("post", path, { data });
+}
+async function listInstalledEquipmentCustomFieldTypes(client, params = {}) {
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment", idOrSubpath: "custom-field-types" });
+  return client.request("get", path, { params });
+}
+async function getInstalledEquipment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateInstalledEquipment(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "equipment-systems", subject: "installed-equipment", idOrSubpath: String(id) });
+  return client.request("patch", path, { data });
+}
+
+// src/resources/jpm/index.ts
+var jpm_exports = {};
+__export(jpm_exports, {
+  attachJob: () => attachJob,
+  batchCreateBudgetCodes: () => batchCreateBudgetCodes,
+  batchPartialUpdateBudgetCodes: () => batchPartialUpdateBudgetCodes,
+  cancelJob: () => cancelJob,
+  confirmAppointment: () => confirmAppointment,
+  createBudgetCode: () => createBudgetCode,
+  createJobNote: () => createJobNote,
+  createJobType: () => createJobType,
+  createProjectNote: () => createProjectNote,
+  detachJob: () => detachJob,
+  exportAppointments: () => exportAppointments,
+  exportJobCanceledLogs: () => exportJobCanceledLogs,
+  exportJobHistory: () => exportJobHistory,
+  exportJobNotes: () => exportJobNotes,
+  exportJobs: () => exportJobs,
+  exportProjectNotes: () => exportProjectNotes,
+  exportProjects: () => exportProjects,
+  getAppointment: () => getAppointment,
+  getCancelReasons: () => getCancelReasons,
+  getJob: () => getJob,
+  getJobBookedLog: () => getJobBookedLog,
+  getJobCanceledLog: () => getJobCanceledLog,
+  getJobHistory: () => getJobHistory,
+  getJobType: () => getJobType,
+  getProject: () => getProject,
+  getProjectStatus: () => getProjectStatus,
+  getProjectSubStatus: () => getProjectSubStatus,
+  getProjectType: () => getProjectType,
+  holdAppointment: () => holdAppointment,
+  listAppointments: () => listAppointments,
+  listBudgetCodes: () => listBudgetCodes,
+  listJobCancelReasons: () => listJobCancelReasons,
+  listJobHoldReasons: () => listJobHoldReasons,
+  listJobNotes: () => listJobNotes,
+  listJobTypes: () => listJobTypes,
+  listJobs: () => listJobs,
+  listProjectBudgetCodes: () => listProjectBudgetCodes,
+  listProjectCustomFields: () => listProjectCustomFields,
+  listProjectNotes: () => listProjectNotes,
+  listProjectSegmentItemChildren: () => listProjectSegmentItemChildren,
+  listProjectSegmentItems: () => listProjectSegmentItems,
+  listProjectSegments: () => listProjectSegments,
+  listProjectStatuses: () => listProjectStatuses,
+  listProjectSubStatuses: () => listProjectSubStatuses,
+  listProjectTypes: () => listProjectTypes,
+  listProjects: () => listProjects,
+  listSegmentItemChildren: () => listSegmentItemChildren,
+  listSegmentItems: () => listSegmentItems,
+  listSegments: () => listSegments,
+  partialUpdateBudgetCodes: () => partialUpdateBudgetCodes,
+  removeJobCancellation: () => removeJobCancellation,
+  rescheduleAppointment: () => rescheduleAppointment,
+  unconfirmAppointment: () => unconfirmAppointment,
+  unholdAppointment: () => unholdAppointment,
+  updateJobType: () => updateJobType,
+  updateSpecialInstructions: () => updateSpecialInstructions
+});
+
+// src/resources/jpm/export.ts
+async function exportAppointments(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "appointments" });
+  return client.request("get", path, { params });
+}
+async function exportJobCanceledLogs(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "job-canceled-logs" });
+  return client.request("get", path, { params });
+}
+async function exportJobHistory(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "job-history" });
+  return client.request("get", path, { params });
+}
+async function exportJobNotes(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "job-notes" });
+  return client.request("get", path, { params });
+}
+async function exportJobs(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "jobs" });
+  return client.request("get", path, { params });
+}
+async function exportProjectNotes(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "project-notes" });
+  return client.request("get", path, { params });
+}
+async function exportProjects(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "export", idOrSubpath: "projects" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/jpm/appointments.ts
+async function listAppointments(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "appointments" });
+  return client.request("get", path, { params });
+}
+async function getAppointment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function confirmAppointment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: `${id}/confirmation` });
+  return client.request("post", path);
+}
+async function unconfirmAppointment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: `${id}/confirmation` });
+  return client.request("delete", path);
+}
+async function holdAppointment(client, id, data = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: `${id}/hold` });
+  return client.request("post", path, { data });
+}
+async function unholdAppointment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: `${id}/hold` });
+  return client.request("delete", path);
+}
+async function rescheduleAppointment(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: `${id}/reschedule` });
+  return client.request("post", path, { data });
+}
+async function updateSpecialInstructions(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "appointments", idOrSubpath: `${id}/special-instructions` });
+  return client.request("put", path, { data });
+}
+
+// src/resources/jpm/jobs.ts
+async function listJobs(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "jobs" });
+  return client.request("get", path, { params });
+}
+async function getJob(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: String(id) });
+  return client.request("get", path, { params });
+}
+async function getJobBookedLog(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/booked-log` });
+  return client.request("get", path);
+}
+async function cancelJob(client, id, data = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/cancel` });
+  return client.request("post", path, { data });
+}
+async function getJobCanceledLog(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/canceled-log` });
+  return client.request("get", path);
+}
+async function getJobHistory(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/history` });
+  return client.request("get", path);
+}
+async function listJobNotes(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/notes` });
+  return client.request("get", path);
+}
+async function createJobNote(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/notes` });
+  return client.request("post", path, { data });
+}
+async function removeJobCancellation(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: `${id}/remove-cancellation` });
+  return client.request("post", path);
+}
+async function getCancelReasons(client, ids) {
+  const params = {};
+  if (ids && ids.length > 0) {
+    params.ids = ids.join(",");
+  }
+  const path = client.buildPath({ category: "jpm", subject: "jobs", idOrSubpath: "cancel-reasons" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/jpm/projects.ts
+async function listProjects(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "projects" });
+  return client.request("get", path, { params });
+}
+async function getProject(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "projects", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function detachJob(client, jobId) {
+  if (!jobId) throw new Error("jobId is required");
+  const path = client.buildPath({ category: "jpm", subject: "projects", idOrSubpath: `detach-job/${jobId}` });
+  return client.request("post", path);
+}
+async function attachJob(client, id, jobId) {
+  if (!id || !jobId) throw new Error("id and jobId are required");
+  const path = client.buildPath({ category: "jpm", subject: "projects", idOrSubpath: `${id}/attach-job/${jobId}` });
+  return client.request("post", path);
+}
+async function listProjectNotes(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "projects", idOrSubpath: `${id}/notes` });
+  return client.request("get", path);
+}
+async function createProjectNote(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "projects", idOrSubpath: `${id}/notes` });
+  return client.request("post", path, { data });
+}
+async function listProjectCustomFields(client) {
+  const path = client.buildPath({ category: "jpm", subject: "projects", idOrSubpath: "custom-fields" });
+  return client.request("get", path);
+}
+
+// src/resources/jpm/job-cancel-reasons.ts
+async function listJobCancelReasons(client) {
+  const path = client.buildPath({ category: "jpm", subject: "job-cancel-reasons" });
+  return client.request("get", path);
+}
+
+// src/resources/jpm/job-hold-reasons.ts
+async function listJobHoldReasons(client) {
+  const path = client.buildPath({ category: "jpm", subject: "job-hold-reasons" });
+  return client.request("get", path);
+}
+
+// src/resources/jpm/job-types.ts
+async function listJobTypes(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "job-types" });
+  return client.request("get", path, { params });
+}
+async function createJobType(client, data) {
+  const path = client.buildPath({ category: "jpm", subject: "job-types" });
+  return client.request("post", path, { data });
+}
+async function getJobType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "job-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateJobType(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "job-types", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/jpm/project-statuses.ts
+async function listProjectStatuses(client) {
+  const path = client.buildPath({ category: "jpm", subject: "project-statuses" });
+  return client.request("get", path);
+}
+async function getProjectStatus(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "project-statuses", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/jpm/project-substatuses.ts
+async function listProjectSubStatuses(client) {
+  const path = client.buildPath({ category: "jpm", subject: "project-substatuses" });
+  return client.request("get", path);
+}
+async function getProjectSubStatus(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "project-substatuses", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/jpm/project-types.ts
+async function listProjectTypes(client) {
+  const path = client.buildPath({ category: "jpm", subject: "project-types" });
+  return client.request("get", path);
+}
+async function getProjectType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "jpm", subject: "project-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/jpm/work-breakdown-structure.ts
+async function listBudgetCodes(client, params = {}) {
+  const path = client.buildPath({ category: "jpm", subject: "work-breakdown-structure/budget-codes" });
+  return client.request("get", path, { params });
+}
+async function createBudgetCode(client, data) {
+  const path = client.buildPath({ category: "jpm", subject: "work-breakdown-structure/budget-codes" });
+  return client.request("post", path, { data });
+}
+async function batchCreateBudgetCodes(client, data) {
+  const path = client.buildPath({ category: "jpm", subject: "work-breakdown-structure/budget-codes/batch" });
+  return client.request("post", path, { data });
+}
+async function partialUpdateBudgetCodes(client, data) {
+  const path = client.buildPath({ category: "jpm", subject: "work-breakdown-structure/budget-codes/partial" });
+  return client.request("post", path, { data });
+}
+async function batchPartialUpdateBudgetCodes(client, data) {
+  const path = client.buildPath({ category: "jpm", subject: "work-breakdown-structure/budget-codes/partial/batch" });
+  return client.request("post", path, { data });
+}
+async function listProjectBudgetCodes(client, projectId) {
+  if (!projectId) throw new Error("projectId is required");
+  const path = client.buildPath({ category: "jpm", subject: `work-breakdown-structure/projects/${projectId}/budget-codes` });
+  return client.request("get", path);
+}
+async function listProjectSegments(client, projectId) {
+  if (!projectId) throw new Error("projectId is required");
+  const path = client.buildPath({ category: "jpm", subject: `work-breakdown-structure/projects/${projectId}/segments` });
+  return client.request("get", path);
+}
+async function listProjectSegmentItems(client, projectId, segmentId) {
+  if (!projectId || !segmentId) throw new Error("projectId and segmentId are required");
+  const path = client.buildPath({ category: "jpm", subject: `work-breakdown-structure/projects/${projectId}/segments/${segmentId}/items` });
+  return client.request("get", path);
+}
+async function listProjectSegmentItemChildren(client, projectId, segmentId, segmentItemId) {
+  if (!projectId || !segmentId || !segmentItemId) throw new Error("projectId, segmentId and segmentItemId are required");
+  const path = client.buildPath({ category: "jpm", subject: `work-breakdown-structure/projects/${projectId}/segments/${segmentId}/items/${segmentItemId}/children` });
+  return client.request("get", path);
+}
+async function listSegments(client) {
+  const path = client.buildPath({ category: "jpm", subject: "work-breakdown-structure/segments" });
+  return client.request("get", path);
+}
+async function listSegmentItems(client, segmentId) {
+  if (!segmentId) throw new Error("segmentId is required");
+  const path = client.buildPath({ category: "jpm", subject: `work-breakdown-structure/segments/${segmentId}/items` });
+  return client.request("get", path);
+}
+async function listSegmentItemChildren(client, segmentId, segmentItemId) {
+  if (!segmentId || !segmentItemId) throw new Error("segmentId and segmentItemId are required");
+  const path = client.buildPath({ category: "jpm", subject: `work-breakdown-structure/segments/${segmentId}/items/${segmentItemId}/children` });
+  return client.request("get", path);
+}
+
+// src/resources/inventory/index.ts
+var inventory_exports = {};
+__export(inventory_exports, {
+  approvePurchaseOrderRequest: () => approvePurchaseOrderRequest,
+  cancelPurchaseOrder: () => cancelPurchaseOrder,
+  cancelReceipt: () => cancelReceipt,
+  cancelReturn: () => cancelReturn,
+  createPurchaseOrder: () => createPurchaseOrder,
+  createPurchaseOrderMarkup: () => createPurchaseOrderMarkup,
+  createPurchaseOrderType: () => createPurchaseOrderType,
+  createReceipt: () => createReceipt,
+  createReturn: () => createReturn,
+  createVendor: () => createVendor,
+  deletePurchaseOrderMarkup: () => deletePurchaseOrderMarkup,
+  exportAdjustments: () => exportAdjustments,
+  exportPurchaseOrders: () => exportPurchaseOrders,
+  exportReturns: () => exportReturns,
+  exportTransfers: () => exportTransfers,
+  getAdjustment: () => getAdjustment,
+  getPurchaseOrder: () => getPurchaseOrder,
+  getPurchaseOrderMarkup: () => getPurchaseOrderMarkup,
+  getPurchaseOrderType: () => getPurchaseOrderType,
+  getReturn: () => getReturn,
+  getReturnType: () => getReturnType,
+  getTransfer: () => getTransfer,
+  getTruck: () => getTruck,
+  getVendor: () => getVendor,
+  getWarehouse: () => getWarehouse,
+  listAdjustmentCustomFields: () => listAdjustmentCustomFields,
+  listAdjustments: () => listAdjustments,
+  listPurchaseOrderMarkups: () => listPurchaseOrderMarkups,
+  listPurchaseOrderRequests: () => listPurchaseOrderRequests,
+  listPurchaseOrderTypes: () => listPurchaseOrderTypes,
+  listPurchaseOrders: () => listPurchaseOrders,
+  listReceiptCustomFields: () => listReceiptCustomFields,
+  listReceipts: () => listReceipts,
+  listReturnCustomFields: () => listReturnCustomFields,
+  listReturnTypes: () => listReturnTypes,
+  listReturns: () => listReturns,
+  listTransferCustomFields: () => listTransferCustomFields,
+  listTransfers: () => listTransfers,
+  listTrucks: () => listTrucks,
+  listVendors: () => listVendors,
+  listWarehouses: () => listWarehouses,
+  rejectPurchaseOrderRequest: () => rejectPurchaseOrderRequest,
+  updatePurchaseOrder: () => updatePurchaseOrder,
+  updatePurchaseOrderMarkup: () => updatePurchaseOrderMarkup,
+  updateVendor: () => updateVendor
+});
+
+// src/resources/inventory/export.ts
+async function exportAdjustments(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "export", idOrSubpath: "adjustments" });
+  return client.request("get", path, { params });
+}
+async function exportPurchaseOrders(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "export", idOrSubpath: "purchase-orders" });
+  return client.request("get", path, { params });
+}
+async function exportReturns(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "export", idOrSubpath: "returns" });
+  return client.request("get", path, { params });
+}
+async function exportTransfers(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "export", idOrSubpath: "transfers" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/inventory/adjustments.ts
+async function listAdjustments(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "adjustments" });
+  return client.request("get", path, { params });
+}
+async function listAdjustmentCustomFields(client) {
+  const path = client.buildPath({ category: "inventory", subject: "adjustments", idOrSubpath: "custom-fields" });
+  return client.request("get", path);
+}
+async function getAdjustment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "adjustments", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/inventory/purchase-orders.ts
+async function listPurchaseOrders(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-orders" });
+  return client.request("get", path, { params });
+}
+async function createPurchaseOrder(client, data) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-orders" });
+  return client.request("post", path, { data });
+}
+async function listPurchaseOrderRequests(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-orders/requests" });
+  return client.request("get", path, { params });
+}
+async function approvePurchaseOrderRequest(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: `purchase-orders/requests/${id}/approve` });
+  return client.request("post", path);
+}
+async function rejectPurchaseOrderRequest(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: `purchase-orders/requests/${id}/reject` });
+  return client.request("post", path);
+}
+async function getPurchaseOrder(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "purchase-orders", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updatePurchaseOrder(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "purchase-orders", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function cancelPurchaseOrder(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: `purchase-orders/${id}/cancellation` });
+  return client.request("post", path);
+}
+
+// src/resources/inventory/purchase-order-markups.ts
+async function listPurchaseOrderMarkups(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-markups" });
+  return client.request("get", path, { params });
+}
+async function createPurchaseOrderMarkup(client, data) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-markups" });
+  return client.request("post", path, { data });
+}
+async function getPurchaseOrderMarkup(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-markups", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updatePurchaseOrderMarkup(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-markups", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function deletePurchaseOrderMarkup(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-markups", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/inventory/purchase-order-types.ts
+async function listPurchaseOrderTypes(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-types" });
+  return client.request("get", path, { params });
+}
+async function createPurchaseOrderType(client, data) {
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-types" });
+  return client.request("post", path, { data });
+}
+async function getPurchaseOrderType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "purchase-order-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/inventory/receipts.ts
+async function listReceipts(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "receipts" });
+  return client.request("get", path, { params });
+}
+async function createReceipt(client, data) {
+  const path = client.buildPath({ category: "inventory", subject: "receipts" });
+  return client.request("post", path, { data });
+}
+async function listReceiptCustomFields(client) {
+  const path = client.buildPath({ category: "inventory", subject: "receipts", idOrSubpath: "custom-fields" });
+  return client.request("get", path);
+}
+async function cancelReceipt(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: `receipts/${id}/cancellation` });
+  return client.request("post", path);
+}
+
+// src/resources/inventory/returns.ts
+async function listReturns(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "returns" });
+  return client.request("get", path, { params });
+}
+async function createReturn(client, data) {
+  const path = client.buildPath({ category: "inventory", subject: "returns" });
+  return client.request("post", path, { data });
+}
+async function listReturnCustomFields(client) {
+  const path = client.buildPath({ category: "inventory", subject: "returns", idOrSubpath: "custom-fields" });
+  return client.request("get", path);
+}
+async function getReturn(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "returns", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function cancelReturn(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: `returns/${id}/cancellation` });
+  return client.request("post", path);
+}
+
+// src/resources/inventory/return-types.ts
+async function listReturnTypes(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "return-types" });
+  return client.request("get", path, { params });
+}
+async function getReturnType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "return-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/inventory/transfers.ts
+async function listTransfers(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "transfers" });
+  return client.request("get", path, { params });
+}
+async function listTransferCustomFields(client) {
+  const path = client.buildPath({ category: "inventory", subject: "transfers", idOrSubpath: "custom-fields" });
+  return client.request("get", path);
+}
+async function getTransfer(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "transfers", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/inventory/trucks.ts
+async function listTrucks(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "trucks" });
+  return client.request("get", path, { params });
+}
+async function getTruck(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "trucks", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/inventory/vendors.ts
+async function listVendors(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "vendors" });
+  return client.request("get", path, { params });
+}
+async function createVendor(client, data) {
+  const path = client.buildPath({ category: "inventory", subject: "vendors" });
+  return client.request("post", path, { data });
+}
+async function getVendor(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "vendors", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateVendor(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "vendors", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/inventory/warehouses.ts
+async function listWarehouses(client, params = {}) {
+  const path = client.buildPath({ category: "inventory", subject: "warehouses" });
+  return client.request("get", path, { params });
+}
+async function getWarehouse(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "inventory", subject: "warehouses", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/memberships/index.ts
+var memberships_exports = {};
+__export(memberships_exports, {
+  exportInvoiceTemplates: () => exportInvoiceTemplates,
+  exportMembershipStatusChanges: () => exportMembershipStatusChanges,
+  exportMembershipTypes: () => exportMembershipTypes,
+  exportMemberships: () => exportMemberships,
+  exportRecurringServiceEvents: () => exportRecurringServiceEvents,
+  exportRecurringServiceTypes: () => exportRecurringServiceTypes,
+  exportRecurringServices: () => exportRecurringServices,
+  getInvoiceTemplate: () => getInvoiceTemplate,
+  getMembership: () => getMembership,
+  getMembershipType: () => getMembershipType,
+  getRecurringService: () => getRecurringService,
+  getRecurringServiceType: () => getRecurringServiceType,
+  listInvoiceTemplates: () => listInvoiceTemplates,
+  listInvoiceTemplatesByIds: () => listInvoiceTemplatesByIds,
+  listMembershipCustomFields: () => listMembershipCustomFields,
+  listMembershipStatusChanges: () => listMembershipStatusChanges,
+  listMembershipTypeDiscounts: () => listMembershipTypeDiscounts,
+  listMembershipTypeDurationBillingItems: () => listMembershipTypeDurationBillingItems,
+  listMembershipTypeRecurringServiceItems: () => listMembershipTypeRecurringServiceItems,
+  listMembershipTypes: () => listMembershipTypes,
+  listMemberships: () => listMemberships,
+  listRecurringServiceEvents: () => listRecurringServiceEvents,
+  listRecurringServiceTypes: () => listRecurringServiceTypes,
+  listRecurringServices: () => listRecurringServices,
+  markRecurringServiceEventComplete: () => markRecurringServiceEventComplete,
+  markRecurringServiceEventIncomplete: () => markRecurringServiceEventIncomplete,
+  membershipSale: () => membershipSale,
+  updateInvoiceTemplate: () => updateInvoiceTemplate,
+  updateMembership: () => updateMembership,
+  updateRecurringService: () => updateRecurringService
+});
+
+// src/resources/memberships/export.ts
+async function exportInvoiceTemplates(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "invoice-templates" });
+  return client.request("get", path, { params });
+}
+async function exportMembershipStatusChanges(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "membership-status-changes" });
+  return client.request("get", path, { params });
+}
+async function exportMembershipTypes(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "membership-types" });
+  return client.request("get", path, { params });
+}
+async function exportMemberships(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "memberships" });
+  return client.request("get", path, { params });
+}
+async function exportRecurringServiceEvents(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "recurring-service-events" });
+  return client.request("get", path, { params });
+}
+async function exportRecurringServiceTypes(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "recurring-service-types" });
+  return client.request("get", path, { params });
+}
+async function exportRecurringServices(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "export", idOrSubpath: "recurring-services" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/memberships/memberships.ts
+async function listMemberships(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "memberships" });
+  return client.request("get", path, { params });
+}
+async function listMembershipCustomFields(client) {
+  const path = client.buildPath({ category: "memberships", subject: "memberships", idOrSubpath: "custom-fields" });
+  return client.request("get", path);
+}
+async function membershipSale(client, data) {
+  const path = client.buildPath({ category: "memberships", subject: "memberships", idOrSubpath: "sale" });
+  return client.request("post", path, { data });
+}
+async function getMembership(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "memberships", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateMembership(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "memberships", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function listMembershipStatusChanges(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "memberships", idOrSubpath: `${id}/status-changes` });
+  return client.request("get", path);
+}
+
+// src/resources/memberships/invoice-templates.ts
+async function listInvoiceTemplates(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "invoice-templates" });
+  return client.request("get", path, { params });
+}
+async function getInvoiceTemplate(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "invoice-templates", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateInvoiceTemplate(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "invoice-templates", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function listInvoiceTemplatesByIds(client, ids) {
+  const params = {};
+  if (ids && ids.length > 0) {
+    params.ids = ids.join(",");
+  }
+  const path = client.buildPath({ category: "memberships", subject: "invoice-templates" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/memberships/recurring-service-events.ts
+async function listRecurringServiceEvents(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "recurring-service-events" });
+  return client.request("get", path, { params });
+}
+async function markRecurringServiceEventComplete(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: `recurring-service-events/${id}/mark-complete` });
+  return client.request("post", path);
+}
+async function markRecurringServiceEventIncomplete(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: `recurring-service-events/${id}/mark-incomplete` });
+  return client.request("post", path);
+}
+
+// src/resources/memberships/recurring-services.ts
+async function listRecurringServices(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "recurring-services" });
+  return client.request("get", path, { params });
+}
+async function getRecurringService(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "recurring-services", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateRecurringService(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "recurring-services", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/memberships/membership-types.ts
+async function listMembershipTypes(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "membership-types" });
+  return client.request("get", path, { params });
+}
+async function getMembershipType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "membership-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function listMembershipTypeDiscounts(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: `membership-types/${id}/discounts` });
+  return client.request("get", path);
+}
+async function listMembershipTypeDurationBillingItems(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: `membership-types/${id}/duration-billing-items` });
+  return client.request("get", path);
+}
+async function listMembershipTypeRecurringServiceItems(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: `membership-types/${id}/recurring-service-items` });
+  return client.request("get", path);
+}
+
+// src/resources/memberships/recurring-service-types.ts
+async function listRecurringServiceTypes(client, params = {}) {
+  const path = client.buildPath({ category: "memberships", subject: "recurring-service-types" });
+  return client.request("get", path, { params });
+}
+async function getRecurringServiceType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "memberships", subject: "recurring-service-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/payroll/index.ts
+var payroll_exports = {};
+__export(payroll_exports, {
+  createGrossPayItem: () => createGrossPayItem,
+  createPayrollAdjustment: () => createPayrollAdjustment,
+  exportActivityCodes: () => exportActivityCodes,
+  exportGrossPayItems: () => exportGrossPayItems,
+  exportJobSplits: () => exportJobSplits,
+  exportJobTimesheets: () => exportJobTimesheets,
+  exportPayrollAdjustments: () => exportPayrollAdjustments,
+  exportPayrollSettings: () => exportPayrollSettings,
+  exportTimesheetCodes: () => exportTimesheetCodes,
+  getActivityCode: () => getActivityCode,
+  getEmployeePayrollSettings: () => getEmployeePayrollSettings,
+  getGrossPayItem: () => getGrossPayItem,
+  getPayrollAdjustment: () => getPayrollAdjustment,
+  getPayrollSettings: () => getPayrollSettings,
+  getTechnicianPayrollSettings: () => getTechnicianPayrollSettings,
+  getTimesheetCode: () => getTimesheetCode,
+  listActivityCodes: () => listActivityCodes,
+  listEmployeePayrolls: () => listEmployeePayrolls,
+  listGrossPayItems: () => listGrossPayItems,
+  listJobSplits: () => listJobSplits,
+  listJobSplitsByJob: () => listJobSplitsByJob,
+  listJobTimesheets: () => listJobTimesheets,
+  listLocationLaborRates: () => listLocationLaborRates,
+  listNonJobTimesheets: () => listNonJobTimesheets,
+  listPayrollAdjustments: () => listPayrollAdjustments,
+  listPayrolls: () => listPayrolls,
+  listTechnicianPayrolls: () => listTechnicianPayrolls,
+  listTimesheetCodes: () => listTimesheetCodes,
+  listTimesheetsForJob: () => listTimesheetsForJob,
+  updateEmployeePayrollSettings: () => updateEmployeePayrollSettings,
+  updateGrossPayItem: () => updateGrossPayItem,
+  updateTechnicianPayrollSettings: () => updateTechnicianPayrollSettings
+});
+
+// src/resources/payroll/export.ts
+async function exportActivityCodes(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "activity-codes" });
+  return client.request("get", path, { params });
+}
+async function exportGrossPayItems(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "gross-pay-items" });
+  return client.request("get", path, { params });
+}
+async function exportJobSplits(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "jobs/splits" });
+  return client.request("get", path, { params });
+}
+async function exportJobTimesheets(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "jobs/timesheets" });
+  return client.request("get", path, { params });
+}
+async function exportPayrollAdjustments(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "payroll-adjustments" });
+  return client.request("get", path, { params });
+}
+async function exportPayrollSettings(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "payroll-settings" });
+  return client.request("get", path, { params });
+}
+async function exportTimesheetCodes(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "export", idOrSubpath: "timesheet-codes" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/payroll/activity-codes.ts
+async function listActivityCodes(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "activity-codes" });
+  return client.request("get", path, { params });
+}
+async function getActivityCode(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "payroll", subject: "activity-codes", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/payroll/gross-pay-items.ts
+async function listGrossPayItems(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "gross-pay-items" });
+  return client.request("get", path, { params });
+}
+async function createGrossPayItem(client, data) {
+  const path = client.buildPath({ category: "payroll", subject: "gross-pay-items" });
+  return client.request("post", path, { data });
+}
+async function getGrossPayItem(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "payroll", subject: "gross-pay-items", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateGrossPayItem(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "payroll", subject: "gross-pay-items", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/payroll/job-splits.ts
+async function listJobSplits(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "jobs/splits" });
+  return client.request("get", path, { params });
+}
+async function listJobSplitsByJob(client, jobId) {
+  if (!jobId) throw new Error("job is required");
+  const path = client.buildPath({ category: "payroll", subject: `jobs/${jobId}/splits` });
+  return client.request("get", path);
+}
+
+// src/resources/payroll/location-labor-type.ts
+async function listLocationLaborRates(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "locations/rates" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/payroll/payroll-adjustments.ts
+async function listPayrollAdjustments(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "payroll-adjustments" });
+  return client.request("get", path, { params });
+}
+async function createPayrollAdjustment(client, data) {
+  const path = client.buildPath({ category: "payroll", subject: "payroll-adjustments" });
+  return client.request("post", path, { data });
+}
+async function getPayrollAdjustment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "payroll", subject: "payroll-adjustments", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/payroll/payrolls.ts
+async function listEmployeePayrolls(client, employeeId, params = {}) {
+  if (!employeeId) throw new Error("employee is required");
+  const path = client.buildPath({ category: "payroll", subject: `employees/${employeeId}/payrolls` });
+  return client.request("get", path, { params });
+}
+async function listPayrolls(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "payrolls" });
+  return client.request("get", path, { params });
+}
+async function listTechnicianPayrolls(client, technicianId, params = {}) {
+  if (!technicianId) throw new Error("technician is required");
+  const path = client.buildPath({ category: "payroll", subject: `technicians/${technicianId}/payrolls` });
+  return client.request("get", path, { params });
+}
+
+// src/resources/payroll/payroll-settings.ts
+async function getEmployeePayrollSettings(client, employeeId, params = {}) {
+  if (!employeeId) throw new Error("employee is required");
+  const path = client.buildPath({ category: "payroll", subject: `employees/${employeeId}/payroll-settings` });
+  return client.request("get", path, { params });
+}
+async function updateEmployeePayrollSettings(client, employeeId, data) {
+  if (!employeeId) throw new Error("employee is required");
+  const path = client.buildPath({ category: "payroll", subject: `employees/${employeeId}/payroll-settings` });
+  return client.request("put", path, { data });
+}
+async function getPayrollSettings(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "payroll-settings" });
+  return client.request("get", path, { params });
+}
+async function getTechnicianPayrollSettings(client, technicianId, params = {}) {
+  if (!technicianId) throw new Error("technician is required");
+  const path = client.buildPath({ category: "payroll", subject: `technicians/${technicianId}/payroll-settings` });
+  return client.request("get", path, { params });
+}
+async function updateTechnicianPayrollSettings(client, technicianId, data) {
+  if (!technicianId) throw new Error("technician is required");
+  const path = client.buildPath({ category: "payroll", subject: `technicians/${technicianId}/payroll-settings` });
+  return client.request("put", path, { data });
+}
+
+// src/resources/payroll/timesheet-codes.ts
+async function listTimesheetCodes(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "timesheet-codes" });
+  return client.request("get", path, { params });
+}
+async function getTimesheetCode(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "payroll", subject: "timesheet-codes", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/payroll/timesheets.ts
+async function listJobTimesheets(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "jobs/timesheets" });
+  return client.request("get", path, { params });
+}
+async function listTimesheetsForJob(client, jobId, params = {}) {
+  if (!jobId) throw new Error("job is required");
+  const path = client.buildPath({ category: "payroll", subject: `jobs/${jobId}/timesheets` });
+  return client.request("get", path, { params });
+}
+async function listNonJobTimesheets(client, params = {}) {
+  const path = client.buildPath({ category: "payroll", subject: "non-job-timesheets" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/forms/index.ts
+var forms_exports = {};
+__export(forms_exports, {
+  getJobAttachment: () => getJobAttachment,
+  listFormSubmissions: () => listFormSubmissions,
+  listForms: () => listForms,
+  listJobAttachments: () => listJobAttachments,
+  listJobAttachmentsByJobId: () => listJobAttachmentsByJobId
+});
+
+// src/resources/forms/forms.ts
+async function listForms(client, params = {}) {
+  const path = client.buildPath({ category: "forms", subject: "forms" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/forms/submissions.ts
+async function listFormSubmissions(client, params = {}) {
+  const path = client.buildPath({ category: "forms", subject: "submissions" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/forms/jobs.ts
+async function getJobAttachment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "forms", subject: `jobs/attachment/${id}` });
+  return client.request("get", path);
+}
+async function listJobAttachments(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "forms", subject: `jobs/${id}/attachments` });
+  return client.request("get", path);
+}
+async function listJobAttachmentsByJobId(client, jobId) {
+  if (!jobId) throw new Error("jobId is required");
+  const path = client.buildPath({ category: "forms", subject: `jobs/${jobId}/attachments` });
+  return client.request("get", path);
+}
+
+// src/resources/customer-interactions/index.ts
+var customer_interactions_exports = {};
+__export(customer_interactions_exports, {
+  updateTechnicianRating: () => updateTechnicianRating
+});
+
+// src/resources/customer-interactions/technician-rating.ts
+async function updateTechnicianRating(client, technicianId, jobId, data) {
+  if (!technicianId || !jobId) throw new Error("technicianId and jobId are required");
+  const path = client.buildPath({ category: "customer-interactions", subject: `technician-rating/technician/${technicianId}/job/${jobId}` });
+  return client.request("put", path, { data });
+}
+
+// src/resources/job-bookings/index.ts
+var job_bookings_exports = {};
+__export(job_bookings_exports, {
+  listCallReasons: () => listCallReasons
+});
+
+// src/resources/job-bookings/call-reasons.ts
+async function listCallReasons(client, params = {}) {
+  const path = client.buildPath({ category: "jbce", subject: "call-reasons" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing/index.ts
+var marketing_exports = {};
+__export(marketing_exports, {
+  createCampaign: () => createCampaign,
+  createCampaignCategory: () => createCampaignCategory,
+  createCampaignCost: () => createCampaignCost,
+  getCampaign: () => getCampaign,
+  getCampaignCategory: () => getCampaignCategory,
+  getCampaignCost: () => getCampaignCost,
+  getSuppressionByEmail: () => getSuppressionByEmail,
+  listCampaignCategories: () => listCampaignCategories,
+  listCampaignCosts: () => listCampaignCosts,
+  listCampaignCostsForCampaign: () => listCampaignCostsForCampaign,
+  listCampaigns: () => listCampaigns,
+  listSuppressions: () => listSuppressions,
+  suppressEmail: () => suppressEmail,
+  unsuppressEmail: () => unsuppressEmail,
+  updateCampaign: () => updateCampaign,
+  updateCampaignCategory: () => updateCampaignCategory,
+  updateCampaignCost: () => updateCampaignCost
+});
+
+// src/resources/marketing/categories.ts
+async function listCampaignCategories(client, params = {}) {
+  const path = client.buildPath({ category: "marketing", subject: "categories" });
+  return client.request("get", path, { params });
+}
+async function createCampaignCategory(client, data) {
+  const path = client.buildPath({ category: "marketing", subject: "categories" });
+  return client.request("post", path, { data });
+}
+async function getCampaignCategory(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: "categories", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateCampaignCategory(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: "categories", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/marketing/costs.ts
+async function listCampaignCosts(client, params = {}) {
+  const path = client.buildPath({ category: "marketing", subject: "costs" });
+  return client.request("get", path, { params });
+}
+async function createCampaignCost(client, data) {
+  const path = client.buildPath({ category: "marketing", subject: "costs" });
+  return client.request("post", path, { data });
+}
+async function getCampaignCost(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: "costs", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateCampaignCost(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: "costs", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/marketing/campaigns.ts
+async function listCampaigns(client, params = {}) {
+  const path = client.buildPath({ category: "marketing", subject: "campaigns" });
+  return client.request("get", path, { params });
+}
+async function createCampaign(client, data) {
+  const path = client.buildPath({ category: "marketing", subject: "campaigns" });
+  return client.request("post", path, { data });
+}
+async function getCampaign(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: "campaigns", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateCampaign(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: "campaigns", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function listCampaignCostsForCampaign(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "marketing", subject: `campaigns/${id}/costs` });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing/suppressions.ts
+async function listSuppressions(client, params = {}) {
+  const path = client.buildPath({ category: "marketing", subject: "suppressions" });
+  return client.request("get", path, { params });
+}
+async function suppressEmail(client, data) {
+  const path = client.buildPath({ category: "marketing", subject: "suppressions/suppress" });
+  return client.request("post", path, { data });
+}
+async function unsuppressEmail(client, data) {
+  const path = client.buildPath({ category: "marketing", subject: "suppressions/unsuppress" });
+  return client.request("post", path, { data });
+}
+async function getSuppressionByEmail(client, email) {
+  if (!email) throw new Error("email is required");
+  const encoded = encodeURIComponent(email);
+  const path = client.buildPath({ category: "marketing", subject: `suppressions/${encoded}` });
+  return client.request("get", path);
+}
+
+// src/resources/marketing-ads/index.ts
+var marketing_ads_exports = {};
+__export(marketing_ads_exports, {
+  getPerformance: () => getPerformance,
+  listAttributedLeads: () => listAttributedLeads,
+  listCapacityWarnings: () => listCapacityWarnings,
+  listExternalCallAttributions: () => listExternalCallAttributions,
+  listScheduledJobAttributions: () => listScheduledJobAttributions,
+  listWebBookingAttributions: () => listWebBookingAttributions,
+  listWebLeadFormAttributions: () => listWebLeadFormAttributions
+});
+
+// src/resources/marketing-ads/attributed-leads.ts
+async function listAttributedLeads(client, params) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "attributed-leads" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing-ads/capacity-warnings.ts
+async function listCapacityWarnings(client, params = {}) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "capacity-warnings" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing-ads/external-call-attributions.ts
+async function listExternalCallAttributions(client, params = {}) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "external-call-attributions" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing-ads/performance.ts
+async function getPerformance(client, params) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "performance" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing-ads/scheduled-job-attributions.ts
+async function listScheduledJobAttributions(client, params = {}) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "job-attributions" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing-ads/web-booking-attributions.ts
+async function listWebBookingAttributions(client, params = {}) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "web-booking-attributions" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/marketing-ads/web-lead-form-attributions.ts
+async function listWebLeadFormAttributions(client, params = {}) {
+  const path = client.buildPath({ category: "marketing-ads", subject: "web-lead-form-attributions" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/reporting/index.ts
+var reporting_exports = {};
+__export(reporting_exports, {
+  getDynamicValueSet: () => getDynamicValueSet,
+  getReport: () => getReport,
+  getReportData: () => getReportData,
+  listReportCategories: () => listReportCategories,
+  listReportsForCategory: () => listReportsForCategory
+});
+
+// src/resources/reporting/dynamic-value-sets.ts
+async function getDynamicValueSet(client, dynamicSetId, params = {}) {
+  if (!dynamicSetId) throw new Error("dynamicSetId is required");
+  const path = client.buildPath({ category: "reporting", subject: `dynamic-value-sets/${dynamicSetId}` });
+  return client.request("get", path, { params });
+}
+
+// src/resources/reporting/report-categories.ts
+async function listReportCategories(client, params = {}) {
+  const path = client.buildPath({ category: "reporting", subject: "report-categories" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/reporting/report-category-reports.ts
+async function listReportsForCategory(client, reportCategory, params = {}) {
+  if (!reportCategory) throw new Error("report_category is required");
+  const path = client.buildPath({ category: "reporting", subject: `${reportCategory}/reports` });
+  return client.request("get", path, { params });
+}
+async function getReport(client, reportCategory, reportId) {
+  if (!reportCategory || !reportId) throw new Error("report_category and reportId are required");
+  const path = client.buildPath({ category: "reporting", subject: `${reportCategory}/reports/${reportId}` });
+  return client.request("get", path);
+}
+async function getReportData(client, reportCategory, reportId, params = {}) {
+  if (!reportCategory || !reportId) throw new Error("report_category and reportId are required");
+  const path = client.buildPath({ category: "reporting", subject: `${reportCategory}/reports/${reportId}/data` });
+  return client.request("get", path, { params });
+}
+
+// src/resources/pricebook/index.ts
+var pricebook_exports = {};
+__export(pricebook_exports, {
+  createCategory: () => createCategory,
+  createDiscountOrFee: () => createDiscountOrFee,
+  createEquipment: () => createEquipment,
+  createMaterial: () => createMaterial,
+  createMaterialsMarkup: () => createMaterialsMarkup,
+  createService: () => createService,
+  deleteCategory: () => deleteCategory,
+  deleteDiscountOrFee: () => deleteDiscountOrFee,
+  deleteEquipment: () => deleteEquipment,
+  deleteMaterial: () => deleteMaterial,
+  deleteService: () => deleteService,
+  exportCategories: () => exportCategories,
+  exportEquipment: () => exportEquipment,
+  exportMaterials: () => exportMaterials,
+  exportPricebook: () => exportPricebook,
+  exportServices: () => exportServices,
+  getCategory: () => getCategory,
+  getClientSpecificPricingRateSheet: () => getClientSpecificPricingRateSheet,
+  getDiscountOrFee: () => getDiscountOrFee,
+  getEquipment: () => getEquipment,
+  getMaterial: () => getMaterial,
+  getMaterialsMarkup: () => getMaterialsMarkup,
+  getService: () => getService,
+  importPricebook: () => importPricebook,
+  listCategories: () => listCategories,
+  listClientSpecificPricing: () => listClientSpecificPricing,
+  listDiscountsAndFees: () => listDiscountsAndFees,
+  listEquipment: () => listEquipment,
+  listImages: () => listImages,
+  listMaterialCostTypes: () => listMaterialCostTypes,
+  listMaterials: () => listMaterials,
+  listMaterialsMarkup: () => listMaterialsMarkup,
+  listServices: () => listServices,
+  updateCategory: () => updateCategory,
+  updateDiscountOrFee: () => updateDiscountOrFee,
+  updateEquipment: () => updateEquipment,
+  updateMaterial: () => updateMaterial,
+  updateMaterialsMarkup: () => updateMaterialsMarkup,
+  updateService: () => updateService,
+  uploadImage: () => uploadImage
+});
+
+// src/resources/pricebook/export.ts
+async function exportCategories(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "export", idOrSubpath: "categories" });
+  return client.request("get", path, { params });
+}
+async function exportEquipment(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "export", idOrSubpath: "equipment" });
+  return client.request("get", path, { params });
+}
+async function exportMaterials(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "export", idOrSubpath: "materials" });
+  return client.request("get", path, { params });
+}
+async function exportServices(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "export", idOrSubpath: "services" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/pricebook/categories.ts
+async function listCategories(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "categories" });
+  return client.request("get", path, { params });
+}
+async function createCategory(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "categories" });
+  return client.request("post", path, { data });
+}
+async function getCategory(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "categories", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateCategory(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "categories", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function deleteCategory(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "categories", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/pricebook/client-specific-pricing.ts
+async function listClientSpecificPricing(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "clientspecificpricing" });
+  return client.request("get", path, { params });
+}
+async function getClientSpecificPricingRateSheet(client, rateSheetId) {
+  if (!rateSheetId) throw new Error("rateSheetId is required");
+  const path = client.buildPath({ category: "pricebook", subject: `clientspecificpricing/${rateSheetId}` });
+  return client.request("get", path);
+}
+
+// src/resources/pricebook/discounts-and-fees.ts
+async function listDiscountsAndFees(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "discounts-and-fees" });
+  return client.request("get", path, { params });
+}
+async function createDiscountOrFee(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "discounts-and-fees" });
+  return client.request("post", path, { data });
+}
+async function getDiscountOrFee(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "discounts-and-fees", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateDiscountOrFee(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "discounts-and-fees", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function deleteDiscountOrFee(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "discounts-and-fees", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/pricebook/equipment.ts
+async function listEquipment(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "equipment" });
+  return client.request("get", path, { params });
+}
+async function createEquipment(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "equipment" });
+  return client.request("post", path, { data });
+}
+async function getEquipment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "equipment", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateEquipment(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "equipment", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function deleteEquipment(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "equipment", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/pricebook/images.ts
+async function listImages(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "images" });
+  return client.request("get", path, { params });
+}
+async function uploadImage(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "images" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/pricebook/materials.ts
+async function listMaterials(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "materials" });
+  return client.request("get", path, { params });
+}
+async function createMaterial(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "materials" });
+  return client.request("post", path, { data });
+}
+async function listMaterialCostTypes(client) {
+  const path = client.buildPath({ category: "pricebook", subject: "materials", idOrSubpath: "costtypes" });
+  return client.request("get", path);
+}
+async function getMaterial(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "materials", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateMaterial(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "materials", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function deleteMaterial(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "materials", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/pricebook/materials-markup.ts
+async function listMaterialsMarkup(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "materialsmarkup" });
+  return client.request("get", path, { params });
+}
+async function createMaterialsMarkup(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "materialsmarkup" });
+  return client.request("post", path, { data });
+}
+async function getMaterialsMarkup(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "materialsmarkup", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateMaterialsMarkup(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "materialsmarkup", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/pricebook/pricebook-bulk.ts
+async function exportPricebook(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "pricebook" });
+  return client.request("get", path, { params });
+}
+async function importPricebook(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "pricebook" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/pricebook/services.ts
+async function listServices(client, params = {}) {
+  const path = client.buildPath({ category: "pricebook", subject: "services" });
+  return client.request("get", path, { params });
+}
+async function createService(client, data) {
+  const path = client.buildPath({ category: "pricebook", subject: "services" });
+  return client.request("post", path, { data });
+}
+async function getService(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "services", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateService(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "services", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function deleteService(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "pricebook", subject: "services", idOrSubpath: String(id) });
+  return client.request("delete", path);
+}
+
+// src/resources/task-management/index.ts
+var task_management_exports = {};
+__export(task_management_exports, {
+  createTask: () => createTask,
+  getClientSideData: () => getClientSideData,
+  getTask: () => getTask,
+  listSubtasks: () => listSubtasks,
+  listTasks: () => listTasks
+});
+
+// src/resources/task-management/client-side-data.ts
+async function getClientSideData(client, params = {}) {
+  const path = client.buildPath({ category: "task-management", subject: "data" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/task-management/tasks.ts
+async function listTasks(client, params = {}) {
+  const path = client.buildPath({ category: "task-management", subject: "tasks" });
+  return client.request("get", path, { params });
+}
+async function createTask(client, data) {
+  const path = client.buildPath({ category: "task-management", subject: "tasks" });
+  return client.request("post", path, { data });
+}
+async function getTask(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "task-management", subject: "tasks", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function listSubtasks(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "task-management", subject: `tasks/${id}/subtasks` });
+  return client.request("get", path);
+}
+
+// src/resources/telecom/index.ts
+var telecom_exports = {};
+__export(telecom_exports, {
+  exportCalls: () => exportCalls,
+  getCall: () => getCall,
+  getCallRecording: () => getCallRecording,
+  getCallVoicemail: () => getCallVoicemail,
+  listCalls: () => listCalls,
+  updateCall: () => updateCall
+});
+
+// src/resources/telecom/export.ts
+async function exportCalls(client, params = {}) {
+  const path = client.buildPath({ category: "telecom", subject: "export", idOrSubpath: "calls" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/telecom/calls.ts
+async function listCalls(client, params = {}) {
+  const path = client.buildPath({ category: "telecom", subject: "calls" });
+  return client.request("get", path, { params });
+}
+async function getCall(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "telecom", subject: "calls", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateCall(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "telecom", subject: "calls", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function getCallRecording(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "telecom", subject: `calls/${id}/recording` });
+  return client.request("get", path);
+}
+async function getCallVoicemail(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "telecom", subject: `calls/${id}/voicemail` });
+  return client.request("get", path);
+}
+
+// src/resources/timesheets-v2/index.ts
+var timesheets_v2_exports = {};
+__export(timesheets_v2_exports, {
+  exportActivities: () => exportActivities,
+  exportActivityCategories: () => exportActivityCategories,
+  exportActivityTypes: () => exportActivityTypes,
+  getActivity: () => getActivity,
+  getActivityCategory: () => getActivityCategory,
+  getActivityType: () => getActivityType,
+  listActivities: () => listActivities,
+  listActivityCategories: () => listActivityCategories,
+  listActivityTypes: () => listActivityTypes
+});
+
+// src/resources/timesheets-v2/export.ts
+async function exportActivities(client, params = {}) {
+  const path = client.buildPath({ category: "timesheets", subject: "export", idOrSubpath: "activities" });
+  return client.request("get", path, { params });
+}
+async function exportActivityCategories(client, params = {}) {
+  const path = client.buildPath({ category: "timesheets", subject: "export", idOrSubpath: "activity-categories" });
+  return client.request("get", path, { params });
+}
+async function exportActivityTypes(client, params = {}) {
+  const path = client.buildPath({ category: "timesheets", subject: "export", idOrSubpath: "activity-types" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/timesheets-v2/activities.ts
+async function listActivities(client, params = {}) {
+  const path = client.buildPath({ category: "timesheets", subject: "activities" });
+  return client.request("get", path, { params });
+}
+async function getActivity(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "timesheets", subject: "activities", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/timesheets-v2/activity-categories.ts
+async function listActivityCategories(client, params = {}) {
+  const path = client.buildPath({ category: "timesheets", subject: "activity-categories" });
+  return client.request("get", path, { params });
+}
+async function getActivityCategory(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "timesheets", subject: "activity-categories", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/timesheets-v2/activity-types.ts
+async function listActivityTypes(client, params = {}) {
+  const path = client.buildPath({ category: "timesheets", subject: "activity-types" });
+  return client.request("get", path, { params });
+}
+async function getActivityType(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "timesheets", subject: "activity-types", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+
+// src/resources/settings/index.ts
+var settings_exports = {};
+__export(settings_exports, {
+  createEmployee: () => createEmployee,
+  createTagType: () => createTagType,
+  createTechnician: () => createTechnician,
+  exportBusinessUnits: () => exportBusinessUnits,
+  exportEmployees: () => exportEmployees,
+  exportTagTypes: () => exportTagTypes,
+  exportTechnicians: () => exportTechnicians,
+  getBusinessUnit: () => getBusinessUnit,
+  getEmployee: () => getEmployee,
+  getEmployeeAccountActions: () => getEmployeeAccountActions,
+  getTechnician: () => getTechnician,
+  getTechnicianAccountActions: () => getTechnicianAccountActions,
+  listBusinessUnits: () => listBusinessUnits,
+  listEmployees: () => listEmployees,
+  listTagTypes: () => listTagTypes,
+  listTechnicians: () => listTechnicians,
+  listUserRoles: () => listUserRoles,
+  updateBusinessUnit: () => updateBusinessUnit,
+  updateEmployee: () => updateEmployee,
+  updateTechnician: () => updateTechnician
+});
+
+// src/resources/settings/export.ts
+async function exportBusinessUnits(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "export", idOrSubpath: "business-units" });
+  return client.request("get", path, { params });
+}
+async function exportEmployees(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "export", idOrSubpath: "employees" });
+  return client.request("get", path, { params });
+}
+async function exportTagTypes(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "export", idOrSubpath: "tag-types" });
+  return client.request("get", path, { params });
+}
+async function exportTechnicians(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "export", idOrSubpath: "technicians" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/settings/business-units.ts
+async function listBusinessUnits(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "business-units" });
+  return client.request("get", path, { params });
+}
+async function getBusinessUnit(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: "business-units", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateBusinessUnit(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: "business-units", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+
+// src/resources/settings/employees.ts
+async function listEmployees(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "employees" });
+  return client.request("get", path, { params });
+}
+async function createEmployee(client, data) {
+  const path = client.buildPath({ category: "settings", subject: "employees" });
+  return client.request("post", path, { data });
+}
+async function getEmployee(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: "employees", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateEmployee(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: "employees", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function getEmployeeAccountActions(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: `employees/${id}/account-actions` });
+  return client.request("get", path);
+}
+
+// src/resources/settings/tag-types.ts
+async function listTagTypes(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "tag-types" });
+  return client.request("get", path, { params });
+}
+async function createTagType(client, data) {
+  const path = client.buildPath({ category: "settings", subject: "tag-types" });
+  return client.request("post", path, { data });
+}
+
+// src/resources/settings/technicians.ts
+async function listTechnicians(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "technicians" });
+  return client.request("get", path, { params });
+}
+async function createTechnician(client, data) {
+  const path = client.buildPath({ category: "settings", subject: "technicians" });
+  return client.request("post", path, { data });
+}
+async function getTechnician(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: "technicians", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateTechnician(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: "technicians", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function getTechnicianAccountActions(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "settings", subject: `technicians/${id}/account-actions` });
+  return client.request("get", path);
+}
+
+// src/resources/settings/user-roles.ts
+async function listUserRoles(client, params = {}) {
+  const path = client.buildPath({ category: "settings", subject: "user-roles" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/sales-estimates/index.ts
+var sales_estimates_exports = {};
+__export(sales_estimates_exports, {
+  createEstimate: () => createEstimate,
+  dismissEstimate: () => dismissEstimate,
+  exportEstimates: () => exportEstimates,
+  getEstimate: () => getEstimate,
+  getEstimateItem: () => getEstimateItem,
+  listEstimateItems: () => listEstimateItems,
+  listEstimateItemsByEstimate: () => listEstimateItemsByEstimate,
+  listEstimates: () => listEstimates,
+  sellEstimate: () => sellEstimate,
+  unsellEstimate: () => unsellEstimate,
+  updateEstimate: () => updateEstimate
+});
+
+// src/resources/sales-estimates/estimates.ts
+async function listEstimates(client, params = {}) {
+  const path = client.buildPath({ category: "salestech", subject: "estimates" });
+  return client.request("get", path, { params });
+}
+async function createEstimate(client, data) {
+  const path = client.buildPath({ category: "salestech", subject: "estimates" });
+  return client.request("post", path, { data });
+}
+async function listEstimateItems(client, params = {}) {
+  const path = client.buildPath({ category: "salestech", subject: "estimates/items" });
+  return client.request("get", path, { params });
+}
+async function getEstimate(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "salestech", subject: "estimates", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+async function updateEstimate(client, id, data) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "salestech", subject: "estimates", idOrSubpath: String(id) });
+  return client.request("put", path, { data });
+}
+async function dismissEstimate(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "salestech", subject: `estimates/${id}/dismiss` });
+  return client.request("post", path);
+}
+async function listEstimateItemsByEstimate(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "salestech", subject: `estimates/${id}/items` });
+  return client.request("get", path);
+}
+async function getEstimateItem(client, id, itemId) {
+  if (!id || !itemId) throw new Error("id and itemId are required");
+  const path = client.buildPath({ category: "salestech", subject: `estimates/${id}/items/${itemId}` });
+  return client.request("get", path);
+}
+async function sellEstimate(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "salestech", subject: `estimates/${id}/sell` });
+  return client.request("post", path);
+}
+async function unsellEstimate(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "salestech", subject: `estimates/${id}/unsell` });
+  return client.request("post", path);
+}
+
+// src/resources/sales-estimates/estimates-export.ts
+async function exportEstimates(client, params = {}) {
+  const path = client.buildPath({ category: "salestech", subject: "estimates", idOrSubpath: "export" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/scheduling-pro/index.ts
+var scheduling_pro_exports = {};
+__export(scheduling_pro_exports, {
+  getRouterPerformance: () => getRouterPerformance,
+  getSchedulerPerformance: () => getSchedulerPerformance,
+  listRouterSessions: () => listRouterSessions,
+  listSchedulerSessions: () => listSchedulerSessions,
+  listSchedulers: () => listSchedulers
+});
+
+// src/resources/scheduling-pro/routers.ts
+async function getRouterPerformance(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "scheduling-pro", subject: `routers/${id}/performance` });
+  return client.request("get", path, { params });
+}
+async function listRouterSessions(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "scheduling-pro", subject: `routers/${id}/sessions` });
+  return client.request("get", path, { params });
+}
+
+// src/resources/scheduling-pro/schedulers.ts
+async function listSchedulers(client, params = {}) {
+  const path = client.buildPath({ category: "scheduling-pro", subject: "schedulers" });
+  return client.request("get", path, { params });
+}
+async function getSchedulerPerformance(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "scheduling-pro", subject: `schedulers/${id}/performance` });
+  return client.request("get", path, { params });
+}
+async function listSchedulerSessions(client, id, params = {}) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "scheduling-pro", subject: `schedulers/${id}/sessions` });
+  return client.request("get", path, { params });
+}
+
+// src/resources/service-agreements/index.ts
+var service_agreements_exports = {};
+__export(service_agreements_exports, {
+  exportServiceAgreements: () => exportServiceAgreements,
+  getServiceAgreement: () => getServiceAgreement,
+  listServiceAgreements: () => listServiceAgreements
+});
+
+// src/resources/service-agreements/export.ts
+async function exportServiceAgreements(client, params = {}) {
+  const path = client.buildPath({ category: "service-agreements", subject: "export", idOrSubpath: "service-agreements" });
+  return client.request("get", path, { params });
+}
+
+// src/resources/service-agreements/service-agreements.ts
+async function listServiceAgreements(client, params = {}) {
+  const path = client.buildPath({ category: "service-agreements", subject: "service-agreements" });
+  return client.request("get", path, { params });
+}
+async function getServiceAgreement(client, id) {
+  if (!id) throw new Error("id is required");
+  const path = client.buildPath({ category: "service-agreements", subject: "service-agreements", idOrSubpath: String(id) });
+  return client.request("get", path);
+}
+export {
+  accounting_exports as Accounting,
+  crm_exports as CRM,
+  customer_interactions_exports as CustomerInteractions,
+  dispatch_exports as Dispatch,
+  equipment_systems_exports as EquipmentSystems,
+  forms_exports as Forms,
+  inventory_exports as Inventory,
+  job_bookings_exports as JBCE,
+  jpm_exports as JPM,
+  marketing_exports as Marketing,
+  marketing_ads_exports as MarketingAds,
+  memberships_exports as Memberships,
+  payroll_exports as Payroll,
+  pricebook_exports as Pricebook,
+  reporting_exports as Reporting,
+  sales_estimates_exports as SalesEstimates,
+  scheduling_pro_exports as SchedulingPro,
+  service_agreements_exports as ServiceAgreements,
+  ServiceTitanClient,
+  settings_exports as Settings,
+  task_management_exports as TaskManagement,
+  telecom_exports as Telecom,
+  timesheets_v2_exports as TimesheetsV2,
+  createClientFromEnv
+};