@simpleapps-com/augur-server 0.2.6 → 0.2.7

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { QueryClient } from '@tanstack/react-query';
 export { QueryOptionsConfig, createQueryOptions, createSuspenseQueryOptions } from './query.js';
-import { TPriceData, TTaxItem, TTax, TCategory, TAttribute, TInvMast, TInvMastDoc, TStockData, TItemAccessory, TStock, TCartLookUp, TCartLine, TProductItem } from '@simpleapps-com/augur-utils';
+import { TPriceData, TTaxItem, TTax, TCategory, TAttribute, TInvMast, TInvMastDoc, TStockData, TItemAccessory, TStock, TCartLookUp, TCartLine, TProductItem, TWebDesc } from '@simpleapps-com/augur-utils';
 
 declare const env: "development" | "staging" | "production";
 declare const isDev: boolean;
@@ -307,7 +307,8 @@ interface CommerceActions {
     }) => Promise<TCartLookUp>;
     getCartLines: (cartHdrUid: number) => Promise<TCartLine[]>;
     addToCart: (cartHdrUid: number, items: {
-        itemId: string;
+        itemId?: string;
+        invMastUid?: number;
         quantity: number;
         unitOfMeasure: string;
     }[]) => Promise<unknown>;
@@ -393,40 +394,45 @@ interface OrderActions {
  */
 declare function createOrderActions(api: OrderApiClient, config?: OrderActionsConfig): OrderActions;
 
-/**
- * The subset of augur-api used by search actions.
- * Avoids importing the full SDK type so augur-server stays lightweight.
- */
-interface SearchApiClient {
-    openSearch: {
-        itemSearch: {
+/** Shape of the openSearch service used by search actions. */
+interface OpenSearchService {
+    itemSearch: {
+        list: (params: Record<string, unknown>) => Promise<{
+            data: {
+                items: TProductItem[];
+                totalResults: number;
+            };
+        }>;
+        attributes: {
             list: (params: Record<string, unknown>) => Promise<{
                 data: {
-                    items: TProductItem[];
-                    totalResults: number;
+                    attributes: TAttribute[];
                 };
             }>;
-            attributes: {
-                list: (params: Record<string, unknown>) => Promise<{
-                    data: {
-                        attributes: TAttribute[];
-                    };
-                }>;
-            };
         };
-        suggestions: {
-            suggest: {
-                list: (params: Record<string, unknown>) => Promise<{
-                    data: {
-                        data: unknown[];
-                        total: number;
-                        totalResults: number;
-                    };
-                }>;
-            };
+    };
+    suggestions: {
+        suggest: {
+            list: (params: Record<string, unknown>) => Promise<{
+                data: {
+                    data: unknown[];
+                    total: number;
+                    totalResults: number;
+                };
+            }>;
         };
     };
 }
+/**
+ * The subset of augur-api used by search actions.
+ * Accepts both `openSearch` (camelCase) and `opensearch` (lowercase)
+ * to match SDK v0.9.x which exposes `api.opensearch`.
+ */
+type SearchApiClient = {
+    openSearch: OpenSearchService;
+} | {
+    opensearch: OpenSearchService;
+};
 interface SearchActionsConfig {
     /** Cache key prefix (e.g. "ampro:"). Default: "". */
     cachePrefix?: string;
@@ -467,27 +473,6 @@ interface SearchActions {
         filters?: [string, string][];
     }, itemCategoryUid?: number | string, pageParam?: number) => Promise<SearchPage>;
 }
-/**
- * Creates server-side search actions with Redis caching and edge cache support.
- *
- * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
- * `withCache`, so server-prefetched data is shared with client-side hooks.
- *
- * @example
- * ```ts
- * // lib/search-actions.ts
- * import { createSearchActions } from "@simpleapps-com/augur-server";
- * import { getAugurClient } from "./augur-client";
- *
- * export const searchActions = createSearchActions(getAugurClient(), {
- *   cachePrefix: "ampro:",
- * });
- *
- * // In a server component:
- * const attrs = await searchActions.getSearchAttributes("widget");
- * const results = await searchActions.itemSearch({ q: "widget", limit: 20, offset: 0 });
- * ```
- */
 declare function createSearchActions(api: SearchApiClient, config?: SearchActionsConfig): SearchActions;
 
 interface ShippingAddress {
@@ -608,4 +593,1285 @@ interface JoomlaActions {
  */
 declare function createJoomlaActions(api: JoomlaApiClient, config?: JoomlaActionsConfig): JoomlaActions;
 
-export { type CommerceActions, type CommerceActionsConfig, type CommerceApiClient, type ItemActions, type ItemActionsConfig, type ItemsApiClient, type JoomlaActions, type JoomlaActionsConfig, type JoomlaApiClient, type OrderActions, type OrderActionsConfig, type OrderApiClient, type PricingActions, type PricingActionsConfig, type PricingApiClient, type SearchActions, type SearchActionsConfig, type SearchApiClient, type SearchPage, type ShippingActions, type ShippingActionsConfig, type ShippingAddress, type ShippingApiClient, cacheGet, cacheSet, createCommerceActions, createItemActions, createJoomlaActions, createOrderActions, createPricingActions, createSearchActions, createServerQueryClient, createShippingActions, env, getCircuitState, getServerQueryClient, isDev, isProduction, isRedisConnected, isStaging, sdkCall, withServerCache };
+/**
+ * The subset of augur-api used by legacy actions.
+ * Matches `api.legacy` from the SDK.
+ */
+interface LegacyApiClient {
+    legacy: {
+        invMast: {
+            webDesc: {
+                list: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TWebDesc[];
+                }>;
+            };
+            alsoBought: {
+                list: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            tags: {
+                list: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+        legacy: {
+            state: {
+                list: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+    };
+}
+interface LegacyActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data like states. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface LegacyActions {
+    getItemWebDesc: (invMastUid: number) => Promise<TWebDesc | undefined>;
+    getAlsoBoughtItems: (invMastUid: number) => Promise<unknown[]>;
+    getItemTags: (invMastUid: number) => Promise<unknown[]>;
+    getStates: (params?: {
+        twoLetterCode?: string;
+    }) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side legacy actions with Redis caching and edge cache support.
+ *
+ * Covers the legacy microservice endpoints used by ecommerce sites:
+ * webDesc, alsoBought, tags, and states.
+ *
+ * @example
+ * ```ts
+ * import { createLegacyActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const legacyActions = createLegacyActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const webDesc = await legacyActions.getItemWebDesc(12345);
+ * const states = await legacyActions.getStates();
+ * ```
+ */
+declare function createLegacyActions(api: LegacyApiClient, config?: LegacyActionsConfig): LegacyActions;
+
+/**
+ * The subset of augur-api used by customer actions.
+ * Matches `api.customers` from the SDK.
+ */
+interface CustomersApiClient {
+    customers: {
+        customer: {
+            get: (customerId: number, params?: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+            lookup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            doc: {
+                list: (customerId: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            orders: {
+                list: (customerId: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            shipTo: {
+                list: (customerId: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+        contacts: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface CustomersActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface CustomersActions {
+    getCustomer: (customerId: number) => Promise<unknown>;
+    customerLookup: (params: Record<string, unknown>) => Promise<unknown[]>;
+    getCustomerDoc: (customerId: number) => Promise<unknown>;
+    getCustomerOrders: (customerId: number, params?: Record<string, unknown>) => Promise<unknown[]>;
+    getContacts: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getShipToAddresses: (customerId: number) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side customer actions with Redis caching and edge cache support.
+ *
+ * Covers the customers microservice endpoints used by ecommerce sites:
+ * customer get, lookup, doc, orders, contacts, and ship-to addresses.
+ *
+ * @example
+ * ```ts
+ * import { createCustomersActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const customersActions = createCustomersActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const customer = await customersActions.getCustomer(123);
+ * const orders = await customersActions.getCustomerOrders(123);
+ * ```
+ */
+declare function createCustomersActions(api: CustomersApiClient, config?: CustomersActionsConfig): CustomersActions;
+
+/**
+ * The subset of augur-api used by SmartyStreets actions.
+ * Matches `api.smartyStreets` from the SDK.
+ */
+interface SmartyStreetsApiClient {
+    smartyStreets: {
+        us: {
+            lookup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface SmartyStreetsActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+}
+interface SmartyStreetsActions {
+    validateAddress: (params: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Creates server-side SmartyStreets actions for address validation.
+ *
+ * Note: Address validation is a real-time operation and does NOT use caching.
+ * Each call hits the SmartyStreets API directly to ensure up-to-date results.
+ *
+ * @example
+ * ```ts
+ * import { createSmartyStreetsActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const smartyStreetsActions = createSmartyStreetsActions(getAugurClient());
+ *
+ * const result = await smartyStreetsActions.validateAddress({
+ *   address1: "123 Main St",
+ *   city: "Provo",
+ *   state: "UT",
+ *   postalCode: "84606",
+ * });
+ * ```
+ */
+declare function createSmartyStreetsActions(api: SmartyStreetsApiClient, config?: SmartyStreetsActionsConfig): SmartyStreetsActions;
+
+/**
+ * The subset of augur-api used by P21 PIM actions.
+ * Matches `api.p21Pim` from the SDK.
+ */
+interface P21PimApiClient {
+    p21Pim: {
+        invMastExt: {
+            get: (invMastUid: number, params?: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface P21PimActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface P21PimActions {
+    getInvMastExt: (invMastUid: number) => Promise<unknown>;
+    listInvMastExt: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side P21 PIM actions with Redis caching and edge cache support.
+ *
+ * Covers the P21 PIM microservice endpoints for extended inventory data
+ * including UPC/EAN codes, brand information, and SEO metadata.
+ *
+ * @example
+ * ```ts
+ * import { createP21PimActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const p21PimActions = createP21PimActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const ext = await p21PimActions.getInvMastExt(12345);
+ * const list = await p21PimActions.listInvMastExt({ limit: 20 });
+ * ```
+ */
+declare function createP21PimActions(api: P21PimApiClient, config?: P21PimActionsConfig): P21PimActions;
+
+/**
+ * The subset of augur-api used by AGR Site actions.
+ * Matches `api.agrSite` from the SDK.
+ */
+interface AgrSiteApiClient {
+    agrSite: {
+        settings: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        metaFiles: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface AgrSiteActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value for rarely-changing data. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface AgrSiteActions {
+    getSettings: (serviceName?: string) => Promise<unknown[]>;
+    getMetaFiles: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side AGR Site actions with Redis caching and edge cache support.
+ *
+ * Covers the AGR Site microservice endpoints for site configuration settings
+ * and meta file management (robots.txt, etc.). Both endpoints use long TTLs
+ * since site settings and meta files rarely change.
+ *
+ * @example
+ * ```ts
+ * import { createAgrSiteActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const agrSiteActions = createAgrSiteActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const settings = await agrSiteActions.getSettings("my-service");
+ * const metaFiles = await agrSiteActions.getMetaFiles();
+ * ```
+ */
+declare function createAgrSiteActions(api: AgrSiteApiClient, config?: AgrSiteActionsConfig): AgrSiteActions;
+
+/**
+ * The subset of augur-api used by Avalara actions.
+ * Matches `api.avalara` from the SDK.
+ */
+interface AvalaraApiClient {
+    avalara: {
+        rates: {
+            create: (data: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+    };
+}
+interface AvalaraActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+}
+interface AvalaraActions {
+    calculateTax: (data: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Creates server-side Avalara actions for real-time tax calculation.
+ *
+ * Note: Tax calculation is a real-time operation and does NOT use caching.
+ * Each call hits the Avalara API directly to ensure up-to-date tax rates.
+ *
+ * @example
+ * ```ts
+ * import { createAvalaraActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const avalaraActions = createAvalaraActions(getAugurClient());
+ *
+ * const taxResult = await avalaraActions.calculateTax({
+ *   lines: [{ amount: 100.00, description: "Widget" }],
+ *   addresses: {
+ *     shipTo: {
+ *       line1: "123 Main St",
+ *       city: "Irvine",
+ *       region: "CA",
+ *       country: "US",
+ *       postalCode: "92602",
+ *     },
+ *   },
+ *   type: "SalesOrder",
+ * });
+ * ```
+ */
+declare function createAvalaraActions(api: AvalaraApiClient, config?: AvalaraActionsConfig): AvalaraActions;
+
+/**
+ * The subset of augur-api used by payment actions.
+ * Matches `api.payments` from the SDK.
+ */
+interface PaymentsApiClient {
+    payments: {
+        unified: {
+            transactionSetup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            accountQuery: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            surcharge: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface PaymentsActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+}
+interface PaymentsActions {
+    transactionSetup: (params: Record<string, unknown>) => Promise<unknown>;
+    accountQuery: (params: Record<string, unknown>) => Promise<unknown>;
+    getSurcharge: (params: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Creates server-side payment actions.
+ *
+ * Payment actions do NOT use caching because every call deals with
+ * real-time payment processing that must always reflect current state.
+ *
+ * @example
+ * ```ts
+ * import { createPaymentsActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const paymentsActions = createPaymentsActions(getAugurClient());
+ *
+ * const setup = await paymentsActions.transactionSetup({ customerId: "123" });
+ * const account = await paymentsActions.accountQuery({ transactionSetupId: "abc" });
+ * const surcharge = await paymentsActions.getSurcharge({ amount: 100 });
+ * ```
+ */
+declare function createPaymentsActions(api: PaymentsApiClient, config?: PaymentsActionsConfig): PaymentsActions;
+
+/**
+ * The subset of augur-api used by UPS actions.
+ * Matches `api.ups` from the SDK.
+ */
+interface UpsApiClient {
+    ups: {
+        ratesShop: {
+            get: (params: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+    };
+}
+interface UpsActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+}
+interface UpsActions {
+    getRates: (params: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Creates server-side UPS shipping actions.
+ *
+ * UPS rate actions do NOT use caching because rate quotes are real-time
+ * and must always reflect current carrier pricing.
+ *
+ * @example
+ * ```ts
+ * import { createUpsActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const upsActions = createUpsActions(getAugurClient());
+ *
+ * const rates = await upsActions.getRates({
+ *   fromPostalCode: "90210",
+ *   toPostalCode: "10001",
+ *   weight: 5,
+ * });
+ * ```
+ */
+declare function createUpsActions(api: UpsApiClient, config?: UpsActionsConfig): UpsActions;
+
+/**
+ * The subset of augur-api used by logistics actions.
+ * Matches `api.logistics` from the SDK.
+ */
+interface LogisticsApiClient {
+    logistics: {
+        speedship: {
+            freight: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+        shipvia: {
+            rates: {
+                list: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+    };
+}
+interface LogisticsActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data like ship-via options. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface LogisticsActions {
+    getFreightRates: (params: Record<string, unknown>) => Promise<unknown>;
+    getShipVia: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side logistics actions with selective Redis caching.
+ *
+ * Freight rate lookups are real-time and NOT cached.
+ * Ship-via carrier options rarely change and ARE cached with long TTL.
+ *
+ * @example
+ * ```ts
+ * import { createLogisticsActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const logisticsActions = createLogisticsActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const rates = await logisticsActions.getFreightRates({ fromPostalCode: "90210" });
+ * const carriers = await logisticsActions.getShipVia();
+ * ```
+ */
+declare function createLogisticsActions(api: LogisticsApiClient, config?: LogisticsActionsConfig): LogisticsActions;
+
+/**
+ * The subset of augur-api used by nexus actions.
+ * Matches `api.nexus` from the SDK.
+ */
+interface NexusApiClient {
+    nexus: {
+        binTransfer: {
+            create: (data: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        receiving: {
+            create: (data: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        transfer: {
+            create: (data: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        purchaseOrderReceipt: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        transferReceipt: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        transferShipping: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface NexusActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface NexusActions {
+    createBinTransfer: (data: Record<string, unknown>) => Promise<unknown>;
+    createReceiving: (data: Record<string, unknown>) => Promise<unknown>;
+    createTransfer: (data: Record<string, unknown>) => Promise<unknown>;
+    getPurchaseOrderReceipts: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getTransferReceipts: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getTransferShipping: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side nexus (warehouse management) actions with selective caching.
+ *
+ * Write operations (bin transfer, receiving, transfer) do NOT use caching.
+ * Read/list operations (receipts, shipping) ARE cached with standard TTL.
+ *
+ * @example
+ * ```ts
+ * import { createNexusActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const nexusActions = createNexusActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const transfer = await nexusActions.createBinTransfer({ locationId: 5, transfers: [] });
+ * const receipts = await nexusActions.getPurchaseOrderReceipts();
+ * ```
+ */
+declare function createNexusActions(api: NexusApiClient, config?: NexusActionsConfig): NexusActions;
+
+/**
+ * The subset of augur-api used by VMI actions.
+ * Matches `api.vmi` from the SDK.
+ */
+interface VmiApiClient {
+    vmi: {
+        warehouse: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            availability: {
+                get: (warehouseUid: number, params: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+        distributors: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        products: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        invProfileHdr: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        restockHdr: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        sections: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface VmiActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for short-lived data like availability. Default: 300 (5 min). */
+    shortRedisTtl?: number;
+}
+interface VmiActions {
+    getWarehouses: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getWarehouseAvailability: (warehouseUid: number, params?: Record<string, unknown>) => Promise<unknown[]>;
+    getDistributors: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getProducts: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getInventoryProfiles: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getRestockHeaders: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getSections: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side VMI (Vendor Managed Inventory) actions with Redis caching.
+ *
+ * All VMI read operations are cached. Warehouse availability uses a shorter TTL
+ * because inventory levels change more frequently than configuration data.
+ *
+ * @example
+ * ```ts
+ * import { createVmiActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const vmiActions = createVmiActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const warehouses = await vmiActions.getWarehouses({ customerId: 12345 });
+ * const availability = await vmiActions.getWarehouseAvailability(123);
+ * const distributors = await vmiActions.getDistributors({ customerId: 12345 });
+ * ```
+ */
+declare function createVmiActions(api: VmiApiClient, config?: VmiActionsConfig): VmiActions;
+
+/**
+ * The subset of augur-api used by p21-core actions.
+ * Matches `api.p21Core` from the SDK.
+ */
+interface P21CoreApiClient {
+    p21Core: {
+        address: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        company: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            get: (params: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        location: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        paymentTypes: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        cashDrawer: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        codeP21: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface P21CoreActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface P21CoreActions {
+    getAddresses: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getCompanies: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getCompany: (companyId: number) => Promise<unknown | undefined>;
+    getLocations: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getPaymentTypes: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getCashDrawers: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getCodeP21: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side P21 Core actions with Redis caching and edge cache support.
+ *
+ * Covers the P21 Core microservice endpoints: addresses, companies,
+ * locations, payment types, cash drawers, and P21 codes.
+ *
+ * @example
+ * ```ts
+ * import { createP21CoreActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const p21CoreActions = createP21CoreActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const companies = await p21CoreActions.getCompanies();
+ * const company = await p21CoreActions.getCompany(123);
+ * ```
+ */
+declare function createP21CoreActions(api: P21CoreApiClient, config?: P21CoreActionsConfig): P21CoreActions;
+
+/**
+ * The subset of augur-api used by p21-apis actions.
+ * Matches `api.p21Apis` from the SDK.
+ */
+interface P21ApisApiClient {
+    p21Apis: {
+        transCategory: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            defaults: {
+                get: (categoryUid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+        transCompany: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        transUser: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        transWebDisplayType: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            defaults: {
+                get: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+        entityContacts: {
+            refresh: {
+                create: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+        entityCustomers: {
+            refresh: {
+                create: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface P21ApisActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface P21ApisActions {
+    getCategories: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getCategoryDefaults: (categoryId: number) => Promise<unknown | undefined>;
+    getCompanies: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getUsers: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getWebDisplayTypes: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getWebDisplayTypeDefaults: (id?: number) => Promise<unknown | undefined>;
+    refreshContacts: (params?: Record<string, unknown>) => Promise<unknown | undefined>;
+    refreshCustomers: (params?: Record<string, unknown>) => Promise<unknown | undefined>;
+}
+/**
+ * Creates server-side P21 APIs actions with Redis caching and edge cache support.
+ *
+ * Covers the P21 APIs microservice endpoints: transaction categories,
+ * companies, users, web display types, and entity refresh operations.
+ *
+ * @example
+ * ```ts
+ * import { createP21ApisActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const p21ApisActions = createP21ApisActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const categories = await p21ApisActions.getCategories();
+ * await p21ApisActions.refreshContacts();
+ * ```
+ */
+declare function createP21ApisActions(api: P21ApisApiClient, config?: P21ApisActionsConfig): P21ApisActions;
+
+/**
+ * The subset of augur-api used by p21-sism actions.
+ * Matches `api.p21Sism` from the SDK.
+ */
+interface P21SismApiClient {
+    p21Sism: {
+        import: {
+            recent: {
+                list: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            get: (importUid: string) => Promise<{
+                data: unknown;
+            }>;
+        };
+        impOeLine: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        scheduledImportMaster: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface P21SismActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface P21SismActions {
+    getRecentImports: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getImport: (importId: string) => Promise<unknown | undefined>;
+    getImportLines: (importId: number, params?: Record<string, unknown>) => Promise<unknown[]>;
+    getScheduledImports: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side P21 SISM actions with Redis caching and edge cache support.
+ *
+ * Covers the P21 SISM (System Integration & Storage Management) endpoints:
+ * imports, import lines, and scheduled import masters.
+ *
+ * @example
+ * ```ts
+ * import { createP21SismActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const p21SismActions = createP21SismActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const recentImports = await p21SismActions.getRecentImports({ hours: 24 });
+ * const importDetail = await p21SismActions.getImport("12345");
+ * ```
+ */
+declare function createP21SismActions(api: P21SismApiClient, config?: P21SismActionsConfig): P21SismActions;
+
+/**
+ * The subset of augur-api used by agr-work actions.
+ * Matches `api.agrWork` from the SDK.
+ */
+interface AgrWorkApiClient {
+    agrWork: {
+        healthCheck: {
+            get: () => Promise<{
+                data: string;
+            }>;
+        };
+        ping: {
+            get: () => Promise<{
+                data: string;
+            }>;
+        };
+    };
+}
+interface AgrWorkActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+}
+interface AgrWorkActions {
+    healthCheck: () => Promise<string | undefined>;
+    ping: () => Promise<string | undefined>;
+}
+/**
+ * Creates server-side AGR Work actions for health monitoring and connectivity.
+ *
+ * Covers the AGR Work microservice endpoints: healthCheck and ping.
+ * These are real-time operations and do not use caching.
+ *
+ * @example
+ * ```ts
+ * import { createAgrWorkActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const agrWorkActions = createAgrWorkActions(getAugurClient());
+ *
+ * const health = await agrWorkActions.healthCheck();
+ * const pong = await agrWorkActions.ping();
+ * ```
+ */
+declare function createAgrWorkActions(api: AgrWorkApiClient, _config?: AgrWorkActionsConfig): AgrWorkActions;
+
+/**
+ * The subset of augur-api used by agr-info actions.
+ * Matches `api.agrInfo` from the SDK.
+ */
+interface AgrInfoApiClient {
+    agrInfo: {
+        context: {
+            get: (siteId: string, params?: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        rubrics: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        microservices: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        akasha: {
+            generate: {
+                create: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+        joomla: {
+            generate: {
+                create: (params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface AgrInfoActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface AgrInfoActions {
+    getContext: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getRubrics: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getMicroservices: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    generateAkasha: (data?: Record<string, unknown>) => Promise<unknown | undefined>;
+    generateJoomla: (data?: Record<string, unknown>) => Promise<unknown | undefined>;
+}
+/**
+ * Creates server-side AGR Info actions with Redis caching and edge cache support.
+ *
+ * Covers the AGR Info microservice endpoints: context, rubrics,
+ * microservices, and AI generation (akasha/joomla).
+ *
+ * @example
+ * ```ts
+ * import { createAgrInfoActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const agrInfoActions = createAgrInfoActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const rubrics = await agrInfoActions.getRubrics();
+ * const result = await agrInfoActions.generateAkasha({ prompt: "Hello" });
+ * ```
+ */
+declare function createAgrInfoActions(api: AgrInfoApiClient, config?: AgrInfoActionsConfig): AgrInfoActions;
+
+/**
+ * The subset of augur-api used by basecamp2 actions.
+ * Matches `api.basecamp2` from the SDK.
+ */
+interface Basecamp2ApiClient {
+    basecamp2: {
+        todos: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            get: (todoId: number, params?: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        todosSummary: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        comments: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        people: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        projects: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        events: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        metrics: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+        todolists: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface Basecamp2ActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data like people. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface Basecamp2Actions {
+    getTodos: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getTodo: (todoId: number) => Promise<unknown>;
+    getTodosSummary: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getComments: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getPeople: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getProjects: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getEvents: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getMetrics: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getTodolists: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side basecamp2 actions with Redis caching and edge cache support.
+ *
+ * Covers the Basecamp2 project management endpoints: todos, todo summaries,
+ * comments, people, projects, events, metrics, and todolists.
+ *
+ * @example
+ * ```ts
+ * import { createBasecamp2Actions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const basecamp2Actions = createBasecamp2Actions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const todos = await basecamp2Actions.getTodos();
+ * const people = await basecamp2Actions.getPeople();
+ * ```
+ */
+declare function createBasecamp2Actions(api: Basecamp2ApiClient, config?: Basecamp2ActionsConfig): Basecamp2Actions;
+
+/**
+ * The subset of augur-api used by brand-folder actions.
+ * Matches `api.brandFolder` from the SDK.
+ */
+interface BrandFolderApiClient {
+    brandFolder: {
+        categories: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            get: (categoryId: string, params?: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+            focus: {
+                create: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface BrandFolderActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface BrandFolderActions {
+    getCategories: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    getCategory: (categoryId: string) => Promise<unknown>;
+    createFocus: (categoryId: string, data: Record<string, unknown>) => Promise<unknown | undefined>;
+}
+/**
+ * Creates server-side brand-folder actions with Redis caching and edge cache support.
+ *
+ * Covers the Brand Folder service endpoints: category listing, category detail,
+ * and category focus creation.
+ *
+ * @example
+ * ```ts
+ * import { createBrandFolderActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const brandFolderActions = createBrandFolderActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const categories = await brandFolderActions.getCategories();
+ * const category = await brandFolderActions.getCategory("cat-123");
+ * const focus = await brandFolderActions.createFocus("cat-123", { focusLevel: "primary" });
+ * ```
+ */
+declare function createBrandFolderActions(api: BrandFolderApiClient, config?: BrandFolderActionsConfig): BrandFolderActions;
+
+/**
+ * The subset of augur-api used by gregorovich actions.
+ * Matches `api.gregorovich` from the SDK.
+ */
+interface GregorovichApiClient {
+    gregorovich: {
+        chatGpt: {
+            ask: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+        documents: {
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+            create: (data: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+        ollama: {
+            generate: {
+                create: (data: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface GregorovichActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface GregorovichActions {
+    askChatGpt: (params: Record<string, unknown>) => Promise<unknown | undefined>;
+    getDocuments: (params?: Record<string, unknown>) => Promise<unknown[]>;
+    createDocument: (data: Record<string, unknown>) => Promise<unknown | undefined>;
+    generateOllama: (data: Record<string, unknown>) => Promise<unknown | undefined>;
+}
+/**
+ * Creates server-side gregorovich actions with Redis caching and edge cache support.
+ *
+ * Covers the Gregorovich AI service endpoints: ChatGPT ask, document listing,
+ * document creation, and Ollama generation.
+ *
+ * @example
+ * ```ts
+ * import { createGregorovichActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const gregorovichActions = createGregorovichActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const answer = await gregorovichActions.askChatGpt({ question: "What is AI?" });
+ * const docs = await gregorovichActions.getDocuments();
+ * ```
+ */
+declare function createGregorovichActions(api: GregorovichApiClient, config?: GregorovichActionsConfig): GregorovichActions;
+
+/**
+ * The subset of augur-api used by slack actions.
+ * Matches `api.slack` from the SDK.
+ */
+interface SlackApiClient {
+    slack: {
+        webHook: {
+            create: (data: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface SlackActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface SlackActions {
+    sendWebhook: (data: Record<string, unknown>) => Promise<unknown | undefined>;
+    getWebhooks: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side slack actions with Redis caching and edge cache support.
+ *
+ * Covers the Slack integration endpoints: webhook sending and webhook listing.
+ *
+ * @example
+ * ```ts
+ * import { createSlackActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const slackActions = createSlackActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * const result = await slackActions.sendWebhook({ text: "Hello!" });
+ * const webhooks = await slackActions.getWebhooks();
+ * ```
+ */
+declare function createSlackActions(api: SlackApiClient, config?: SlackActionsConfig): SlackActions;
+
+export { type AgrInfoActions, type AgrInfoActionsConfig, type AgrInfoApiClient, type AgrSiteActions, type AgrSiteActionsConfig, type AgrSiteApiClient, type AgrWorkActions, type AgrWorkActionsConfig, type AgrWorkApiClient, type AvalaraActions, type AvalaraActionsConfig, type AvalaraApiClient, type Basecamp2Actions, type Basecamp2ActionsConfig, type Basecamp2ApiClient, type BrandFolderActions, type BrandFolderActionsConfig, type BrandFolderApiClient, type CommerceActions, type CommerceActionsConfig, type CommerceApiClient, type CustomersActions, type CustomersActionsConfig, type CustomersApiClient, type GregorovichActions, type GregorovichActionsConfig, type GregorovichApiClient, type ItemActions, type ItemActionsConfig, type ItemsApiClient, type JoomlaActions, type JoomlaActionsConfig, type JoomlaApiClient, type LegacyActions, type LegacyActionsConfig, type LegacyApiClient, type LogisticsActions, type LogisticsActionsConfig, type LogisticsApiClient, type NexusActions, type NexusActionsConfig, type NexusApiClient, type OrderActions, type OrderActionsConfig, type OrderApiClient, type P21ApisActions, type P21ApisActionsConfig, type P21ApisApiClient, type P21CoreActions, type P21CoreActionsConfig, type P21CoreApiClient, type P21PimActions, type P21PimActionsConfig, type P21PimApiClient, type P21SismActions, type P21SismActionsConfig, type P21SismApiClient, type PaymentsActions, type PaymentsActionsConfig, type PaymentsApiClient, type PricingActions, type PricingActionsConfig, type PricingApiClient, type SearchActions, type SearchActionsConfig, type SearchApiClient, type SearchPage, type ShippingActions, type ShippingActionsConfig, type ShippingAddress, type ShippingApiClient, type SlackActions, type SlackActionsConfig, type SlackApiClient, type SmartyStreetsActions, type SmartyStreetsActionsConfig, type SmartyStreetsApiClient, type UpsActions, type UpsActionsConfig, type UpsApiClient, type VmiActions, type VmiActionsConfig, type VmiApiClient, cacheGet, cacheSet, createAgrInfoActions, createAgrSiteActions, createAgrWorkActions, createAvalaraActions, createBasecamp2Actions, createBrandFolderActions, createCommerceActions, createCustomersActions, createGregorovichActions, createItemActions, createJoomlaActions, createLegacyActions, createLogisticsActions, createNexusActions, createOrderActions, createP21ApisActions, createP21CoreActions, createP21PimActions, createP21SismActions, createPaymentsActions, createPricingActions, createSearchActions, createServerQueryClient, createShippingActions, createSlackActions, createSmartyStreetsActions, createUpsActions, createVmiActions, env, getCircuitState, getServerQueryClient, isDev, isProduction, isRedisConnected, isStaging, sdkCall, withServerCache };