@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/esm/services/items/client.js

@@ -7,22 +7,27 @@ HealthCheckResponseSchema, PingResponseSchema,
 // Product schemas
 ProductSearchParamsSchema, ProductListParamsSchema, ProductLookupParamsSchema, ProductResponseSchema, ProductListResponseSchema, ProductLookupResponseSchema, AccessoryListResponseSchema, BinInfoListResponseSchema, 
 // Category schemas
-CategoryDetailsParamsSchema, CategoryItemsParamsSchema, CategoryListParamsSchema, CategoryLookupParamsSchema, CategoryResponseSchema, CategoryListResponseSchema, CategoryLookupResponseSchema, CategoryPreCacheResponseSchema, CategoryItemsResponseSchema, CategoryAttributesResponseSchema, CategoryFiltersResponseSchema, CategoryImagesResponseSchema, 
+CategoryDetailsParamsSchema, CategoryItemsParamsSchema, CategoryListParamsSchema, CategoryLookupParamsSchema, CategoryResponseSchema, CategoryListResponseSchema, CategoryLookupResponseSchema, CategoryItemsResponseSchema, CategoryAttributesResponseSchema, CategoryImagesResponseSchema, 
 // Attribute schemas
 CreateAttributeRequestSchema, UpdateAttributeRequestSchema, AttributeResponseSchema, AttributeListResponseSchema, AttributeValueListResponseSchema, 
 // Attribute Group schemas
 CreateAttributeGroupRequestSchema, UpdateAttributeGroupRequestSchema, AttributeGroupListParamsSchema, AttributeGroupResponseSchema, AttributeGroupListResponseSchema, 
 // Stock schemas
+// Note: GetStock schemas still used by invMast.stock endpoint
 GetStockParamsSchema, GetStockResponseSchema, 
 // Brand schemas
 CreateBrandRequestSchema, UpdateBrandRequestSchema, BrandListParamsSchema, BrandResponseSchema, BrandListResponseSchema, 
 // Alternate Code schemas
+AlternateCodeListResponseSchema, AlternateCodeListParamsSchema, 
 // Item attribute value schemas
 CreateItemAttributeValueRequestSchema, ItemAttributeValueListResponseSchema, ItemAttributeValueResponseSchema, 
-// Favorites schemas
-CreateItemFavoriteRequestSchema, UpdateItemFavoriteRequestSchema, ItemFavoritesListParamsSchema, ItemFavoriteResponseSchema, ItemFavoriteListResponseSchema, 
+// Favorites schemas - unused imports removed for OpenAPI compliance
+// New missing implementation schemas
+InternalPdfResponseSchema, 
 // Wishlists schemas
-CreateItemWishlistHeaderRequestSchema, UpdateItemWishlistHeaderRequestSchema, CreateItemWishlistLineRequestSchema, UpdateItemWishlistLineRequestSchema, ItemWishlistListParamsSchema, ItemWishlistLineListParamsSchema, ItemWishlistHeaderResponseSchema, ItemWishlistHeaderListResponseSchema, ItemWishlistLineResponseSchema, ItemWishlistLineListResponseSchema, 
+CreateItemWishlistHeaderRequestSchema, 
+// Note: Removed unused schemas for methods removed for OpenAPI compliance
+ItemWishlistHeaderResponseSchema, ItemWishlistHeaderListResponseSchema, ItemWishlistLineResponseSchema, 
 // Variants schemas
 CreateItemVariantHeaderRequestSchema, UpdateItemVariantHeaderRequestSchema, CreateItemVariantLineRequestSchema, UpdateItemVariantLineRequestSchema, ItemVariantListParamsSchema, ItemVariantHeaderResponseSchema, ItemVariantHeaderListResponseSchema, ItemVariantLineResponseSchema, ItemVariantLineListResponseSchema, 
 // FAQ schemas
@@ -34,7 +39,9 @@ CreateProductLinkRequestSchema, UpdateProductLinkRequestSchema, ProductLinkListP
 // Sub-parts schemas
 CreateSubPartRequestSchema, UpdateSubPartRequestSchema, SubPartListParamsSchema, SubPartResponseSchema, SubPartListResponseSchema, 
 // Bins schemas
-CreateBinRequestSchema, UpdateBinRequestSchema, BinListParamsSchema, InventoryLocationBinListParamsSchema, BinResponseSchema, BinListResponseSchema, InventoryLocationBinListResponseSchema, } from './schemas';
+CreateBinRequestSchema, UpdateBinRequestSchema, BinResponseSchema, LocationsBinsParamsSchema, LocationsBinsResponseSchema, 
+// New OpenAPI endpoint schemas
+InvMastLinksResponseSchema, InvMastSubPartsParamsSchema, InvMastSubPartsResponseSchema, ItemFavoritesListResponseSchema, ItemFavoritesItemResponseSchema, } from './schemas';
 /**
  * Items API Client
  * @description Client for interacting with Items microservice API endpoints for comprehensive product catalog, inventory, categories, and attributes management
@@ -68,7 +75,7 @@ CreateBinRequestSchema, UpdateBinRequestSchema, BinListParamsSchema, InventoryLo
  *
  * // 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 class ItemsClient extends BaseServiceClient {
@@ -84,19 +91,22 @@ export 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
          */
-        this.categories = {
+        this.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
              * });
@@ -111,257 +121,267 @@ export class ItemsClient extends BaseServiceClient {
                 }, params);
             },
             /**
-             * 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: async (params) => {
+            get: async (itemCategoryUid) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/item-category/lookup',
-                    paramsSchema: CategoryLookupParamsSchema,
-                    responseSchema: CategoryLookupResponseSchema,
-                }, params);
+                    path: '/item-category/{itemCategoryUid}',
+                    responseSchema: CategoryResponseSchema,
+                }, undefined, { itemCategoryUid: String(itemCategoryUid) });
             },
             /**
-             * 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: async (itemCategoryUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-category/{id}/precache',
-                    responseSchema: CategoryPreCacheResponseSchema,
-                }, undefined, { id: String(itemCategoryUid) });
+            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: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/item-category/lookup',
+                        paramsSchema: CategoryLookupParamsSchema,
+                        responseSchema: CategoryLookupResponseSchema,
+                    }, params);
+                },
+            },
+            /**
+             * 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: async (itemCategoryUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/item-category/{itemCategoryUid}/doc',
+                        responseSchema: CategoryResponseSchema,
+                    }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+                },
             },
+        };
+        /**
+         * Category management endpoints
+         * @description Methods for /categories/* paths following OpenAPI Path Mirroring Pattern
+         */
+        this.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: async (itemCategoryUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/categories/{id}',
+                    path: '/categories/{itemCategoryUid}',
                     paramsSchema: CategoryDetailsParamsSchema,
                     responseSchema: CategoryResponseSchema,
-                }, params, { id: String(itemCategoryUid) });
+                }, params, { itemCategoryUid: String(itemCategoryUid) });
             },
             /**
-             * 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: async (itemCategoryUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/categories/{id}/items',
-                    paramsSchema: CategoryItemsParamsSchema,
-                    responseSchema: CategoryItemsResponseSchema,
-                }, params, { id: String(itemCategoryUid) });
+            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: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/categories/lookup',
+                        paramsSchema: CategoryLookupParamsSchema,
+                        responseSchema: CategoryLookupResponseSchema,
+                    }, params);
+                },
             },
             /**
-             * 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: async (itemCategoryUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/categories/{id}/attributes',
-                    responseSchema: CategoryAttributesResponseSchema,
-                }, undefined, { id: String(itemCategoryUid) });
+            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: async (itemCategoryUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/categories/{itemCategoryUid}/item',
+                        responseSchema: CategoryItemsResponseSchema,
+                    }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+                },
             },
             /**
-             * 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: async (itemCategoryUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/categories/{id}/filters',
-                    responseSchema: CategoryFiltersResponseSchema,
-                }, undefined, { id: String(itemCategoryUid) });
+            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: async (itemCategoryUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/categories/{itemCategoryUid}/attributes',
+                        responseSchema: CategoryAttributesResponseSchema,
+                    }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+                },
             },
             /**
-             * 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: async (itemCategoryUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/categories/{id}/images',
-                    responseSchema: CategoryImagesResponseSchema,
-                }, undefined, { id: String(itemCategoryUid) });
+            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: async (itemCategoryUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/categories/{itemCategoryUid}/images',
+                        responseSchema: CategoryImagesResponseSchema,
+                    }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+                },
             },
         };
         /**
-         * 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
          */
