@simpleapps-com/augur-api 0.1.5 → 0.1.7

package/dist/cjs/services/items/client.d.ts

@@ -1,6 +1,6 @@
 import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
-import { PingResponse, ProductSearchParams, ProductListParams, CategoryDetailsParams, CategoryItemsParams } from './schemas';
+import { PingResponse, ProductSearchParams, ProductListParams, ProductDetailParams, ProductLookupParams, CategoryDetailsParams, CategoryItemsParams, CategoryListParams, CategoryLookupParams, AttributeGroupListParams, BrandListParams, GetStockParams, AlternateCodeListParams } from './schemas';
 /**
  * Items API Client
  * @description Client for interacting with Items microservice API endpoints for product catalog, inventory, categories, and attributes management
@@ -39,14 +39,15 @@ export declare class ItemsClient extends BaseServiceClient {
          * Get product details by inventory master UID
          * @description Retrieves comprehensive details for a specific inventory item including categories, attributes, images, and related data
          * @param invMastUid Inventory master unique identifier
+         * @param params Optional parameters for including additional data
          * @returns Complete product details with all related information
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
          * const product = await client.products.get(12345);
-         * console.log(product.itemId, product.itemDesc, product.listPrice);
-         * console.log('Categories:', product.categories);
-         * console.log('Attributes:', product.attributes);
+         * console.log(product.data.itemId, product.data.itemDesc, product.data.listPrice);
+         * console.log('Categories:', product.data.categories);
+         * console.log('Attributes:', product.data.attributes);
          * ```
          */
         get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
@@ -55,20 +56,37 @@ export declare class ItemsClient extends BaseServiceClient {
                 invMastUid: number;
                 itemId: string;
                 itemDesc: string;
+                length?: number | null | undefined;
                 images?: {
                     imageUid: number;
                     imagePath: string;
                 }[] | undefined;
+                dateCreated?: string | undefined;
+                dateLastModified?: string | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
                 unitOfMeasure?: string | undefined;
+                displayOnWebFlag?: string | undefined;
+                deleteFlag?: string | undefined;
+                weight?: number | null | undefined;
+                width?: number | null | undefined;
+                height?: number | null | undefined;
                 attributes?: {
                     value: string;
                     attributeId: string;
                 }[] | undefined;
-                upc?: string | undefined;
+                upc?: string | null | undefined;
                 listPrice?: number | undefined;
                 stdPrice?: number | undefined;
                 onlineCd?: number | undefined;
-                displayOnWebFlag?: string | undefined;
+                createdBy?: string | undefined;
+                lastMaintainedBy?: string | undefined;
+                typeCd?: number | undefined;
+                brandName?: string | null | undefined;
+                brandId?: string | null | undefined;
+                brandsUid?: number | null | undefined;
+                weightUnitOfMeasure?: string | null | undefined;
+                dimensionUnitOfMeasure?: string | null | undefined;
                 categories?: {
                     categoryUid: number;
                     categoryDesc: string;
@@ -82,6 +100,85 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults?: number | undefined;
             count?: number | undefined;
         }>;
+        /**
+         * Get detailed product information by inventory master UID
+         * @description Retrieves detailed product information with comprehensive data
+         * @param invMastUid Inventory master unique identifier
+         * @param params Optional parameters for including additional data
+         * @returns Detailed product information
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const productDetail = await client.products.getDetail(12345, {
+         *   includeCategories: true,
+         *   includeAttributes: true,
+         *   includeStock: true
+         * });
+         * ```
+         */
+        getDetail: (invMastUid: number, params?: ProductDetailParams) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                statusCd: number;
+                updateCd: number;
+                processCd: number;
+                invMastUid: number;
+                itemId: string;
+                displayOnWebFlag: string;
+                itemDesc: string;
+                deleteFlag: string;
+                onlineCd: number;
+                createdBy: string;
+                lastMaintainedBy: string;
+                typeCd: number;
+                length?: number | null | undefined;
+                images?: {
+                    imageUid: number;
+                    imagePath: string;
+                }[] | undefined;
+                unitOfMeasure?: string | null | undefined;
+                weight?: number | null | undefined;
+                width?: number | null | undefined;
+                height?: number | null | undefined;
+                attributes?: {
+                    value: string;
+                    attributeId: string;
+                }[] | undefined;
+                upc?: string | null | undefined;
+                listPrice?: number | null | undefined;
+                stdPrice?: number | null | undefined;
+                brandName?: string | null | undefined;
+                brandId?: string | null | undefined;
+                brandsUid?: number | null | undefined;
+                weightUnitOfMeasure?: string | null | undefined;
+                dimensionUnitOfMeasure?: string | null | undefined;
+                categories?: {
+                    categoryUid: number;
+                    categoryDesc: string;
+                }[] | undefined;
+                accessories?: unknown[] | undefined;
+                alternateCode?: unknown[] | undefined;
+                itemType?: string | null | undefined;
+                lotControlled?: string | null | undefined;
+                serialControlled?: string | null | undefined;
+                shelfLife?: number | null | undefined;
+                shelfLifeUnitOfMeasure?: string | null | undefined;
+                hazardous?: string | null | undefined;
+                fragile?: string | null | undefined;
+                temperatureControlled?: string | null | undefined;
+                minOrderQuantity?: number | null | undefined;
+                maxOrderQuantity?: number | null | undefined;
+                orderMultiple?: number | null | undefined;
+                leadTime?: number | null | undefined;
+                leadTimeUnitOfMeasure?: string | null | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Search products using various criteria
          * @description Search for products by item ID, description, UPC, or other criteria with filtering and pagination
@@ -101,12 +198,98 @@ export declare class ItemsClient extends BaseServiceClient {
          *   onlineCd: 704  // Online only
          * });
          *
