@simpleapps-com/augur-server 0.2.7 → 0.2.9

package/dist/site-BSw5o836.d.ts

@@ -0,0 +1,1912 @@
+import { TPriceData, TTaxItem, TTax, TCategory, TAttribute, TInvMast, TInvMastDoc, TStockData, TItemAccessory, TStock, TCartLookUp, TCartLine, TProductItem, TWebDesc } from '@simpleapps-com/augur-utils';
+
+/**
+ * The subset of augur-api used by pricing actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface PricingApiClient {
+    pricing: {
+        priceEngine: {
+            get: (params: Record<string, unknown>) => Promise<{
+                data: TPriceData;
+            }>;
+        };
+        taxEngine: {
+            create: (params: Record<string, unknown>) => Promise<{
+                data: TTax;
+            }>;
+        };
+    };
+}
+interface PricingActionsConfig {
+    /** Default customer ID when none is provided by the caller. */
+    defaultCustomerId?: string | number;
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 2 (hours). */
+    edgeCache?: number;
+    /** Redis TTL for price lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for tax lookups in seconds. Default: 1800 (30 min). */
+    taxRedisTtl?: number;
+}
+interface PricingActions {
+    getItemPrice: (itemId: string, customerId?: string | number, quantity?: number) => Promise<TPriceData>;
+    batchGetItemPrices: (itemIds: string[], customerId?: string | number, quantity?: number) => Promise<Record<string, TPriceData>>;
+    getTaxEstimate: (customerId: string | number, postalCode: string, items: TTaxItem[]) => Promise<TTax>;
+}
+/**
+ * Creates server-side pricing 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/pricing-actions.ts
+ * import { createPricingActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const pricingActions = createPricingActions(getAugurClient(), {
+ *   defaultCustomerId: process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_ID,
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const price = await pricingActions.getItemPrice("ITEM-1");
+ * const prices = await pricingActions.batchGetItemPrices(["ITEM-1", "ITEM-2"]);
+ * ```
+ */
+declare function createPricingActions(api: PricingApiClient, config?: PricingActionsConfig): PricingActions;
+
+/**
+ * The subset of augur-api used by item actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface ItemsApiClient {
+    items: {
+        categories: {
+            get: (uid: number, params?: Record<string, unknown>) => Promise<{
+                data: TCategory;
+            }>;
+            lookup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            items: {
+                list: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            attributes: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: {
+                        attributes: TAttribute[];
+                    };
+                }>;
+            };
+        };
+        invMast: {
+            get: (uid: number, params?: Record<string, unknown>) => Promise<{
+                data: TInvMast;
+            }>;
+            doc: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TInvMastDoc;
+                }>;
+            };
+            stock: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TStock;
+                }>;
+            };
+            faq: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            invSub: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            invAccessory: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TItemAccessory[];
+                }>;
+            };
+            similar: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+    };
+}
+interface ItemActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value for most calls. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data like FAQs. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL for most calls in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+    /** Sort category children by sequenceNo. Default: true. */
+    sortChildren?: boolean;
+}
+interface ItemActions {
+    itemCategoryLookup: (path: string) => Promise<unknown>;
+    getItemCategory: (uid: number, options?: Record<string, unknown>) => Promise<TCategory>;
+    getCategoryItems: (uid: number, filters: Record<string, unknown>) => Promise<unknown>;
+    getItemAttributes: (categoryUid: number) => Promise<TAttribute[]>;
+    getInvMast: (uid: number) => Promise<TInvMast>;
+    getInvMastDoc: (params: {
+        invMastUid?: number;
+        itemId?: string;
+        includePricing?: "Y" | "N";
+    }) => Promise<TInvMastDoc>;
+    getStock: (invMastUid: number) => Promise<TStockData[]>;
+    getStockCompanySummary: (invMastUid: number) => Promise<Record<string, number>>;
+    getItemFaqs: (invMastUid: number) => Promise<unknown[]>;
+    getItemSubstitutes: (invMastUid: number) => Promise<unknown[]>;
+    getItemAccessories: (invMastUid: number) => Promise<TItemAccessory[]>;
+    getSimilarItems: (invMastUid: number) => Promise<unknown[]>;
+    batchGetInvMastDocs: (params: {
+        invMastUid?: number;
+        itemId?: string;
+    }[]) => Promise<Record<string, TInvMastDoc>>;
+    batchGetStockData: (invMastUids: number[]) => Promise<Record<number, TStockData[]>>;
+}
+/**
+ * Creates server-side item 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/item-actions.ts
+ * import { createItemActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const itemActions = createItemActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const category = await itemActions.getItemCategory(123);
+ * const doc = await itemActions.getInvMastDoc({ itemId: "ITEM-1" });
+ * ```
+ */
+declare function createItemActions(api: ItemsApiClient, config?: ItemActionsConfig): ItemActions;
+
+/**
+ * The subset of augur-api used by commerce actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface CommerceApiClient {
+    commerce: {
+        cartHdr: {
+            lookup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: TCartLookUp;
+                }>;
+            };
+            alsoBought: {
+                get: (cartHdrUid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+        cartLine: {
+            get: (cartHdrUid: number) => Promise<{
+                data: TCartLine[];
+            }>;
+            add: {
+                create: (cartHdrUid: number, params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            update: {
+                create: (cartHdrUid: number, params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            delete: (cartHdrUid: number) => Promise<{
+                data: unknown;
+            }>;
+        };
+        checkout: {
+            create: (params: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+    };
+}
+interface CommerceActionsConfig {
+    defaultContactId?: string | number;
+    defaultCustomerId?: string | number;
+    /** Optional UOM conversion function. E.g. (uom) => uom === "EA" ? "EACH" : uom */
+    convertUnitOfMeasure?: (uom: string) => string;
+}
+interface CommerceActions {
+    cartHdrLookup: (params: {
+        userId?: string | number;
+        cartToken?: string;
+        contactId?: string | number;
+        customerId?: string | number;
+    }) => Promise<TCartLookUp>;
+    getCartLines: (cartHdrUid: number) => Promise<TCartLine[]>;
+    addToCart: (cartHdrUid: number, items: {
+        itemId?: string;
+        invMastUid?: number;
+        quantity: number;
+        unitOfMeasure: string;
+    }[]) => Promise<unknown>;
+    updateCartLines: (cartHdrUid: number, lines: {
+        lineNo: number;
+        quantity: number;
+        unitOfMeasure: string;
+    }[]) => Promise<unknown>;
+    deleteCartItems: (cartHdrUid: number) => Promise<void>;
+    getCartAlsoBought: (cartHdrUid: number) => Promise<unknown[]>;
+    checkoutOrder: (cartHdrUid: number, data: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Creates server-side commerce actions for cart operations.
+ *
+ * Unlike pricing actions, commerce actions do NOT use caching because
+ * cart operations are real-time and must always reflect current state.
+ *
+ * @example
+ * ```ts
+ * // lib/commerce-actions.ts
+ * import { createCommerceActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const commerceActions = createCommerceActions(getAugurClient(), {
+ *   defaultContactId: process.env.NEXT_PUBLIC_DEFAULT_CONTACT_ID,
+ *   defaultCustomerId: process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_ID,
+ *   convertUnitOfMeasure: (uom) => uom === "EA" ? "EACH" : uom,
+ * });
+ *
+ * // In a server action:
+ * const cart = await commerceActions.cartHdrLookup({ userId: 123 });
+ * const lines = await commerceActions.getCartLines(cart.cartHdrUid);
+ * ```
+ */
+declare function createCommerceActions(api: CommerceApiClient, config?: CommerceActionsConfig): CommerceActions;
+
+/**
+ * The subset of augur-api used by order actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface OrderApiClient {
+    orders: {
+        oeHdr: {
+            doc: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface OrderActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for order doc lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface OrderActions {
+    getOrderDoc: (orderNo: string, zipCode: string) => Promise<unknown>;
+}
+/**
+ * Creates server-side order 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/order-actions.ts
+ * import { createOrderActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const orderActions = createOrderActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const doc = await orderActions.getOrderDoc("12345", "90210");
+ * ```
+ */
+declare function createOrderActions(api: OrderApiClient, config?: OrderActionsConfig): OrderActions;
+
+/** 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: {
+                    attributes: TAttribute[];
+                };
+            }>;
+        };
+    };
+    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;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for search lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Default source fields for item search. Default: "display_desc". */
+    defaultSourceFields?: string;
+}
+/** Paginated response for infinite scroll. */
+interface SearchPage {
+    data: TProductItem[];
+    total: number;
+    nextCursor?: number;
+}
+interface SearchActions {
+    getSearchAttributes: (q: string) => Promise<TAttribute[]>;
+    getSearchSuggestions: (q: string, limit?: number, offset?: number) => Promise<{
+        data: unknown[];
+        total: number;
+        totalResults: number;
+    }>;
+    itemSearch: (filters: {
+        q: string;
+        limit: number;
+        offset: number;
+        sortBy?: string;
+        filters?: [string, string][];
+    }, itemCategoryUid?: number | string) => Promise<{
+        items: TProductItem[];
+        totalResults: number;
+    }>;
+    itemSearchInfinite: (filters: {
+        q: string;
+        limit: number;
+        sortBy?: string;
+        filters?: [string, string][];
+    }, itemCategoryUid?: number | string, pageParam?: number) => Promise<SearchPage>;
+}
+declare function createSearchActions(api: SearchApiClient, config?: SearchActionsConfig): SearchActions;
+
+interface ShippingAddress {
+    address1: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country?: string;
+}
+/**
+ * The subset of augur-api used by shipping actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface ShippingApiClient {
+    ups: {
+        ratesShop: {
+            get: (params: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+    };
+}
+interface ShippingActionsConfig {
+    /** Warehouse/origin address for rate calculations. */
+    fromAddress: ShippingAddress;
+    /** UPS service codes to filter results. Default: undefined (return all). */
+    defaultServiceCodes?: string[];
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for shipping rate lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface ShippingActions {
+    getShippingRates: (toAddress: ShippingAddress, weight: number, serviceCodes?: string[]) => Promise<unknown>;
+}
+/**
+ * Creates server-side shipping 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/shipping-actions.ts
+ * import { createShippingActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const shippingActions = createShippingActions(getAugurClient(), {
+ *   fromAddress: {
+ *     address1: "123 Warehouse Ln",
+ *     city: "Chicago",
+ *     state: "IL",
+ *     postalCode: "60601",
+ *   },
+ * });
+ *
+ * // In a server component:
+ * const rates = await shippingActions.getShippingRates(
+ *   { address1: "456 Main St", city: "Denver", state: "CO", postalCode: "80202" },
+ *   5.0,
+ * );
+ * ```
+ */
+declare function createShippingActions(api: ShippingApiClient, config: ShippingActionsConfig): ShippingActions;
+
+/**
+ * The subset of augur-api used by Joomla content actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface JoomlaApiClient {
+    joomla: {
+        content: {
+            doc: {
+                get: (articleId: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface JoomlaActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for Joomla lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface JoomlaActions {
+    getJoomlaContent: (articleId: number) => Promise<unknown>;
+    getJoomlaContentList: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side Joomla content 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/joomla-actions.ts
+ * import { createJoomlaActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const joomlaActions = createJoomlaActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const article = await joomlaActions.getJoomlaContent(42);
+ * const articles = await joomlaActions.getJoomlaContentList({ catid: 5 });
+ * ```
+ */
+declare function createJoomlaActions(api: JoomlaApiClient, config?: JoomlaActionsConfig): JoomlaActions;
+
+/**
+ * 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;
+
+interface SiteActionsConfig {
+    /** Cache key prefix shared across all services (e.g. "ampro:") */
+    cachePrefix?: string;
+    /** Default edge cache TTL in seconds */
+    edgeCache?: number;
+    /** Default Redis TTL in seconds */
+    redisTtl?: number;
+    /** Long-lived edge cache TTL for rarely-changing data */
+    longEdgeCache?: number;
+    /** Long-lived Redis TTL for rarely-changing data */
+    longRedisTtl?: number;
+    /** Default contact ID for commerce operations */
+    defaultContactId?: string | number;
+    /** Default customer ID for pricing and commerce */
+    defaultCustomerId?: string | number;
+    /** UOM conversion function for commerce (e.g. "EA" → "EACH") */
+    convertUnitOfMeasure?: (uom: string) => string;
+    /** Pricing-specific overrides */
+    pricing?: {
+        taxRedisTtl?: number;
+    };
+    /** Items-specific overrides */
+    items?: {
+        sortChildren?: boolean;
+    };
+    /** Search-specific overrides */
+    search?: {
+        defaultSourceFields?: string;
+    };
+    /** Shipping config — fromAddress is required for shipping to work */
+    shipping?: {
+        fromAddress: ShippingAddress;
+        defaultServiceCodes?: string[];
+    };
+    /** VMI-specific overrides */
+    vmi?: {
+        shortRedisTtl?: number;
+    };
+}
+interface SiteActions {
+    pricing: PricingActions;
+    items: ItemActions;
+    commerce: CommerceActions;
+    search: SearchActions;
+    orders: OrderActions;
+    shipping: ShippingActions;
+    joomla: JoomlaActions;
+    legacy: LegacyActions;
+    customers: CustomersActions;
+    smartyStreets: SmartyStreetsActions;
+    p21Pim: P21PimActions;
+    agrSite: AgrSiteActions;
+    avalara: AvalaraActions;
+    payments: PaymentsActions;
+    ups: UpsActions;
+    logistics: LogisticsActions;
+    nexus: NexusActions;
+    vmi: VmiActions;
+    p21Core: P21CoreActions;
+    p21Apis: P21ApisActions;
+    p21Sism: P21SismActions;
+    agrWork: AgrWorkActions;
+    agrInfo: AgrInfoActions;
+    basecamp2: Basecamp2Actions;
+    brandFolder: BrandFolderActions;
+    gregorovich: GregorovichActions;
+    slack: SlackActions;
+}
+/**
+ * Creates a unified site actions object with all service factories.
+ *
+ * Shared config (cachePrefix, edgeCache, redisTtl, etc.) is passed to all
+ * services automatically. Per-service overrides are available for services
+ * with additional configuration.
+ *
+ * @example
+ * ```ts
+ * import { createSiteActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const actions = createSiteActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ *   defaultCustomerId: process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_ID,
+ *   defaultContactId: process.env.NEXT_PUBLIC_DEFAULT_CONTACT_ID,
+ *   convertUnitOfMeasure: (uom) => uom === "EA" ? "EACH" : uom,
+ *   items: { sortChildren: true },
+ *   shipping: {
+ *     fromAddress: { address1: "123 Main", city: "Provo", state: "UT", postalCode: "84606" },
+ *     defaultServiceCodes: ["03"],
+ *   },
+ * });
+ *
+ * // Usage:
+ * const price = await actions.pricing.getItemPrice("ITEM-1");
+ * const doc = await actions.items.getInvMastDoc("ITEM-1");
+ * const cart = await actions.commerce.cartHdrLookup({ userId: 123 });
+ * ```
+ */
+declare function createSiteActions<TApi extends object>(api: TApi, config?: SiteActionsConfig): SiteActions;
+
+export { type P21PimApiClient as $, type AgrInfoActions as A, type Basecamp2Actions as B, type CommerceActions as C, type JoomlaApiClient as D, type LegacyActionsConfig as E, type LegacyApiClient as F, type GregorovichActions as G, type LogisticsActions as H, type ItemActions as I, type JoomlaActions as J, type LogisticsActionsConfig as K, type LegacyActions as L, type LogisticsApiClient as M, type NexusActions as N, type NexusActionsConfig as O, type NexusApiClient as P, type OrderActions as Q, type OrderActionsConfig as R, type OrderApiClient as S, type P21ApisActions as T, type P21ApisActionsConfig as U, type P21ApisApiClient as V, type P21CoreActions as W, type P21CoreActionsConfig as X, type P21CoreApiClient as Y, type P21PimActions as Z, type P21PimActionsConfig as _, type AgrInfoActionsConfig as a, type P21SismActions as a0, type P21SismActionsConfig as a1, type P21SismApiClient as a2, type PaymentsActions as a3, type PaymentsActionsConfig as a4, type PaymentsApiClient as a5, type PricingActions as a6, type PricingActionsConfig as a7, type PricingApiClient as a8, type SearchActions as a9, createBrandFolderActions as aA, createCommerceActions as aB, createCustomersActions as aC, createGregorovichActions as aD, createItemActions as aE, createJoomlaActions as aF, createLegacyActions as aG, createLogisticsActions as aH, createNexusActions as aI, createOrderActions as aJ, createP21ApisActions as aK, createP21CoreActions as aL, createP21PimActions as aM, createP21SismActions as aN, createPaymentsActions as aO, createPricingActions as aP, createSearchActions as aQ, createShippingActions as aR, createSiteActions as aS, createSlackActions as aT, createSmartyStreetsActions as aU, createUpsActions as aV, createVmiActions as aW, type SearchActionsConfig as aa, type SearchApiClient as ab, type SearchPage as ac, type ShippingActions as ad, type ShippingActionsConfig as ae, type ShippingAddress as af, type ShippingApiClient as ag, type SiteActions as ah, type SiteActionsConfig as ai, type SlackActions as aj, type SlackActionsConfig as ak, type SlackApiClient as al, type SmartyStreetsActions as am, type SmartyStreetsActionsConfig as an, type SmartyStreetsApiClient as ao, type UpsActions as ap, type UpsActionsConfig as aq, type UpsApiClient as ar, type VmiActions as as, type VmiActionsConfig as at, type VmiApiClient as au, createAgrInfoActions as av, createAgrSiteActions as aw, createAgrWorkActions as ax, createAvalaraActions as ay, createBasecamp2Actions as az, type AgrInfoApiClient as b, type AgrSiteActions as c, type AgrSiteActionsConfig as d, type AgrSiteApiClient as e, type AgrWorkActions as f, type AgrWorkActionsConfig as g, type AgrWorkApiClient as h, type AvalaraActions as i, type AvalaraActionsConfig as j, type AvalaraApiClient as k, type Basecamp2ActionsConfig as l, type Basecamp2ApiClient as m, type BrandFolderActions as n, type BrandFolderActionsConfig as o, type BrandFolderApiClient as p, type CommerceActionsConfig as q, type CommerceApiClient as r, type CustomersActions as s, type CustomersActionsConfig as t, type CustomersApiClient as u, type GregorovichActionsConfig as v, type GregorovichApiClient as w, type ItemActionsConfig as x, type ItemsApiClient as y, type JoomlaActionsConfig as z };