-        this.categoriesData = {
+        this.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: async (itemCategoryUid, params) => {
-                const response = await this.categories.get(itemCategoryUid, params);
+            get: async (itemCategoryUid) => {
+                const response = await this.itemCategory.get(itemCategoryUid);
                 return response.data;
             },
             /**
-             * 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: async (params) => {
-                const response = await this.categories.list(params);
+                const response = await this.itemCategory.list(params);
                 return response.data;
             },
+        };
+        /**
+         * Category data-only endpoints
+         * @description Data-only methods that return just the data portion of category responses
+         */
+        this.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: async (itemCategoryUid, params) => {
-                const response = await this.categories.getItems(itemCategoryUid, params);
+            get: async (itemCategoryUid, params) => {
+                const response = await this.categories.get(itemCategoryUid, params);
                 return response.data;
             },
         };
@@ -404,7 +424,7 @@ export class ItemsClient extends BaseServiceClient {
              * console.log(attribute.attributeDesc, attribute.dataType, attribute.maxLength);
              * ```
              */
-            get: this.createGetMethod('/attributes/{id}', AttributeResponseSchema),
+            get: this.createGetMethod('/attributes/{attributeUid}', AttributeResponseSchema),
             /**
              * Create a new attribute
              * @description Create a new attribute with specified properties
@@ -438,7 +458,7 @@ export class ItemsClient extends BaseServiceClient {
              * });
              * ```
              */
-            update: this.createUpdateMethod('/attributes/{id}', UpdateAttributeRequestSchema, AttributeResponseSchema),
+            update: this.createUpdateMethod('/attributes/{attributeUid}', UpdateAttributeRequestSchema, AttributeResponseSchema),
             /**
              * Delete an attribute
              * @description Soft delete an attribute (sets status to inactive)
@@ -456,87 +476,319 @@ export class ItemsClient extends BaseServiceClient {
             delete: async (attributeUid) => {
                 await this.executeRequest({
                     method: 'DELETE',
-                    path: '/attributes/{id}',
+                    path: '/attributes/{attributeUid}',
                     responseSchema: z.undefined(),
-                }, undefined, { id: String(attributeUid) });
+                }, undefined, { attributeUid: String(attributeUid) });
                 return true;
             },
-        };
-        /**
-         * Stock and location management endpoints
-         * @description Methods for inventory stock information across locations
-         */
-        this.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})`);
-             * });
-             * ```
-             */
-            getDetails: async (invMastUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-loc/{id}/stock',
-                    paramsSchema: GetStockParamsSchema,
-                    responseSchema: GetStockResponseSchema,
-                }, params, { id: String(invMastUid) });
-            },
-        };
-        /**
-         * Brand management endpoints
-         * @description Methods for managing product brands including CRUD operations
-         */
-        this.brands = {
-            /**
-             * List all brands
-             * @description Retrieve a paginated list of brands with filtering options
-             * @param params Optional filtering and pagination parameters
-             * @returns Array of brands
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const brands = await client.brands.list({ limit: 50, statusCd: 704 });
-             * brands.data.forEach(brand => {
-             *   console.log(`${brand.brandsId}: ${brand.brandsName}`);
-             * });
-             * ```
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/brands',
-                    paramsSchema: BrandListParamsSchema,
-                    responseSchema: BrandListResponseSchema,
-                }, params);
-            },
             /**
-             * Get brand details by ID
-             * @description Retrieve details for a specific brand
-             * @param brandsUid Brand unique identifier
-             * @returns Brand details
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const brand = await client.brands.get(123);
-             * console.log(brand.data.brandsName, brand.data.brandsDesc);
-             * ```
+             * Attribute values - Direct path mapping to /attributes/{attributeUid}/values
+             * @description OpenAPI Path Mirroring: /attributes/{attributeUid}/values → attributes.values.*
              */
-            get: this.createGetMethod('/brands/{id}', BrandResponseSchema),
-            /**
-             * Create a new brand
-             * @description Create a new brand with specified properties
+            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: async (attributeUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/attributes/{attributeUid}/values',
+                        paramsSchema: StandardPaginationParamsSchema,
+                        responseSchema: AttributeValueListResponseSchema,
+                    }, params, { attributeUid: String(attributeUid) });
+                },
+                /**
+                 * 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: async (attributeUid, attributeValueUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/attributes/{attributeUid}/values/{attributeValueUid}',
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.object({
+                                attributeValueUid: z.number(),
+                                attributeUid: z.number(),
+                                value: z.string(),
+                                displayValue: z.string().optional(),
+                                sequenceNo: z.number().optional(),
+                            }),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, undefined, {
+                        attributeUid: String(attributeUid),
+                        attributeValueUid: String(attributeValueUid),
+                    });
+                },
+                /**
+                 * 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: async (attributeUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/attributes/{attributeUid}/values',
+                        paramsSchema: z.object({
+                            value: z.string(),
+                            displayValue: z.string().optional(),
+                            sequenceNo: z.number().optional(),
+                        }),
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.object({
+                                attributeValueUid: z.number(),
+                                attributeUid: z.number(),
+                                value: z.string(),
+                                displayValue: z.string().optional(),
+                                sequenceNo: z.number().optional(),
+                            }),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, request, { attributeUid: String(attributeUid) });
+                },
+                /**
+                 * 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: async (attributeUid, attributeValueUid, request) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/attributes/{attributeUid}/values/{attributeValueUid}',
+                        paramsSchema: z.object({
+                            value: z.string().optional(),
+                            displayValue: z.string().optional(),
+                            sequenceNo: z.number().optional(),
+                        }),
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.object({
+                                attributeValueUid: z.number(),
+                                attributeUid: z.number(),
+                                value: z.string(),
+                                displayValue: z.string().optional(),
+                                sequenceNo: z.number().optional(),
+                            }),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, request, {
+                        attributeUid: String(attributeUid),
+                        attributeValueUid: String(attributeValueUid),
+                    });
+                },
+                /**
+                 * 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: async (attributeUid, attributeValueUid) => {
+                    await this.executeRequest({
+                        method: 'DELETE',
+                        path: '/attributes/{attributeUid}/values/{attributeValueUid}',
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.any(),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, undefined, {
+                        attributeUid: String(attributeUid),
+                        attributeValueUid: String(attributeValueUid),
+                    });
+                    return true;
+                },
+            },
+        };
+        // Note: stock endpoints removed - not part of OpenAPI specification
+        /**
+         * Brand management endpoints
+         * @description Methods for managing product brands including CRUD operations
+         */
+        this.brands = {
+            /**
+             * List all brands
+             * @description Retrieve a paginated list of brands with filtering options
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of brands
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const brands = await client.brands.list({ limit: 50, statusCd: 704 });
+             * brands.data.forEach(brand => {
+             *   console.log(`${brand.brandsId}: ${brand.brandsName}`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/brands',
+                    paramsSchema: BrandListParamsSchema,
+                    responseSchema: BrandListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get brand details by ID
+             * @description Retrieve details for a specific brand
+             * @param brandsUid Brand unique identifier
+             * @returns Brand details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const brand = await client.brands.get(123);
+             * console.log(brand.data.brandsName, brand.data.brandsDesc);
+             * ```
+             */
+            get: this.createGetMethod('/brands/{brandsUid}', BrandResponseSchema),
+            /**
+             * Create a new brand
+             * @description Create a new brand with specified properties
              * @param request Brand creation data
              * @returns Created brand information
              * @throws ValidationError When request is invalid or response is malformed
@@ -564,7 +816,7 @@ export class ItemsClient extends BaseServiceClient {
              * });
              * ```
              */
-            update: this.createUpdateMethod('/brands/{id}', UpdateBrandRequestSchema, BrandResponseSchema),
+            update: this.createUpdateMethod('/brands/{brandsUid}', UpdateBrandRequestSchema, BrandResponseSchema),
             /**
              * Delete a brand
              * @description Soft delete a brand (sets status to inactive)
@@ -582,11 +834,220 @@ export class ItemsClient extends BaseServiceClient {
             delete: async (brandsUid) => {
                 await this.executeRequest({
                     method: 'DELETE',
-                    path: '/brands/{id}',
+                    path: '/brands/{brandsUid}',
                     responseSchema: z.undefined(),
-                }, undefined, { id: String(brandsUid) });
+                }, undefined, { brandsUid: String(brandsUid) });
                 return true;
             },
+            /**
+             * 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: async (brandsUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/brands/{brandsUid}/items',
+                        paramsSchema: BrandItemListParamsSchema,
+                        responseSchema: BrandItemListResponseSchema,
+                    }, params, { brandsUid: String(brandsUid) });
+                },
+                /**
+                 * 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: async (brandsUid, brandsXItemsUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/brands/{brandsUid}/items/{brandsXItemsUid}',
+                        responseSchema: BrandItemResponseSchema,
+                    }, undefined, {
+                        brandsUid: String(brandsUid),
+                        brandsXItemsUid: String(brandsXItemsUid),
+                    });
+                },
+                /**
+                 * 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: async (brandsUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/brands/{brandsUid}/items',
+                        paramsSchema: CreateBrandItemRequestSchema,
+                        responseSchema: BrandItemResponseSchema,
+                    }, request, { brandsUid: String(brandsUid) });
+                },
+                /**
+                 * 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: async (brandsUid, brandsXItemsUid, request) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/brands/{brandsUid}/items/{brandsXItemsUid}',
+                        paramsSchema: UpdateBrandItemRequestSchema,
+                        responseSchema: BrandItemResponseSchema,
+                    }, request, {
+                        brandsUid: String(brandsUid),
+                        brandsXItemsUid: String(brandsXItemsUid),
+                    });
+                },
+                /**
+                 * 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: async (brandsUid, brandsXItemsUid) => {
+                    return this.executeRequest({
+                        method: 'DELETE',
+                        path: '/brands/{brandsUid}/items/{brandsXItemsUid}',
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.any(),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, undefined, {
+                        brandsUid: String(brandsUid),
+                        brandsXItemsUid: String(brandsXItemsUid),
+                    });
+                },
+            },
         };
         /**
          * Attribute group management endpoints
@@ -630,7 +1091,7 @@ export class ItemsClient extends BaseServiceClient {
              * console.log(group.data.attributeGroupDesc, group.data.attributeGroupType);
              * ```
              */
-            get: this.createGetMethod('/attribute-groups/{id}', AttributeGroupResponseSchema),
+            get: this.createGetMethod('/attribute-groups/{attributeGroupUid}', AttributeGroupResponseSchema),
             /**
              * Create a new attribute group
              * @description Create a new attribute group with specified properties
@@ -662,7 +1123,7 @@ export class ItemsClient extends BaseServiceClient {
              * });
              * ```
              */
-            update: this.createUpdateMethod('/attribute-groups/{id}', UpdateAttributeGroupRequestSchema, AttributeGroupResponseSchema),
+            update: this.createUpdateMethod('/attribute-groups/{attributeGroupUid}', UpdateAttributeGroupRequestSchema, AttributeGroupResponseSchema),
             /**
              * Delete an attribute group
              * @description Soft delete an attribute group (sets status to inactive)
@@ -678,9 +1139,264 @@ export class ItemsClient extends BaseServiceClient {
             delete: async (attributeGroupUid) => {
                 return this.executeRequest({
                     method: 'DELETE',
-                    path: '/attribute-groups/{id}',
+                    path: '/attribute-groups/{attributeGroupUid}',
                     responseSchema: AttributeGroupResponseSchema,
-                }, undefined, { id: String(attributeGroupUid) });
+                }, undefined, { attributeGroupUid: String(attributeGroupUid) });
+            },
+            /**
+             * 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: async (attributeGroupUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/attribute-groups/{attributeGroupUid}/attributes',
+                        paramsSchema: StandardPaginationParamsSchema,
+                        responseSchema: AttributeValueListResponseSchema,
+                    }, params, { attributeGroupUid: String(attributeGroupUid) });
+                },
+                /**
+                 * 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: async (attributeGroupUid, attributeXAttributeGroupUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/attribute-groups/{attributeGroupUid}/attributes/{attributeXAttributeGroupUid}',
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.object({
+                                attributeXAttributeGroupUid: z.number(),
+                                attributeGroupUid: z.number(),
+                                attributeUid: z.number(),
+                                sequenceNo: z.number().optional(),
+                            }),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, undefined, {
+                        attributeGroupUid: String(attributeGroupUid),
+                        attributeXAttributeGroupUid: String(attributeXAttributeGroupUid),
+                    });
+                },
+                /**
+                 * 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: async (attributeGroupUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/attribute-groups/{attributeGroupUid}/attributes',
+                        paramsSchema: z.object({
+                            attributeUid: z.number(),
+                            sequenceNo: z.number().optional(),
+                        }),
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.object({
+                                attributeXAttributeGroupUid: z.number(),
+                                attributeGroupUid: z.number(),
+                                attributeUid: z.number(),
+                                sequenceNo: z.number().optional(),
+                            }),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, request, { attributeGroupUid: String(attributeGroupUid) });
+                },
+                /**
+                 * 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: async (attributeGroupUid, attributeXAttributeGroupUid, request) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/attribute-groups/{attributeGroupUid}/attributes/{attributeXAttributeGroupUid}',
+                        paramsSchema: z.object({
+                            sequenceNo: z.number().optional(),
+                        }),
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.object({
+                                attributeXAttributeGroupUid: z.number(),
+                                attributeGroupUid: z.number(),
+                                attributeUid: z.number(),
+                                sequenceNo: z.number().optional(),
+                            }),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, request, {
+                        attributeGroupUid: String(attributeGroupUid),
+                        attributeXAttributeGroupUid: String(attributeXAttributeGroupUid),
+                    });
+                },
+                /**
+                 * 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: async (attributeGroupUid, attributeXAttributeGroupUid) => {
+                    await this.executeRequest({
+                        method: 'DELETE',
+                        path: '/attribute-groups/{attributeGroupUid}/attributes/{attributeXAttributeGroupUid}',
+                        responseSchema: z.object({
+                            count: z.number(),
+                            data: z.any(),
+                            message: z.string(),
+                            options: z.any(),
+                            params: z.any(),
+                            status: z.number(),
+                            total: z.number(),
+                            totalResults: z.number(),
+                        }),
+                    }, undefined, {
+                        attributeGroupUid: String(attributeGroupUid),
+                        attributeXAttributeGroupUid: String(attributeXAttributeGroupUid),
+                    });
+                    return true;
+                },
             },
         };
         /**
@@ -710,26 +1426,7 @@ export class ItemsClient extends BaseServiceClient {
                     responseSchema: AttributeValueListResponseSchema,
                 }, params);
             },
-            /**
-             * 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: async (attributeValueUid) => {
-                const response = await this.executeRequest({
-                    method: 'GET',
-                    path: '/attribute-values/{id}',
-                    responseSchema: AttributeValueListResponseSchema,
-                }, undefined, { id: String(attributeValueUid) });
-                return response.data[0];
-            },
+            // Note: get method removed - /attribute-values/{id} not in OpenAPI specification
         };
         /**
          * Item attribute value management endpoints
@@ -777,20 +1474,20 @@ export class ItemsClient extends BaseServiceClient {
             create: this.createCreateMethod('/item-attribute-values', CreateItemAttributeValueRequestSchema, ItemAttributeValueResponseSchema),
         };
         /**
-         * 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()
          */
-        this.health = {
+        this.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"]
@@ -803,26 +1500,32 @@ export 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: this.createHealthCheckMethod(HealthCheckResponseSchema),
+            get: this.createHealthCheckMethod(HealthCheckResponseSchema),
+        };
+        /**
+         * Ping endpoint - Direct path mapping to /ping
+         * @description OpenAPI Path Mirroring: /ping → ping.get()
+         */
+        this.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"
@@ -831,11 +1534,11 @@ export 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: async () => {
+            get: async () => {
                 return this.executeRequest({
                     method: 'GET',
                     path: '/ping',
@@ -845,510 +1548,318 @@ export class ItemsClient extends BaseServiceClient {
             },
         };
         /**
-         * 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
          */
-        this.healthData = {
+        this.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: async () => {
-                const response = await this.health.check();
+            get: async () => {
+                const response = await this.healthCheck.get();
                 return response.data;
             },
+        };
+        /**
+         * Ping data-only endpoints
+         * @description Data-only methods that return just the data portion of ping responses
+         */
+        this.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: async () => {
-                const response = await this.health.ping();
-                return response.data;
-            },
-        };
-        /**
-         * Item favorites management endpoints
-         * @description Methods for managing user favorite items
-         */
-        this.itemFavorites = {
-            /**
-             * 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: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-favorites',
-                    paramsSchema: ItemFavoritesListParamsSchema,
-                    responseSchema: ItemFavoriteListResponseSchema,
-                }, params);
-            },
-            /**
-             * 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: this.createCreateMethod('/item-favorites', CreateItemFavoriteRequestSchema, ItemFavoriteResponseSchema),
-            /**
-             * 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: this.createDeleteMethod('/item-favorites/{id}', ItemFavoriteResponseSchema),
-            /**
-             * 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'
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/item-favorites/{id}', UpdateItemFavoriteRequestSchema, ItemFavoriteResponseSchema),
-        };
-        /**
-         * Item favorites data-only endpoints
-         * @description Data-only methods that return just the data portion of favorites responses
-         */
-        this.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: async (params) => {
-                const response = await this.itemFavorites.list(params);
+            get: async () => {
+                const response = await this.ping.get();
                 return response.data;
             },
         };
         /**
-         * Item wishlists management endpoints
-         * @description Methods for managing user wishlists and wishlist items
-         */
-        this.itemWishlist = {
-            /**
-             * List user's wishlists
-             * @description Retrieve a list of the current user's wishlists
-             * @fullPath api.items.itemWishlist.list
-             * @service items
-             * @domain user-preferences
-             * @dataMethod itemWishlistData.list
-             * @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"]
-             * @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"]
-             * @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
-             * @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 });
-             * wishlists.data.forEach(list => {
-             *   console.log(`Wishlist: ${list.wishlistName} (${list.wishlistDescription})`);
-             * });
-             * ```
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-wishlist',
-                    paramsSchema: ItemWishlistListParamsSchema,
-                    responseSchema: ItemWishlistHeaderListResponseSchema,
-                }, params);
-            },
-            /**
-             * 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: this.createGetMethod('/item-wishlist/{id}', ItemWishlistHeaderResponseSchema),
-            /**
-             * Create new wishlist
-             * @description Create a new wishlist for the current user
-             * @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({
-             *   wishlistName: 'Home Office Setup',
-             *   wishlistDescription: 'Items for my home office renovation',
-             *   isPublic: 'N'
-             * });
-             * ```
-             */
-            create: this.createCreateMethod('/item-wishlist', CreateItemWishlistHeaderRequestSchema, ItemWishlistHeaderResponseSchema),
-            /**
-             * 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: this.createUpdateMethod('/item-wishlist/{id}', UpdateItemWishlistHeaderRequestSchema, ItemWishlistHeaderResponseSchema),
-            /**
-             * 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: this.createDeleteMethod('/item-wishlist/{id}', ItemWishlistHeaderResponseSchema),
-            /**
-             * 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}`);
-             * });
-             * ```
-             */
-            getLines: async (wishlistUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-wishlist/{id}/lines',
-                    paramsSchema: ItemWishlistLineListParamsSchema,
-                    responseSchema: ItemWishlistLineListResponseSchema,
-                }, params, { id: String(wishlistUid) });
-            },
-            /**
-             * 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: async (wishlistUid, request) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/item-wishlist/{id}/lines',
-                    paramsSchema: CreateItemWishlistLineRequestSchema,
-                    responseSchema: ItemWishlistLineResponseSchema,
-                }, request, { id: String(wishlistUid) });
-            },
-            /**
-             * 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: async (wishlistUid, lineUid, request) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: '/item-wishlist/{wishlistId}/lines/{lineId}',
-                    paramsSchema: UpdateItemWishlistLineRequestSchema,
-                    responseSchema: ItemWishlistLineResponseSchema,
-                }, request, { wishlistId: String(wishlistUid), lineId: String(lineUid) });
-            },
-            /**
-             * 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: async (wishlistUid, lineUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: '/item-wishlist/{wishlistId}/lines/{lineId}',
-                    responseSchema: ItemWishlistLineResponseSchema,
-                }, undefined, { wishlistId: String(wishlistUid), lineId: String(lineUid) });
-            },
-        };
-        /**
-         * Item wishlists data-only endpoints
-         * @description Data-only methods that return just the data portion of wishlists responses
+         * Internal endpoints - Direct path mapping to /internal/*
+         * @description OpenAPI Path Mirroring: /internal/* → internal.*
          */
-        this.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: async (params) => {
-                const response = await this.itemWishlist.list(params);
-                return response.data;
-            },
+        this.internal = {
             /**
-             * 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
+             * PDF generation endpoints - Direct path mapping to /internal/pdf
+             * @description OpenAPI Path Mirroring: /internal/pdf → internal.pdf.create()
              */
-            getLines: async (wishlistUid, params) => {
-                const response = await this.itemWishlist.getLines(wishlistUid, params);
-                return response.data;
+            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: async (request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/internal/pdf',
+                        paramsSchema: z.object({
+                            templateId: z.string(),
+                            data: z.record(z.unknown()),
+                        }),
+                        responseSchema: InternalPdfResponseSchema,
+                    }, request);
+                },
             },
         };
         /**
-         * Item category management endpoints
-         * @description Methods for managing item categories following OpenAPI path mirroring pattern
+         * Legacy itemFavorites removed - now using OpenAPI Path Mirroring Pattern
+         * @see itemFavorites implementation below that follows /item-favorites/{usersId} structure
          */
-        this.itemCategory = {
+        // Legacy implementation removed
+        /**
+         * Item wishlists management endpoints
+         * @description Methods for managing user wishlists and wishlist items
+         */
+        this.itemWishlist = {
             /**
-             * List item categories
-             * @description Retrieve a list of item categories
-             * @fullPath api.items.itemCategory.list
+             * Get user's wishlists
+             * @description Retrieve wishlists for a specific user (OpenAPI: /item-wishlist/{usersId})
+             * @fullPath api.items.itemWishlist.get
              * @service items
-             * @domain product-catalog
-             * @dataMethod itemCategoryData.list
+             * @domain user-preferences
+             * @dataMethod itemWishlistData.get
              * @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
+             * @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.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 "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 categories = await client.itemCategory.list({ parentUid: 100 });
-             * categories.data.forEach(cat => {
-             *   console.log(`Category: ${cat.itemCategoryDesc} (${cat.path})`);
+             * const wishlists = await client.itemWishlist.get(12345);
+             * wishlists.data.forEach(list => {
+             *   console.log(`Wishlist: ${list.wishlistName} (${list.wishlistDescription})`);
              * });
              * ```
              */
-            list: async (params) => {
+            get: async (usersId) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/item-category',
-                    paramsSchema: CategoryListParamsSchema,
-                    responseSchema: CategoryListResponseSchema,
-                }, params);
+                    path: '/item-wishlist/{usersId}',
+                    responseSchema: ItemWishlistHeaderListResponseSchema,
+                }, undefined, { usersId: String(usersId) });
             },
+            // Note: duplicate get method removed - OpenAPI structure requires usersId parameter
             /**
-             * 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
+             * 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 category = await client.itemCategory.get(123);
-             * console.log(category.data.itemCategoryDesc, category.data.path);
+             * const wishlist = await client.itemWishlist.create(12345, {
+             *   wishlistName: 'Home Office Setup',
+             *   wishlistDescription: 'Items for my home office renovation',
+             *   isPublic: 'N'
+             * });
              * ```
              */
-            get: this.createGetMethod('/item-category/{id}', CategoryResponseSchema),
+            create: async (usersId, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/item-wishlist/{usersId}',
+                    paramsSchema: CreateItemWishlistHeaderRequestSchema,
+                    responseSchema: ItemWishlistHeaderResponseSchema,
+                }, request, { usersId: String(usersId) });
+            },
             /**
-             * 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);
-             * ```
+             * Wishlist header management endpoints
+             * @description Methods for managing specific wishlist headers (OpenAPI: /item-wishlist/{usersId}/hdr/{itemWishlistHdrUid})
              */
