@simpleapps-com/augur-server 0.2.6 → 0.2.7

package/dist/index.js

@@ -573,6 +573,9 @@ function createOrderActions(api, config = {}) {
 }
 
 // src/actions/search.ts
+function getOpenSearch(api) {
+  return "openSearch" in api ? api.openSearch : api.opensearch;
+}
 function createSearchActions(api, config = {}) {
   const {
     cachePrefix = "",
@@ -580,6 +583,7 @@ function createSearchActions(api, config = {}) {
     redisTtl = 3600,
     defaultSourceFields = "display_desc"
   } = config;
+  const openSearch = getOpenSearch(api);
   async function getSearchAttributes(q) {
     const params = { q, edgeCache };
     return withServerCache(
@@ -587,7 +591,7 @@ function createSearchActions(api, config = {}) {
       redisTtl,
       "openSearch.itemSearch.attributes.list",
       async () => {
-        const response = await api.openSearch.itemSearch.attributes.list(params);
+        const response = await openSearch.itemSearch.attributes.list(params);
         return response.data.attributes;
       },
       q
@@ -602,7 +606,7 @@ function createSearchActions(api, config = {}) {
       redisTtl,
       "openSearch.suggestions.suggest.list",
       async () => {
-        const response = await api.openSearch.suggestions.suggest.list(params);
+        const response = await openSearch.suggestions.suggest.list(params);
         return response.data;
       },
       q
@@ -625,7 +629,7 @@ function createSearchActions(api, config = {}) {
       redisTtl,
       "openSearch.itemSearch.list",
       async () => {
-        const response = await api.openSearch.itemSearch.list(params);
+        const response = await openSearch.itemSearch.list(params);
         return response.data;
       },
       filters,
@@ -649,7 +653,7 @@ function createSearchActions(api, config = {}) {
       redisTtl,
       "openSearch.itemSearch.list",
       async () => {
-        const response = await api.openSearch.itemSearch.list(params);
+        const response = await openSearch.itemSearch.list(params);
         const { items, totalResults } = response.data;
         const nextOffset = pageParam + filters.limit;
         return {
@@ -736,19 +740,1331 @@ function createJoomlaActions(api, config = {}) {
   }
   return { getJoomlaContent, getJoomlaContentList };
 }
+
+// src/actions/legacy.ts
+function createLegacyActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    longEdgeCache = 8,
+    redisTtl = 3600,
+    longRedisTtl = 28800
+  } = config;
+  async function getItemWebDesc(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "legacy.invMast.webDesc.list",
+      async () => {
+        const response = await api.legacy.invMast.webDesc.list(invMastUid, {
+          edgeCache
+        });
+        return response.data[0];
+      },
+      invMastUid
+    );
+  }
+  async function getAlsoBoughtItems(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "legacy.invMast.alsoBought.list",
+      async () => {
+        const response = await api.legacy.invMast.alsoBought.list(
+          invMastUid,
+          { edgeCache }
+        );
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function getItemTags(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "legacy.invMast.tags.list",
+      async () => {
+        const response = await api.legacy.invMast.tags.list(invMastUid, {
+          edgeCache
+        });
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function getStates(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "legacy.legacy.state.list",
+      async () => {
+        const response = await api.legacy.legacy.state.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params?.twoLetterCode
+    );
+  }
+  return {
+    getItemWebDesc,
+    getAlsoBoughtItems,
+    getItemTags,
+    getStates
+  };
+}
+
+// src/actions/customers.ts
+function createCustomersActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function getCustomer(customerId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "customers.customer.get",
+      async () => {
+        const response = await api.customers.customer.get(customerId, {
+          edgeCache
+        });
+        return response.data;
+      },
+      customerId
+    );
+  }
+  async function customerLookup(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "customers.customer.lookup.get",
+      async () => {
+        const response = await api.customers.customer.lookup.get({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCustomerDoc(customerId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "customers.customer.doc.list",
+      async () => {
+        const response = await api.customers.customer.doc.list(customerId, {
+          edgeCache
+        });
+        return response.data;
+      },
+      customerId
+    );
+  }
+  async function getCustomerOrders(customerId, params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "customers.customer.orders.list",
+      async () => {
+        const response = await api.customers.customer.orders.list(customerId, {
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      customerId,
+      params
+    );
+  }
+  async function getContacts(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "customers.contacts.list",
+      async () => {
+        const response = await api.customers.contacts.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getShipToAddresses(customerId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "customers.customer.shipTo.list",
+      async () => {
+        const response = await api.customers.customer.shipTo.list(customerId, {
+          edgeCache
+        });
+        return response.data;
+      },
+      customerId
+    );
+  }
+  return {
+    getCustomer,
+    customerLookup,
+    getCustomerDoc,
+    getCustomerOrders,
+    getContacts,
+    getShipToAddresses
+  };
+}
+
+// src/actions/smarty-streets.ts
+function createSmartyStreetsActions(api, config = {}) {
+  const { cachePrefix: _cachePrefix = "" } = config;
+  async function validateAddress(params) {
+    const response = await api.smartyStreets.us.lookup.get(params);
+    return response.data;
+  }
+  return {
+    validateAddress
+  };
+}
+
+// src/actions/p21-pim.ts
+function createP21PimActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function getInvMastExt(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Pim.invMastExt.get",
+      async () => {
+        const response = await api.p21Pim.invMastExt.get(invMastUid, {
+          edgeCache
+        });
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function listInvMastExt(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Pim.invMastExt.list",
+      async () => {
+        const response = await api.p21Pim.invMastExt.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return {
+    getInvMastExt,
+    listInvMastExt
+  };
+}
+
+// src/actions/agr-site.ts
+function createAgrSiteActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    longEdgeCache = 8,
+    longRedisTtl = 28800
+  } = config;
+  async function getSettings(serviceName) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "agrSite.settings.list",
+      async () => {
+        const response = await api.agrSite.settings.list({
+          ...serviceName ? { serviceName } : {},
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      serviceName
+    );
+  }
+  async function getMetaFiles(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "agrSite.metaFiles.list",
+      async () => {
+        const response = await api.agrSite.metaFiles.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return {
+    getSettings,
+    getMetaFiles
+  };
+}
+
+// src/actions/avalara.ts
+function createAvalaraActions(api, config = {}) {
+  const { cachePrefix: _cachePrefix = "" } = config;
+  async function calculateTax(data) {
+    const response = await api.avalara.rates.create(data);
+    return response.data;
+  }
+  return {
+    calculateTax
+  };
+}
+
+// src/actions/payments.ts
+function createPaymentsActions(api, config = {}) {
+  const { cachePrefix: _cachePrefix = "" } = config;
+  async function transactionSetup(params) {
+    try {
+      const response = await api.payments.unified.transactionSetup.get(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function accountQuery(params) {
+    try {
+      const response = await api.payments.unified.accountQuery.get(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function getSurcharge(params) {
+    try {
+      const response = await api.payments.unified.surcharge.get(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    transactionSetup,
+    accountQuery,
+    getSurcharge
+  };
+}
+
+// src/actions/ups.ts
+function createUpsActions(api, config = {}) {
+  const { cachePrefix: _cachePrefix = "" } = config;
+  async function getRates(params) {
+    try {
+      const response = await api.ups.ratesShop.get(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    getRates
+  };
+}
+
+// src/actions/logistics.ts
+function createLogisticsActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    longEdgeCache = 8,
+    longRedisTtl = 28800
+  } = config;
+  async function getFreightRates(params) {
+    try {
+      const response = await api.logistics.speedship.freight.get(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function getShipVia(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "logistics.shipvia.rates.list",
+      async () => {
+        const response = await api.logistics.shipvia.rates.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  return {
+    getFreightRates,
+    getShipVia
+  };
+}
+
+// src/actions/nexus.ts
+function createNexusActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    redisTtl = 3600
+  } = config;
+  async function createBinTransfer(data) {
+    try {
+      const response = await api.nexus.binTransfer.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function createReceiving(data) {
+    try {
+      const response = await api.nexus.receiving.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function createTransfer(data) {
+    try {
+      const response = await api.nexus.transfer.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function getPurchaseOrderReceipts(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "nexus.purchaseOrderReceipt.list",
+      async () => {
+        const response = await api.nexus.purchaseOrderReceipt.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getTransferReceipts(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "nexus.transferReceipt.list",
+      async () => {
+        const response = await api.nexus.transferReceipt.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getTransferShipping(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "nexus.transferShipping.list",
+      async () => {
+        const response = await api.nexus.transferShipping.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  return {
+    createBinTransfer,
+    createReceiving,
+    createTransfer,
+    getPurchaseOrderReceipts,
+    getTransferReceipts,
+    getTransferShipping
+  };
+}
+
+// src/actions/vmi.ts
+function createVmiActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    redisTtl = 3600,
+    shortRedisTtl = 300
+  } = config;
+  async function getWarehouses(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "vmi.warehouse.list",
+      async () => {
+        const response = await api.vmi.warehouse.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getWarehouseAvailability(warehouseUid, params) {
+    return withServerCache(
+      cachePrefix,
+      shortRedisTtl,
+      "vmi.warehouse.availability.get",
+      async () => {
+        const response = await api.vmi.warehouse.availability.get(
+          warehouseUid,
+          { ...params, edgeCache }
+        );
+        return response.data;
+      },
+      warehouseUid,
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getDistributors(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "vmi.distributors.list",
+      async () => {
+        const response = await api.vmi.distributors.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getProducts(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "vmi.products.list",
+      async () => {
+        const response = await api.vmi.products.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getInventoryProfiles(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "vmi.invProfileHdr.list",
+      async () => {
+        const response = await api.vmi.invProfileHdr.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getRestockHeaders(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "vmi.restockHdr.list",
+      async () => {
+        const response = await api.vmi.restockHdr.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  async function getSections(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "vmi.sections.list",
+      async () => {
+        const response = await api.vmi.sections.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params ? JSON.stringify(params) : void 0
+    );
+  }
+  return {
+    getWarehouses,
+    getWarehouseAvailability,
+    getDistributors,
+    getProducts,
+    getInventoryProfiles,
+    getRestockHeaders,
+    getSections
+  };
+}
+
+// src/actions/p21-core.ts
+function createP21CoreActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    longEdgeCache = 8,
+    redisTtl = 3600,
+    longRedisTtl = 28800
+  } = config;
+  async function getAddresses(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Core.address.list",
+      async () => {
+        const response = await api.p21Core.address.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCompanies(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "p21Core.company.list",
+      async () => {
+        const response = await api.p21Core.company.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCompany(companyId) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "p21Core.company.get",
+      async () => {
+        const response = await api.p21Core.company.get({
+          companyUid: companyId,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      companyId
+    );
+  }
+  async function getLocations(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "p21Core.location.list",
+      async () => {
+        const response = await api.p21Core.location.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getPaymentTypes(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "p21Core.paymentTypes.list",
+      async () => {
+        const response = await api.p21Core.paymentTypes.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCashDrawers(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Core.cashDrawer.list",
+      async () => {
+        const response = await api.p21Core.cashDrawer.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCodeP21(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "p21Core.codeP21.list",
+      async () => {
+        const response = await api.p21Core.codeP21.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return {
+    getAddresses,
+    getCompanies,
+    getCompany,
+    getLocations,
+    getPaymentTypes,
+    getCashDrawers,
+    getCodeP21
+  };
+}
+
+// src/actions/p21-apis.ts
+function createP21ApisActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    redisTtl = 3600
+  } = config;
+  async function getCategories(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Apis.transCategory.list",
+      async () => {
+        const response = await api.p21Apis.transCategory.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCategoryDefaults(categoryId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Apis.transCategory.defaults.get",
+      async () => {
+        const response = await api.p21Apis.transCategory.defaults.get(
+          categoryId,
+          { edgeCache }
+        );
+        return response.data;
+      },
+      categoryId
+    );
+  }
+  async function getCompanies(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Apis.transCompany.list",
+      async () => {
+        const response = await api.p21Apis.transCompany.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getUsers(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Apis.transUser.list",
+      async () => {
+        const response = await api.p21Apis.transUser.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getWebDisplayTypes(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Apis.transWebDisplayType.list",
+      async () => {
+        const response = await api.p21Apis.transWebDisplayType.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getWebDisplayTypeDefaults(id) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Apis.transWebDisplayType.defaults.get",
+      async () => {
+        const response = await api.p21Apis.transWebDisplayType.defaults.get({
+          id,
+          edgeCache
+        });
+        return response.data;
+      },
+      id
+    );
+  }
+  async function refreshContacts(params) {
+    try {
+      const response = await api.p21Apis.entityContacts.refresh.create(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function refreshCustomers(params) {
+    try {
+      const response = await api.p21Apis.entityCustomers.refresh.create(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    getCategories,
+    getCategoryDefaults,
+    getCompanies,
+    getUsers,
+    getWebDisplayTypes,
+    getWebDisplayTypeDefaults,
+    refreshContacts,
+    refreshCustomers
+  };
+}
+
+// src/actions/p21-sism.ts
+function createP21SismActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    redisTtl = 3600
+  } = config;
+  async function getRecentImports(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Sism.import.recent.list",
+      async () => {
+        const response = await api.p21Sism.import.recent.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getImport(importId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Sism.import.get",
+      async () => {
+        const response = await api.p21Sism.import.get(importId);
+        return response.data;
+      },
+      importId
+    );
+  }
+  async function getImportLines(importId, params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Sism.impOeLine.list",
+      async () => {
+        const response = await api.p21Sism.impOeLine.list({
+          ...params,
+          importUid: importId,
+          edgeCache
+        });
+        return response.data;
+      },
+      importId,
+      params
+    );
+  }
+  async function getScheduledImports(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "p21Sism.scheduledImportMaster.list",
+      async () => {
+        const response = await api.p21Sism.scheduledImportMaster.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return {
+    getRecentImports,
+    getImport,
+    getImportLines,
+    getScheduledImports
+  };
+}
+
+// src/actions/agr-work.ts
+function createAgrWorkActions(api, _config = {}) {
+  async function healthCheck() {
+    try {
+      const response = await api.agrWork.healthCheck.get();
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function ping() {
+    try {
+      const response = await api.agrWork.ping.get();
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    healthCheck,
+    ping
+  };
+}
+
+// src/actions/agr-info.ts
+function createAgrInfoActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    longEdgeCache = 8,
+    redisTtl = 3600,
+    longRedisTtl = 28800
+  } = config;
+  async function getContext(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "agrInfo.context.list",
+      async () => {
+        const siteId = params?.siteId ?? "";
+        const response = await api.agrInfo.context.get(siteId, {
+          ...params,
+          edgeCache
+        });
+        return Array.isArray(response.data) ? response.data : [response.data];
+      },
+      params
+    );
+  }
+  async function getRubrics(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "agrInfo.rubrics.list",
+      async () => {
+        const response = await api.agrInfo.rubrics.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getMicroservices(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "agrInfo.microservices.list",
+      async () => {
+        const response = await api.agrInfo.microservices.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function generateAkasha(data) {
+    try {
+      const response = await api.agrInfo.akasha.generate.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function generateJoomla(data) {
+    try {
+      const response = await api.agrInfo.joomla.generate.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    getContext,
+    getRubrics,
+    getMicroservices,
+    generateAkasha,
+    generateJoomla
+  };
+}
+
+// src/actions/basecamp2.ts
+function createBasecamp2Actions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    longEdgeCache = 8,
+    redisTtl = 3600,
+    longRedisTtl = 28800
+  } = config;
+  async function getTodos(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.todos.list",
+      async () => {
+        const response = await api.basecamp2.todos.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getTodo(todoId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.todos.get",
+      async () => {
+        const response = await api.basecamp2.todos.get(todoId, { edgeCache });
+        return response.data;
+      },
+      todoId
+    );
+  }
+  async function getTodosSummary(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.todosSummary.list",
+      async () => {
+        const response = await api.basecamp2.todosSummary.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getComments(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.comments.list",
+      async () => {
+        const response = await api.basecamp2.comments.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getPeople(params) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "basecamp2.people.list",
+      async () => {
+        const response = await api.basecamp2.people.list({
+          ...params,
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getProjects(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.projects.list",
+      async () => {
+        const response = await api.basecamp2.projects.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getEvents(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.events.list",
+      async () => {
+        const response = await api.basecamp2.events.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getMetrics(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.metrics.list",
+      async () => {
+        const response = await api.basecamp2.metrics.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getTodolists(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "basecamp2.todolists.list",
+      async () => {
+        const response = await api.basecamp2.todolists.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return {
+    getTodos,
+    getTodo,
+    getTodosSummary,
+    getComments,
+    getPeople,
+    getProjects,
+    getEvents,
+    getMetrics,
+    getTodolists
+  };
+}
+
+// src/actions/brand-folder.ts
+function createBrandFolderActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function getCategories(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "brandFolder.categories.list",
+      async () => {
+        const response = await api.brandFolder.categories.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function getCategory(categoryId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "brandFolder.categories.get",
+      async () => {
+        const response = await api.brandFolder.categories.get(categoryId, {
+          edgeCache
+        });
+        return response.data;
+      },
+      categoryId
+    );
+  }
+  async function createFocus(categoryId, data) {
+    try {
+      const response = await api.brandFolder.categories.focus.create({
+        ...data,
+        categoryId
+      });
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    getCategories,
+    getCategory,
+    createFocus
+  };
+}
+
+// src/actions/gregorovich.ts
+function createGregorovichActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function askChatGpt(params) {
+    try {
+      const response = await api.gregorovich.chatGpt.ask.get(params);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function getDocuments(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "gregorovich.documents.list",
+      async () => {
+        const response = await api.gregorovich.documents.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  async function createDocument(data) {
+    try {
+      const response = await api.gregorovich.documents.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function generateOllama(data) {
+    try {
+      const response = await api.gregorovich.ollama.generate.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    askChatGpt,
+    getDocuments,
+    createDocument,
+    generateOllama
+  };
+}
+
+// src/actions/slack.ts
+function createSlackActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function sendWebhook(data) {
+    try {
+      const response = await api.slack.webHook.create(data);
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function getWebhooks(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "slack.webHook.list",
+      async () => {
+        const response = await api.slack.webHook.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return {
+    sendWebhook,
+    getWebhooks
+  };
+}
 export {
   cacheGet,
   cacheSet,
+  createAgrInfoActions,
+  createAgrSiteActions,
+  createAgrWorkActions,
+  createAvalaraActions,
+  createBasecamp2Actions,
+  createBrandFolderActions,
   createCommerceActions,
+  createCustomersActions,
+  createGregorovichActions,
   createItemActions,
   createJoomlaActions,
+  createLegacyActions,
+  createLogisticsActions,
+  createNexusActions,
   createOrderActions,
+  createP21ApisActions,
+  createP21CoreActions,
+  createP21PimActions,
+  createP21SismActions,
+  createPaymentsActions,
   createPricingActions,
   createQueryOptions,
   createSearchActions,
   createServerQueryClient,
   createShippingActions,
+  createSlackActions,
+  createSmartyStreetsActions,
   createSuspenseQueryOptions,
+  createUpsActions,
+  createVmiActions,
   env,
   getCircuitState,
   getServerQueryClient,