-         * results.forEach(product => {
+         * results.data.forEach(product => {
          *   console.log(`${product.itemId}: ${product.itemDesc} - $${product.listPrice}`);
          * });
          * ```
          */
-        search: (params: ProductSearchParams) => Promise<any>;
+        search: (params: ProductSearchParams) => Promise<{
+            data: {
+                statusCd: number;
+                invMastUid: number;
+                itemId: string;
+                itemDesc: string;
+                length?: number | null | undefined;
+                images?: {
+                    imageUid: number;
+                    imagePath: string;
+                }[] | undefined;
+                dateCreated?: string | undefined;
+                dateLastModified?: string | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
+                unitOfMeasure?: string | undefined;
+                displayOnWebFlag?: string | undefined;
+                deleteFlag?: string | undefined;
+                weight?: number | null | undefined;
+                width?: number | null | undefined;
+                height?: number | null | undefined;
+                attributes?: {
+                    value: string;
+                    attributeId: string;
+                }[] | undefined;
+                upc?: string | null | undefined;
+                listPrice?: number | undefined;
+                stdPrice?: number | undefined;
+                onlineCd?: number | undefined;
+                createdBy?: string | undefined;
+                lastMaintainedBy?: string | undefined;
+                typeCd?: number | undefined;
+                brandName?: string | null | undefined;
+                brandId?: string | null | undefined;
+                brandsUid?: number | null | undefined;
+                weightUnitOfMeasure?: string | null | undefined;
+                dimensionUnitOfMeasure?: string | null | undefined;
+                categories?: {
+                    categoryUid: number;
+                    categoryDesc: string;
+                }[] | undefined;
+                accessories?: unknown[] | undefined;
+                alternateCode?: unknown[] | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Lookup products with simplified data
+         * @description Lookup products with simplified response format for autocomplete and basic searches
+         * @param params Lookup parameters
+         * @returns Array of simplified product data
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const lookupResults = await client.products.lookup({
+         *   q: 'cable',
+         *   limit: 10
+         * });
+         * ```
+         */
+        lookup: (params?: ProductLookupParams) => Promise<{
+            data: {
+                statusCd: number;
+                invMastUid: number;
+                itemId: string;
+                displayOnWebFlag: string;
+                itemDesc: string;
+                deleteFlag: string;
+                onlineCd: number;
+                unitOfMeasure?: string | null | undefined;
+                upc?: string | null | undefined;
+                listPrice?: number | null | undefined;
+                stdPrice?: number | null | undefined;
+                brandName?: string | null | undefined;
+                brandId?: string | null | undefined;
+                brandsUid?: number | null | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * List products with filtering and pagination
          * @description Retrieve a paginated list of products with comprehensive filtering options
@@ -126,26 +309,111 @@ export declare class ItemsClient extends BaseServiceClient {
          * });
          * ```
          */
-        list: (params?: ProductListParams) => Promise<any>;
+        list: (params?: ProductListParams) => Promise<{
+            data: {
+                statusCd: number;
+                invMastUid: number;
+                itemId: string;
+                itemDesc: string;
+                length?: number | null | undefined;
+                images?: {
+                    imageUid: number;
+                    imagePath: string;
+                }[] | undefined;
+                dateCreated?: string | undefined;
+                dateLastModified?: string | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
+                unitOfMeasure?: string | undefined;
+                displayOnWebFlag?: string | undefined;
+                deleteFlag?: string | undefined;
+                weight?: number | null | undefined;
+                width?: number | null | undefined;
+                height?: number | null | undefined;
+                attributes?: {
+                    value: string;
+                    attributeId: string;
+                }[] | undefined;
+                upc?: string | null | undefined;
+                listPrice?: number | undefined;
+                stdPrice?: number | undefined;
+                onlineCd?: number | undefined;
+                createdBy?: string | undefined;
+                lastMaintainedBy?: string | undefined;
+                typeCd?: number | undefined;
+                brandName?: string | null | undefined;
+                brandId?: string | null | undefined;
+                brandsUid?: number | null | undefined;
+                weightUnitOfMeasure?: string | null | undefined;
+                dimensionUnitOfMeasure?: string | null | undefined;
+                categories?: {
+                    categoryUid: number;
+                    categoryDesc: string;
+                }[] | undefined;
+                accessories?: unknown[] | undefined;
+                alternateCode?: unknown[] | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Pre-cache a single product
+         * @description Trigger pre-caching for a specific product to improve response times
+         * @param invMastUid Inventory master unique identifier
+         * @returns Boolean indicating if pre-cache was queued successfully
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const cached = await client.products.preCache(12345);
+         * if (cached.data) {
+         *   console.log('Product pre-cache queued successfully');
+         * }
+         * ```
+         */
+        preCache: (invMastUid: number) => Promise<{
+            data: boolean;
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get alternate codes for a product
          * @description List alternate codes (UPC, manufacturer codes, etc.) for a specific product
          * @param invMastUid Inventory master unique identifier
-         * @param params Optional pagination parameters
+         * @param params Optional filtering and pagination parameters
          * @returns Array of alternate codes for the product
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
          * const alternateCodes = await client.products.getAlternateCodes(12345);
-         * alternateCodes.forEach(code => {
-         *   console.log(`${code.codeType}: ${code.codeValue}`);
+         * alternateCodes.data.forEach(code => {
+         *   console.log(`${code.alternateCode}: ${code.alternateCodeDesc}`);
          * });
          * ```
          */
-        getAlternateCodes: (invMastUid: number, params?: {
-            limit?: number;
-            offset?: number;
-        }) => Promise<any>;
+        getAlternateCodes: (invMastUid: number, params?: AlternateCodeListParams) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                updateCd: number;
+                invMastUid: number;
+                alternateCode: string;
+                alternateCodeUid: number;
+                sourceTypeCd: number;
+                deleteFlag?: string | null | undefined;
+                alternateCodeDesc?: string | null | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get accessory items for a product
          * @description List accessory items associated with a specific product
@@ -156,7 +424,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const accessories = await client.products.getAccessories(12345);
-         * accessories.forEach(accessory => {
+         * accessories.data.forEach(accessory => {
          *   console.log(`Accessory: ${accessory.itemId} - ${accessory.itemDesc}`);
          * });
          * ```
@@ -164,7 +432,22 @@ export declare class ItemsClient extends BaseServiceClient {
         getAccessories: (invMastUid: number, params?: {
             limit?: number;
             offset?: number;
-        }) => Promise<any>;
+        }) => Promise<{
+            data: {
+                invMastUid: number;
+                itemId: string;
+                itemDesc: string;
+                accessoryUid: number;
+                accessoryInvMastUid: number;
+                quantity?: number | undefined;
+                accessoryType?: string | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get bin information for a product at a specific location
          * @description Get specific bin information for an inventory item at a location
@@ -179,7 +462,13 @@ export declare class ItemsClient extends BaseServiceClient {
          * console.log(`Bin ${binInfo.bin}: ${binInfo.qtyOnHand} on hand`);
          * ```
          */
-        getBinInfo: (invMastUid: number, locationId: number, bin: string) => Promise<any>;
+        getBinInfo: (invMastUid: number, locationId: number, bin: string) => Promise<{
+            locationId: string;
+            bin: string;
+            qtyOnHand?: number | undefined;
+            qtyAllocated?: number | undefined;
+            qtyAvailable?: number | undefined;
+        }>;
         /**
          * List all bins for a product at a specific location
          * @description List all bins for an inventory item at a specific location
@@ -191,7 +480,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const bins = await client.products.getBinsByLocation(12345, 1);
-         * bins.forEach(bin => {
+         * bins.data.forEach(bin => {
          *   console.log(`Bin ${bin.bin}: ${bin.qtyOnHand} on hand, ${bin.qtyAvailable} available`);
          * });
          * ```
@@ -199,13 +488,128 @@ export declare class ItemsClient extends BaseServiceClient {
         getBinsByLocation: (invMastUid: number, locationId: number, params?: {
             limit?: number;
             offset?: number;
-        }) => Promise<any>;
+        }) => Promise<{
+            data: {
+                locationId: string;
+                bin: string;
+                qtyOnHand?: number | undefined;
+                qtyAllocated?: number | undefined;
+                qtyAvailable?: number | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
     };
     /**
      * Category management endpoints
      * @description Methods for hierarchical product categorization including category details, items, attributes, and filtering
      */
     categories: {
+        /**
+         * List all categories with filtering and pagination
+         * @description Retrieve a paginated list of categories with filtering options
+         * @param params Optional filtering and pagination parameters
+         * @returns Array of category entities
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const categories = await client.categories.list({
+         *   displayOnWebFlag: 'Y',
+         *   limit: 50
+         * });
+         * ```
+         */
+        list: (params?: CategoryListParams) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                statusCd: number;
+                updateCd: number;
+                processCd: number;
+                displayOnWebFlag: "Y" | "N";
+                deleteFlag: "Y" | "N";
+                createdBy: string;
+                lastMaintainedBy: string;
+                itemCategoryUid: number;
+                itemCategoryId: string;
+                itemCategoryDesc: string;
+                masterCategoryFlag: string;
+                parentCategoryFlag: string;
+                displayMasterProductFlag: string;
+                itemCount: number;
+                catalogPage?: string | null | undefined;
+                subCategoryImageFile?: string | null | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Lookup category with hierarchical structure
+         * @description Retrieve category with subcategories in hierarchical structure
+         * @param params Lookup parameters including category UID or ID
+         * @returns Category with subcategories
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const categoryLookup = await client.categories.lookup({
+         *   itemCategoryUid: 100,
+         *   includeSubCategories: true
+         * });
+         * ```
+         */
+        lookup: (params?: CategoryLookupParams) => Promise<{
+            data: {
+                displayOnWebFlag: "Y" | "N";
+                deleteFlag: "Y" | "N";
+                itemCategoryUid: number;
+                itemCategoryId: string;
+                itemCategoryDesc: string;
+                itemCount: number;
+                fullPath: string | null;
+                subCategories: {
+                    displayOnWebFlag: "Y" | "N";
+                    deleteFlag: "Y" | "N";
+                    itemCategoryUid: number;
+                    itemCategoryId: string;
+                    itemCategoryDesc: string;
+                    itemCount: number;
+                    fullPath: string | null;
+                }[];
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Pre-cache a single category
+         * @description Trigger pre-caching for a specific category to improve response times
+         * @param itemCategoryUid Category unique identifier
+         * @returns Boolean indicating if pre-cache was queued successfully
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const cached = await client.categories.preCache(100);
+         * if (cached.data) {
+         *   console.log('Category pre-cache queued successfully');
+         * }
+         * ```
+         */
+        preCache: (itemCategoryUid: number) => Promise<{
+            data: boolean;
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get category details by ID or path
          * @description Retrieve comprehensive category information including children, attributes, and metadata
@@ -217,7 +621,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * ```typescript
          * // Get category by ID
          * const category = await client.categories.get(100);
-         * console.log(category.itemCategoryDesc, category.path);
+         * console.log(category.data.itemCategoryDesc, category.data.path);
          *
          * // Get category by path
          * const categoryByPath = await client.categories.get(0, {
@@ -231,7 +635,34 @@ export declare class ItemsClient extends BaseServiceClient {
          * });
          * ```
          */
-        get: (itemCategoryUid: number, params?: CategoryDetailsParams) => Promise<any>;
+        get: (itemCategoryUid: number, params?: CategoryDetailsParams) => Promise<{
+            data: {
+                itemCategoryUid: number;
+                itemCategoryDesc: string;
+                path?: string;
+                parentItemCategoryUid?: number;
+                level?: number;
+                children?: Array<{
+                    itemCategoryUid: number;
+                    itemCategoryDesc: string;
+                    path?: string;
+                    parentItemCategoryUid?: number;
+                    level?: number;
+                    children?: unknown;
+                    attributes?: unknown[];
+                    images?: unknown[];
+                    itemCount?: number;
+                }>;
+                attributes?: unknown[];
+                images?: unknown[];
+                itemCount?: number;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get items within a category
          * @description Retrieve items within a specific category with advanced filtering, sorting, and pagination
@@ -262,7 +693,26 @@ export declare class ItemsClient extends BaseServiceClient {
          * });
          * ```
          */
-        getItems: (itemCategoryUid: number, params?: CategoryItemsParams) => Promise<any>;
+        getItems: (itemCategoryUid: number, params?: CategoryItemsParams) => Promise<{
+            data: {
+                invMastUid: number;
+                itemId: string;
+                itemDesc: string;
+                images?: unknown[] | undefined;
+                attributes?: unknown[] | undefined;
+                listPrice?: number | undefined;
+                stdPrice?: number | undefined;
+                stock?: {
+                    qtyOnHand: number;
+                    qtyAvailable: number;
+                } | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get attributes available for a category
          * @description Retrieve attributes available for filtering within a category
@@ -272,12 +722,25 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const attributes = await client.categories.getAttributes(100);
-         * attributes.forEach(attr => {
+         * attributes.data.forEach(attr => {
          *   console.log(`${attr.attributeDesc}: ${attr.values?.join(', ')}`);
          * });
          * ```
          */
-        getAttributes: (itemCategoryUid: number) => Promise<any>;
+        getAttributes: (itemCategoryUid: number) => Promise<{
+            data: {
+                attributeUid: number;
+                attributeId: string;
+                attributeDesc: string;
+                dataType: string;
+                values?: string[] | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get available filter options for a category
          * @description Get available filter options for a category based on its items
@@ -287,7 +750,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const filters = await client.categories.getFilters(100);
-         * filters.forEach(filter => {
+         * filters.data.forEach(filter => {
          *   console.log(`${filter.attributeDesc}:`);
          *   filter.values.forEach(value => {
          *     console.log(`  ${value.value} (${value.count})`);
@@ -295,7 +758,22 @@ export declare class ItemsClient extends BaseServiceClient {
          * });
          * ```
          */
-        getFilters: (itemCategoryUid: number) => Promise<any>;
+        getFilters: (itemCategoryUid: number) => Promise<{
+            data: {
+                values: {
+                    value: string;
+                    count: number;
+                }[];
+                attributeId: string;
+                attributeDesc: string;
+                filterType: string;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get images for a category
          * @description Retrieve images associated with a category
@@ -305,12 +783,24 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const images = await client.categories.getImages(100);
-         * images.forEach(image => {
+         * images.data.forEach(image => {
          *   console.log(`Image: ${image.imagePath} (${image.imageType})`);
          * });
          * ```
          */
-        getImages: (itemCategoryUid: number) => Promise<any>;
+        getImages: (itemCategoryUid: number) => Promise<{
+            data: {
+                imageUid: number;
+                imagePath: string;
+                imageType: string;
+                altText?: string | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
     };
     /**
      * Attribute management endpoints
@@ -326,7 +816,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const attributes = await client.attributes.list({ limit: 50 });
-         * attributes.forEach(attr => {
+         * attributes.data.forEach(attr => {
          *   console.log(`${attr.attributeId}: ${attr.attributeDesc} (${attr.dataType})`);
          * });
          * ```
@@ -334,7 +824,22 @@ export declare class ItemsClient extends BaseServiceClient {
         list: (params?: {
             limit?: number;
             offset?: number;
-        }) => Promise<any>;
+        }) => Promise<{
+            data: {
+                statusCd: number;
+                attributeUid: number;
+                attributeId: string;
+                attributeDesc: string;
+                dataType: string;
+                sequenceNo?: number | undefined;
+                maxLength?: number | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get attribute details by ID
          * @description Retrieve details for a specific attribute
@@ -354,8 +859,8 @@ export declare class ItemsClient extends BaseServiceClient {
                 attributeId: string;
                 attributeDesc: string;
                 dataType: string;
-                maxLength?: number | undefined;
                 sequenceNo?: number | undefined;
+                maxLength?: number | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -384,8 +889,8 @@ export declare class ItemsClient extends BaseServiceClient {
             attributeId: string;
             attributeDesc: string;
             dataType: string;
-            maxLength?: number | undefined;
             sequenceNo?: number | undefined;
+            maxLength?: number | undefined;
         }) => Promise<{
             data: {
                 statusCd: number;
@@ -393,8 +898,8 @@ export declare class ItemsClient extends BaseServiceClient {
                 attributeId: string;
                 attributeDesc: string;
                 dataType: string;
-                maxLength?: number | undefined;
                 sequenceNo?: number | undefined;
+                maxLength?: number | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -418,11 +923,11 @@ export declare class ItemsClient extends BaseServiceClient {
          * ```
          */
         update: (id: string | number, data: {
+            sequenceNo?: number | undefined;
             maxLength?: number | undefined;
             attributeId?: string | undefined;
             attributeDesc?: string | undefined;
             dataType?: string | undefined;
-            sequenceNo?: number | undefined;
         }) => Promise<{
             data: {
                 statusCd: number;
@@ -430,8 +935,8 @@ export declare class ItemsClient extends BaseServiceClient {
                 attributeId: string;
                 attributeDesc: string;
                 dataType: string;
-                maxLength?: number | undefined;
                 sequenceNo?: number | undefined;
+                maxLength?: number | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -462,22 +967,58 @@ export declare class ItemsClient extends BaseServiceClient {
     stock: {
         /**
          * Get comprehensive stock details for an item
-         * @description Retrieve comprehensive stock information for an item across all locations
+         * @description Retrieve comprehensive stock information for an item across all locations with detailed calculations
          * @param invMastUid Inventory master unique identifier
+         * @param params Optional parameters for filtering and including additional data
          * @returns Stock details with location breakdown and company summary
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
          * const stockInfo = await client.stock.getDetails(12345);
-         * console.log('Total on hand:', stockInfo.companySummary.totalQtyOnHand);
-         * console.log('Total available:', stockInfo.companySummary.totalQtyAvailable);
+         * console.log('Company Summary:', stockInfo.data.companySummary);
          *
-         * stockInfo.stocks.forEach(location => {
-         *   console.log(`Location ${location.locationId}: ${location.qtyOnHand} on hand, ${location.qtyAvailable} available`);
+         * stockInfo.data.stockData.forEach(location => {
+         *   console.log(`Location ${location.locationName}: ${location.qtyOnHand} on hand, ${location.qtyAvailable} available`);
+         *   console.log(`  Calculated: ${location.calcQtyOnHand} (${location.defaultSellingUnit})`);
          * });
          * ```
          */
-        getDetails: (invMastUid: number) => Promise<any>;
+        getDetails: (invMastUid: number, params?: GetStockParams) => Promise<{
+            data: {
+                companySummary: Record<string, number>;
+                stockData: {
+                    defaultSellingUnit: string;
+                    baseUnit: string;
+                    companyId: string;
+                    locationId: number;
+                    qtyOnHand: number;
+                    qtyAllocated: number;
+                    qtyAvailable: number;
+                    unallocated: number;
+                    baseUnitSize: number;
+                    defaultSellingUnitSize: number;
+                    divisor: number;
+                    calcQtyOnHand: number;
+                    calcQtyAllocated: number;
+                    calcQtyAvailable: number;
+                    locationName: string;
+                    qtyBackordered?: number | null | undefined;
+                    stockable?: string | null | undefined;
+                    nextDueInPoDate?: string | null | undefined;
+                    primaryBin?: string | null | undefined;
+                    discontinued?: string | null | undefined;
+                    qtyFrozen?: number | null | undefined;
+                    qtyQuarantined?: number | null | undefined;
+                    orderQuantity?: number | null | undefined;
+                    productGroupId?: string | null | undefined;
+                }[];
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
     };
     /**
      * Brand management endpoints
@@ -486,42 +1027,59 @@ export declare class ItemsClient extends BaseServiceClient {
     brands: {
         /**
          * List all brands
-         * @description Retrieve a paginated list of brands
-         * @param params Optional pagination parameters
+         * @description Retrieve a paginated list of brands with filtering options
+         * @param params Optional filtering and pagination parameters
          * @returns Array of brands
          * @throws ValidationError When parameters are invalid or response is malformed
          * @example
          * ```typescript
-         * const brands = await client.brands.list({ limit: 50 });
-         * brands.forEach(brand => {
-         *   console.log(`${brand.brandId}: ${brand.brandDesc}`);
+         * const brands = await client.brands.list({ limit: 50, statusCd: 704 });
+         * brands.data.forEach(brand => {
+         *   console.log(`${brand.brandsId}: ${brand.brandsName}`);
          * });
          * ```
          */
-        list: (params?: {
-            limit?: number;
-            offset?: number;
-        }) => Promise<any>;
+        list: (params?: BrandListParams) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                statusCd: number;
+                updateCd: number;
+                processCd: number;
+                brandsUid: number;
+                brandsName: string;
+                brandsId: string;
+                brandsDesc?: string | null | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get brand details by ID
          * @description Retrieve details for a specific brand
-         * @param brandUid Brand unique identifier
+         * @param brandsUid Brand unique identifier
          * @returns Brand details
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
          * const brand = await client.brands.get(123);
-         * console.log(brand.brandDesc, brand.website, brand.logoPath);
+         * console.log(brand.data.brandsName, brand.data.brandsDesc);
          * ```
          */
         get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
             data: {
+                dateCreated: string;
+                dateLastModified: string;
                 statusCd: number;
-                brandUid: number;
-                brandId: string;
-                brandDesc: string;
-                website?: string | undefined;
-                logoPath?: string | undefined;
+                updateCd: number;
+                processCd: number;
+                brandsUid: number;
+                brandsName: string;
+                brandsId: string;
+                brandsDesc?: string | null | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -538,26 +1096,25 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const newBrand = await client.brands.create({
-         *   brandId: 'ACME',
-         *   brandDesc: 'ACME Corporation',
-         *   website: 'https://acme.com',
-         *   logoPath: '/images/acme-logo.png'
+         *   brandsName: 'ACME Corporation',
+         *   brandsDesc: 'Leading manufacturer'
          * });
          * ```
          */
         create: (data: {
-            brandId: string;
-            brandDesc: string;
-            website?: string | undefined;
-            logoPath?: string | undefined;
+            brandsName: string;
+            brandsDesc?: string | null | undefined;
         }) => Promise<{
             data: {
+                dateCreated: string;
+                dateLastModified: string;
                 statusCd: number;
-                brandUid: number;
-                brandId: string;
-                brandDesc: string;
-                website?: string | undefined;
-                logoPath?: string | undefined;
+                updateCd: number;
+                processCd: number;
+                brandsUid: number;
+                brandsName: string;
+                brandsId: string;
+                brandsDesc?: string | null | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -568,31 +1125,34 @@ export declare class ItemsClient extends BaseServiceClient {
         /**
          * Update an existing brand
          * @description Update an existing brand with new information
-         * @param brandUid Brand unique identifier
+         * @param brandsUid Brand unique identifier
          * @param request Brand update data
          * @returns Updated brand information
          * @throws ValidationError When request is invalid or response is malformed
          * @example
          * ```typescript
          * const updated = await client.brands.update(123, {
-         *   brandDesc: 'ACME Corporation LLC',
-         *   website: 'https://acme-corp.com'
+         *   brandsName: 'ACME Corporation LLC',
+         *   brandsDesc: 'Updated description'
          * });
          * ```
          */
         update: (id: string | number, data: {
-            brandId?: string | undefined;
-            brandDesc?: string | undefined;
-            website?: string | undefined;
-            logoPath?: string | undefined;
+            statusCd?: number | undefined;
+            processCd?: number | undefined;
+            brandsName?: string | undefined;
+            brandsDesc?: string | null | undefined;
         }) => Promise<{
             data: {
+                dateCreated: string;
+                dateLastModified: string;
                 statusCd: number;
-                brandUid: number;
-                brandId: string;
-                brandDesc: string;
-                website?: string | undefined;
-                logoPath?: string | undefined;
+                updateCd: number;
+                processCd: number;
+                brandsUid: number;
+                brandsName: string;
+                brandsId: string;
+                brandsDesc?: string | null | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -603,7 +1163,7 @@ export declare class ItemsClient extends BaseServiceClient {
         /**
          * Delete a brand
          * @description Soft delete a brand (sets status to inactive)
-         * @param brandUid Brand unique identifier
+         * @param brandsUid Brand unique identifier
          * @returns Boolean indicating successful deletion
          * @throws ValidationError When response is malformed
          * @example
@@ -614,61 +1174,197 @@ export declare class ItemsClient extends BaseServiceClient {
          * }
          * ```
          */
-        delete: (brandUid: number) => Promise<boolean>;
+        delete: (brandsUid: number) => Promise<boolean>;
     };
     /**
      * Attribute group management endpoints
-     * @description Methods for managing attribute groups
+     * @description Methods for managing attribute groups with comprehensive CRUD operations
      */
     attributeGroups: {
         /**
          * List all attribute groups
-         * @description Retrieve a list of attribute groups
-         * @param params Optional pagination parameters
-         * @returns Array of attribute groups
+         * @description Retrieve a list of attribute groups with filtering options
+         * @param params Optional filtering and pagination parameters
+         * @returns Array of attribute group summaries
          * @throws ValidationError When parameters are invalid or response is malformed
          * @example
          * ```typescript
-         * const groups = await client.attributeGroups.list();
-         * groups.forEach(group => {
+         * const groups = await client.attributeGroups.list({
+         *   statusCd: 704,
+         *   limit: 50
+         * });
+         * groups.data.forEach(group => {
          *   console.log(`${group.attributeGroupId}: ${group.attributeGroupDesc}`);
          * });
          * ```
          */
-        list: (params?: {
-            limit?: number;
-            offset?: number;
-        }) => Promise<any>;
+        list: (params?: AttributeGroupListParams) => Promise<{
+            data: {
+                typeCd: number;
+                attributeGroupUid: number;
+                attributeGroupId: string;
+                attributeGroupDesc: string | null;
+                attributeGroupType: number;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get attribute group details by ID
          * @description Retrieve details for a specific attribute group
          * @param attributeGroupUid Attribute group unique identifier
-         * @returns Attribute group details with associated attributes
+         * @returns Complete attribute group details
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
          * const group = await client.attributeGroups.get(123);
-         * console.log(group.attributeGroupDesc);
-         * group.attributes?.forEach(attr => {
-         *   console.log(`  - ${attr.attributeDesc}`);
-         * });
+         * console.log(group.data.attributeGroupDesc, group.data.attributeGroupType);
          * ```
          */
         get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
             data: {
+                dateCreated: string;
+                dateLastModified: string;
+                createdBy: string;
+                lastMaintainedBy: string;
                 attributeGroupUid: number;
                 attributeGroupId: string;
-                attributeGroupDesc: string;
-                attributes?: {
-                    statusCd: number;
-                    attributeUid: number;
-                    attributeId: string;
-                    attributeDesc: string;
-                    dataType: string;
-                    maxLength?: number | undefined;
-                    sequenceNo?: number | undefined;
-                }[] | undefined;
-                sequenceNo?: number | undefined;
+                rowStatusFlag: number;
+                attributeGroupType: number;
+                statusCd?: number | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
+                typeCd?: number | undefined;
+                attributeGroupDesc?: string | null | undefined;
+                searchableCd?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Create a new attribute group
+         * @description Create a new attribute group with specified properties
+         * @param request Attribute group creation data
+         * @returns Created attribute group information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const newGroup = await client.attributeGroups.create({
+         *   attributeGroupDesc: 'Electronics Category',
+         *   attributeGroupType: 3526,
+         *   statusCd: 704
+         * });
+         * ```
+         */
+        create: (data: {
+            attributeGroupDesc: string;
+            statusCd?: number | undefined;
+            typeCd?: number | undefined;
+            attributeGroupType?: number | undefined;
+            searchableCd?: number | undefined;
+        }) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                createdBy: string;
+                lastMaintainedBy: string;
+                attributeGroupUid: number;
+                attributeGroupId: string;
+                rowStatusFlag: number;
+                attributeGroupType: number;
+                statusCd?: number | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
+                typeCd?: number | undefined;
+                attributeGroupDesc?: string | null | undefined;
+                searchableCd?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Update an existing attribute group
+         * @description Update an existing attribute group with new information
+         * @param attributeGroupUid Attribute group unique identifier
+         * @param request Attribute group update data
+         * @returns Updated attribute group information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const updated = await client.attributeGroups.update(123, {
+         *   attributeGroupDesc: 'Updated Electronics Category',
+         *   statusCd: 704
+         * });
+         * ```
+         */
+        update: (id: string | number, data: {
+            statusCd?: number | undefined;
+            updateCd?: number | undefined;
+            processCd?: number | undefined;
+            typeCd?: number | undefined;
+            attributeGroupDesc?: string | null | undefined;
+            attributeGroupType?: number | undefined;
+            searchableCd?: number | undefined;
+        }) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                createdBy: string;
+                lastMaintainedBy: string;
+                attributeGroupUid: number;
+                attributeGroupId: string;
+                rowStatusFlag: number;
+                attributeGroupType: number;
+                statusCd?: number | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
+                typeCd?: number | undefined;
+                attributeGroupDesc?: string | null | undefined;
+                searchableCd?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Delete an attribute group
+         * @description Soft delete an attribute group (sets status to inactive)
+         * @param attributeGroupUid Attribute group unique identifier
+         * @returns Updated attribute group with deleted status
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const deleted = await client.attributeGroups.delete(123);
+         * console.log('Deleted group status:', deleted.data.statusCd); // Should be 700
+         * ```
+         */
+        delete: (attributeGroupUid: number) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                createdBy: string;
+                lastMaintainedBy: string;
+                attributeGroupUid: number;
+                attributeGroupId: string;
+                rowStatusFlag: number;
+                attributeGroupType: number;
+                statusCd?: number | undefined;
+                updateCd?: number | undefined;
+                processCd?: number | undefined;
+                typeCd?: number | undefined;
+                attributeGroupDesc?: string | null | undefined;
+                searchableCd?: number | undefined;
             };
             status: number;
             options?: Record<string, unknown>[] | undefined;
@@ -691,7 +1387,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const values = await client.attributeValues.list();
-         * values.forEach(value => {
+         * values.data.forEach(value => {
          *   console.log(`${value.attributeValue} (${value.displayValue})`);
          * });
          * ```
@@ -699,7 +1395,20 @@ export declare class ItemsClient extends BaseServiceClient {
         list: (params?: {
             limit?: number;
             offset?: number;
-        }) => Promise<any>;
+        }) => Promise<{
+            data: {
+                attributeValueUid: number;
+                attributeValue: string;
+                attributeUid: number;
+                sequenceNo?: number | undefined;
+                displayValue?: string | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Get attribute value details by ID
          * @description Retrieve details for a specific attribute value
@@ -712,7 +1421,13 @@ export declare class ItemsClient extends BaseServiceClient {
          * console.log(value.attributeValue, value.displayValue);
          * ```
          */
-        get: (attributeValueUid: number) => Promise<any>;
+        get: (attributeValueUid: number) => Promise<{
+            attributeValueUid: number;
+            attributeValue: string;
+            attributeUid: number;
+            sequenceNo?: number | undefined;
+            displayValue?: string | undefined;
+        }>;
     };
     /**
      * Item attribute value management endpoints
@@ -728,7 +1443,7 @@ export declare class ItemsClient extends BaseServiceClient {
          * @example
          * ```typescript
          * const itemValues = await client.itemAttributeValues.list();
-         * itemValues.forEach(value => {
+         * itemValues.data.forEach(value => {
          *   console.log(`Item ${value.invMastUid}, Attribute ${value.attributeUid}: ${value.attributeValue}`);
          * });
          * ```
@@ -736,7 +1451,20 @@ export declare class ItemsClient extends BaseServiceClient {
         list: (params?: {
             limit?: number;
             offset?: number;
-        }) => Promise<any>;
+        }) => Promise<{
+            data: {
+                invMastUid: number;
+                attributeValue: string;
+                attributeUid: number;
+                itemAttributeValueUid: number;
+                displayValue?: string | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
         /**
          * Create item attribute value
          * @description Create a new item attribute value relationship