-            doc: {
-                get: async (itemCategoryUid) => {
+            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: async (usersId, itemWishlistHdrUid) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/item-category/{itemCategoryUid}/doc',
-                        responseSchema: CategoryResponseSchema,
-                    }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+                        path: '/item-wishlist/{usersId}/hdr/{itemWishlistHdrUid}',
+                        responseSchema: ItemWishlistHeaderResponseSchema,
+                    }, undefined, { usersId: String(usersId), itemWishlistHdrUid: String(itemWishlistHdrUid) });
+                },
+                /**
+                 * 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: async (usersId, itemWishlistHdrUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/item-wishlist/{usersId}/hdr/{itemWishlistHdrUid}',
+                        paramsSchema: CreateItemWishlistHeaderRequestSchema,
+                        responseSchema: ItemWishlistHeaderResponseSchema,
+                    }, request, { usersId: String(usersId), itemWishlistHdrUid: String(itemWishlistHdrUid) });
+                },
+                /**
+                 * 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: async (usersId, itemWishlistHdrUid, itemWishlistLineUid) => {
+                        return this.executeRequest({
+                            method: 'GET',
+                            path: '/item-wishlist/{usersId}/hdr/{itemWishlistHdrUid}/line/{itemWishlistLineUid}',
+                            responseSchema: ItemWishlistLineResponseSchema,
+                        }, undefined, {
+                            usersId: String(usersId),
+                            itemWishlistHdrUid: String(itemWishlistHdrUid),
+                            itemWishlistLineUid: String(itemWishlistLineUid),
+                        });
+                    },
+                    /**
+                     * 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: async (usersId, itemWishlistHdrUid, itemWishlistLineUid) => {
+                        return this.executeRequest({
+                            method: 'DELETE',
+                            path: '/item-wishlist/{usersId}/hdr/{itemWishlistHdrUid}/line/{itemWishlistLineUid}',
+                            responseSchema: z.object({
+                                count: z.number(),
+                                data: z.any(),
+                                message: z.string(),
+                                options: z.any(),
+                                params: z.any(),
+                                status: z.number(),
+                                total: z.number(),
+                                totalResults: z.number(),
+                            }),
+                        }, undefined, {
+                            usersId: String(usersId),
+                            itemWishlistHdrUid: String(itemWishlistHdrUid),
+                            itemWishlistLineUid: String(itemWishlistLineUid),
+                        });
+                    },
                 },
-            },
-            /**
-             * 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: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-category/lookup',
-                    paramsSchema: CategoryLookupParamsSchema,
-                    responseSchema: CategoryListResponseSchema,
-                }, params);
             },
         };
         /**
-         * 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
          */
