@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/types/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, ProductLookupParams, CategoryDetailsParams, CategoryItemsParams, CategoryListParams, CategoryLookupParams, AttributeGroupListParams, BrandListParams, GetStockParams, ItemFavoritesListParams, ItemWishlistListParams, ItemWishlistLineListParams, ItemVariantListParams, ItemFaqListParams, ItemFaqVoteRequest, BrandItemListParams, ProductLinkListParams, SubPartListParams, BinListParams, InventoryLocationBinListParams, CreateItemWishlistLineRequest, UpdateItemWishlistLineRequest, CreateItemVariantLineRequest, UpdateItemVariantLineRequest, CreateItemFaqRequest, UpdateItemFaqRequest, CreateBrandItemRequest, UpdateBrandItemRequest, CreateProductLinkRequest, UpdateProductLinkRequest, CreateSubPartRequest, UpdateSubPartRequest, CreateBinRequest, UpdateBinRequest } from './schemas';
+import { AlternateCodeListParams, PingResponse, ProductSearchParams, ProductListParams, ProductLookupParams, CategoryDetailsParams, CategoryItemsParams, CategoryListParams, CategoryLookupParams, AttributeGroupListParams, BrandListParams, GetStockParams, CreateItemWishlistHeaderRequest, ItemVariantListParams, ItemFaqListParams, ItemFaqVoteRequest, BrandItemListParams, ProductLinkListParams, SubPartListParams, CreateItemVariantLineRequest, UpdateItemVariantLineRequest, CreateItemFaqRequest, UpdateItemFaqRequest, CreateBrandItemRequest, UpdateBrandItemRequest, CreateProductLinkRequest, UpdateProductLinkRequest, CreateSubPartRequest, UpdateSubPartRequest, CreateBinRequest, UpdateBinRequest, InvMastSubPartsParams, InvMastLinksResponse, InvMastSubPartsResponse, ItemFavoritesListResponse, ItemFavoritesItemResponse, LocationsBinsParams } from './schemas';
 type CreateAttributeValueRequest = {
     value: string;
     displayValue?: string;
@@ -65,7 +65,7 @@ type CreateProductAttributeRequest = {
  *
  * // Get category with items
  * const category = await items.categories.get(100);
- * const categoryItems = await items.categories.getItems(100, { limit: 12 });
+ * const categoryItems = await items.categories.item.list(100);
  * ```
  */
 export declare class ItemsClient extends BaseServiceClient {
@@ -80,19 +80,22 @@ export declare class ItemsClient extends BaseServiceClient {
      * @description Methods for product management including search, details, alternate codes, and accessories
      */
     /**
-     * Category management endpoints
-     * @description Methods for hierarchical product categorization including category details, items, attributes, and filtering
+     * Item Category management endpoints
+     * @description Methods for /item-category/* paths following OpenAPI Path Mirroring Pattern
      */
-    categories: {
+    itemCategory: {
         /**
-         * List all categories with filtering and pagination
-         * @description Retrieve a paginated list of categories with filtering options
+         * List all item categories with filtering and pagination
+         * @description Retrieve a paginated list of item categories with filtering options
+         * @fullPath api.items.itemCategory.list
+         * @service items
+         * @domain inventory-management
          * @param params Optional filtering and pagination parameters
-         * @returns Array of category entities
+         * @returns Array of item category entities
          * @throws ValidationError When parameters are invalid or response is malformed
          * @example
          * ```typescript
-         * const categories = await client.categories.list({
+         * const categories = await client.itemCategory.list({
          *   displayOnWebFlag: 'Y',
          *   limit: 50
          * });
@@ -128,38 +131,42 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * 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
+         * Get item category details by ID
+         * @description Retrieve comprehensive item category information
+         * @fullPath api.items.itemCategory.get
+         * @service items
+         * @domain inventory-management
+         * @param itemCategoryUid Item category unique identifier
+         * @returns Complete item category details
+         * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const categoryLookup = await client.categories.lookup({
-         *   itemCategoryUid: 100,
-         *   includeSubCategories: true
-         * });
+         * const category = await client.itemCategory.get(100);
+         * console.log(category.data.itemCategoryDesc);
          * ```
          */
-        lookup: (params?: CategoryLookupParams) => Promise<{
+        get: (itemCategoryUid: number) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
-                fullPath: string | null;
-                displayOnWebFlag: "Y" | "N";
-                deleteFlag: "Y" | "N";
                 itemCategoryUid: number;
-                itemCategoryId: string;
                 itemCategoryDesc: string;
-                itemCount: number;
-                subCategories: {
-                    fullPath: string | null;
-                    displayOnWebFlag: "Y" | "N";
-                    deleteFlag: "Y" | "N";
+                path?: string;
+                parentItemCategoryUid?: number;
+                level?: number;
+                children?: Array<{
                     itemCategoryUid: number;
-                    itemCategoryId: string;
                     itemCategoryDesc: string;
-                    itemCount: number;
-                }[];
+                    path?: string;
+                    parentItemCategoryUid?: number;
+                    level?: number;
+                    children?: unknown;
+                    attributes?: unknown[];
+                    images?: unknown[];
+                    itemCount?: number;
+                }>;
+                attributes?: unknown[];
+                images?: unknown[];
+                itemCount?: number;
             };
             options: Record<string, unknown> | unknown[];
             status: number;
@@ -169,67 +176,121 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * 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');
-         * }
-         * ```
+         * Item category lookup - Direct path mapping to /item-category/lookup
+         * @description OpenAPI Path Mirroring: /item-category/lookup → itemCategory.lookup.get()
          */
-        preCache: (itemCategoryUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: boolean;
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        lookup: {
+            /**
+             * Lookup item category with hierarchical structure
+             * @description Retrieve item category with subcategories in hierarchical structure
+             * @fullPath api.items.itemCategory.lookup.get
+             * @service items
+             * @domain inventory-management
+             * @param params Lookup parameters
+             * @returns Item category with hierarchical structure
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const categoryLookup = await client.itemCategory.lookup.get();
+             * ```
+             */
+            get: (params?: CategoryLookupParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    fullPath: string | null;
+                    displayOnWebFlag: "Y" | "N";
+                    deleteFlag: "Y" | "N";
+                    itemCategoryUid: number;
+                    itemCategoryId: string;
+                    itemCategoryDesc: string;
+                    itemCount: number;
+                    subCategories: {
+                        fullPath: string | null;
+                        displayOnWebFlag: "Y" | "N";
+                        deleteFlag: "Y" | "N";
+                        itemCategoryUid: number;
+                        itemCategoryId: string;
+                        itemCategoryDesc: string;
+                        itemCount: number;
+                    }[];
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
+        /**
+         * Item category documentation - Direct path mapping to /item-category/{itemCategoryUid}/doc
+         * @description OpenAPI Path Mirroring: /item-category/{itemCategoryUid}/doc → itemCategory.doc.get()
+         */
+        doc: {
+            /**
+             * Get item category documentation
+             * @description Retrieve documentation for a specific item category
+             * @fullPath api.items.itemCategory.doc.get
+             * @service items
+             * @domain inventory-management
+             * @param itemCategoryUid Item category unique identifier
+             * @returns Item category documentation
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const docs = await client.itemCategory.doc.get(100);
+             * ```
+             */
+            get: (itemCategoryUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                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;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
+    };
+    /**
+     * Category management endpoints
+     * @description Methods for /categories/* paths following OpenAPI Path Mirroring Pattern
+     */
+    categories: {
         /**
-         * Get category details by ID or path
-         * @description Retrieve comprehensive category information including children, attributes, and metadata
+         * Get category details by ID
+         * @description Retrieve comprehensive category information
          * @fullPath api.items.categories.get
          * @service items
          * @domain inventory-management
-         * @dataMethod categoriesData.get
-         * @discoverable true
-         * @searchTerms ["category details", "category info", "category by id", "category lookup", "hierarchical categories"]
-         * @relatedEndpoints ["api.items.categories.getItems", "api.items.categories.list", "api.items.categories.getAttributes", "api.opensearch.categories"]
-         * @commonPatterns ["Category navigation", "Get category info", "Category detail page", "Hierarchical browsing"]
-         * @workflow ["category-navigation", "product-browsing", "taxonomy-management"]
-         * @prerequisites ["Valid category UID or path", "Category access permissions"]
-         * @nextSteps ["api.items.categories.getItems", "api.items.categories.getAttributes", "api.items.categories.getFilters"]
-         * @businessRules ["Returns category hierarchy", "Includes subcategories if requested", "Respects category visibility settings"]
-         * @functionalArea "category-and-taxonomy-management"
-         * @caching "Cache for 30 minutes, invalidate on category structure changes"
-         * @performance "Optimized for category navigation, supports path-based lookups"
-         * @param itemCategoryUid Category unique identifier (use 0 for path-based lookup)
-         * @param params Optional parameters for path lookup, filtering, and children pagination
-         * @returns Complete category details with children and attributes
-         * @throws ValidationError When parameters are invalid or response is malformed
+         * @param itemCategoryUid Category unique identifier
+         * @returns Complete category details
+         * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * // Get category by ID
          * const category = await client.categories.get(100);
-         * console.log(category.data.itemCategoryDesc, category.data.path);
-         *
-         * // Get category by path
-         * const categoryByPath = await client.categories.get(0, {
-         *   path: '/Electronics/Cables'
-         * });
-         *
-         * // Get category with filtered children
-         * const categoryWithChildren = await client.categories.get(100, {
-         *   childrenLimit: 10,
-         *   childrenFilter: 'audio'
-         * });
+         * console.log(category.data.itemCategoryDesc);
          * ```
          */
         get: (itemCategoryUid: number, params?: CategoryDetailsParams) => Promise<{
@@ -263,172 +324,184 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Get items within a category
-         * @description Retrieve items within a specific category with advanced filtering, sorting, and pagination
-         * @param itemCategoryUid Category unique identifier
-         * @param params Optional filtering, sorting, and pagination parameters
-         * @returns Array of category items with optional stock information
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * // Get category items with basic pagination
-         * const items = await client.categories.getItems(100, { limit: 12 });
-         *
-         * // Get items with filtering and stock information
-         * const filteredItems = await client.categories.getItems(100, {
-         *   limit: 20,
-         *   sortBy: 'listPrice|ASC',
-         *   includeStock: 'Y',
-         *   displayOnWebFlag: 'Y',
-         *   filters: JSON.stringify([
-         *     { attributeId: 'color', values: ['red', 'blue'], operator: 'IN' }
-         *   ])
-         * });
-         *
-         * // Search within category
-         * const searchResults = await client.categories.getItems(100, {
-         *   q: 'wireless',
-         *   limit: 10
-         * });
-         * ```
+         * Category lookup - Direct path mapping to /categories/lookup
+         * @description OpenAPI Path Mirroring: /categories/lookup → categories.lookup.get()
          */
-        getItems: (itemCategoryUid: number, params?: CategoryItemsParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                itemDesc: string;
-                attributes?: unknown[] | undefined;
-                images?: unknown[] | undefined;
-                listPrice?: number | undefined;
-                stdPrice?: number | undefined;
-                stock?: {
-                    qtyOnHand: number;
-                    qtyAvailable: number;
-                } | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        lookup: {
+            /**
+             * Lookup category with hierarchical structure
+             * @description Retrieve category with subcategories in hierarchical structure
+             * @fullPath api.items.categories.lookup.get
+             * @service items
+             * @domain inventory-management
+             * @param params Lookup parameters
+             * @returns Category with subcategories
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const categoryLookup = await client.categories.lookup.get();
+             * ```
+             */
+            get: (params?: CategoryLookupParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    fullPath: string | null;
+                    displayOnWebFlag: "Y" | "N";
+                    deleteFlag: "Y" | "N";
+                    itemCategoryUid: number;
+                    itemCategoryId: string;
+                    itemCategoryDesc: string;
+                    itemCount: number;
+                    subCategories: {
+                        fullPath: string | null;
+                        displayOnWebFlag: "Y" | "N";
+                        deleteFlag: "Y" | "N";
+                        itemCategoryUid: number;
+                        itemCategoryId: string;
+                        itemCategoryDesc: string;
+                        itemCount: number;
+                    }[];
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
         /**
-         * Get attributes available for a category
-         * @description Retrieve attributes available for filtering within a category
-         * @param itemCategoryUid Category unique identifier
-         * @returns Array of category attributes with their available values
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const attributes = await client.categories.getAttributes(100);
-         * attributes.data.forEach(attr => {
-         *   console.log(`${attr.attributeDesc}: ${attr.values?.join(', ')}`);
-         * });
-         * ```
+         * Category items - Direct path mapping to /categories/{itemCategoryUid}/item
+         * @description OpenAPI Path Mirroring: /categories/{itemCategoryUid}/item → categories.item.list()
          */
-        getAttributes: (itemCategoryUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                attributeUid: number;
-                attributeId: string;
-                attributeDesc: string;
-                dataType: string;
-                values?: string[] | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        item: {
+            /**
+             * List items within a category
+             * @description Retrieve items within a specific category
+             * @fullPath api.items.categories.item.list
+             * @service items
+             * @domain inventory-management
+             * @param itemCategoryUid Category unique identifier
+             * @returns Array of category items
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const items = await client.categories.item.list(100);
+             * ```
+             */
+            list: (itemCategoryUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    invMastUid: number;
+                    itemId: string;
+                    itemDesc: string;
+                    attributes?: unknown[] | undefined;
+                    images?: unknown[] | undefined;
+                    listPrice?: number | undefined;
+                    stdPrice?: number | undefined;
+                    stock?: {
+                        qtyOnHand: number;
+                        qtyAvailable: number;
+                    } | undefined;
+                }[];
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
         /**
-         * Get available filter options for a category
-         * @description Get available filter options for a category based on its items
-         * @param itemCategoryUid Category unique identifier
-         * @returns Array of filter options with values and counts
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const filters = await client.categories.getFilters(100);
-         * filters.data.forEach(filter => {
-         *   console.log(`${filter.attributeDesc}:`);
-         *   filter.values.forEach(value => {
-         *     console.log(`  ${value.value} (${value.count})`);
-         *   });
-         * });
-         * ```
+         * Category attributes - Direct path mapping to /categories/{itemCategoryUid}/attributes
+         * @description OpenAPI Path Mirroring: /categories/{itemCategoryUid}/attributes → categories.attributes.list()
          */
-        getFilters: (itemCategoryUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                values: {
-                    value: string;
-                    count: number;
+        attributes: {
+            /**
+             * List attributes available for a category
+             * @description Retrieve attributes available for filtering within a category
+             * @fullPath api.items.categories.attributes.list
+             * @service items
+             * @domain inventory-management
+             * @param itemCategoryUid Category unique identifier
+             * @returns Array of category attributes with their available values
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const attributes = await client.categories.attributes.list(100);
+             * attributes.data.forEach(attr => {
+             *   console.log(`${attr.attributeDesc}: ${attr.values?.join(', ')}`);
+             * });
+             * ```
+             */
+            list: (itemCategoryUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    attributeUid: number;
+                    attributeId: string;
+                    attributeDesc: string;
+                    dataType: string;
+                    values?: string[] | undefined;
                 }[];
-                attributeId: string;
-                attributeDesc: string;
-                filterType: string;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
         /**
-         * Get images for a category
-         * @description Retrieve images associated with a category
-         * @param itemCategoryUid Category unique identifier
-         * @returns Array of category images
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const images = await client.categories.getImages(100);
-         * images.data.forEach(image => {
-         *   console.log(`Image: ${image.imagePath} (${image.imageType})`);
-         * });
-         * ```
+         * Category images - Direct path mapping to /categories/{itemCategoryUid}/images
+         * @description OpenAPI Path Mirroring: /categories/{itemCategoryUid}/images → categories.images.list()
          */
-        getImages: (itemCategoryUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                imageUid: number;
-                imagePath: string;
-                imageType: string;
-                altText?: string | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        images: {
+            /**
+             * List images for a category
+             * @description Retrieve images associated with a category
+             * @fullPath api.items.categories.images.list
+             * @service items
+             * @domain inventory-management
+             * @param itemCategoryUid Category unique identifier
+             * @returns Array of category images
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const images = await client.categories.images.list(100);
+             * images.data.forEach(image => {
+             *   console.log(`Image: ${image.imagePath} (${image.imageType})`);
+             * });
+             * ```
+             */
+            list: (itemCategoryUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    imageUid: number;
+                    imagePath: string;
+                    imageType: string;
+                    altText?: string | undefined;
+                }[];
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
     };
     /**
-     * Category data-only endpoints
-     * @description Data-only methods that return just the data portion of category responses
+     * Item Category data-only endpoints
+     * @description Data-only methods that return just the data portion of item category responses
      */
-    categoriesData: {
+    itemCategoryData: {
         /**
-         * Get category details data only
-         * @description Returns only the data portion of category details response
-         * @fullPath api.items.categoriesData.get
-         * @service items
-         * @domain inventory-management
-         * @discoverable true
-         * @searchTerms ["category data", "category details data only"]
-         * @relatedEndpoints ["api.items.categories.get"]
-         * @commonPatterns ["Get category data without metadata"]
-         * @param itemCategoryUid Category unique identifier
-         * @param params Optional parameters
-         * @returns Category data only
+         * Get item category details data only
+         * @description Returns only the data portion of item category details response
+         * @param itemCategoryUid Item category unique identifier
+         * @returns Item category data only
          */
-        get: (itemCategoryUid: number, params?: CategoryDetailsParams) => Promise<{
+        get: (itemCategoryUid: number) => Promise<{
             itemCategoryUid: number;
             itemCategoryDesc: string;
             path?: string;
@@ -450,17 +523,10 @@ export declare class ItemsClient extends BaseServiceClient {
             itemCount?: number;
         }>;
         /**
-         * List categories data only
-         * @description Returns only the data portion of category list response
-         * @fullPath api.items.categoriesData.list
-         * @service items
-         * @domain inventory-management
-         * @discoverable true
-         * @searchTerms ["category list data", "categories data only"]
-         * @relatedEndpoints ["api.items.categories.list"]
-         * @commonPatterns ["List categories without metadata"]
+         * List item categories data only
+         * @description Returns only the data portion of item category list response
          * @param params Optional filtering parameters
-         * @returns Category list data only
+         * @returns Item category list data only
          */
         list: (params?: CategoryListParams) => Promise<{
             dateCreated: string;
@@ -482,33 +548,40 @@ export declare class ItemsClient extends BaseServiceClient {
             catalogPage?: string | null | undefined;
             subCategoryImageFile?: string | null | undefined;
         }[]>;
+    };
+    /**
+     * Category data-only endpoints
+     * @description Data-only methods that return just the data portion of category responses
+     */
+    categoriesData: {
         /**
-         * Get category items data only
-         * @description Returns only the data portion of category items response
-         * @fullPath api.items.categoriesData.getItems
-         * @service items
-         * @domain inventory-management
-         * @discoverable true
-         * @searchTerms ["category items data", "items in category data only"]
-         * @relatedEndpoints ["api.items.categories.getItems"]
-         * @commonPatterns ["Get category items without metadata"]
+         * Get category details data only
+         * @description Returns only the data portion of category details response
          * @param itemCategoryUid Category unique identifier
-         * @param params Optional filtering parameters
-         * @returns Category items data only
+         * @param params Optional parameters
+         * @returns Category data only
          */
-        getItems: (itemCategoryUid: number, params?: CategoryItemsParams) => Promise<{
-            invMastUid: number;
-            itemId: string;
-            itemDesc: string;
-            attributes?: unknown[] | undefined;
-            images?: unknown[] | undefined;
-            listPrice?: number | undefined;
-            stdPrice?: number | undefined;
-            stock?: {
-                qtyOnHand: number;
-                qtyAvailable: number;
-            } | undefined;
-        }[]>;
+        get: (itemCategoryUid: number, params?: CategoryDetailsParams) => Promise<{
+            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;
+        }>;
     };
     /**
      * Attribute management endpoints
@@ -638,10 +711,10 @@ 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;
+            maxLength?: number | undefined;
         }) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
@@ -675,68 +748,227 @@ export declare class ItemsClient extends BaseServiceClient {
          * ```
          */
         delete: (attributeUid: number) => Promise<boolean>;
-    };
-    /**
-     * Stock and location management endpoints
-     * @description Methods for inventory stock information across locations
-     */
-    stock: {
         /**
-         * Get comprehensive stock details for an item
-         * @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('Company Summary:', stockInfo.data.companySummary);
-         *
-         * stockInfo.data.stockData.forEach(location => {
-         *   console.log(`Location ${location.locationName}: ${location.qtyOnHand} on hand, ${location.qtyAvailable} available`);
-         *   console.log(`  Calculated: ${location.calcQtyOnHand} (${location.defaultSellingUnit})`);
-         * });
-         * ```
+         * Attribute values - Direct path mapping to /attributes/{attributeUid}/values
+         * @description OpenAPI Path Mirroring: /attributes/{attributeUid}/values → attributes.values.*
          */
-        getDetails: (invMastUid: number, params?: GetStockParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            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;
+        values: {
+            /**
+             * List attribute values for a specific attribute
+             * @description Retrieve all values for an attribute
+             * @fullPath api.items.attributes.values.list
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributesValuesData.list
+             * @discoverable true
+             * @searchTerms ["attribute values", "attribute options", "value list", "attribute choices"]
+             * @relatedEndpoints ["api.items.attributes.list", "api.items.attributeGroups.attributes.list"]
+             * @commonPatterns ["List available values for an attribute", "Manage attribute options"]
+             * @workflow ["attribute-management", "value-management"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Attribute must exist"]
+             * @nextSteps ["Create new values", "Edit value details", "Associate with products"]
+             * @businessRules ["Values define available options for attributes", "Can be used across multiple products"]
+             * @functionalArea "attribute-and-value-management"
+             * @caching "Standard pagination caching"
+             * @performance "Use pagination for attributes with many values"
+             * @param attributeUid Attribute unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of attribute values
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const values = await client.attributes.values.list(123);
+             * values.data.forEach(value => {
+             *   console.log(`${value.attributeValueId}: ${value.value}`);
+             * });
+             * ```
+             */
+            list: (attributeUid: number, params?: {
+                limit?: number;
+                offset?: number;
+            }) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    attributeValueUid: number;
+                    attributeValue: string;
+                    attributeUid: number;
+                    sequenceNo?: number | undefined;
+                    displayValue?: string | undefined;
                 }[];
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Get specific attribute value details
+             * @description Retrieve details for a specific attribute value
+             * @fullPath api.items.attributes.values.get
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributesValuesData.get
+             * @discoverable true
+             * @searchTerms ["attribute value details", "specific value", "value information"]
+             * @relatedEndpoints ["api.items.attributes.values.list", "api.items.attributes.get"]
+             * @commonPatterns ["Get value details", "View value information"]
+             * @workflow ["attribute-management", "value-details"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Value must exist"]
+             * @nextSteps ["Update value", "Delete value", "Use in product associations"]
+             * @businessRules ["Value belongs to specific attribute", "Includes display and internal values"]
+             * @functionalArea "attribute-and-value-management"
+             * @caching "Standard detail caching"
+             * @performance "Direct lookup by ID"
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @returns Attribute value details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const value = await client.attributes.values.get(123, 456);
+             * console.log(value.data.value, value.data.displayValue);
+             * ```
+             */
+            get: (attributeUid: number, attributeValueUid: number) => Promise<{
+                data: {
+                    value: string;
+                    attributeValueUid: number;
+                    attributeUid: number;
+                    sequenceNo?: number | undefined;
+                    displayValue?: string | undefined;
+                };
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                options?: any;
+            }>;
+            /**
+             * Create new attribute value
+             * @description Create a new value for an attribute
+             * @fullPath api.items.attributes.values.create
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributesValuesData.create
+             * @discoverable true
+             * @searchTerms ["create attribute value", "add value", "new attribute option"]
+             * @relatedEndpoints ["api.items.attributes.values.list", "api.items.attributes.get"]
+             * @commonPatterns ["Add new attribute option", "Expand attribute choices"]
+             * @workflow ["attribute-management", "value-creation"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Attribute must exist"]
+             * @nextSteps ["List updated values", "Use in products"]
+             * @businessRules ["Value must be unique within attribute", "Display value enhances user experience"]
+             * @functionalArea "attribute-and-value-management"
+             * @caching "Invalidates attribute cache"
+             * @performance "Direct creation operation"
+             * @param attributeUid Attribute unique identifier
+             * @param request Attribute value data
+             * @returns Created attribute value information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const value = await client.attributes.values.create(123, {
+             *   value: 'Blue',
+             *   displayValue: 'Royal Blue',
+             *   sequenceNo: 10
+             * });
+             * ```
+             */
+            create: (attributeUid: number, request: CreateAttributeValueRequest) => Promise<{
+                data: {
+                    value: string;
+                    attributeValueUid: number;
+                    attributeUid: number;
+                    sequenceNo?: number | undefined;
+                    displayValue?: string | undefined;
+                };
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                options?: any;
+            }>;
+            /**
+             * Update existing attribute value
+             * @description Update an existing attribute value
+             * @fullPath api.items.attributes.values.update
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributesValuesData.update
+             * @discoverable true
+             * @searchTerms ["update attribute value", "modify value", "edit attribute option"]
+             * @relatedEndpoints ["api.items.attributes.values.get", "api.items.attributes.values.list"]
+             * @commonPatterns ["Update value details", "Modify attribute options"]
+             * @workflow ["attribute-management", "value-maintenance"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Value must exist"]
+             * @nextSteps ["Verify changes", "Update product associations if needed"]
+             * @businessRules ["Cannot change core value without affecting products", "Display value changes are safe"]
+             * @functionalArea "attribute-and-value-management"
+             * @caching "Invalidates attribute cache"
+             * @performance "Direct update operation"
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @param request Update data
+             * @returns Updated attribute value information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.attributes.values.update(123, 456, {
+             *   displayValue: 'Deep Royal Blue',
+             *   sequenceNo: 15
+             * });
+             * ```
+             */
+            update: (attributeUid: number, attributeValueUid: number, request: UpdateAttributeValueRequest) => Promise<{
+                data: {
+                    value: string;
+                    attributeValueUid: number;
+                    attributeUid: number;
+                    sequenceNo?: number | undefined;
+                    displayValue?: string | undefined;
+                };
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                options?: any;
+            }>;
+            /**
+             * Delete attribute value
+             * @description Delete an attribute value
+             * @fullPath api.items.attributes.values.delete
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributesValuesData.delete
+             * @discoverable true
+             * @searchTerms ["delete attribute value", "remove value", "delete attribute option"]
+             * @relatedEndpoints ["api.items.attributes.values.list", "api.items.attributes.values.create"]
+             * @commonPatterns ["Remove attribute option", "Clean up unused values"]
+             * @workflow ["attribute-management", "value-cleanup"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Value must exist", "Value not in use by products"]
+             * @nextSteps ["Verify removal", "List remaining values"]
+             * @businessRules ["Cannot delete values in use by products", "Deletion may affect product availability"]
+             * @functionalArea "attribute-and-value-management"
+             * @caching "Invalidates attribute cache"
+             * @performance "Direct deletion operation"
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @returns Success status
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.attributes.values.delete(123, 456);
+             * ```
+             */
+            delete: (attributeUid: number, attributeValueUid: number) => Promise<boolean>;
+        };
     };
     /**
      * Brand management endpoints
@@ -901,7 +1133,266 @@ export declare class ItemsClient extends BaseServiceClient {
          * ```
          */
         delete: (brandsUid: number) => Promise<boolean>;
-    };
+        /**
+         * Brand items - Direct path mapping to /brands/{brandsUid}/items
+         * @description OpenAPI Path Mirroring: /brands/{brandsUid}/items → brands.items.*
+         */
+        items: {
+            /**
+             * List items associated with a brand
+             * @description Retrieve all items associated with a specific brand
+             * @fullPath api.items.brands.items.list
+             * @service items
+             * @domain product-catalog
+             * @dataMethod brandsItemsData.list
+             * @discoverable true
+             * @searchTerms ["brand items", "brand products", "brand relationships", "manufacturer items", "brand catalog"]
+             * @relatedEndpoints ["api.items.brands.list", "api.items.invMast.list"]
+             * @commonPatterns ["List products from a manufacturer", "Browse brand catalog"]
+             * @workflow ["product-catalog", "brand-management"]
+             * @prerequisites ["Valid authentication token", "Product catalog permissions", "Brand must exist"]
+             * @nextSteps ["Get item details", "Create brand associations"]
+             * @businessRules ["Items can belong to multiple brands", "Primary brand relationships have priority"]
+             * @functionalArea "product-catalog-and-brand-management"
+             * @caching "Standard pagination caching"
+             * @performance "Use pagination for brands with many items"
+             * @param brandsUid Brand unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of items associated with the brand
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const brandItems = await client.brands.items.list(123);
+             * brandItems.data.forEach(item => {
+             *   console.log(`${item.itemId}: ${item.itemDesc}`);
+             * });
+             * ```
+             */
+            list: (brandsUid: number, params?: BrandItemListParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    invMastUid: number;
+                    itemId: string;
+                    brandUid: number;
+                    brandItemUid: number;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    itemDesc?: string | undefined;
+                    createdBy?: string | undefined;
+                    lastMaintainedBy?: string | undefined;
+                    isActive?: string | undefined;
+                    brandPartNumber?: string | undefined;
+                    brandItemDesc?: string | undefined;
+                    isPrimary?: string | undefined;
+                }[];
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Get specific brand-item association
+             * @description Retrieve details for a specific brand-item association
+             * @fullPath api.items.brands.items.get
+             * @service items
+             * @domain product-catalog
+             * @dataMethod brandsItemsData.get
+             * @discoverable true
+             * @searchTerms ["brand item association", "brand product details", "manufacturer item details"]
+             * @relatedEndpoints ["api.items.brands.items.list", "api.items.invMast.get"]
+             * @commonPatterns ["Get brand-item relationship details", "View manufacturer part information"]
+             * @workflow ["product-catalog", "brand-relationship-details"]
+             * @prerequisites ["Valid authentication token", "Product catalog permissions", "Association must exist"]
+             * @nextSteps ["Update association", "Remove brand relationship"]
+             * @businessRules ["Includes manufacturer part numbers", "Shows relationship priority"]
+             * @functionalArea "product-catalog-and-brand-management"
+             * @caching "Standard detail caching"
+             * @performance "Direct lookup by ID"
+             * @param brandsUid Brand unique identifier
+             * @param brandsXItemsUid Brand-item association unique identifier
+             * @returns Brand-item association details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.brands.items.get(123, 789);
+             * console.log(association.data.brandPartNumber, association.data.isPrimary);
+             * ```
+             */
+            get: (brandsUid: number, brandsXItemsUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    invMastUid: number;
+                    itemId: string;
+                    brandUid: number;
+                    brandItemUid: number;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    itemDesc?: string | undefined;
+                    createdBy?: string | undefined;
+                    lastMaintainedBy?: string | undefined;
+                    isActive?: string | undefined;
+                    brandPartNumber?: string | undefined;
+                    brandItemDesc?: string | undefined;
+                    isPrimary?: string | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Create brand-item association
+             * @description Create a new association between a brand and an item
+             * @fullPath api.items.brands.items.create
+             * @service items
+             * @domain product-catalog
+             * @dataMethod brandsItemsData.create
+             * @discoverable true
+             * @searchTerms ["create brand association", "add item to brand", "brand item relationship"]
+             * @relatedEndpoints ["api.items.brands.items.list", "api.items.invMast.get"]
+             * @commonPatterns ["Associate product with manufacturer", "Add brand to product"]
+             * @workflow ["product-catalog", "brand-association"]
+             * @prerequisites ["Valid authentication token", "Product catalog permissions", "Both brand and item must exist"]
+             * @nextSteps ["List updated brand items", "Set as primary brand"]
+             * @businessRules ["Item can have multiple brand associations", "Only one primary brand per item"]
+             * @functionalArea "product-catalog-and-brand-management"
+             * @caching "Invalidates brand catalog cache"
+             * @performance "Direct creation operation"
+             * @param brandsUid Brand unique identifier
+             * @param request Brand-item association data
+             * @returns Created association information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.brands.items.create(123, {
+             *   invMastUid: 456,
+             *   brandPartNumber: 'ACME-12345',
+             *   isPrimary: 'Y'
+             * });
+             * ```
+             */
+            create: (brandsUid: number, request: CreateBrandItemRequest) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    invMastUid: number;
+                    itemId: string;
+                    brandUid: number;
+                    brandItemUid: number;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    itemDesc?: string | undefined;
+                    createdBy?: string | undefined;
+                    lastMaintainedBy?: string | undefined;
+                    isActive?: string | undefined;
+                    brandPartNumber?: string | undefined;
+                    brandItemDesc?: string | undefined;
+                    isPrimary?: string | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Update brand-item association
+             * @description Update an existing brand-item association
+             * @fullPath api.items.brands.items.update
+             * @service items
+             * @domain product-catalog
+             * @dataMethod brandsItemsData.update
+             * @discoverable true
+             * @searchTerms ["update brand association", "modify brand relationship", "brand item update"]
+             * @relatedEndpoints ["api.items.brands.items.get", "api.items.brands.items.list"]
+             * @commonPatterns ["Update manufacturer part number", "Change primary brand status"]
+             * @workflow ["product-catalog", "brand-maintenance"]
+             * @prerequisites ["Valid authentication token", "Product catalog permissions", "Association must exist"]
+             * @nextSteps ["Verify changes", "Update product information"]
+             * @businessRules ["Cannot change core brand-item link", "Can update metadata like part numbers"]
+             * @functionalArea "product-catalog-and-brand-management"
+             * @caching "Invalidates brand catalog cache"
+             * @performance "Direct update operation"
+             * @param brandsUid Brand unique identifier
+             * @param brandsXItemsUid Brand-item association unique identifier
+             * @param request Update data
+             * @returns Updated association information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.brands.items.update(123, 789, {
+             *   brandPartNumber: 'ACME-12345-V2',
+             *   isPrimary: 'N'
+             * });
+             * ```
+             */
+            update: (brandsUid: number, brandsXItemsUid: number, request: UpdateBrandItemRequest) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    invMastUid: number;
+                    itemId: string;
+                    brandUid: number;
+                    brandItemUid: number;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    itemDesc?: string | undefined;
+                    createdBy?: string | undefined;
+                    lastMaintainedBy?: string | undefined;
+                    isActive?: string | undefined;
+                    brandPartNumber?: string | undefined;
+                    brandItemDesc?: string | undefined;
+                    isPrimary?: string | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Delete brand-item association
+             * @description Remove an item from a brand
+             * @fullPath api.items.brands.items.delete
+             * @service items
+             * @domain product-catalog
+             * @dataMethod brandsItemsData.delete
+             * @discoverable true
+             * @searchTerms ["remove brand association", "delete brand relationship", "brand item removal"]
+             * @relatedEndpoints ["api.items.brands.items.list", "api.items.brands.items.create"]
+             * @commonPatterns ["Remove product from brand", "Clean up brand associations"]
+             * @workflow ["product-catalog", "brand-cleanup"]
+             * @prerequisites ["Valid authentication token", "Product catalog permissions", "Association must exist"]
+             * @nextSteps ["Verify removal", "Update product brand information"]
+             * @businessRules ["Only removes association, not the item or brand", "May affect primary brand status"]
+             * @functionalArea "product-catalog-and-brand-management"
+             * @caching "Invalidates brand catalog cache"
+             * @performance "Direct deletion operation"
+             * @param brandsUid Brand unique identifier
+             * @param brandsXItemsUid Brand-item association unique identifier
+             * @returns Success status
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.brands.items.delete(123, 789);
+             * ```
+             */
+            delete: (brandsUid: number, brandsXItemsUid: number) => Promise<{
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                data?: any;
+                options?: any;
+            }>;
+        };
+    };
     /**
      * Attribute group management endpoints
      * @description Methods for managing attribute groups with comprehensive CRUD operations
@@ -1108,6 +1599,222 @@ export declare class ItemsClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Attribute group attributes - Direct path mapping to /attribute-groups/{attributeGroupUid}/attributes
+         * @description OpenAPI Path Mirroring: /attribute-groups/{attributeGroupUid}/attributes → attributeGroups.attributes.*
+         */
+        attributes: {
+            /**
+             * List attributes in a group
+             * @description Retrieve all attributes associated with an attribute group
+             * @fullPath api.items.attributeGroups.attributes.list
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributeGroupsAttributesData.list
+             * @discoverable true
+             * @searchTerms ["attribute group attributes", "group attributes", "attribute associations"]
+             * @relatedEndpoints ["api.items.attributes.list", "api.items.attributeGroups.list"]
+             * @commonPatterns ["List attributes in a group", "Manage attribute groups"]
+             * @workflow ["attribute-management", "group-management"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions"]
+             * @nextSteps ["Create attribute associations", "Manage individual attributes"]
+             * @businessRules ["Attributes can belong to multiple groups", "Group membership controls attribute display"]
+             * @functionalArea "attribute-and-group-management"
+             * @caching "Standard pagination caching"
+             * @performance "Use pagination for large attribute groups"
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of attributes in the group
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const groupAttrs = await client.attributeGroups.attributes.list(123);
+             * groupAttrs.data.forEach(attr => {
+             *   console.log(`${attr.attributeId}: ${attr.attributeDesc}`);
+             * });
+             * ```
+             */
+            list: (attributeGroupUid: number, params?: {
+                limit?: number;
+                offset?: number;
+            }) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    attributeValueUid: number;
+                    attributeValue: string;
+                    attributeUid: number;
+                    sequenceNo?: number | undefined;
+                    displayValue?: string | undefined;
+                }[];
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Get specific attribute association in a group
+             * @description Retrieve details for a specific attribute-group association
+             * @fullPath api.items.attributeGroups.attributes.get
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributeGroupsAttributesData.get
+             * @discoverable true
+             * @searchTerms ["attribute group association", "group attribute details", "attribute association"]
+             * @relatedEndpoints ["api.items.attributeGroups.attributes.list", "api.items.attributes.get"]
+             * @commonPatterns ["Get attribute association details", "View group membership"]
+             * @workflow ["attribute-management", "association-details"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions"]
+             * @nextSteps ["Update association", "Remove from group"]
+             * @businessRules ["Association must exist", "Includes sequence information"]
+             * @functionalArea "attribute-and-group-management"
+             * @caching "Standard detail caching"
+             * @performance "Direct lookup by ID"
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param attributeXAttributeGroupUid Attribute association unique identifier
+             * @returns Attribute association details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.attributeGroups.attributes.get(123, 789);
+             * console.log(association.data.attributeUid, association.data.sequenceNo);
+             * ```
+             */
+            get: (attributeGroupUid: number, attributeXAttributeGroupUid: number) => Promise<{
+                data: {
+                    attributeUid: number;
+                    attributeGroupUid: number;
+                    attributeXAttributeGroupUid: number;
+                    sequenceNo?: number | undefined;
+                };
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                options?: any;
+            }>;
+            /**
+             * Create attribute association in a group
+             * @description Create an association between an attribute and an attribute group
+             * @fullPath api.items.attributeGroups.attributes.create
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributeGroupsAttributesData.create
+             * @discoverable true
+             * @searchTerms ["create attribute association", "add attribute to group", "attribute group membership"]
+             * @relatedEndpoints ["api.items.attributeGroups.attributes.list", "api.items.attributes.list"]
+             * @commonPatterns ["Add attribute to group", "Organize attributes"]
+             * @workflow ["attribute-management", "group-organization"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Both attribute and group must exist"]
+             * @nextSteps ["Update association sequence", "List group attributes"]
+             * @businessRules ["Attribute can belong to multiple groups", "Sequence controls display order"]
+             * @functionalArea "attribute-and-group-management"
+             * @caching "Invalidates group cache"
+             * @performance "Direct creation operation"
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param request Attribute association data
+             * @returns Created association information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.attributeGroups.attributes.create(123, {
+             *   attributeUid: 456,
+             *   sequenceNo: 10
+             * });
+             * ```
+             */
+            create: (attributeGroupUid: number, request: CreateAttributeGroupAttributeRequest) => Promise<{
+                data: {
+                    attributeUid: number;
+                    attributeGroupUid: number;
+                    attributeXAttributeGroupUid: number;
+                    sequenceNo?: number | undefined;
+                };
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                options?: any;
+            }>;
+            /**
+             * Update attribute association in a group
+             * @description Update an existing attribute-group association
+             * @fullPath api.items.attributeGroups.attributes.update
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributeGroupsAttributesData.update
+             * @discoverable true
+             * @searchTerms ["update attribute association", "modify group membership", "attribute sequence"]
+             * @relatedEndpoints ["api.items.attributeGroups.attributes.get", "api.items.attributeGroups.attributes.list"]
+             * @commonPatterns ["Update display sequence", "Modify group organization"]
+             * @workflow ["attribute-management", "group-organization"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Association must exist"]
+             * @nextSteps ["List updated group attributes", "Verify changes"]
+             * @businessRules ["Can only update sequence and other non-key fields", "Sequence controls display order"]
+             * @functionalArea "attribute-and-group-management"
+             * @caching "Invalidates group cache"
+             * @performance "Direct update operation"
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param attributeXAttributeGroupUid Attribute association unique identifier
+             * @param request Update data
+             * @returns Updated association information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.attributeGroups.attributes.update(123, 789, {
+             *   sequenceNo: 20
+             * });
+             * ```
+             */
+            update: (attributeGroupUid: number, attributeXAttributeGroupUid: number, request: UpdateAttributeGroupAttributeRequest) => Promise<{
+                data: {
+                    attributeUid: number;
+                    attributeGroupUid: number;
+                    attributeXAttributeGroupUid: number;
+                    sequenceNo?: number | undefined;
+                };
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+                params?: any;
+                options?: any;
+            }>;
+            /**
+             * Delete attribute association from a group
+             * @description Remove an attribute from an attribute group
+             * @fullPath api.items.attributeGroups.attributes.delete
+             * @service items
+             * @domain attribute-management
+             * @dataMethod attributeGroupsAttributesData.delete
+             * @discoverable true
+             * @searchTerms ["remove attribute from group", "delete attribute association", "group membership removal"]
+             * @relatedEndpoints ["api.items.attributeGroups.attributes.list", "api.items.attributeGroups.attributes.create"]
+             * @commonPatterns ["Remove attribute from group", "Clean up attribute organization"]
+             * @workflow ["attribute-management", "group-cleanup"]
+             * @prerequisites ["Valid authentication token", "Attribute management permissions", "Association must exist"]
+             * @nextSteps ["List remaining group attributes", "Verify removal"]
+             * @businessRules ["Only removes association, not the attribute itself", "Does not affect other group memberships"]
+             * @functionalArea "attribute-and-group-management"
+             * @caching "Invalidates group cache"
+             * @performance "Direct deletion operation"
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param attributeXAttributeGroupUid Attribute association unique identifier
+             * @returns Success status
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.attributeGroups.attributes.delete(123, 789);
+             * ```
+             */
+            delete: (attributeGroupUid: number, attributeXAttributeGroupUid: number) => Promise<boolean>;
+        };
     };
     /**
      * Attribute value management endpoints
@@ -1147,25 +1854,6 @@ export declare class ItemsClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
-        /**
-         * Get attribute value details by ID
-         * @description Retrieve details for a specific attribute value
-         * @param attributeValueUid Attribute value unique identifier
-         * @returns Attribute value details
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const value = await client.attributeValues.get(123);
-         * console.log(value.attributeValue, value.displayValue);
-         * ```
-         */
-        get: (attributeValueUid: number) => Promise<{
-            attributeValueUid: number;
-            attributeValue: string;
-            attributeUid: number;
-            sequenceNo?: number | undefined;
-            displayValue?: string | undefined;
-        }>;
     };
     /**
      * Item attribute value management endpoints
@@ -1244,20 +1932,20 @@ export declare class ItemsClient extends BaseServiceClient {
         }>;
     };
     /**
-     * Health monitoring endpoints
-     * @description Service health monitoring and connectivity testing
+     * Health check endpoint - Direct path mapping to /health-check
+     * @description OpenAPI Path Mirroring: /health-check → healthCheck.get()
      */
-    health: {
+    healthCheck: {
         /**
          * Service health check
          * @description Verify service health and trigger seed jobs if needed
-         * @fullPath api.items.health.check
+         * @fullPath api.items.healthCheck.get
          * @service items
          * @domain system-health
-         * @dataMethod healthData.check
+         * @dataMethod healthCheckData.get
          * @discoverable true
          * @searchTerms ["health check", "service status", "system health", "service monitoring"]
-         * @relatedEndpoints ["api.joomla.health.check", "api.nexus.health.check", "api.commerce.health.check"]
+         * @relatedEndpoints ["api.joomla.healthCheck.get", "api.nexus.healthCheck.get", "api.commerce.healthCheck.get"]
          * @commonPatterns ["Check service health", "Monitor system status", "Verify connectivity"]
          * @workflow ["service-monitoring", "health-verification", "system-diagnostics"]
          * @prerequisites ["Valid authentication token", "System monitoring permissions"]
@@ -1270,12 +1958,12 @@ export declare class ItemsClient extends BaseServiceClient {
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const health = await client.health.check();
+         * const health = await client.healthCheck.get();
          * console.log('Site ID:', health.data.siteId);
          * console.log('Site Hash:', health.data.siteHash);
          * ```
          */
-        check: () => Promise<{
+        get: () => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 siteHash: string;
@@ -1288,20 +1976,26 @@ export declare class ItemsClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+    };
+    /**
+     * Ping endpoint - Direct path mapping to /ping
+     * @description OpenAPI Path Mirroring: /ping → ping.get()
+     */
+    ping: {
         /**
          * Simple connectivity test
          * @description Simple connectivity test endpoint (no authentication required)
-         * @fullPath api.items.health.ping
+         * @fullPath api.items.ping.get
          * @service items
          * @domain system-health
-         * @dataMethod healthData.ping
+         * @dataMethod pingData.get
          * @discoverable true
          * @searchTerms ["ping", "connectivity test", "service alive", "basic health"]
-         * @relatedEndpoints ["api.joomla.health.ping", "api.nexus.health.ping", "api.commerce.health.ping"]
+         * @relatedEndpoints ["api.joomla.ping.get", "api.nexus.ping.get", "api.commerce.ping.get"]
          * @commonPatterns ["Test connectivity", "Basic health check", "Service alive check"]
          * @workflow ["connectivity-verification", "basic-monitoring"]
          * @prerequisites ["Network connectivity"]
-         * @nextSteps ["api.items.health.check for full health verification"]
+         * @nextSteps ["api.items.healthCheck.get for full health verification"]
          * @businessRules ["No authentication required", "Always returns 'pong'", "Minimal resource usage"]
          * @functionalArea "basic-connectivity-testing"
          * @caching "No caching, real-time response"
@@ -1310,264 +2004,152 @@ export declare class ItemsClient extends BaseServiceClient {
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const pong = await client.health.ping();
+         * const pong = await client.ping.get();
          * console.log(pong.data); // "pong"
          * ```
          */
-        ping: () => Promise<PingResponse>;
+        get: () => Promise<PingResponse>;
     };
     /**
-     * Health monitoring data-only endpoints
-     * @description Data-only methods that return just the data portion of health responses
+     * Health check data-only endpoints
+     * @description Data-only methods that return just the data portion of health check responses
      */
-    healthData: {
+    healthCheckData: {
         /**
          * Service health check data only
          * @description Returns only the data portion of health check response
-         * @fullPath api.items.healthData.check
+         * @fullPath api.items.healthCheckData.get
          * @service items
          * @domain system-health
          * @discoverable true
          * @searchTerms ["health data", "service status data", "health check data only"]
-         * @relatedEndpoints ["api.items.health.check"]
+         * @relatedEndpoints ["api.items.healthCheck.get"]
          * @commonPatterns ["Get health status without metadata"]
          * @returns Health check data only
          */
-        check: () => Promise<{
+        get: () => Promise<{
             siteHash: string;
             siteId: string;
         }>;
+    };
+    /**
+     * Ping data-only endpoints
+     * @description Data-only methods that return just the data portion of ping responses
+     */
+    pingData: {
         /**
          * Simple connectivity test data only
          * @description Returns only the data portion of ping response
-         * @fullPath api.items.healthData.ping
+         * @fullPath api.items.pingData.get
          * @service items
          * @domain system-health
          * @discoverable true
          * @searchTerms ["ping data", "connectivity data", "service alive data"]
-         * @relatedEndpoints ["api.items.health.ping"]
+         * @relatedEndpoints ["api.items.ping.get"]
          * @commonPatterns ["Test connectivity without metadata"]
          * @returns Ping data only
          */
-        ping: () => Promise<"pong">;
+        get: () => Promise<"pong">;
     };
     /**
-     * Item favorites management endpoints
-     * @description Methods for managing user favorite items
+     * Internal endpoints - Direct path mapping to /internal/*
+     * @description OpenAPI Path Mirroring: /internal/* → internal.*
      */
-    itemFavorites: {
+    internal: {
         /**
-         * List user's favorite items
-         * @description Retrieve a list of the current user's favorite items
-         * @fullPath api.items.itemFavorites.list
-         * @service items
-         * @domain user-preferences
-         * @dataMethod itemFavoritesData.list
-         * @discoverable true
-         * @searchTerms ["favorites", "user favorites", "liked items", "bookmarked items", "favorite products"]
-         * @relatedEndpoints ["api.items.itemWishlist.list", "api.customers.users.preferences"]
-         * @commonPatterns ["Show user favorites", "Manage favorite items", "User preference management"]
-         * @workflow ["user-preferences", "favorites-management"]
-         * @prerequisites ["Valid authentication token", "User context"]
-         * @nextSteps ["api.items.invMast.get for product details", "api.commerce.cartHeaders.addItem for adding to cart"]
-         * @businessRules ["Shows only current user's favorites", "Respects product visibility", "Returns active favorites only"]
-         * @functionalArea "user-preference-management"
-         * @caching "Cache for 5 minutes, invalidate on favorites changes"
-         * @performance "Paginated results for large favorite lists"
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of user's favorite items
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const favorites = await client.itemFavorites.list({ limit: 20 });
-         * favorites.data.forEach(fav => {
-         *   console.log(`Favorite: ${fav.itemDesc} (${fav.itemId})`);
-         * });
-         * ```
-         */
-        list: (params?: ItemFavoritesListParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                usersId: number;
-                itemFavoritesUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Add item to favorites
-         * @description Add an item to the current user's favorites
-         * @param request Favorite item creation data
-         * @returns Created favorite item information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const favorite = await client.itemFavorites.create({
-         *   invMastUid: 12345,
-         *   itemNote: 'Great product for my projects'
-         * });
-         * ```
-         */
-        create: (data: {
-            invMastUid: number;
-            itemNote?: string | undefined;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                usersId: number;
-                itemFavoritesUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Remove item from favorites
-         * @description Remove an item from the current user's favorites
-         * @param favoriteUid Favorite item unique identifier
-         * @returns Success response
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * await client.itemFavorites.delete(123);
-         * ```
-         */
-        delete: (id: string | number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                usersId: number;
-                itemFavoritesUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Update favorite item
-         * @description Update a favorite item's information
-         * @param favoriteUid Favorite item unique identifier
-         * @param request Update data
-         * @returns Updated favorite item information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const updated = await client.itemFavorites.update(123, {
-         *   itemNote: 'Updated note about this favorite item'
-         * });
-         * ```
+         * PDF generation endpoints - Direct path mapping to /internal/pdf
+         * @description OpenAPI Path Mirroring: /internal/pdf → internal.pdf.create()
          */
-        update: (id: string | number, data: {
-            itemNote?: string | undefined;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                usersId: number;
-                itemFavoritesUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        pdf: {
+            /**
+             * Create internal PDF
+             * @description Generate internal PDF documents
+             * @fullPath api.items.internal.pdf.create
+             * @service items
+             * @domain document-generation
+             * @dataMethod internalPdfData.create
+             * @discoverable true
+             * @searchTerms ["pdf generation", "internal pdf", "document creation", "pdf templates"]
+             * @relatedEndpoints ["api.joomla.internal.pdf.create", "api.nexus.internal.pdf.create"]
+             * @commonPatterns ["Generate PDF documents", "Create reports", "Export data to PDF"]
+             * @workflow ["document-generation", "report-creation"]
+             * @prerequisites ["Valid authentication token", "Document generation permissions"]
+             * @nextSteps ["Download generated PDF", "Store PDF reference"]
+             * @businessRules ["Template must exist", "Data structure must match template requirements"]
+             * @functionalArea "document-and-report-generation"
+             * @caching "No caching, dynamic generation"
+             * @performance "PDF generation can take 1-5 seconds depending on complexity"
+             * @param request PDF generation parameters
+             * @returns PDF generation result
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const pdf = await client.internal.pdf.create({
+             *   templateId: 'invoice',
+             *   data: { orderId: 12345 }
+             * });
+             * console.log('PDF URL:', pdf.data.pdfUrl);
+             * ```
+             */
+            create: (request: CreateInternalPdfRequest) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    documentType: string;
+                    pdfId: string;
+                    fileName: string;
+                    fileSize: number;
+                    downloadUrl: string;
+                    createdAt: string;
+                    expiresAt?: string | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
     };
     /**
-     * Item favorites data-only endpoints
-     * @description Data-only methods that return just the data portion of favorites responses
+     * Legacy itemFavorites removed - now using OpenAPI Path Mirroring Pattern
+     * @see itemFavorites implementation below that follows /item-favorites/{usersId} structure
      */
-    itemFavoritesData: {
-        /**
-         * List user's favorite items data only
-         * @description Returns only the data portion of favorites list response
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of favorite items data
-         */
-        list: (params?: ItemFavoritesListParams) => Promise<{
-            invMastUid: number;
-            itemId: string;
-            usersId: number;
-            itemFavoritesUid: number;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            itemDesc?: string | undefined;
-            createdBy?: string | undefined;
-            lastMaintainedBy?: string | undefined;
-        }[]>;
-    };
     /**
      * Item wishlists management endpoints
      * @description Methods for managing user wishlists and wishlist items
      */
     itemWishlist: {
         /**
-         * List user's wishlists
-         * @description Retrieve a list of the current user's wishlists
-         * @fullPath api.items.itemWishlist.list
+         * Get user's wishlists
+         * @description Retrieve wishlists for a specific user (OpenAPI: /item-wishlist/{usersId})
+         * @fullPath api.items.itemWishlist.get
          * @service items
          * @domain user-preferences
-         * @dataMethod itemWishlistData.list
+         * @dataMethod itemWishlistData.get
          * @discoverable true
-         * @searchTerms ["wishlists", "user wishlists", "shopping lists", "saved lists", "wishlist management"]
-         * @relatedEndpoints ["api.items.itemFavorites.list", "api.commerce.cartHeaders.list"]
-         * @commonPatterns ["Show user wishlists", "Manage wishlist collections", "Shopping list management"]
+         * @searchTerms ["wishlists", "user wishlists", "shopping lists", "user lists"]
+         * @relatedEndpoints ["api.items.itemFavorites.list", "api.items.itemWishlist.hdr.get"]
+         * @commonPatterns ["Get user wishlists", "Wishlist management by user"]
          * @workflow ["user-preferences", "wishlist-management"]
          * @prerequisites ["Valid authentication token", "User context"]
-         * @nextSteps ["api.items.itemWishlist.getLines for wishlist items", "api.commerce.cartHeaders.create for converting to cart"]
-         * @businessRules ["Shows only current user's wishlists", "Includes public wishlists if shared", "Returns active wishlists only"]
+         * @nextSteps ["api.items.itemWishlist.hdr.get for specific wishlist", "api.items.itemWishlist.hdr.line.get for line items"]
+         * @businessRules ["Shows wishlists for specified user", "Includes accessible wishlists only"]
          * @functionalArea "user-preference-management"
          * @caching "Cache for 5 minutes, invalidate on wishlist changes"
-         * @performance "Paginated results for large wishlist collections"
-         * @param params Optional filtering and pagination parameters
+         * @performance "Returns all wishlists for user"
+         * @param usersId User unique identifier
          * @returns Array of user's wishlists
          * @throws ValidationError When parameters are invalid or response is malformed
          * @example
          * ```typescript
-         * const wishlists = await client.itemWishlist.list({ limit: 10 });
+         * const wishlists = await client.itemWishlist.get(12345);
          * wishlists.data.forEach(list => {
          *   console.log(`Wishlist: ${list.wishlistName} (${list.wishlistDescription})`);
          * });
          * ```
          */
-        list: (params?: ItemWishlistListParams) => Promise<{
+        get: (usersId: number) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 usersId: number;
@@ -1589,130 +2171,22 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Get wishlist details
-         * @description Retrieve details for a specific wishlist
-         * @param wishlistUid Wishlist unique identifier
-         * @returns Wishlist details
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const wishlist = await client.itemWishlist.get(123);
-         * console.log(wishlist.data.wishlistName, wishlist.data.wishlistDescription);
-         * ```
-         */
-        get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                usersId: number;
-                itemWishlistHdrUid: number;
-                wishlistName: string;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                wishlistDescription?: string | undefined;
-                isPublic?: string | undefined;
-                shareCode?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Create new wishlist
-         * @description Create a new wishlist for the current user
+         * Create new wishlist for user
+         * @description Create a new wishlist for a specific user (OpenAPI: /item-wishlist/{usersId})
+         * @param usersId User unique identifier
          * @param request Wishlist creation data
          * @returns Created wishlist information
          * @throws ValidationError When request is invalid or response is malformed
          * @example
          * ```typescript
-         * const wishlist = await client.itemWishlist.create({
+         * const wishlist = await client.itemWishlist.create(12345, {
          *   wishlistName: 'Home Office Setup',
          *   wishlistDescription: 'Items for my home office renovation',
          *   isPublic: 'N'
          * });
          * ```
          */
-        create: (data: {
-            wishlistName: string;
-            wishlistDescription?: string | undefined;
-            isPublic?: string | undefined;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                usersId: number;
-                itemWishlistHdrUid: number;
-                wishlistName: string;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                wishlistDescription?: string | undefined;
-                isPublic?: string | undefined;
-                shareCode?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Update wishlist
-         * @description Update a wishlist's information
-         * @param wishlistUid Wishlist unique identifier
-         * @param request Update data
-         * @returns Updated wishlist information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const updated = await client.itemWishlist.update(123, {
-         *   wishlistName: 'Updated Office Setup',
-         *   wishlistDescription: 'Updated description for my office items'
-         * });
-         * ```
-         */
-        update: (id: string | number, data: {
-            wishlistName?: string | undefined;
-            wishlistDescription?: string | undefined;
-            isPublic?: string | undefined;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                usersId: number;
-                itemWishlistHdrUid: number;
-                wishlistName: string;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                wishlistDescription?: string | undefined;
-                isPublic?: string | undefined;
-                shareCode?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Delete wishlist
-         * @description Delete a wishlist and all its items
-         * @param wishlistUid Wishlist unique identifier
-         * @returns Success response
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * await client.itemWishlist.delete(123);
-         * ```
-         */
-        delete: (id: string | number) => Promise<{
+        create: (usersId: number, request: CreateItemWishlistHeaderRequest) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 usersId: number;
@@ -1734,360 +2208,69 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Get wishlist items
-         * @description Retrieve items in a specific wishlist
-         * @param wishlistUid Wishlist unique identifier
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of wishlist items
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const items = await client.itemWishlist.getLines(123, { limit: 20 });
-         * items.data.forEach(item => {
-         *   console.log(`${item.itemDesc} - Qty: ${item.qtyDesired}, Priority: ${item.priority}`);
-         * });
-         * ```
+         * Wishlist header management endpoints
+         * @description Methods for managing specific wishlist headers (OpenAPI: /item-wishlist/{usersId}/hdr/{itemWishlistHdrUid})
          */
-        getLines: (wishlistUid: number, params?: ItemWishlistLineListParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                itemWishlistHdrUid: number;
-                itemWishlistLineUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                notes?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                qtyDesired?: number | undefined;
-                priority?: number | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Add item to wishlist
-         * @description Add an item to a specific wishlist
-         * @param wishlistUid Wishlist unique identifier
-         * @param request Wishlist item creation data
-         * @returns Created wishlist item information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const item = await client.itemWishlist.addLine(123, {
-         *   invMastUid: 12345,
-         *   qtyDesired: 2,
-         *   priority: 1,
-         *   notes: 'Need this for the new office setup'
-         * });
-         * ```
-         */
-        addLine: (wishlistUid: number, request: CreateItemWishlistLineRequest) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                itemWishlistHdrUid: number;
-                itemWishlistLineUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                notes?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                qtyDesired?: number | undefined;
-                priority?: number | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Update wishlist item
-         * @description Update an item in a wishlist
-         * @param wishlistUid Wishlist unique identifier
-         * @param lineUid Wishlist line unique identifier
-         * @param request Update data
-         * @returns Updated wishlist item information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const updated = await client.itemWishlist.updateLine(123, 456, {
-         *   qtyDesired: 3,
-         *   priority: 2,
-         *   notes: 'Updated quantity needed'
-         * });
-         * ```
-         */
-        updateLine: (wishlistUid: number, lineUid: number, request: UpdateItemWishlistLineRequest) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                itemWishlistHdrUid: number;
-                itemWishlistLineUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                notes?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                qtyDesired?: number | undefined;
-                priority?: number | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Remove item from wishlist
-         * @description Remove an item from a wishlist
-         * @param wishlistUid Wishlist unique identifier
-         * @param lineUid Wishlist line unique identifier
-         * @returns Success response
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * await client.itemWishlist.deleteLine(123, 456);
-         * ```
-         */
-        deleteLine: (wishlistUid: number, lineUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                itemWishlistHdrUid: number;
-                itemWishlistLineUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                notes?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                qtyDesired?: number | undefined;
-                priority?: number | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-    };
-    /**
-     * Item wishlists data-only endpoints
-     * @description Data-only methods that return just the data portion of wishlists responses
-     */
-    itemWishlistData: {
-        /**
-         * List user's wishlists data only
-         * @description Returns only the data portion of wishlists list response
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of wishlists data
-         */
-        list: (params?: ItemWishlistListParams) => Promise<{
-            usersId: number;
-            itemWishlistHdrUid: number;
-            wishlistName: string;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            createdBy?: string | undefined;
-            lastMaintainedBy?: string | undefined;
-            wishlistDescription?: string | undefined;
-            isPublic?: string | undefined;
-            shareCode?: string | undefined;
-        }[]>;
-        /**
-         * Get wishlist items data only
-         * @description Returns only the data portion of wishlist items response
-         * @param wishlistUid Wishlist unique identifier
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of wishlist items data
-         */
-        getLines: (wishlistUid: number, params?: ItemWishlistLineListParams) => Promise<{
-            invMastUid: number;
-            itemId: string;
-            itemWishlistHdrUid: number;
-            itemWishlistLineUid: number;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            notes?: string | undefined;
-            itemDesc?: string | undefined;
-            createdBy?: string | undefined;
-            lastMaintainedBy?: string | undefined;
-            qtyDesired?: number | undefined;
-            priority?: number | undefined;
-        }[]>;
-    };
-    /**
-     * Item category management endpoints
-     * @description Methods for managing item categories following OpenAPI path mirroring pattern
-     */
-    itemCategory: {
-        /**
-         * List item categories
-         * @description Retrieve a list of item categories
-         * @fullPath api.items.itemCategory.list
-         * @service items
-         * @domain product-catalog
-         * @dataMethod itemCategoryData.list
-         * @discoverable true
-         * @searchTerms ["categories", "item categories", "product categories", "category management"]
-         * @relatedEndpoints ["api.items.invMast.list", "api.items.attributes.list"]
-         * @commonPatterns ["Show categories", "Manage category structure", "Category navigation"]
-         * @workflow ["product-catalog-management", "category-management"]
-         * @prerequisites ["Valid authentication token", "Catalog permissions"]
-         * @nextSteps ["api.items.itemCategory.get for category details", "api.items.invMast.list for category products"]
-         * @businessRules ["Shows active categories only", "Respects category hierarchy", "Returns visible categories"]
-         * @functionalArea "product-catalog-management"
-         * @caching "Cache for 30 minutes, invalidate on category changes"
-         * @performance "Paginated results for large category trees"
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of item categories
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const categories = await client.itemCategory.list({ parentUid: 100 });
-         * categories.data.forEach(cat => {
-         *   console.log(`Category: ${cat.itemCategoryDesc} (${cat.path})`);
-         * });
-         * ```
-         */
-        list: (params?: CategoryListParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            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;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Get item category details
-         * @description Retrieve detailed information about a specific item category
-         * @fullPath api.items.itemCategory.get
-         * @service items
-         * @domain product-catalog
-         * @dataMethod itemCategoryData.get
-         * @discoverable true
-         * @searchTerms ["category details", "category info", "category data"]
-         * @relatedEndpoints ["api.items.itemCategory.list", "api.items.invMast.list"]
-         * @commonPatterns ["Show category details", "Category information lookup"]
-         * @param itemCategoryUid Category unique identifier
-         * @param params Optional query parameters
-         * @returns Category details
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const category = await client.itemCategory.get(123);
-         * console.log(category.data.itemCategoryDesc, category.data.path);
-         * ```
-         */
-        get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            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;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Get category documentation
-         * @description Retrieve documentation for a specific item category
-         * @fullPath api.items.itemCategory.doc.get
-         * @service items
-         * @domain product-catalog
-         * @discoverable true
-         * @searchTerms ["category documentation", "category docs", "category help"]
-         * @relatedEndpoints ["api.items.itemCategory.get", "api.items.itemCategory.list"]
-         * @commonPatterns ["Show category documentation", "Category help content"]
-         * @param itemCategoryUid Category unique identifier
-         * @returns Category documentation
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const docs = await client.itemCategory.doc.get(123);
-         * console.log(docs.data.documentationContent);
-         * ```
-         */
-        doc: {
-            get: (itemCategoryUid: number) => Promise<{
+        hdr: {
+            /**
+             * Get wishlist header details
+             * @description Retrieve details for a specific wishlist header
+             * @fullPath api.items.itemWishlist.hdr.get
+             * @service items
+             * @domain user-preferences
+             * @param usersId User unique identifier
+             * @param itemWishlistHdrUid Wishlist header unique identifier
+             * @returns Wishlist header details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const wishlist = await client.itemWishlist.hdr.get(12345, 678);
+             * console.log(wishlist.data.wishlistName);
+             * ```
+             */
+            get: (usersId: number, itemWishlistHdrUid: number) => Promise<{
                 params: Record<string, unknown> | unknown[];
                 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;
+                    usersId: number;
+                    itemWishlistHdrUid: number;
+                    wishlistName: string;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    createdBy?: string | undefined;
+                    lastMaintainedBy?: string | undefined;
+                    wishlistDescription?: string | undefined;
+                    isPublic?: string | undefined;
+                    shareCode?: string | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Create wishlist header
+             * @description Create a new wishlist header
+             * @param usersId User unique identifier
+             * @param itemWishlistHdrUid Wishlist header unique identifier
+             * @param request Wishlist header creation data
+             * @returns Created wishlist header information
+             * @throws ValidationError When request is invalid or response is malformed
+             */
+            create: (usersId: number, itemWishlistHdrUid: number, request: CreateItemWishlistHeaderRequest) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    usersId: number;
+                    itemWishlistHdrUid: number;
+                    wishlistName: string;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    createdBy?: string | undefined;
+                    lastMaintainedBy?: string | undefined;
+                    wishlistDescription?: string | undefined;
+                    isPublic?: string | undefined;
+                    shareCode?: string | undefined;
                 };
                 options: Record<string, unknown> | unknown[];
                 status: number;
@@ -2096,116 +2279,115 @@ export declare class ItemsClient extends BaseServiceClient {
                 total: number;
                 totalResults: number;
             }>;
+            /**
+             * Wishlist line management endpoints
+             * @description Methods for managing specific wishlist line items
+             */
+            line: {
+                /**
+                 * Get wishlist line details
+                 * @description Retrieve details for a specific wishlist line item
+                 * @fullPath api.items.itemWishlist.hdr.line.get
+                 * @service items
+                 * @domain user-preferences
+                 * @param usersId User unique identifier
+                 * @param itemWishlistHdrUid Wishlist header unique identifier
+                 * @param itemWishlistLineUid Wishlist line unique identifier
+                 * @returns Wishlist line details
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * const line = await client.itemWishlist.hdr.line.get(12345, 678, 901);
+                 * console.log(`Item: ${line.data.itemDesc}, Qty: ${line.data.qtyDesired}`);
+                 * ```
+                 */
+                get: (usersId: number, itemWishlistHdrUid: number, itemWishlistLineUid: number) => Promise<{
+                    params: Record<string, unknown> | unknown[];
+                    data: {
+                        invMastUid: number;
+                        itemId: string;
+                        itemWishlistHdrUid: number;
+                        itemWishlistLineUid: number;
+                        dateCreated?: string | undefined;
+                        dateLastModified?: string | undefined;
+                        notes?: string | undefined;
+                        itemDesc?: string | undefined;
+                        createdBy?: string | undefined;
+                        lastMaintainedBy?: string | undefined;
+                        qtyDesired?: number | undefined;
+                        priority?: number | undefined;
+                    };
+                    options: Record<string, unknown> | unknown[];
+                    status: number;
+                    message: string;
+                    count: number;
+                    total: number;
+                    totalResults: number;
+                }>;
+                /**
+                 * Delete wishlist line item
+                 * @description Remove a specific item from a wishlist
+                 * @fullPath api.items.itemWishlist.hdr.line.delete
+                 * @service items
+                 * @domain user-preferences
+                 * @dataMethod itemWishlistData.hdr.line.delete
+                 * @discoverable true
+                 * @searchTerms ["delete wishlist item", "remove wishlist item", "wishlist line deletion"]
+                 * @relatedEndpoints ["api.items.itemWishlist.hdr.line.get", "api.items.itemWishlist.hdr.get"]
+                 * @commonPatterns ["Remove item from wishlist", "Clean up wishlist"]
+                 * @workflow ["user-preferences", "wishlist-maintenance"]
+                 * @prerequisites ["Valid authentication token", "User context", "Line item must exist"]
+                 * @nextSteps ["Verify deletion", "Update wishlist display"]
+                 * @businessRules ["Removes specific line item only", "Does not affect other wishlist items"]
+                 * @functionalArea "user-preference-management"
+                 * @caching "Invalidates wishlist cache"
+                 * @performance "Direct deletion operation"
+                 * @param usersId User unique identifier
+                 * @param itemWishlistHdrUid Wishlist header unique identifier
+                 * @param itemWishlistLineUid Wishlist line unique identifier
+                 * @returns Success status
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * await client.itemWishlist.hdr.line.delete(12345, 678, 901);
+                 * ```
+                 */
+                delete: (usersId: number, itemWishlistHdrUid: number, itemWishlistLineUid: number) => Promise<{
+                    status: number;
+                    message: string;
+                    count: number;
+                    total: number;
+                    totalResults: number;
+                    params?: any;
+                    data?: any;
+                    options?: any;
+                }>;
+            };
         };
-        /**
-         * Category lookup
-         * @description Lookup categories by various criteria
-         * @fullPath api.items.itemCategory.lookup
-         * @service items
-         * @domain product-catalog
-         * @discoverable true
-         * @searchTerms ["category lookup", "find categories", "category search"]
-         * @relatedEndpoints ["api.items.itemCategory.list", "api.items.itemCategory.get"]
-         * @commonPatterns ["Find categories", "Category search", "Category filtering"]
-         * @param params Lookup criteria
-         * @returns Matching categories
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const categories = await client.itemCategory.lookup({
-         *   categoryPath: '/Electronics/Components'
-         * });
-         * ```
-         */
-        lookup: (params?: CategoryLookupParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            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;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
     };
     /**
-     * Item category data-only endpoints
-     * @description Data-only methods that return just the data portion of category responses
+     * Item wishlists data-only endpoints
+     * @description Data-only methods that return just the data portion of wishlists responses
      */
-    itemCategoryData: {
-        /**
-         * List item categories data only
-         * @description Returns only the data portion of categories list response
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of category data
-         */
-        list: (params?: CategoryListParams) => Promise<{
-            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;
-        }[]>;
+    itemWishlistData: {
         /**
-         * Get item category details data only
-         * @description Returns only the data portion of category details response
-         * @param itemCategoryUid Category unique identifier
-         * @param params Optional query parameters
-         * @returns Category data
+         * Get user's wishlists data only
+         * @description Returns only the data portion of user wishlists response
+         * @param usersId User unique identifier
+         * @returns Array of wishlists data
          */
-        get: (itemCategoryUid: number) => Promise<{
-            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;
-        }>;
+        get: (usersId: number) => Promise<{
+            usersId: number;
+            itemWishlistHdrUid: number;
+            wishlistName: string;
+            dateCreated?: string | undefined;
+            dateLastModified?: string | undefined;
+            createdBy?: string | undefined;
+            lastMaintainedBy?: string | undefined;
+            wishlistDescription?: string | undefined;
+            isPublic?: string | undefined;
+            shareCode?: string | undefined;
+        }[]>;
     };
     /**
      * Product variants management endpoints
@@ -2931,248 +3113,6 @@ export declare class ItemsClient extends BaseServiceClient {
             helpfulCount?: number | undefined;
         }[]>;
     };
-    /**
-     * Brand-item relationship management endpoints
-     * @description Methods for managing relationships between brands and items
-     */
-    brandItems: {
-        /**
-         * List brand-item relationships
-         * @description Retrieve brand-item relationships for a specific brand
-         * @fullPath api.items.brandItems.list
-         * @service items
-         * @domain product-catalog
-         * @dataMethod brandItemsData.list
-         * @discoverable true
-         * @searchTerms ["brand items", "brand products", "brand relationships", "manufacturer items", "brand catalog"]
-         * @relatedEndpoints ["api.items.brands.list", "api.items.products.get"]
-         * @commonPatterns ["Show brand products", "Manage brand relationships", "Brand catalog management"]
-         * @workflow ["product-catalog-management", "brand-management"]
-         * @prerequisites ["Valid authentication token", "Brand management permissions"]
-         * @nextSteps ["api.items.products.get for product details", "api.items.brands.get for brand details"]
-         * @businessRules ["Shows active relationships only", "Respects product visibility", "Primary brand identification"]
-         * @functionalArea "product-catalog-management"
-         * @caching "Cache for 20 minutes, invalidate on relationship changes"
-         * @performance "Paginated results for brands with many products"
-         * @param brandUid Brand unique identifier
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of brand-item relationships
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const brandItems = await client.brandItems.list(123, { isPrimary: 'Y' });
-         * brandItems.data.forEach(item => {
-         *   console.log(`${item.itemDesc} - Brand Part: ${item.brandPartNumber}`);
-         * });
-         * ```
-         */
-        list: (brandUid: number, params?: BrandItemListParams) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                brandUid: number;
-                brandItemUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                isActive?: string | undefined;
-                brandPartNumber?: string | undefined;
-                brandItemDesc?: string | undefined;
-                isPrimary?: string | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Get brand-item relationship details
-         * @description Retrieve details for a specific brand-item relationship
-         * @param brandUid Brand unique identifier
-         * @param brandItemUid Brand-item relationship unique identifier
-         * @returns Brand-item relationship details
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const relationship = await client.brandItems.get(123, 456);
-         * console.log(relationship.data.brandPartNumber, relationship.data.brandItemDesc);
-         * ```
-         */
-        get: (brandUid: number, brandItemUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                brandUid: number;
-                brandItemUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                isActive?: string | undefined;
-                brandPartNumber?: string | undefined;
-                brandItemDesc?: string | undefined;
-                isPrimary?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Create brand-item relationship
-         * @description Create a new relationship between a brand and an item
-         * @param brandUid Brand unique identifier
-         * @param request Brand-item relationship creation data
-         * @returns Created relationship information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const relationship = await client.brandItems.create(123, {
-         *   invMastUid: 12345,
-         *   brandPartNumber: 'BRD-001',
-         *   brandItemDesc: 'Brand-specific description',
-         *   isPrimary: 'Y'
-         * });
-         * ```
-         */
-        create: (brandUid: number, request: CreateBrandItemRequest) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                brandUid: number;
-                brandItemUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                isActive?: string | undefined;
-                brandPartNumber?: string | undefined;
-                brandItemDesc?: string | undefined;
-                isPrimary?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Update brand-item relationship
-         * @description Update an existing brand-item relationship
-         * @param brandUid Brand unique identifier
-         * @param brandItemUid Brand-item relationship unique identifier
-         * @param request Update data
-         * @returns Updated relationship information
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const updated = await client.brandItems.update(123, 456, {
-         *   brandPartNumber: 'BRD-001-V2',
-         *   brandItemDesc: 'Updated brand-specific description'
-         * });
-         * ```
-         */
-        update: (brandUid: number, brandItemUid: number, request: UpdateBrandItemRequest) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                brandUid: number;
-                brandItemUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                isActive?: string | undefined;
-                brandPartNumber?: string | undefined;
-                brandItemDesc?: string | undefined;
-                isPrimary?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Delete brand-item relationship
-         * @description Remove a relationship between a brand and an item
-         * @param brandUid Brand unique identifier
-         * @param brandItemUid Brand-item relationship unique identifier
-         * @returns Success response
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * await client.brandItems.delete(123, 456);
-         * ```
-         */
-        delete: (brandUid: number, brandItemUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                invMastUid: number;
-                itemId: string;
-                brandUid: number;
-                brandItemUid: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                itemDesc?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                isActive?: string | undefined;
-                brandPartNumber?: string | undefined;
-                brandItemDesc?: string | undefined;
-                isPrimary?: string | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-    };
-    /**
-     * Brand-item relationship data-only endpoints
-     * @description Data-only methods that return just the data portion of brand-item responses
-     */
-    brandItemsData: {
-        /**
-         * List brand-item relationships data only
-         * @description Returns only the data portion of brand-item relationships response
-         * @param brandUid Brand unique identifier
-         * @param params Optional filtering and pagination parameters
-         * @returns Array of brand-item relationships data
-         */
-        list: (brandUid: number, params?: BrandItemListParams) => Promise<{
-            invMastUid: number;
-            itemId: string;
-            brandUid: number;
-            brandItemUid: number;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            itemDesc?: string | undefined;
-            createdBy?: string | undefined;
-            lastMaintainedBy?: string | undefined;
-            isActive?: string | undefined;
-            brandPartNumber?: string | undefined;
-            brandItemDesc?: string | undefined;
-            isPrimary?: string | undefined;
-        }[]>;
-    };
     /**
      * Product links management endpoints
      * @description Methods for managing relationships between products (accessories, related items, etc.)
@@ -3687,54 +3627,39 @@ export declare class ItemsClient extends BaseServiceClient {
          */
         bins: {
             /**
-             * List location bins
-             * @description Retrieve bins for a specific location
+             * List all items in bins at a location
+             * @description OpenAPI: /locations/{locationId}/bins - "List all items in bins at a location"
              * @fullPath api.items.locations.bins.list
              * @service items
              * @domain inventory-management
-             * @dataMethod locationsData.bins.list
-             * @discoverable true
-             * @searchTerms ["bins", "warehouse bins", "location bins", "storage bins", "inventory locations"]
-             * @relatedEndpoints ["api.nexus.inventory.locations", "api.items.stock.getDetails"]
-             * @commonPatterns ["Warehouse management", "Inventory location tracking", "Bin organization"]
-             * @workflow ["inventory-management", "warehouse-operations"]
-             * @prerequisites ["Valid authentication token", "Warehouse access permissions"]
-             * @nextSteps ["api.items.bins.getInventory for stock levels", "api.nexus.inventory.movements for movements"]
-             * @businessRules ["Shows active bins only", "Location-specific access", "Capacity tracking"]
-             * @functionalArea "warehouse-and-inventory-management"
-             * @caching "Cache for 10 minutes, invalidate on bin changes"
-             * @performance "Paginated results for locations with many bins"
              * @param locationId Location unique identifier
-             * @param params Optional filtering and pagination parameters
-             * @returns Array of location bins
-             * @throws ValidationError When parameters are invalid or response is malformed
+             * @param params Optional filtering parameters (excludeZero, bin filter, pagination)
+             * @returns Array of inventory items in bins at the location
              * @example
              * ```typescript
-             * const bins = await client.locations.bins.list(123, { zone: 'A', isActive: 'Y' });
-             * bins.data.forEach(bin => {
-             *   console.log(`${bin.bin} - ${bin.binDesc} (${bin.zone}-${bin.aisle}-${bin.shelf})`);
+             * const items = await client.locations.bins.list(123);
+             * items.data.forEach(item => {
+             *   console.log(`${item.bin}: ${item.itemId} (${item.qtyOnHand})`);
              * });
              * ```
              */
-            list: (locationId: number, params?: BinListParams) => Promise<{
+            list: (locationId: number, params?: LocationsBinsParams) => Promise<{
                 params: Record<string, unknown> | unknown[];
                 data: {
+                    invMastUid: number;
+                    itemId: string;
                     locationId: number;
                     bin: string;
+                    qtyOnHand: number;
                     binUid: number;
+                    invLocBinUid: number;
                     dateCreated?: string | undefined;
                     dateLastModified?: string | undefined;
-                    createdBy?: string | undefined;
-                    lastMaintainedBy?: string | undefined;
-                    isActive?: string | undefined;
-                    binDesc?: string | undefined;
-                    binType?: string | undefined;
-                    maxCapacity?: number | undefined;
-                    currentCapacity?: number | undefined;
-                    zone?: string | undefined;
-                    aisle?: string | undefined;
-                    shelf?: string | undefined;
-                    position?: string | undefined;
+                    qtyAllocated?: number | undefined;
+                    qtyAvailable?: number | undefined;
+                    unitCost?: number | undefined;
+                    lastCountDate?: string | undefined;
+                    lastMovementDate?: string | undefined;
                 }[];
                 options: Record<string, unknown> | unknown[];
                 status: number;
@@ -3744,45 +3669,54 @@ export declare class ItemsClient extends BaseServiceClient {
                 totalResults: number;
             }>;
             /**
-             * Get bin details
-             * @description Retrieve details for a specific bin
-             * @param locationId Location unique identifier
-             * @param bin Bin identifier
-             * @returns Bin details
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const binDetails = await client.bins.get(123, 'A01-B02-S03');
-             * console.log(binDetails.data.binDesc, binDetails.data.maxCapacity);
-             * ```
+             * Specific bin endpoints
+             * @description Methods for accessing specific bins by identifier
              */
-            get: (locationId: number, bin: string) => Promise<{
-                params: Record<string, unknown> | unknown[];
-                data: {
-                    locationId: number;
-                    bin: string;
-                    binUid: number;
-                    dateCreated?: string | undefined;
-                    dateLastModified?: string | undefined;
-                    createdBy?: string | undefined;
-                    lastMaintainedBy?: string | undefined;
-                    isActive?: string | undefined;
-                    binDesc?: string | undefined;
-                    binType?: string | undefined;
-                    maxCapacity?: number | undefined;
-                    currentCapacity?: number | undefined;
-                    zone?: string | undefined;
-                    aisle?: string | undefined;
-                    shelf?: string | undefined;
-                    position?: string | undefined;
-                };
-                options: Record<string, unknown> | unknown[];
-                status: number;
-                message: string;
-                count: number;
-                total: number;
-                totalResults: number;
-            }>;
+            bin: {
+                /**
+                 * List all items in a specific bin
+                 * @description OpenAPI: /locations/{locationId}/bins/{bin} - "List all items in a specific bin"
+                 * @fullPath api.items.locations.bins.bin.get
+                 * @service items
+                 * @domain inventory-management
+                 * @param locationId Location unique identifier
+                 * @param bin Bin identifier
+                 * @param params Optional filtering parameters (excludeZero, pagination)
+                 * @returns Array of inventory items in the specific bin
+                 * @example
+                 * ```typescript
+                 * const items = await client.locations.bins.bin.get(123, 'A-01');
+                 * items.data.forEach(item => {
+                 *   console.log(`${item.itemId}: ${item.qtyOnHand}`);
+                 * });
+                 * ```
+                 */
+                get: (locationId: number, bin: string, params?: LocationsBinsParams) => Promise<{
+                    params: Record<string, unknown> | unknown[];
+                    data: {
+                        invMastUid: number;
+                        itemId: string;
+                        locationId: number;
+                        bin: string;
+                        qtyOnHand: number;
+                        binUid: number;
+                        invLocBinUid: number;
+                        dateCreated?: string | undefined;
+                        dateLastModified?: string | undefined;
+                        qtyAllocated?: number | undefined;
+                        qtyAvailable?: number | undefined;
+                        unitCost?: number | undefined;
+                        lastCountDate?: string | undefined;
+                        lastMovementDate?: string | undefined;
+                    }[];
+                    options: Record<string, unknown> | unknown[];
+                    status: number;
+                    message: string;
+                    count: number;
+                    total: number;
+                    totalResults: number;
+                }>;
+            };
             /**
              * Create new bin
              * @description Create a new bin in a location
@@ -3928,7 +3862,7 @@ export declare class ItemsClient extends BaseServiceClient {
              * });
              * ```
              */
-            getInventory: (invMastUid: number, locationId: number, params?: InventoryLocationBinListParams) => Promise<{
+            getInventory: (invMastUid: number, locationId: number, params?: LocationsBinsParams) => Promise<{
                 params: Record<string, unknown> | unknown[];
                 data: {
                     invMastUid: number;
@@ -3972,23 +3906,21 @@ export declare class ItemsClient extends BaseServiceClient {
              * @param params Optional filtering and pagination parameters
              * @returns Array of bins data
              */
-            list: (locationId: number, params?: BinListParams) => Promise<{
+            list: (locationId: number, params?: LocationsBinsParams) => Promise<{
+                invMastUid: number;
+                itemId: string;
                 locationId: number;
                 bin: string;
+                qtyOnHand: number;
                 binUid: number;
+                invLocBinUid: number;
                 dateCreated?: string | undefined;
                 dateLastModified?: string | undefined;
-                createdBy?: string | undefined;
-                lastMaintainedBy?: string | undefined;
-                isActive?: string | undefined;
-                binDesc?: string | undefined;
-                binType?: string | undefined;
-                maxCapacity?: number | undefined;
-                currentCapacity?: number | undefined;
-                zone?: string | undefined;
-                aisle?: string | undefined;
-                shelf?: string | undefined;
-                position?: string | undefined;
+                qtyAllocated?: number | undefined;
+                qtyAvailable?: number | undefined;
+                unitCost?: number | undefined;
+                lastCountDate?: string | undefined;
+                lastMovementDate?: string | undefined;
             }[]>;
             /**
              * Get inventory in bins data only
@@ -3998,7 +3930,7 @@ export declare class ItemsClient extends BaseServiceClient {
              * @param params Optional filtering and pagination parameters
              * @returns Array of inventory location bin data
              */
-            getInventory: (invMastUid: number, locationId: number, params?: InventoryLocationBinListParams) => Promise<{
+            getInventory: (invMastUid: number, locationId: number, params?: LocationsBinsParams) => Promise<{
                 invMastUid: number;
                 itemId: string;
                 locationId: number;
@@ -4014,6 +3946,52 @@ export declare class ItemsClient extends BaseServiceClient {
                 lastCountDate?: string | undefined;
                 lastMovementDate?: string | undefined;
             }[]>;
+            /**
+             * Bin-specific data methods
+             * @description Data-only methods for specific bin operations
+             */
+            bin: {
+                /**
+                 * Get items in specific bin data only
+                 * @description Returns only the data portion of items in a specific bin
+                 *
+                 * @fullPath api.items.locations.bins.bin.get
+                 * @service items
+                 * @domain inventory
+                 * @dataMethod true
+                 * @discoverable true
+                 * @searchTerms ["specific bin items", "bin contents", "single bin inventory"]
+                 * @relatedEndpoints ["locations.bins.list"]
+                 * @commonPatterns ["show items in bin A-01", "what's in bin B-02"]
+                 *
+                 * @param locationId Location unique identifier
+                 * @param bin Bin identifier
+                 * @param params Optional filtering parameters
+                 * @returns Array of items in the specified bin
+                 *
+                 * @example
+                 * ```typescript
+                 * // Get items in specific bin
+                 * const items = await client.locationsData.bins.bin.get(100, 'A-01');
+                 * ```
+                 */
+                get: (locationId: number, bin: string, params?: LocationsBinsParams) => Promise<{
+                    invMastUid: number;
+                    itemId: string;
+                    locationId: number;
+                    bin: string;
+                    qtyOnHand: number;
+                    binUid: number;
+                    invLocBinUid: number;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    qtyAllocated?: number | undefined;
+                    qtyAvailable?: number | undefined;
+                    unitCost?: number | undefined;
+                    lastCountDate?: string | undefined;
+                    lastMovementDate?: string | undefined;
+                }[]>;
+            };
         };
     };
     /**
@@ -4155,223 +4133,46 @@ export declare class ItemsClient extends BaseServiceClient {
          * @param attributeValueUid Attribute value unique identifier
          * @returns Success indication
          * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * await client.attributeValues.delete(123, 456);
-         * ```
-         */
-        delete: (attributeUid: number, attributeValueUid: number) => Promise<boolean>;
-    };
-    /**
-     * Attribute group attribute associations
-     * @description Methods for managing attribute associations within attribute groups
-     */
-    attributeGroupAttributes: {
-        /**
-         * List attributes in a group
-         * @description Retrieve all attributes associated with an attribute group
-         * @param attributeGroupUid Attribute group unique identifier
-         * @param params Optional pagination parameters
-         * @returns Array of attributes in the group
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const groupAttrs = await client.attributeGroupAttributes.list(123);
-         * groupAttrs.data.forEach(attr => {
-         *   console.log(`${attr.attributeId}: ${attr.attributeDesc}`);
-         * });
-         * ```
-         */
-        list: (attributeGroupUid: number, params?: {
-            limit?: number;
-            offset?: number;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                statusCd: number;
-                attributeUid: number;
-                attributeId: string;
-                attributeDesc: string;
-                dataType: string;
-                sequenceNo?: number | undefined;
-                maxLength?: number | undefined;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Add attribute to group
-         * @description Associate an attribute with an attribute group
-         * @param attributeGroupUid Attribute group unique identifier
-         * @param request Association data
-         * @returns Created association
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const association = await client.attributeGroupAttributes.create(123, {
-         *   attributeUid: 456,
-         *   sequenceNo: 10
-         * });
-         * ```
-         */
-        create: (attributeGroupUid: number, request: CreateAttributeGroupAttributeRequest) => Promise<{
-            data: {
-                attributeUid: number;
-                attributeGroupUid: number;
-                attributeXAttributeGroupUid: number;
-                sequenceNo?: number | undefined;
-            };
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            params?: any;
-            options?: any;
-        }>;
-        /**
-         * Get specific attribute in group
-         * @description Get details of a specific attribute association in a group
-         * @param attributeGroupUid Attribute group unique identifier
-         * @param attributeXAttributeGroupUid Association unique identifier
-         * @returns Association details
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const association = await client.attributeGroupAttributes.get(123, 789);
-         * console.log(association.data.attributeUid, association.data.sequenceNo);
-         * ```
-         */
-        get: (attributeGroupUid: number, attributeXAttributeGroupUid: number) => Promise<{
-            data: {
-                attributeUid: number;
-                attributeGroupUid: number;
-                attributeXAttributeGroupUid: number;
-                sequenceNo?: number | undefined;
-            };
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            params?: any;
-            options?: any;
-        }>;
-        /**
-         * Update attribute in group
-         * @description Update an attribute association in a group
-         * @param attributeGroupUid Attribute group unique identifier
-         * @param attributeXAttributeGroupUid Association unique identifier
-         * @param request Update data
-         * @returns Updated association
-         * @throws ValidationError When request is invalid or response is malformed
-         * @example
-         * ```typescript
-         * const updated = await client.attributeGroupAttributes.update(123, 789, {
-         *   sequenceNo: 20
-         * });
-         * ```
-         */
-        update: (attributeGroupUid: number, attributeXAttributeGroupUid: number, request: UpdateAttributeGroupAttributeRequest) => Promise<{
-            data: {
-                attributeUid: number;
-                attributeGroupUid: number;
-                attributeXAttributeGroupUid: number;
-                sequenceNo?: number | undefined;
-            };
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-            params?: any;
-            options?: any;
-        }>;
-        /**
-         * Remove attribute from group
-         * @description Remove an attribute association from a group
-         * @param attributeGroupUid Attribute group unique identifier
-         * @param attributeXAttributeGroupUid Association unique identifier
-         * @returns Success indication
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * await client.attributeGroupAttributes.delete(123, 789);
-         * ```
-         */
-        delete: (attributeGroupUid: number, attributeXAttributeGroupUid: number) => Promise<boolean>;
-    };
-    /**
-     * Brand item associations
-     * @description Methods for managing item associations within brands
-     */
-    brandsItems: {
-        /**
-         * List items for a brand
-         * @description Retrieve all items associated with a brand
-         * @param brandsUid Brand unique identifier
-         * @param params Optional pagination parameters
-         * @returns Array of items for the brand
-         * @throws ValidationError When parameters are invalid or response is malformed
-         * @example
-         * ```typescript
-         * const brandItems = await client.brandsItems.list(123);
-         * brandItems.data.forEach(item => {
-         *   console.log(`${item.itemId}: ${item.itemDesc}`);
-         * });
-         * ```
-         */
-        list: (brandsUid: number, params?: {
-            limit?: number;
-            offset?: number;
-        }) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                statusCd: number;
-                invMastUid: number;
-                itemId: string;
-                itemDesc: string;
-                length?: number | null | 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;
-                images?: {
-                    imageUid: number;
-                    imagePath: 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;
+         * @example
+         * ```typescript
+         * await client.attributeValues.delete(123, 456);
+         * ```
+         */
+        delete: (attributeUid: number, attributeValueUid: number) => Promise<boolean>;
+    };
+    /**
+     * Attribute group attribute associations
+     * @description Methods for managing attribute associations within attribute groups
+     */
+    attributeGroupAttributes: {
+        /**
+         * List attributes in a group
+         * @description Retrieve all attributes associated with an attribute group
+         * @param attributeGroupUid Attribute group unique identifier
+         * @param params Optional pagination parameters
+         * @returns Array of attributes in the group
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const groupAttrs = await client.attributeGroupAttributes.list(123);
+         * groupAttrs.data.forEach(attr => {
+         *   console.log(`${attr.attributeId}: ${attr.attributeDesc}`);
+         * });
+         * ```
+         */
+        list: (attributeGroupUid: number, params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<{
+            params: Record<string, unknown> | unknown[];
+            data: {
+                statusCd: number;
+                attributeUid: number;
+                attributeId: string;
+                attributeDesc: string;
+                dataType: string;
+                sequenceNo?: number | undefined;
+                maxLength?: number | undefined;
             }[];
             options: Record<string, unknown> | unknown[];
             status: number;
@@ -4381,24 +4182,26 @@ export declare class ItemsClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Add item to brand
-         * @description Associate an item with a brand
-         * @param brandsUid Brand unique identifier
+         * Add attribute to group
+         * @description Associate an attribute with an attribute group
+         * @param attributeGroupUid Attribute group unique identifier
          * @param request Association data
          * @returns Created association
          * @throws ValidationError When request is invalid or response is malformed
          * @example
          * ```typescript
-         * const association = await client.brandsItems.create(123, {
-         *   invMastUid: 456
+         * const association = await client.attributeGroupAttributes.create(123, {
+         *   attributeUid: 456,
+         *   sequenceNo: 10
          * });
          * ```
          */
-        create: (brandsUid: number, request: CreateBrandItemRequest) => Promise<{
+        create: (attributeGroupUid: number, request: CreateAttributeGroupAttributeRequest) => Promise<{
             data: {
-                invMastUid: number;
-                brandsUid: number;
-                brandsXItemsUid: number;
+                attributeUid: number;
+                attributeGroupUid: number;
+                attributeXAttributeGroupUid: number;
+                sequenceNo?: number | undefined;
             };
             status: number;
             message: string;
@@ -4409,23 +4212,24 @@ export declare class ItemsClient extends BaseServiceClient {
             options?: any;
         }>;
         /**
-         * Get specific brand-item association
-         * @description Get details of a specific brand-item association
-         * @param brandsUid Brand unique identifier
-         * @param brandsXItemsUid Association unique identifier
+         * Get specific attribute in group
+         * @description Get details of a specific attribute association in a group
+         * @param attributeGroupUid Attribute group unique identifier
+         * @param attributeXAttributeGroupUid Association unique identifier
          * @returns Association details
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const association = await client.brandItems.get(123, 789);
-         * console.log(association.data.invMastUid);
+         * const association = await client.attributeGroupAttributes.get(123, 789);
+         * console.log(association.data.attributeUid, association.data.sequenceNo);
          * ```
          */
-        get: (brandsUid: number, brandsXItemsUid: number) => Promise<{
+        get: (attributeGroupUid: number, attributeXAttributeGroupUid: number) => Promise<{
             data: {
-                invMastUid: number;
-                brandsUid: number;
-                brandsXItemsUid: number;
+                attributeUid: number;
+                attributeGroupUid: number;
+                attributeXAttributeGroupUid: number;
+                sequenceNo?: number | undefined;
             };
             status: number;
             message: string;
@@ -4436,25 +4240,26 @@ export declare class ItemsClient extends BaseServiceClient {
             options?: any;
         }>;
         /**
-         * Update brand-item association
-         * @description Update a brand-item association
-         * @param brandsUid Brand unique identifier
-         * @param brandsXItemsUid Association unique identifier
+         * Update attribute in group
+         * @description Update an attribute association in a group
+         * @param attributeGroupUid Attribute group unique identifier
+         * @param attributeXAttributeGroupUid Association unique identifier
          * @param request Update data
          * @returns Updated association
          * @throws ValidationError When request is invalid or response is malformed
          * @example
          * ```typescript
-         * const updated = await client.brandItems.update(123, 789, {
-         *   invMastUid: 999
+         * const updated = await client.attributeGroupAttributes.update(123, 789, {
+         *   sequenceNo: 20
          * });
          * ```
          */
-        update: (brandsUid: number, brandsXItemsUid: number, request: UpdateBrandItemRequest) => Promise<{
+        update: (attributeGroupUid: number, attributeXAttributeGroupUid: number, request: UpdateAttributeGroupAttributeRequest) => Promise<{
             data: {
-                invMastUid: number;
-                brandsUid: number;
-                brandsXItemsUid: number;
+                attributeUid: number;
+                attributeGroupUid: number;
+                attributeXAttributeGroupUid: number;
+                sequenceNo?: number | undefined;
             };
             status: number;
             message: string;
@@ -4465,19 +4270,23 @@ export declare class ItemsClient extends BaseServiceClient {
             options?: any;
         }>;
         /**
-         * Remove item from brand
-         * @description Remove an item association from a brand
-         * @param brandsUid Brand unique identifier
-         * @param brandsXItemsUid Association unique identifier
+         * Remove attribute from group
+         * @description Remove an attribute association from a group
+         * @param attributeGroupUid Attribute group unique identifier
+         * @param attributeXAttributeGroupUid Association unique identifier
          * @returns Success indication
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * await client.brandItems.delete(123, 789);
+         * await client.attributeGroupAttributes.delete(123, 789);
          * ```
          */
-        delete: (brandsUid: number, brandsXItemsUid: number) => Promise<boolean>;
+        delete: (attributeGroupUid: number, attributeXAttributeGroupUid: number) => Promise<boolean>;
     };
+    /**
+     * Brand item associations
+     * @description Methods for managing item associations within brands
+     */
     /**
      * Additional missing endpoints
      * @description Methods for endpoints that were missing from the implementation
@@ -4627,8 +4436,8 @@ export declare class ItemsClient extends BaseServiceClient {
          */
         createInternalPdf: (request: CreateInternalPdfRequest) => Promise<{
             data: {
-                pdfUrl: string;
                 pdfId: string;
+                pdfUrl: string;
                 expiresAt?: string | undefined;
             };
             status: number;
@@ -5228,7 +5037,7 @@ export declare class ItemsClient extends BaseServiceClient {
         /**
          * Get similar inventory masters
          * @description Retrieve similar inventory masters to the specified one
-         * @fullPath api.items.invMast.similar.get
+         * @fullPath api.items.invMast.similar.list
          * @service items
          * @domain inventory-management
          * @discoverable true
@@ -5238,11 +5047,11 @@ export declare class ItemsClient extends BaseServiceClient {
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const similar = await client.invMast.similar.get(12345);
+         * const similar = await client.invMast.similar.list(12345);
          * ```
          */
         similar: {
-            get: (invMastUid: number) => Promise<{
+            list: (invMastUid: number) => Promise<{
                 params: Record<string, unknown> | unknown[];
                 data: {
                     statusCd: number;
@@ -5298,7 +5107,7 @@ export declare class ItemsClient extends BaseServiceClient {
         /**
          * Get inventory master alternate codes
          * @description Retrieve alternate codes for a specific inventory master
-         * @fullPath api.items.invMast.alternateCode.get
+         * @fullPath api.items.invMast.alternateCode.list
          * @service items
          * @domain inventory-management
          * @discoverable true
@@ -5308,28 +5117,35 @@ export declare class ItemsClient extends BaseServiceClient {
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const altCodes = await client.invMast.alternateCode.get(12345);
+         * const altCodes = await client.invMast.alternateCode.list(12345);
          * ```
          */
         alternateCode: {
-            get: (invMastUid: number) => Promise<{
+            list: (invMastUid: number, params?: AlternateCodeListParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
                 data: {
+                    dateCreated: string;
+                    dateLastModified: string;
+                    updateCd: number;
+                    invMastUid: number;
                     alternateCode: string;
-                    codeType?: string | undefined;
+                    alternateCodeUid: number;
+                    sourceTypeCd: number;
+                    deleteFlag?: string | null | undefined;
+                    alternateCodeDesc?: string | null | undefined;
                 }[];
+                options: Record<string, unknown> | unknown[];
                 status: number;
                 message: string;
                 count: number;
                 total: number;
                 totalResults: number;
-                params?: any;
-                options?: any;
             }>;
         };
         /**
          * Get inventory master accessories
          * @description Retrieve accessories for a specific inventory master
-         * @fullPath api.items.invMast.invAccessory.get
+         * @fullPath api.items.invMast.invAccessory.list
          * @service items
          * @domain inventory-management
          * @discoverable true
@@ -5339,11 +5155,11 @@ export declare class ItemsClient extends BaseServiceClient {
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const accessories = await client.invMast.invAccessory.get(12345);
+         * const accessories = await client.invMast.invAccessory.list(12345);
          * ```
          */
         invAccessory: {
-            get: (invMastUid: number) => Promise<{
+            list: (invMastUid: number) => Promise<{
                 params: Record<string, unknown> | unknown[];
                 data: {
                     invMastUid: number;
@@ -5365,7 +5181,7 @@ export declare class ItemsClient extends BaseServiceClient {
         /**
          * Get inventory master sub-items
          * @description Retrieve sub-items for a specific inventory master
-         * @fullPath api.items.invMast.invSub.get
+         * @fullPath api.items.invMast.invSub.list
          * @service items
          * @domain inventory-management
          * @discoverable true
@@ -5375,11 +5191,11 @@ export declare class ItemsClient extends BaseServiceClient {
          * @throws ValidationError When response is malformed
          * @example
          * ```typescript
-         * const subItems = await client.invMast.invSub.get(12345);
+         * const subItems = await client.invMast.invSub.list(12345);
          * ```
          */
         invSub: {
-            get: (invMastUid: number) => Promise<{
+            list: (invMastUid: number) => Promise<{
                 params: Record<string, unknown> | unknown[];
                 data: {
                     statusCd: number;
@@ -5874,6 +5690,331 @@ export declare class ItemsClient extends BaseServiceClient {
             };
         };
     };
+    /**
+     * Inventory Master Links - Direct OpenAPI Path Mirror
+     * @description New OpenAPI endpoint for listing document links for an item
+     *
+     * **CRITICAL: This endpoint follows OpenAPI Path Mirroring Pattern**
+     * OpenAPI Path: /inv-mast-links/{invMastUid} → api.items.invMastLinks.list()
+     */
+    invMastLinks: {
+        /**
+         * List document links for an inventory master item
+         *
+         * @fullPath api.items.invMastLinks.list
+         * @service items
+         * @domain inventory-management
+         * @dataMethod listData - returns only the links array without metadata
+         * @discoverable true
+         * @searchTerms ["inventory links", "item documents", "product links", "inv mast links", "document links"]
+         * @relatedEndpoints ["api.items.productLinks.list", "api.items.invMast.get", "api.legacy.invMastTags.list"]
+         * @commonPatterns ["Get item documentation links", "Find product documents", "Document management"]
+         * @workflow ["inventory-management", "document-management", "product-information"]
+         * @prerequisites ["Valid authentication token", "Inventory access permissions"]
+         * @nextSteps ["api.items.invMast.get for item details", "api.legacy.invMastTags for additional metadata"]
+         * @businessRules ["Returns active document links only", "Ordered by link type and display order"]
+         * @functionalArea "inventory-master-management"
+         * @caching "Cache for 10 minutes, invalidate on item changes"
+         * @performance "Fast lookup by inventory master UID"
+         *
+         * @param invMastUid Inventory master unique identifier
+         * @returns Promise<InvMastLinksResponse> Complete response with document links array and metadata
+         *
+         * @example
+         * ```typescript
+         * // Get all document links for an item
+         * const response = await api.items.invMastLinks.list(12345);
+         * console.log(response.data); // ProductLink[]
+         *
+         * // Get just the data
+         * const links = await api.items.invMastLinks.listData(12345);
+         * ```
+         */
+        list: (invMastUid: number) => Promise<InvMastLinksResponse>;
+        /**
+         * List document links data only
+         * @description Returns only the links array without BaseResponse wrapper
+         * @param invMastUid Inventory master unique identifier
+         * @returns Promise<ProductLink[]> Links array only
+         */
+        listData: (invMastUid: number) => Promise<{
+            productLinkUid: number;
+            parentInvMastUid: number;
+            childInvMastUid: number;
+            parentItemId: string;
+            childItemId: string;
+            linkType: string;
+            dateCreated?: string | undefined;
+            dateLastModified?: string | undefined;
+            createdBy?: string | undefined;
+            lastMaintainedBy?: string | undefined;
+            isActive?: string | undefined;
+            displayOrder?: number | undefined;
+            linkDescription?: string | undefined;
+        }[]>;
+    };
+    /**
+     * Inventory Master Sub Parts - Direct OpenAPI Path Mirror
+     * @description New OpenAPI endpoint for listing sub parts for an item
+     *
+     * **CRITICAL: This endpoint follows OpenAPI Path Mirroring Pattern**
+     * OpenAPI Path: /inv-mast-sub-parts/{invMastUid} → api.items.invMastSubParts.list()
+     */
+    invMastSubParts: {
+        /**
+         * List sub parts for an inventory master item
+         *
+         * @fullPath api.items.invMastSubParts.list
+         * @service items
+         * @domain inventory-management
+         * @dataMethod listData - returns only the sub parts array without metadata
+         * @discoverable true
+         * @searchTerms ["inventory sub parts", "item subparts", "product parts", "inv mast subparts", "component parts"]
+         * @relatedEndpoints ["api.items.subparts.list", "api.items.invMast.get", "api.items.invMastLinks.list"]
+         * @commonPatterns ["Get item sub parts", "Find product components", "Parts management"]
+         * @workflow ["inventory-management", "parts-management", "product-assembly"]
+         * @prerequisites ["Valid authentication token", "Inventory access permissions"]
+         * @nextSteps ["api.items.invMast.get for part details", "api.items.subparts.get for specific subpart info"]
+         * @businessRules ["Returns active sub parts only", "Optional filtering by links", "Ordered by display sequence"]
+         * @functionalArea "inventory-master-management"
+         * @caching "Cache for 15 minutes, invalidate on parts changes"
+         * @performance "Supports optional filtering by inv mast links UID"
+         *
+         * @param invMastUid Inventory master unique identifier
+         * @param params Optional filtering parameters
+         * @returns Promise<InvMastSubPartsResponse> Complete response with sub parts array and metadata
+         *
+         * @example
+         * ```typescript
+         * // Get all sub parts for an item
+         * const response = await api.items.invMastSubParts.list(12345);
+         * console.log(response.data); // Subpart[]
+         *
+         * // Filter by specific link
+         * const filtered = await api.items.invMastSubParts.list(12345, { invMastLinksUid: 67890 });
+         *
+         * // Get just the data
+         * const parts = await api.items.invMastSubParts.listData(12345);
+         * ```
+         */
+        list: (invMastUid: number, params?: InvMastSubPartsParams) => Promise<InvMastSubPartsResponse>;
+        /**
+         * List sub parts data only
+         * @description Returns only the sub parts array without BaseResponse wrapper
+         * @param invMastUid Inventory master unique identifier
+         * @param params Optional filtering parameters
+         * @returns Promise<Subpart[]> Sub parts array only
+         */
+        listData: (invMastUid: number, params?: InvMastSubPartsParams) => Promise<{
+            parentInvMastUid: number;
+            childInvMastUid: number;
+            parentItemId: string;
+            childItemId: string;
+            subPartUid: number;
+            qtyRequired: number;
+            description?: string | undefined;
+            dateCreated?: string | undefined;
+            dateLastModified?: string | undefined;
+            unitOfMeasure?: string | undefined;
+            createdBy?: string | undefined;
+            lastMaintainedBy?: string | undefined;
+            isActive?: string | undefined;
+            displayOrder?: number | undefined;
+            childItemDesc?: string | undefined;
+            isOptional?: string | undefined;
+        }[]>;
+    };
+    /**
+     * User Favorites (User-based) - Direct OpenAPI Path Mirror
+     * @description New OpenAPI endpoints for user-specific item favorites
+     *
+     * **CRITICAL: This endpoint follows OpenAPI Path Mirroring Pattern**
+     * OpenAPI Paths:
+     * - /item-favorites/{usersId} → api.items.itemFavorites.list()
+     * - /item-favorites/{usersId}/{invMastUid} → api.items.itemFavorites.get/create/delete()
+     */
+    itemFavorites: {
+        /**
+         * List favorites for a specific user
+         *
+         * @fullPath api.items.itemFavorites.list
+         * @service items
+         * @domain user-management
+         * @dataMethod listData - returns only the favorites array without metadata
+         * @discoverable true
+         * @searchTerms ["user favorites", "item favorites", "user wishlist", "favorite products", "bookmarked items"]
+         * @relatedEndpoints ["api.items.favorites.list", "api.joomla.users.get", "api.items.itemWishlist.list"]
+         * @commonPatterns ["Get user's favorite items", "User preference management", "Personalized catalogs"]
+         * @workflow ["user-experience", "personalization", "catalog-management"]
+         * @prerequisites ["Valid authentication token", "User access permissions"]
+         * @nextSteps ["api.items.invMast.get for item details", "api.items.itemFavorites.create to add favorites"]
+         * @businessRules ["User can only see their own favorites", "Returns active favorites only"]
+         * @functionalArea "user-and-account-management"
+         * @caching "Cache for 5 minutes per user, invalidate on user changes"
+         * @performance "Indexed by user ID for fast retrieval"
+         *
+         * @param usersId User unique identifier
+         * @returns Promise<ItemFavoritesListResponse> Complete response with user favorites array and metadata
+         *
+         * @example
+         * ```typescript
+         * // Get all favorites for a user
+         * const response = await api.items.itemFavorites.list(123);
+         * console.log(response.data); // ItemFavorite[]
+         *
+         * // Get just the data
+         * const favorites = await api.items.itemFavorites.listData(123);
+         * ```
+         */
+        list: (usersId: number) => Promise<ItemFavoritesListResponse>;
+        /**
+         * Create a favorite item for a user
+         *
+         * @fullPath api.items.itemFavorites.create
+         * @service items
+         * @domain user-management
+         * @dataMethod N/A - creation operation
+         * @discoverable true
+         * @searchTerms ["add favorite", "bookmark item", "save favorite", "user preferences"]
+         * @relatedEndpoints ["api.items.itemFavorites.list", "api.items.itemFavorites.delete"]
+         * @commonPatterns ["Add item to favorites", "Bookmark product", "User preference setting"]
+         * @workflow ["user-experience", "personalization"]
+         * @prerequisites ["Valid authentication token", "User must own the favorites"]
+         * @nextSteps ["api.items.itemFavorites.list to view updated favorites"]
+         * @businessRules ["Users can only manage their own favorites", "Prevents duplicate favorites"]
+         * @functionalArea "user-and-account-management"
+         * @performance "Fast creation with duplicate prevention"
+         *
+         * @param usersId User unique identifier
+         * @returns Promise<ItemFavoritesItemResponse> Complete response with created favorite and metadata
+         *
+         * @example
+         * ```typescript
+         * // Add item to user's favorites
+         * const response = await api.items.itemFavorites.create(123);
+         * console.log(response.data); // ItemFavorite
+         * ```
+         */
+        create: (usersId: number) => Promise<ItemFavoritesItemResponse>;
+        /**
+         * Get specific favorite item for a user
+         *
+         * @fullPath api.items.itemFavorites.get
+         * @service items
+         * @domain user-management
+         * @dataMethod getData - returns only the favorite data without metadata
+         * @discoverable true
+         * @searchTerms ["get favorite", "check favorite", "favorite status", "user item preference"]
+         * @relatedEndpoints ["api.items.itemFavorites.list", "api.items.invMast.get"]
+         * @commonPatterns ["Check if item is favorited", "Get favorite details"]
+         * @workflow ["user-experience", "personalization"]
+         * @prerequisites ["Valid authentication token", "User access permissions"]
+         * @nextSteps ["api.items.invMast.get for full item details"]
+         * @businessRules ["Users can only see their own favorites", "Returns 404 if not favorited"]
+         * @functionalArea "user-and-account-management"
+         * @performance "Direct lookup by user and item IDs"
+         *
+         * @param usersId User unique identifier
+         * @param invMastUid Inventory master unique identifier
+         * @returns Promise<ItemFavoritesItemResponse> Complete response with favorite details and metadata
+         *
+         * @example
+         * ```typescript
+         * // Check if user has favorited specific item
+         * const response = await api.items.itemFavorites.get(123, 12345);
+         * console.log(response.data); // ItemFavorite or null
+         *
+         * // Get just the data
+         * const favorite = await api.items.itemFavorites.getData(123, 12345);
+         * ```
+         */
+        get: (usersId: number, invMastUid: number) => Promise<ItemFavoritesItemResponse>;
+        /**
+         * Delete specific favorite item for a user
+         *
+         * @fullPath api.items.itemFavorites.delete
+         * @service items
+         * @domain user-management
+         * @dataMethod N/A - deletion operation
+         * @discoverable true
+         * @searchTerms ["remove favorite", "delete favorite", "unfavorite", "remove bookmark"]
+         * @relatedEndpoints ["api.items.itemFavorites.list", "api.items.itemFavorites.create"]
+         * @commonPatterns ["Remove from favorites", "Unfavorite item", "User preference removal"]
+         * @workflow ["user-experience", "personalization"]
+         * @prerequisites ["Valid authentication token", "User must own the favorite"]
+         * @nextSteps ["api.items.itemFavorites.list to view updated favorites"]
+         * @businessRules ["Users can only delete their own favorites", "Idempotent operation"]
+         * @functionalArea "user-and-account-management"
+         * @performance "Fast deletion with proper cleanup"
+         *
+         * @param usersId User unique identifier
+         * @param invMastUid Inventory master unique identifier
+         * @returns Promise<UserFavoriteResponse> Complete response confirming deletion
+         *
+         * @example
+         * ```typescript
+         * // Remove item from user's favorites
+         * const response = await api.items.itemFavorites.delete(123, 12345);
+         * console.log(response.success); // true
+         * ```
+         */
+        delete: (usersId: number, invMastUid: number) => Promise<ItemFavoritesItemResponse>;
+        /**
+         * Update specific favorite item for a user
+         *
+         * @fullPath api.items.itemFavorites.update
+         * @service items
+         * @domain user-management
+         * @dataMethod N/A - update operation
+         * @discoverable true
+         * @searchTerms ["update favorite", "modify favorite", "favorite metadata", "user preference update"]
+         * @relatedEndpoints ["api.items.itemFavorites.get", "api.items.itemFavorites.list"]
+         * @commonPatterns ["Update favorite details", "Modify user preference"]
+         * @workflow ["user-experience", "personalization"]
+         * @prerequisites ["Valid authentication token", "User must own the favorite", "Favorite must exist"]
+         * @nextSteps ["api.items.itemFavorites.get to verify changes"]
+         * @businessRules ["Users can only update their own favorites", "Maintains favorite relationship"]
+         * @functionalArea "user-and-account-management"
+         * @performance "Direct update by user and item IDs"
+         *
+         * @param usersId User unique identifier
+         * @param invMastUid Inventory master unique identifier
+         * @returns Promise<ItemFavoritesItemResponse> Complete response with updated favorite and metadata
+         *
+         * @example
+         * ```typescript
+         * // Update user's favorite item metadata
+         * const response = await api.items.itemFavorites.update(123, 12345);
+         * console.log(response.data); // Updated ItemFavorite
+         * ```
+         */
+        update: (usersId: number, invMastUid: number) => Promise<ItemFavoritesItemResponse>;
+        /**
+         * Data-only methods for item favorites
+         */
+        listData: (usersId: number) => Promise<{
+            invMastUid: number;
+            itemId: string;
+            usersId: number;
+            itemFavoritesUid: number;
+            dateCreated?: string | undefined;
+            dateLastModified?: string | undefined;
+            itemDesc?: string | undefined;
+            createdBy?: string | undefined;
+            lastMaintainedBy?: string | undefined;
+        }[]>;
+        getData: (usersId: number, invMastUid: number) => Promise<{
+            invMastUid: number;
+            itemId: string;
+            usersId: number;
+            itemFavoritesUid: number;
+            dateCreated?: string | undefined;
+            dateLastModified?: string | undefined;
+            itemDesc?: string | undefined;
+            createdBy?: string | undefined;
+            lastMaintainedBy?: string | undefined;
+        }>;
+    };
 }
 export {};
 //# sourceMappingURL=client.d.ts.map