-        this.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: async (params) => {
-                const response = await this.itemCategory.list(params);
-                return response.data;
-            },
+        this.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: async (itemCategoryUid) => {
-                const response = await this.itemCategory.get(itemCategoryUid);
+            get: async (usersId) => {
+                const response = await this.itemWishlist.get(usersId);
                 return response.data;
             },
+            // Note: getLines data method removed - parent method was removed for OpenAPI compliance
         };
         /**
          * Product variants management endpoints
@@ -1404,7 +1915,7 @@ export class ItemsClient extends BaseServiceClient {
              * console.log(variant.data.variantGroupName, variant.data.variantType);
              * ```
              */
-            get: this.createGetMethod('/variants/{id}', ItemVariantHeaderResponseSchema),
+            get: this.createGetMethod('/variants/{itemVariantHdrUid}', ItemVariantHeaderResponseSchema),
             /**
              * Create new variant group
              * @description Create a new product variant group
@@ -1437,7 +1948,7 @@ export class ItemsClient extends BaseServiceClient {
              * });
              * ```
              */
-            update: this.createUpdateMethod('/variants/{id}', UpdateItemVariantHeaderRequestSchema, ItemVariantHeaderResponseSchema),
+            update: this.createUpdateMethod('/variants/{itemVariantHdrUid}', UpdateItemVariantHeaderRequestSchema, ItemVariantHeaderResponseSchema),
             /**
              * Delete variant group
              * @description Delete a variant group and all its variant items
@@ -1449,7 +1960,7 @@ export class ItemsClient extends BaseServiceClient {
              * await client.variants.delete(123);
              * ```
              */
-            delete: this.createDeleteMethod('/variants/{id}', ItemVariantHeaderResponseSchema),
+            delete: this.createDeleteMethod('/variants/{itemVariantHdrUid}', ItemVariantHeaderResponseSchema),
             /**
              * Get variant items
              * @description Retrieve items in a specific variant group
@@ -1467,9 +1978,9 @@ export class ItemsClient extends BaseServiceClient {
             getLines: async (variantHeaderUid) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/variants/{id}/lines',
+                    path: '/variants/{itemVariantHdrUid}/lines',
                     responseSchema: ItemVariantLineListResponseSchema,
-                }, undefined, { id: String(variantHeaderUid) });
+                }, undefined, { itemVariantHdrUid: String(variantHeaderUid) });
             },
             /**
              * Add variant item
@@ -1492,10 +2003,10 @@ export class ItemsClient extends BaseServiceClient {
             addLine: async (variantHeaderUid, request) => {
                 return this.executeRequest({
                     method: 'POST',
-                    path: '/variants/{id}/lines',
+                    path: '/variants/{itemVariantHdrUid}/lines',
                     paramsSchema: CreateItemVariantLineRequestSchema,
                     responseSchema: ItemVariantLineResponseSchema,
-                }, request, { id: String(variantHeaderUid) });
+                }, request, { itemVariantHdrUid: String(variantHeaderUid) });
             },
             /**
              * Update variant item
@@ -1607,10 +2118,10 @@ export class ItemsClient extends BaseServiceClient {
             list: async (invMastUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/inv-mast/{id}/faq',
+                    path: '/inv-mast/{invMastUid}/faq',
                     paramsSchema: ItemFaqListParamsSchema,
                     responseSchema: ItemFaqListResponseSchema,
-                }, params, { id: String(invMastUid) });
+                }, params, { invMastUid: String(invMastUid) });
             },
             /**
              * Get FAQ details
@@ -1652,10 +2163,10 @@ export class ItemsClient extends BaseServiceClient {
             create: async (invMastUid, request) => {
                 return this.executeRequest({
                     method: 'POST',
-                    path: '/inv-mast/{id}/faq',
+                    path: '/inv-mast/{invMastUid}/faq',
                     paramsSchema: CreateItemFaqRequestSchema,
                     responseSchema: ItemFaqResponseSchema,
-                }, request, { id: String(invMastUid) });
+                }, request, { invMastUid: String(invMastUid) });
             },
             /**
              * Update FAQ
@@ -1739,155 +2250,6 @@ export class ItemsClient extends BaseServiceClient {
                 return response.data;
             },
         };
-        /**
-         * Brand-item relationship management endpoints
-         * @description Methods for managing relationships between brands and items
-         */
-        this.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: async (brandUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/brands/{id}/items',
-                    paramsSchema: BrandItemListParamsSchema,
-                    responseSchema: BrandItemListResponseSchema,
-                }, params, { id: String(brandUid) });
-            },
-            /**
-             * 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: async (brandUid, brandItemUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/brands/{brandId}/items/{itemId}',
-                    responseSchema: BrandItemResponseSchema,
-                }, undefined, { brandId: String(brandUid), itemId: String(brandItemUid) });
-            },
-            /**
-             * 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: async (brandUid, request) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/brands/{id}/items',
-                    paramsSchema: CreateBrandItemRequestSchema,
-                    responseSchema: BrandItemResponseSchema,
-                }, request, { id: String(brandUid) });
-            },
-            /**
-             * 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: async (brandUid, brandItemUid, request) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: '/brands/{brandId}/items/{itemId}',
-                    paramsSchema: UpdateBrandItemRequestSchema,
-                    responseSchema: BrandItemResponseSchema,
-                }, request, { brandId: String(brandUid), itemId: String(brandItemUid) });
-            },
-            /**
-             * 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: async (brandUid, brandItemUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: '/brands/{brandId}/items/{itemId}',
-                    responseSchema: BrandItemResponseSchema,
-                }, undefined, { brandId: String(brandUid), itemId: String(brandItemUid) });
-            },
-        };
-        /**
-         * Brand-item relationship data-only endpoints
-         * @description Data-only methods that return just the data portion of brand-item responses
-         */
-        this.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: async (brandUid, params) => {
-                const response = await this.brandItems.list(brandUid, params);
-                return response.data;
-            },
-        };
         /**
          * Product links management endpoints
          * @description Methods for managing relationships between products (accessories, related items, etc.)
@@ -1926,10 +2288,10 @@ export class ItemsClient extends BaseServiceClient {
             list: async (invMastUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/inv-mast/{id}/links',
+                    path: '/inv-mast/{invMastUid}/links',
                     paramsSchema: ProductLinkListParamsSchema,
                     responseSchema: ProductLinkListResponseSchema,
-                }, params, { id: String(invMastUid) });
+                }, params, { invMastUid: String(invMastUid) });
             },
             /**
              * Get product link details
@@ -1971,10 +2333,10 @@ export class ItemsClient extends BaseServiceClient {
             create: async (invMastUid, request) => {
                 return this.executeRequest({
                     method: 'POST',
-                    path: '/inv-mast/{id}/links',
+                    path: '/inv-mast/{invMastUid}/links',
                     paramsSchema: CreateProductLinkRequestSchema,
                     responseSchema: ProductLinkResponseSchema,
-                }, request, { id: String(invMastUid) });
+                }, request, { invMastUid: String(invMastUid) });
             },
             /**
              * Update product link
@@ -2075,10 +2437,10 @@ export class ItemsClient extends BaseServiceClient {
             list: async (invMastUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/inv-mast/{id}/subparts',
+                    path: '/inv-mast/{invMastUid}/subparts',
                     paramsSchema: SubPartListParamsSchema,
                     responseSchema: SubPartListResponseSchema,
-                }, params, { id: String(invMastUid) });
+                }, params, { invMastUid: String(invMastUid) });
             },
             /**
              * Get sub-part details
@@ -2121,10 +2483,10 @@ export class ItemsClient extends BaseServiceClient {
             create: async (invMastUid, request) => {
                 return this.executeRequest({
                     method: 'POST',
-                    path: '/inv-mast/{id}/subparts',
+                    path: '/inv-mast/{invMastUid}/subparts',
                     paramsSchema: CreateSubPartRequestSchema,
                     responseSchema: SubPartResponseSchema,
-                }, request, { id: String(invMastUid) });
+                }, request, { invMastUid: String(invMastUid) });
             },
             /**
              * Update sub-part relationship
@@ -2198,62 +2560,61 @@ export 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: async (locationId, params) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/locations/{id}/bins',
-                        paramsSchema: BinListParamsSchema,
-                        responseSchema: BinListResponseSchema,
-                    }, params, { id: String(locationId) });
+                        path: '/locations/{locationId}/bins',
+                        paramsSchema: LocationsBinsParamsSchema,
+                        responseSchema: LocationsBinsResponseSchema,
+                    }, params, { locationId: String(locationId) });
                 },
                 /**
-                 * 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: async (locationId, bin) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/locations/{locationId}/bins/{bin}',
-                        responseSchema: BinResponseSchema,
-                    }, undefined, { locationId: String(locationId), bin });
+                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: async (locationId, bin, params) => {
+                        return this.executeRequest({
+                            method: 'GET',
+                            path: '/locations/{locationId}/bins/{bin}',
+                            paramsSchema: LocationsBinsParamsSchema,
+                            responseSchema: LocationsBinsResponseSchema,
+                        }, params, { locationId: String(locationId), bin });
+                    },
                 },
                 /**
                  * Create new bin
@@ -2278,10 +2639,10 @@ export class ItemsClient extends BaseServiceClient {
                 create: async (locationId, request) => {
                     return this.executeRequest({
                         method: 'POST',
-                        path: '/locations/{id}/bins',
+                        path: '/locations/{locationId}/bins',
                         paramsSchema: CreateBinRequestSchema,
                         responseSchema: BinResponseSchema,
-                    }, request, { id: String(locationId) });
+                    }, request, { locationId: String(locationId) });
                 },
                 /**
                  * Update bin
@@ -2346,8 +2707,8 @@ export class ItemsClient extends BaseServiceClient {
                     return this.executeRequest({
                         method: 'GET',
                         path: '/inv-mast/{invMastId}/locations/{locationId}/bins',
-                        paramsSchema: InventoryLocationBinListParamsSchema,
-                        responseSchema: InventoryLocationBinListResponseSchema,
+                        paramsSchema: LocationsBinsParamsSchema,
+                        responseSchema: LocationsBinsResponseSchema,
                     }, params, { invMastId: String(invMastUid), locationId: String(locationId) });
                 },
             },
@@ -2385,6 +2746,40 @@ export class ItemsClient extends BaseServiceClient {
                     const response = await this.locations.bins.getInventory(invMastUid, locationId, params);
                     return response.data;
                 },
+                /**
+                 * 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: async (locationId, bin, params) => {
+                        const response = await this.locations.bins.bin.get(locationId, bin, params);
+                        return response.data;
+                    },
+                },
             },
         };
         /**
@@ -2732,157 +3127,6 @@ export class ItemsClient extends BaseServiceClient {
          * Brand item associations
          * @description Methods for managing item associations within brands
          */
-        this.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: async (brandsUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/brands/{brandsUid}/items',
-                    paramsSchema: StandardPaginationParamsSchema,
-                    responseSchema: ProductListResponseSchema,
-                }, params, { brandsUid: String(brandsUid) });
-            },
-            /**
-             * Add item to brand
-             * @description Associate an item with a brand
-             * @param brandsUid Brand 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
-             * });
-             * ```
-             */
-            create: async (brandsUid, request) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/brands/{brandsUid}/items',
-                    paramsSchema: z.object({
-                        invMastUid: z.number(),
-                    }),
-                    responseSchema: z.object({
-                        count: z.number(),
-                        data: z.object({
-                            brandsXItemsUid: z.number(),
-                            brandsUid: z.number(),
-                            invMastUid: z.number(),
-                        }),
-                        message: z.string(),
-                        options: z.any(),
-                        params: z.any(),
-                        status: z.number(),
-                        total: z.number(),
-                        totalResults: z.number(),
-                    }),
-                }, request, { brandsUid: String(brandsUid) });
-            },
-            /**
-             * Get specific brand-item association
-             * @description Get details of a specific brand-item association
-             * @param brandsUid Brand unique identifier
-             * @param brandsXItemsUid 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);
-             * ```
-             */
-            get: async (brandsUid, brandsXItemsUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/brands/{brandsUid}/items/{brandsXItemsUid}',
-                    responseSchema: z.object({
-                        count: z.number(),
-                        data: z.object({
-                            brandsXItemsUid: z.number(),
-                            brandsUid: z.number(),
-                            invMastUid: z.number(),
-                        }),
-                        message: z.string(),
-                        options: z.any(),
-                        params: z.any(),
-                        status: z.number(),
-                        total: z.number(),
-                        totalResults: z.number(),
-                    }),
-                }, undefined, { brandsUid: String(brandsUid), brandsXItemsUid: String(brandsXItemsUid) });
-            },
-            /**
-             * Update brand-item association
-             * @description Update a brand-item association
-             * @param brandsUid Brand unique identifier
-             * @param brandsXItemsUid 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
-             * });
-             * ```
-             */
-            update: async (brandsUid, brandsXItemsUid, request) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: '/brands/{brandsUid}/items/{brandsXItemsUid}',
-                    paramsSchema: UpdateBrandItemRequestSchema,
-                    responseSchema: z.object({
-                        count: z.number(),
-                        data: z.object({
-                            brandsXItemsUid: z.number(),
-                            brandsUid: z.number(),
-                            invMastUid: z.number(),
-                        }),
-                        message: z.string(),
-                        options: z.any(),
-                        params: z.any(),
-                        status: z.number(),
-                        total: z.number(),
-                        totalResults: z.number(),
-                    }),
-                }, request, { brandsUid: String(brandsUid), brandsXItemsUid: String(brandsXItemsUid) });
-            },
-            /**
-             * Remove item from brand
-             * @description Remove an item association from a brand
-             * @param brandsUid Brand unique identifier
-             * @param brandsXItemsUid Association unique identifier
-             * @returns Success indication
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * await client.brandItems.delete(123, 789);
-             * ```
-             */
-            delete: async (brandsUid, brandsXItemsUid) => {
-                await this.executeRequest({
-                    method: 'DELETE',
-                    path: '/brands/{brandsUid}/items/{brandsXItemsUid}',
-                    responseSchema: z.undefined(),
-                }, undefined, { brandsUid: String(brandsUid), brandsXItemsUid: String(brandsXItemsUid) });
-                return true;
-            },
-        };
         /**
          * Additional missing endpoints
          * @description Methods for endpoints that were missing from the implementation
@@ -3269,7 +3513,7 @@ export class ItemsClient extends BaseServiceClient {
              * console.log(invMast.data.itemId, invMast.data.itemDesc, invMast.data.listPrice);
              * ```
              */
-            get: this.createGetMethod('/inv-mast/{id}', ProductResponseSchema),
+            get: this.createGetMethod('/inv-mast/{invMastUid}', ProductResponseSchema),
             /**
              * List inventory masters with filtering and pagination
              * @description Retrieve a paginated list of inventory masters with comprehensive filtering options
@@ -3372,7 +3616,7 @@ export class ItemsClient extends BaseServiceClient {
                 get: async (invMastUid, params) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/doc',
+                        path: '/inv-mast/{invMastUid}/doc',
                         paramsSchema: z
                             .object({
                             includePricing: z.string().optional(),
@@ -3380,13 +3624,13 @@ export class ItemsClient extends BaseServiceClient {
                         })
                             .optional(),
                         responseSchema: ProductResponseSchema,
-                    }, params, { id: String(invMastUid) });
+                    }, params, { invMastUid: String(invMastUid) });
                 },
             },
             /**
              * 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
@@ -3396,22 +3640,22 @@ export 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: async (invMastUid) => {
+                list: async (invMastUid) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/similar',
+                        path: '/inv-mast/{invMastUid}/similar',
                         responseSchema: ProductListResponseSchema,
-                    }, undefined, { id: String(invMastUid) });
+                    }, undefined, { invMastUid: String(invMastUid) });
                 },
             },
             /**
              * 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
@@ -3421,34 +3665,23 @@ export 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: async (invMastUid) => {
+                list: async (invMastUid, params) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/alternate-code',
-                        responseSchema: z.object({
-                            count: z.number(),
-                            data: z.array(z.object({
-                                alternateCode: z.string(),
-                                codeType: z.string().optional(),
-                            })),
-                            message: z.string(),
-                            options: z.any(),
-                            params: z.any(),
-                            status: z.number(),
-                            total: z.number(),
-                            totalResults: z.number(),
-                        }),
-                    }, undefined, { id: String(invMastUid) });
+                        path: '/inv-mast/{invMastUid}/alternate-code',
+                        paramsSchema: AlternateCodeListParamsSchema,
+                        responseSchema: AlternateCodeListResponseSchema,
+                    }, params, { invMastUid: String(invMastUid) });
                 },
             },
             /**
              * 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
@@ -3458,22 +3691,22 @@ export 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: async (invMastUid) => {
+                list: async (invMastUid) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/inv-accessory',
+                        path: '/inv-mast/{invMastUid}/inv-accessory',
                         responseSchema: AccessoryListResponseSchema,
-                    }, undefined, { id: String(invMastUid) });
+                    }, undefined, { invMastUid: String(invMastUid) });
                 },
             },
             /**
              * 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
@@ -3483,16 +3716,16 @@ export 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: async (invMastUid) => {
+                list: async (invMastUid) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/inv-sub',
+                        path: '/inv-mast/{invMastUid}/inv-sub',
                         responseSchema: ProductListResponseSchema,
-                    }, undefined, { id: String(invMastUid) });
+                    }, undefined, { invMastUid: String(invMastUid) });
                 },
             },
             /**
@@ -3516,10 +3749,10 @@ export class ItemsClient extends BaseServiceClient {
                 get: async (invMastUid, params) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/stock',
+                        path: '/inv-mast/{invMastUid}/stock',
                         paramsSchema: GetStockParamsSchema,
                         responseSchema: GetStockResponseSchema,
-                    }, params, { id: String(invMastUid) });
+                    }, params, { invMastUid: String(invMastUid) });
                 },
             },
             /**
@@ -3537,10 +3770,10 @@ export class ItemsClient extends BaseServiceClient {
                 list: async (invMastUid, params) => {
                     return this.executeRequest({
                         method: 'GET',
-                        path: '/inv-mast/{id}/faq',
+                        path: '/inv-mast/{invMastUid}/faq',
                         paramsSchema: ItemFaqListParamsSchema,
                         responseSchema: ItemFaqListResponseSchema,
-                    }, params, { id: String(invMastUid) });
+                    }, params, { invMastUid: String(invMastUid) });
                 },
                 /**
                  * Create FAQ for an inventory master
@@ -3552,10 +3785,10 @@ export class ItemsClient extends BaseServiceClient {
                 create: async (invMastUid, request) => {
                     return this.executeRequest({
                         method: 'POST',
-                        path: '/inv-mast/{id}/faq',
+                        path: '/inv-mast/{invMastUid}/faq',
                         paramsSchema: CreateItemFaqRequestSchema,
                         responseSchema: ItemFaqResponseSchema,
-                    }, request, { id: String(invMastUid) });
+                    }, request, { invMastUid: String(invMastUid) });
                 },
                 /**
                  * Get specific FAQ for an inventory master
@@ -3862,6 +4095,335 @@ export 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()
+         */
+        this.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: async (invMastUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast-links/{invMastUid}',
+                    responseSchema: InvMastLinksResponseSchema,
+                }, undefined, { invMastUid: String(invMastUid) });
+            },
+            /**
+             * 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: async (invMastUid) => {
+                const response = await this.invMastLinks.list(invMastUid);
+                return response.data;
+            },
+        };
+        /**
+         * 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()
+         */
+        this.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: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast-sub-parts/{invMastUid}',
+                    paramsSchema: InvMastSubPartsParamsSchema,
+                    responseSchema: InvMastSubPartsResponseSchema,
+                }, params, { invMastUid: String(invMastUid) });
+            },
+            /**
+             * 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: async (invMastUid, params) => {
+                const response = await this.invMastSubParts.list(invMastUid, params);
+                return response.data;
+            },
+        };
+        /**
+         * 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()
+         */
+        this.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: async (usersId) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/item-favorites/{usersId}',
+                    responseSchema: ItemFavoritesListResponseSchema,
+                }, undefined, { usersId: String(usersId) });
+            },
+            /**
+             * 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: async (usersId) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/item-favorites/{usersId}',
+                    responseSchema: ItemFavoritesItemResponseSchema,
+                }, undefined, { usersId: String(usersId) });
+            },
+            /**
+             * 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: async (usersId, invMastUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/item-favorites/{usersId}/{invMastUid}',
+                    responseSchema: ItemFavoritesItemResponseSchema,
+                }, undefined, { usersId: String(usersId), invMastUid: String(invMastUid) });
+            },
+            /**
+             * 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: async (usersId, invMastUid) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/item-favorites/{usersId}/{invMastUid}',
+                    responseSchema: ItemFavoritesItemResponseSchema,
+                }, undefined, { usersId: String(usersId), invMastUid: String(invMastUid) });
+            },
+            /**
+             * 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: async (usersId, invMastUid) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/item-favorites/{usersId}/{invMastUid}',
+                    responseSchema: ItemFavoritesItemResponseSchema,
+                }, undefined, { usersId: String(usersId), invMastUid: String(invMastUid) });
+            },
+            /**
+             * Data-only methods for item favorites
+             */
+            listData: async (usersId) => {
+                const response = await this.itemFavorites.list(usersId);
+                return response.data;
+            },
+            getData: async (usersId, invMastUid) => {
+                const response = await this.itemFavorites.get(usersId, invMastUid);
+                return response.data;
+            },
+        };
     }
 }
 //# sourceMappingURL=client.js.map