@simpleapps-com/augur-api 0.2.12 → 0.3.0

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

@@ -31,10 +31,10 @@ const schemas_1 = require("./schemas");
  * const items = new ItemsClient(http);
  *
  * // Get product details
- * const product = await items.products.get(12345);
+ * const product = await items.invMast.get(12345);
  *
  * // Search products
- * const results = await items.products.search({ q: 'cable', limit: 20 });
+ * const results = await items.invMast.search({ q: 'cable', limit: 20 });
  *
  * // Get category with items
  * const category = await items.categories.get(100);
@@ -53,337 +53,6 @@ class ItemsClient extends base_client_1.BaseServiceClient {
          * Product catalog endpoints (Inventory Master - inv_mast)
          * @description Methods for product management including search, details, alternate codes, and accessories
          */
-        this.products = {
-            /**
-             * Get product details by inventory master UID
-             * @description Retrieves comprehensive details for a specific inventory item including categories, attributes, images, and related data
-             * @fullPath api.items.products.get
-             * @service items
-             * @domain inventory-management
-             * @dataMethod productsData.get
-             * @discoverable true
-             * @searchTerms ["product details", "item info", "inventory master", "product lookup", "item by id"]
-             * @relatedEndpoints ["api.items.products.search", "api.items.categories.getItems", "api.commerce.cartHeaders.addItem", "api.pricing.priceEngine.calculate"]
-             * @commonPatterns ["Get product by ID", "Product detail page", "Item information lookup"]
-             * @workflow ["product-detail-view", "add-to-cart-preparation", "inventory-verification"]
-             * @prerequisites ["Valid inventory master UID", "Product access permissions"]
-             * @nextSteps ["api.commerce.cartHeaders.addItem", "api.items.stock.getDetails", "api.items.products.getAccessories"]
-             * @businessRules ["Returns only accessible products", "Includes pricing if authorized", "Shows real-time stock if enabled"]
-             * @functionalArea "product-catalog-management"
-             * @caching "Cache for 10 minutes, invalidate on product updates"
-             * @performance "Single product lookup, optimized for product detail pages"
-             * @param invMastUid Inventory master unique identifier
-             * @param params Optional parameters for including additional data
-             * @returns Complete product details with all related information
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const product = await client.products.get(12345);
-             * console.log(product.data.itemId, product.data.itemDesc, product.data.listPrice);
-             * console.log('Categories:', product.data.categories);
-             * console.log('Attributes:', product.data.attributes);
-             * ```
-             */
-            get: this.createGetMethod('/inv-mast/{id}', schemas_1.ProductResponseSchema),
-            /**
-             * Get detailed product information by inventory master UID
-             * @description Retrieves detailed product information with comprehensive data
-             * @param invMastUid Inventory master unique identifier
-             * @param params Optional parameters for including additional data
-             * @returns Detailed product information
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const productDetail = await client.products.getDetail(12345, {
-             *   includeCategories: true,
-             *   includeAttributes: true,
-             *   includeStock: true
-             * });
-             * ```
-             */
-            getDetail: async (invMastUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{id}/detail',
-                    paramsSchema: schemas_1.ProductDetailParamsSchema,
-                    responseSchema: schemas_1.ProductDetailResponseSchema,
-                }, params, { id: String(invMastUid) });
-            },
-            /**
-             * Search products using various criteria
-             * @description Search for products by item ID, description, UPC, or other criteria with advanced filtering and pagination
-             * @fullPath api.items.products.search
-             * @service items
-             * @domain inventory-management
-             * @dataMethod productsData.search
-             * @discoverable true
-             * @searchTerms ["product search", "item search", "find products", "search catalog", "product lookup", "item finder"]
-             * @relatedEndpoints ["api.opensearch.items.search", "api.items.categories.getItems", "api.items.products.lookup", "api.legacy.inventory.search"]
-             * @commonPatterns ["Search product catalog", "Find items by keyword", "Product discovery", "Search with filters"]
-             * @workflow ["product-search", "catalog-browsing", "inventory-lookup"]
-             * @prerequisites ["Search query string", "Optional filters for refinement"]
-             * @nextSteps ["api.items.products.get for details", "api.items.categories.getItems for category filtering", "api.commerce.cartHeaders.addItem"]
-             * @businessRules ["Respects product visibility settings", "Filters by status and online codes", "Supports fuzzy search on descriptions"]
-             * @functionalArea "product-search-and-discovery"
-             * @caching "Search results cached for 5 minutes, vary by query parameters"
-             * @performance "Use limit parameter for pagination, combine with filters for better performance"
-             * @param params Search parameters including required query string
-             * @returns Array of matching products with basic information
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * // Basic product search
-             * const results = await client.products.search({ q: 'ethernet cable' });
-             *
-             * // Advanced search with filters
-             * const filtered = await client.products.search({
-             *   q: 'cable',
-             *   limit: 20,
-             *   statusCd: 704, // Active only
-             *   onlineCd: 704  // Online only
-             * });
-             *
-             * results.data.forEach(product => {
-             *   console.log(`${product.itemId}: ${product.itemDesc} - $${product.listPrice}`);
-             * });
-             * ```
-             */
-            search: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/search',
-                    paramsSchema: schemas_1.ProductSearchParamsSchema,
-                    responseSchema: schemas_1.ProductListResponseSchema,
-                }, params);
-            },
-            /**
-             * Lookup products with simplified data
-             * @description Lookup products with simplified response format for autocomplete and basic searches
-             * @param params Lookup parameters
-             * @returns Array of simplified product data
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const lookupResults = await client.products.lookup({
-             *   q: 'cable',
-             *   limit: 10
-             * });
-             * ```
-             */
-            lookup: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/lookup',
-                    paramsSchema: schemas_1.ProductLookupParamsSchema,
-                    responseSchema: schemas_1.ProductLookupResponseSchema,
-                }, params);
-            },
-            /**
-             * List products with filtering and pagination
-             * @description Retrieve a paginated list of products with comprehensive filtering options
-             * @param params Optional filtering and pagination parameters
-             * @returns Paginated list of products
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * // Get all active products
-             * const products = await client.products.list({ statusCd: 704, limit: 50 });
-             *
-             * // Get online products only
-             * const onlineProducts = await client.products.list({
-             *   onlineCd: 704,
-             *   displayOnWebFlag: 'Y',
-             *   orderBy: 'item_id|ASC'
-             * });
-             * ```
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast',
-                    paramsSchema: schemas_1.ProductListParamsSchema,
-                    responseSchema: schemas_1.ProductListResponseSchema,
-                }, params);
-            },
-            /**
-             * Pre-cache a single product
-             * @description Trigger pre-caching for a specific product to improve response times
-             * @param invMastUid Inventory master unique identifier
-             * @returns Boolean indicating if pre-cache was queued successfully
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const cached = await client.products.preCache(12345);
-             * if (cached.data) {
-             *   console.log('Product pre-cache queued successfully');
-             * }
-             * ```
-             */
-            preCache: async (invMastUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{id}/precache',
-                    responseSchema: schemas_1.ProductPreCacheResponseSchema,
-                }, undefined, { id: String(invMastUid) });
-            },
-            /**
-             * Get alternate codes for a product
-             * @description List alternate codes (UPC, manufacturer codes, etc.) for a specific product
-             * @param invMastUid Inventory master unique identifier
-             * @param params Optional filtering and pagination parameters
-             * @returns Array of alternate codes for the product
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const alternateCodes = await client.products.getAlternateCodes(12345);
-             * alternateCodes.data.forEach(code => {
-             *   console.log(`${code.alternateCode}: ${code.alternateCodeDesc}`);
-             * });
-             * ```
-             */
-            getAlternateCodes: async (invMastUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{id}/alternate-code',
-                    paramsSchema: schemas_1.AlternateCodeListParamsSchema,
-                    responseSchema: schemas_1.AlternateCodeListResponseSchema,
-                }, params, { id: String(invMastUid) });
-            },
-            /**
-             * Get accessory items for a product
-             * @description List accessory items associated with a specific product
-             * @param invMastUid Inventory master unique identifier
-             * @param params Optional pagination parameters
-             * @returns Array of accessory items
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const accessories = await client.products.getAccessories(12345);
-             * accessories.data.forEach(accessory => {
-             *   console.log(`Accessory: ${accessory.itemId} - ${accessory.itemDesc}`);
-             * });
-             * ```
-             */
-            getAccessories: async (invMastUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{id}/inv-accessory',
-                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                    responseSchema: schemas_1.AccessoryListResponseSchema,
-                }, params, { id: String(invMastUid) });
-            },
-            /**
-             * Get bin information for a product at a specific location
-             * @description Get specific bin information for an inventory item at a location
-             * @param invMastUid Inventory master unique identifier
-             * @param locationId Location ID
-             * @param bin Bin identifier
-             * @returns Bin information for the product at the location
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const binInfo = await client.products.getBinInfo(12345, 1, 'A-01');
-             * console.log(`Bin ${binInfo.bin}: ${binInfo.qtyOnHand} on hand`);
-             * ```
-             */
-            getBinInfo: async (invMastUid, locationId, bin) => {
-                const response = await this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{invMastUid}/locations/{locationId}/bins/{bin}',
-                    responseSchema: schemas_1.BinInfoListResponseSchema,
-                }, undefined, {
-                    invMastUid: String(invMastUid),
-                    locationId: String(locationId),
-                    bin,
-                });
-                // Return first bin info from array response
-                return response.data[0];
-            },
-            /**
-             * List all bins for a product at a specific location
-             * @description List all bins for an inventory item at a specific location
-             * @param invMastUid Inventory master unique identifier
-             * @param locationId Location ID
-             * @param params Optional pagination parameters
-             * @returns Array of bin information for the product at the location
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const bins = await client.products.getBinsByLocation(12345, 1);
-             * bins.data.forEach(bin => {
-             *   console.log(`Bin ${bin.bin}: ${bin.qtyOnHand} on hand, ${bin.qtyAvailable} available`);
-             * });
-             * ```
-             */
-            getBinsByLocation: async (invMastUid, locationId, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{invMastUid}/locations/{locationId}/bins',
-                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                    responseSchema: schemas_1.BinInfoListResponseSchema,
-                }, params, {
-                    invMastUid: String(invMastUid),
-                    locationId: String(locationId),
-                });
-            },
-        };
-        /**
-         * Product catalog data-only endpoints
-         * @description Data-only methods that return just the data portion of product responses
-         */
-        this.productsData = {
-            /**
-             * Get product details data only
-             * @description Returns only the data portion of product details response
-             * @fullPath api.items.productsData.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @searchTerms ["product data", "item data", "product details data only"]
-             * @relatedEndpoints ["api.items.products.get"]
-             * @commonPatterns ["Get product data without metadata"]
-             * @param invMastUid Inventory master unique identifier
-             * @returns Product data only
-             */
-            get: async (invMastUid) => {
-                const response = await this.products.get(invMastUid);
-                return response.data;
-            },
-            /**
-             * Search products data only
-             * @description Returns only the data portion of product search response
-             * @fullPath api.items.productsData.search
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @searchTerms ["product search data", "search results data only"]
-             * @relatedEndpoints ["api.items.products.search"]
-             * @commonPatterns ["Search products without metadata"]
-             * @param params Search parameters
-             * @returns Product search data only
-             */
-            search: async (params) => {
-                const response = await this.products.search(params);
-                return response.data;
-            },
-            /**
-             * List products data only
-             * @description Returns only the data portion of product list response
-             * @fullPath api.items.productsData.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @searchTerms ["product list data", "products data only"]
-             * @relatedEndpoints ["api.items.products.list"]
-             * @commonPatterns ["List products without metadata"]
-             * @param params Optional filtering parameters
-             * @returns Product list data only
-             */
-            list: async (params) => {
-                const response = await this.products.list(params);
-                return response.data;
-            },
-        };
         /**
          * Category management endpoints
          * @description Methods for hierarchical product categorization including category details, items, attributes, and filtering
@@ -1139,7 +808,7 @@ class ItemsClient extends base_client_1.BaseServiceClient {
             ping: async () => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/health-check/ping',
+                    path: '/ping',
                     responseSchema: schemas_1.PingResponseSchema,
                     requiresAuth: false,
                 });
@@ -1183,6 +852,2986 @@ class ItemsClient extends base_client_1.BaseServiceClient {
                 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: schemas_1.ItemFavoritesListParamsSchema,
+                    responseSchema: schemas_1.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', schemas_1.CreateItemFavoriteRequestSchema, schemas_1.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}', schemas_1.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}', schemas_1.UpdateItemFavoriteRequestSchema, schemas_1.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);
+                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: schemas_1.ItemWishlistListParamsSchema,
+                    responseSchema: schemas_1.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}', schemas_1.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', schemas_1.CreateItemWishlistHeaderRequestSchema, schemas_1.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}', schemas_1.UpdateItemWishlistHeaderRequestSchema, schemas_1.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}', schemas_1.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: schemas_1.ItemWishlistLineListParamsSchema,
+                    responseSchema: schemas_1.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: schemas_1.CreateItemWishlistLineRequestSchema,
+                    responseSchema: schemas_1.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: schemas_1.UpdateItemWishlistLineRequestSchema,
+                    responseSchema: schemas_1.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: schemas_1.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
+         */
+        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;
+            },
+            /**
+             * Get wishlist items data only
+             * @description Returns only the data portion of wishlist items response
+             * @param wishlistUid Wishlist unique identifier
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of wishlist items data
+             */
+            getLines: async (wishlistUid, params) => {
+                const response = await this.itemWishlist.getLines(wishlistUid, params);
+                return response.data;
+            },
+        };
+        /**
+         * Item category management endpoints
+         * @description Methods for managing item categories following OpenAPI path mirroring pattern
+         */
+        this.itemCategory = {
+            /**
+             * List item categories
+             * @description Retrieve a list of item categories
+             * @fullPath api.items.itemCategory.list
+             * @service items
+             * @domain product-catalog
+             * @dataMethod itemCategoryData.list
+             * @discoverable true
+             * @searchTerms ["categories", "item categories", "product categories", "category management"]
+             * @relatedEndpoints ["api.items.invMast.list", "api.items.attributes.list"]
+             * @commonPatterns ["Show categories", "Manage category structure", "Category navigation"]
+             * @workflow ["product-catalog-management", "category-management"]
+             * @prerequisites ["Valid authentication token", "Catalog permissions"]
+             * @nextSteps ["api.items.itemCategory.get for category details", "api.items.invMast.list for category products"]
+             * @businessRules ["Shows active categories only", "Respects category hierarchy", "Returns visible categories"]
+             * @functionalArea "product-catalog-management"
+             * @caching "Cache for 30 minutes, invalidate on category changes"
+             * @performance "Paginated results for large category trees"
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of item categories
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const categories = await client.itemCategory.list({ parentUid: 100 });
+             * categories.data.forEach(cat => {
+             *   console.log(`Category: ${cat.itemCategoryDesc} (${cat.path})`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/item-category',
+                    paramsSchema: schemas_1.CategoryListParamsSchema,
+                    responseSchema: schemas_1.CategoryListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get item category details
+             * @description Retrieve detailed information about a specific item category
+             * @fullPath api.items.itemCategory.get
+             * @service items
+             * @domain product-catalog
+             * @dataMethod itemCategoryData.get
+             * @discoverable true
+             * @searchTerms ["category details", "category info", "category data"]
+             * @relatedEndpoints ["api.items.itemCategory.list", "api.items.invMast.list"]
+             * @commonPatterns ["Show category details", "Category information lookup"]
+             * @param itemCategoryUid Category unique identifier
+             * @param params Optional query parameters
+             * @returns Category details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const category = await client.itemCategory.get(123);
+             * console.log(category.data.itemCategoryDesc, category.data.path);
+             * ```
+             */
+            get: this.createGetMethod('/item-category/{id}', schemas_1.CategoryResponseSchema),
+            /**
+             * Get category documentation
+             * @description Retrieve documentation for a specific item category
+             * @fullPath api.items.itemCategory.doc.get
+             * @service items
+             * @domain product-catalog
+             * @discoverable true
+             * @searchTerms ["category documentation", "category docs", "category help"]
+             * @relatedEndpoints ["api.items.itemCategory.get", "api.items.itemCategory.list"]
+             * @commonPatterns ["Show category documentation", "Category help content"]
+             * @param itemCategoryUid Category unique identifier
+             * @returns Category documentation
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const docs = await client.itemCategory.doc.get(123);
+             * console.log(docs.data.documentationContent);
+             * ```
+             */
+            doc: {
+                get: async (itemCategoryUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/item-category/{itemCategoryUid}/doc',
+                        responseSchema: schemas_1.CategoryResponseSchema,
+                    }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+                },
+            },
+            /**
+             * 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: schemas_1.CategoryLookupParamsSchema,
+                    responseSchema: schemas_1.CategoryListResponseSchema,
+                }, params);
+            },
+        };
+        /**
+         * Item category data-only endpoints
+         * @description Data-only methods that return just the data portion of category 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;
+            },
+            /**
+             * 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: async (itemCategoryUid) => {
+                const response = await this.itemCategory.get(itemCategoryUid);
+                return response.data;
+            },
+        };
+        /**
+         * Product variants management endpoints
+         * @description Methods for managing product variants and variant groups
+         */
+        this.variants = {
+            /**
+             * List product variants
+             * @description Retrieve a list of product variants
+             * @fullPath api.items.variants.list
+             * @service items
+             * @domain product-catalog
+             * @dataMethod variantsData.list
+             * @discoverable true
+             * @searchTerms ["variants", "product variants", "product variations", "variant groups", "product options"]
+             * @relatedEndpoints ["api.items.products.get", "api.items.attributes.list"]
+             * @commonPatterns ["Show product variants", "Manage product variations", "Product option management"]
+             * @workflow ["product-catalog-management", "variant-management"]
+             * @prerequisites ["Valid authentication token", "Product catalog permissions"]
+             * @nextSteps ["api.items.variants.getLines for variant items", "api.items.products.get for base product details"]
+             * @businessRules ["Shows active variants only", "Groups variants by base product", "Respects product visibility"]
+             * @functionalArea "product-catalog-management"
+             * @caching "Cache for 15 minutes, invalidate on variant changes"
+             * @performance "Paginated results for large variant collections"
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of product variants
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const variants = await client.variants.list({ baseInvMastUid: 12345 });
+             * variants.data.forEach(variant => {
+             *   console.log(`Variant Group: ${variant.variantGroupName} (${variant.variantType})`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/variants',
+                    paramsSchema: schemas_1.ItemVariantListParamsSchema,
+                    responseSchema: schemas_1.ItemVariantHeaderListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get variant group details
+             * @description Retrieve details for a specific variant group
+             * @param variantHeaderUid Variant header unique identifier
+             * @returns Variant group details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const variant = await client.variants.get(123);
+             * console.log(variant.data.variantGroupName, variant.data.variantType);
+             * ```
+             */
+            get: this.createGetMethod('/variants/{id}', schemas_1.ItemVariantHeaderResponseSchema),
+            /**
+             * Create new variant group
+             * @description Create a new product variant group
+             * @param request Variant group creation data
+             * @returns Created variant group information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const variant = await client.variants.create({
+             *   baseInvMastUid: 12345,
+             *   variantGroupName: 'Color Options',
+             *   variantType: 'color',
+             *   variantGroupDescription: 'Available color variations for this product'
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/variants', schemas_1.CreateItemVariantHeaderRequestSchema, schemas_1.ItemVariantHeaderResponseSchema),
+            /**
+             * Update variant group
+             * @description Update a variant group's information
+             * @param variantHeaderUid Variant header unique identifier
+             * @param request Update data
+             * @returns Updated variant group information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.variants.update(123, {
+             *   variantGroupName: 'Color & Style Options',
+             *   variantGroupDescription: 'Updated description for color and style variations'
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/variants/{id}', schemas_1.UpdateItemVariantHeaderRequestSchema, schemas_1.ItemVariantHeaderResponseSchema),
+            /**
+             * Delete variant group
+             * @description Delete a variant group and all its variant items
+             * @param variantHeaderUid Variant header unique identifier
+             * @returns Success response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.variants.delete(123);
+             * ```
+             */
+            delete: this.createDeleteMethod('/variants/{id}', schemas_1.ItemVariantHeaderResponseSchema),
+            /**
+             * Get variant items
+             * @description Retrieve items in a specific variant group
+             * @param variantHeaderUid Variant header unique identifier
+             * @returns Array of variant items
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const items = await client.variants.getLines(123);
+             * items.data.forEach(item => {
+             *   console.log(`${item.variantValue} - ${item.itemDesc} (${item.itemId})`);
+             * });
+             * ```
+             */
+            getLines: async (variantHeaderUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/variants/{id}/lines',
+                    responseSchema: schemas_1.ItemVariantLineListResponseSchema,
+                }, undefined, { id: String(variantHeaderUid) });
+            },
+            /**
+             * Add variant item
+             * @description Add an item to a specific variant group
+             * @param variantHeaderUid Variant header unique identifier
+             * @param request Variant item creation data
+             * @returns Created variant item information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const item = await client.variants.addLine(123, {
+             *   invMastUid: 12345,
+             *   variantValue: 'Red',
+             *   variantDisplay: 'Bright Red',
+             *   colorCode: '#FF0000',
+             *   priceDifference: 0
+             * });
+             * ```
+             */
+            addLine: async (variantHeaderUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/variants/{id}/lines',
+                    paramsSchema: schemas_1.CreateItemVariantLineRequestSchema,
+                    responseSchema: schemas_1.ItemVariantLineResponseSchema,
+                }, request, { id: String(variantHeaderUid) });
+            },
+            /**
+             * Update variant item
+             * @description Update an item in a variant group
+             * @param variantHeaderUid Variant header unique identifier
+             * @param lineUid Variant line unique identifier
+             * @param request Update data
+             * @returns Updated variant item information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.variants.updateLine(123, 456, {
+             *   variantValue: 'Deep Red',
+             *   variantDisplay: 'Deep Red Color',
+             *   priceDifference: 5.00
+             * });
+             * ```
+             */
+            updateLine: async (variantHeaderUid, lineUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/variants/{headerId}/lines/{lineId}',
+                    paramsSchema: schemas_1.UpdateItemVariantLineRequestSchema,
+                    responseSchema: schemas_1.ItemVariantLineResponseSchema,
+                }, request, { headerId: String(variantHeaderUid), lineId: String(lineUid) });
+            },
+            /**
+             * Remove variant item
+             * @description Remove an item from a variant group
+             * @param variantHeaderUid Variant header unique identifier
+             * @param lineUid Variant line unique identifier
+             * @returns Success response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.variants.deleteLine(123, 456);
+             * ```
+             */
+            deleteLine: async (variantHeaderUid, lineUid) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/variants/{headerId}/lines/{lineId}',
+                    responseSchema: schemas_1.ItemVariantLineResponseSchema,
+                }, undefined, { headerId: String(variantHeaderUid), lineId: String(lineUid) });
+            },
+        };
+        /**
+         * Product variants data-only endpoints
+         * @description Data-only methods that return just the data portion of variants responses
+         */
+        this.variantsData = {
+            /**
+             * List product variants data only
+             * @description Returns only the data portion of variants list response
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of variants data
+             */
+            list: async (params) => {
+                const response = await this.variants.list(params);
+                return response.data;
+            },
+            /**
+             * Get variant items data only
+             * @description Returns only the data portion of variant items response
+             * @param variantHeaderUid Variant header unique identifier
+             * @returns Array of variant items data
+             */
+            getLines: async (variantHeaderUid) => {
+                const response = await this.variants.getLines(variantHeaderUid);
+                return response.data;
+            },
+        };
+        /**
+         * Product FAQ management endpoints
+         * @description Methods for managing product frequently asked questions
+         */
+        this.faq = {
+            /**
+             * List product FAQs
+             * @description Retrieve FAQs for a specific product
+             * @fullPath api.items.faq.list
+             * @service items
+             * @domain product-information
+             * @dataMethod faqData.list
+             * @discoverable true
+             * @searchTerms ["faq", "questions", "product faq", "frequently asked questions", "product help"]
+             * @relatedEndpoints ["api.items.products.get", "api.joomla.articles.list"]
+             * @commonPatterns ["Show product FAQs", "Product help system", "Customer support information"]
+             * @workflow ["product-information", "customer-support"]
+             * @prerequisites ["Valid authentication token", "Product access permissions"]
+             * @nextSteps ["api.items.faq.vote for rating helpfulness", "api.items.products.get for product details"]
+             * @businessRules ["Shows active FAQs only", "Respects public/private settings", "Ordered by display order"]
+             * @functionalArea "product-information-management"
+             * @caching "Cache for 30 minutes, invalidate on FAQ changes"
+             * @performance "Paginated results for products with many FAQs"
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of product FAQs
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const faqs = await client.faq.list(12345, { category: 'installation' });
+             * faqs.data.forEach(faq => {
+             *   console.log(`Q: ${faq.question}`);
+             *   console.log(`A: ${faq.answer}`);
+             * });
+             * ```
+             */
+            list: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{id}/faq',
+                    paramsSchema: schemas_1.ItemFaqListParamsSchema,
+                    responseSchema: schemas_1.ItemFaqListResponseSchema,
+                }, params, { id: String(invMastUid) });
+            },
+            /**
+             * Get FAQ details
+             * @description Retrieve details for a specific FAQ
+             * @param invMastUid Inventory master unique identifier
+             * @param faqUid FAQ unique identifier
+             * @returns FAQ details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const faq = await client.faq.get(12345, 123);
+             * console.log(faq.data.question, faq.data.answer);
+             * ```
+             */
+            get: async (invMastUid, faqUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastId}/faq/{faqId}',
+                    responseSchema: schemas_1.ItemFaqResponseSchema,
+                }, undefined, { invMastId: String(invMastUid), faqId: String(faqUid) });
+            },
+            /**
+             * Create new FAQ
+             * @description Create a new FAQ for a product
+             * @param invMastUid Inventory master unique identifier
+             * @param request FAQ creation data
+             * @returns Created FAQ information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const faq = await client.faq.create(12345, {
+             *   question: 'How do I install this product?',
+             *   answer: 'Installation is simple: 1) Remove from packaging, 2) Connect cables, 3) Power on',
+             *   category: 'installation',
+             *   isPublic: 'Y'
+             * });
+             * ```
+             */
+            create: async (invMastUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/inv-mast/{id}/faq',
+                    paramsSchema: schemas_1.CreateItemFaqRequestSchema,
+                    responseSchema: schemas_1.ItemFaqResponseSchema,
+                }, request, { id: String(invMastUid) });
+            },
+            /**
+             * Update FAQ
+             * @description Update an existing FAQ
+             * @param invMastUid Inventory master unique identifier
+             * @param faqUid FAQ unique identifier
+             * @param request Update data
+             * @returns Updated FAQ information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.faq.update(12345, 123, {
+             *   answer: 'Updated installation instructions with more detail...',
+             *   category: 'installation-guide'
+             * });
+             * ```
+             */
+            update: async (invMastUid, faqUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/inv-mast/{invMastId}/faq/{faqId}',
+                    paramsSchema: schemas_1.UpdateItemFaqRequestSchema,
+                    responseSchema: schemas_1.ItemFaqResponseSchema,
+                }, request, { invMastId: String(invMastUid), faqId: String(faqUid) });
+            },
+            /**
+             * Delete FAQ
+             * @description Delete a FAQ
+             * @param invMastUid Inventory master unique identifier
+             * @param faqUid FAQ unique identifier
+             * @returns Success response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.faq.delete(12345, 123);
+             * ```
+             */
+            delete: async (invMastUid, faqUid) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/inv-mast/{invMastId}/faq/{faqId}',
+                    responseSchema: schemas_1.ItemFaqResponseSchema,
+                }, undefined, { invMastId: String(invMastUid), faqId: String(faqUid) });
+            },
+            /**
+             * Vote on FAQ helpfulness
+             * @description Rate whether a FAQ was helpful or not
+             * @param invMastUid Inventory master unique identifier
+             * @param faqUid FAQ unique identifier
+             * @param request Vote data
+             * @returns Success response
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.faq.vote(12345, 123, { isHelpful: true });
+             * ```
+             */
+            vote: async (invMastUid, faqUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/inv-mast/{invMastId}/faq/{faqId}/vote',
+                    paramsSchema: schemas_1.ItemFaqVoteRequestSchema,
+                    responseSchema: schemas_1.ItemFaqResponseSchema,
+                }, request, { invMastId: String(invMastUid), faqId: String(faqUid) });
+            },
+        };
+        /**
+         * Product FAQ data-only endpoints
+         * @description Data-only methods that return just the data portion of FAQ responses
+         */
+        this.faqData = {
+            /**
+             * List product FAQs data only
+             * @description Returns only the data portion of FAQ list response
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of FAQ data
+             */
+            list: async (invMastUid, params) => {
+                const response = await this.faq.list(invMastUid, params);
+                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: schemas_1.BrandItemListParamsSchema,
+                    responseSchema: schemas_1.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: schemas_1.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: schemas_1.CreateBrandItemRequestSchema,
+                    responseSchema: schemas_1.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: schemas_1.UpdateBrandItemRequestSchema,
+                    responseSchema: schemas_1.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: schemas_1.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.)
+         */
+        this.productLinks = {
+            /**
+             * List product links
+             * @description Retrieve product links for a specific product
+             * @fullPath api.items.productLinks.list
+             * @service items
+             * @domain product-catalog
+             * @dataMethod productLinksData.list
+             * @discoverable true
+             * @searchTerms ["product links", "related products", "accessories", "product relationships", "cross-sell"]
+             * @relatedEndpoints ["api.items.products.get", "api.commerce.cartHeaders.addItem"]
+             * @commonPatterns ["Show related products", "Product accessories", "Cross-sell recommendations"]
+             * @workflow ["product-catalog-management", "cross-selling"]
+             * @prerequisites ["Valid authentication token", "Product access permissions"]
+             * @nextSteps ["api.items.products.get for linked product details", "api.commerce.cartHeaders.addItem for adding accessories"]
+             * @businessRules ["Shows active links only", "Respects product visibility", "Ordered by display order"]
+             * @functionalArea "product-catalog-management"
+             * @caching "Cache for 15 minutes, invalidate on link changes"
+             * @performance "Paginated results for products with many links"
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of product links
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const links = await client.productLinks.list(12345, { linkType: 'accessory' });
+             * links.data.forEach(link => {
+             *   console.log(`${link.linkType}: ${link.childItemId} - ${link.linkDescription}`);
+             * });
+             * ```
+             */
+            list: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{id}/links',
+                    paramsSchema: schemas_1.ProductLinkListParamsSchema,
+                    responseSchema: schemas_1.ProductLinkListResponseSchema,
+                }, params, { id: String(invMastUid) });
+            },
+            /**
+             * Get product link details
+             * @description Retrieve details for a specific product link
+             * @param invMastUid Inventory master unique identifier
+             * @param linkUid Product link unique identifier
+             * @returns Product link details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const link = await client.productLinks.get(12345, 123);
+             * console.log(link.data.linkType, link.data.linkDescription);
+             * ```
+             */
+            get: async (invMastUid, linkUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastId}/links/{linkId}',
+                    responseSchema: schemas_1.ProductLinkResponseSchema,
+                }, undefined, { invMastId: String(invMastUid), linkId: String(linkUid) });
+            },
+            /**
+             * Create product link
+             * @description Create a new link between products
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param request Product link creation data
+             * @returns Created product link information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const link = await client.productLinks.create(12345, {
+             *   childInvMastUid: 67890,
+             *   linkType: 'accessory',
+             *   linkDescription: 'Compatible mounting bracket',
+             *   displayOrder: 1
+             * });
+             * ```
+             */
+            create: async (invMastUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/inv-mast/{id}/links',
+                    paramsSchema: schemas_1.CreateProductLinkRequestSchema,
+                    responseSchema: schemas_1.ProductLinkResponseSchema,
+                }, request, { id: String(invMastUid) });
+            },
+            /**
+             * Update product link
+             * @description Update an existing product link
+             * @param invMastUid Inventory master unique identifier
+             * @param linkUid Product link unique identifier
+             * @param request Update data
+             * @returns Updated product link information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.productLinks.update(12345, 123, {
+             *   linkDescription: 'Updated compatible mounting bracket description',
+             *   displayOrder: 2
+             * });
+             * ```
+             */
+            update: async (invMastUid, linkUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/inv-mast/{invMastId}/links/{linkId}',
+                    paramsSchema: schemas_1.UpdateProductLinkRequestSchema,
+                    responseSchema: schemas_1.ProductLinkResponseSchema,
+                }, request, { invMastId: String(invMastUid), linkId: String(linkUid) });
+            },
+            /**
+             * Delete product link
+             * @description Remove a link between products
+             * @param invMastUid Inventory master unique identifier
+             * @param linkUid Product link unique identifier
+             * @returns Success response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.productLinks.delete(12345, 123);
+             * ```
+             */
+            delete: async (invMastUid, linkUid) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/inv-mast/{invMastId}/links/{linkId}',
+                    responseSchema: schemas_1.ProductLinkResponseSchema,
+                }, undefined, { invMastId: String(invMastUid), linkId: String(linkUid) });
+            },
+        };
+        /**
+         * Product links data-only endpoints
+         * @description Data-only methods that return just the data portion of product links responses
+         */
+        this.productLinksData = {
+            /**
+             * List product links data only
+             * @description Returns only the data portion of product links response
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of product links data
+             */
+            list: async (invMastUid, params) => {
+                const response = await this.productLinks.list(invMastUid, params);
+                return response.data;
+            },
+        };
+        /**
+         * Sub-parts management endpoints
+         * @description Methods for managing product sub-parts and components
+         */
+        this.subparts = {
+            /**
+             * List product sub-parts
+             * @description Retrieve sub-parts for a specific product
+             * @fullPath api.items.subparts.list
+             * @service items
+             * @domain product-catalog
+             * @dataMethod subpartsData.list
+             * @discoverable true
+             * @searchTerms ["subparts", "components", "product parts", "assembly components", "sub-components"]
+             * @relatedEndpoints ["api.items.products.get", "api.nexus.manufacturing.bomComponents"]
+             * @commonPatterns ["Show product components", "Assembly management", "Bill of materials"]
+             * @workflow ["product-catalog-management", "assembly-management"]
+             * @prerequisites ["Valid authentication token", "Product access permissions"]
+             * @nextSteps ["api.items.products.get for component details", "api.nexus.inventory.checkStock for availability"]
+             * @businessRules ["Shows active sub-parts only", "Respects component visibility", "Quantity requirements"]
+             * @functionalArea "product-catalog-management"
+             * @caching "Cache for 20 minutes, invalidate on sub-part changes"
+             * @performance "Paginated results for complex assemblies"
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of product sub-parts
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const subparts = await client.subparts.list(12345, { isOptional: 'N' });
+             * subparts.data.forEach(part => {
+             *   console.log(`${part.childItemDesc} - Qty: ${part.qtyRequired} ${part.unitOfMeasure}`);
+             * });
+             * ```
+             */
+            list: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{id}/subparts',
+                    paramsSchema: schemas_1.SubPartListParamsSchema,
+                    responseSchema: schemas_1.SubPartListResponseSchema,
+                }, params, { id: String(invMastUid) });
+            },
+            /**
+             * Get sub-part details
+             * @description Retrieve details for a specific sub-part relationship
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param subpartUid Sub-part unique identifier
+             * @returns Sub-part details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const subpart = await client.subparts.get(12345, 123);
+             * console.log(subpart.data.childItemDesc, subpart.data.qtyRequired);
+             * ```
+             */
+            get: async (invMastUid, subpartUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastId}/subparts/{subpartId}',
+                    responseSchema: schemas_1.SubPartResponseSchema,
+                }, undefined, { invMastId: String(invMastUid), subpartId: String(subpartUid) });
+            },
+            /**
+             * Create sub-part relationship
+             * @description Create a new sub-part relationship for a product
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param request Sub-part creation data
+             * @returns Created sub-part information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const subpart = await client.subparts.create(12345, {
+             *   childInvMastUid: 67890,
+             *   qtyRequired: 2,
+             *   unitOfMeasure: 'EA',
+             *   isOptional: 'N',
+             *   description: 'Required mounting screws'
+             * });
+             * ```
+             */
+            create: async (invMastUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/inv-mast/{id}/subparts',
+                    paramsSchema: schemas_1.CreateSubPartRequestSchema,
+                    responseSchema: schemas_1.SubPartResponseSchema,
+                }, request, { id: String(invMastUid) });
+            },
+            /**
+             * Update sub-part relationship
+             * @description Update an existing sub-part relationship
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param subpartUid Sub-part unique identifier
+             * @param request Update data
+             * @returns Updated sub-part information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.subparts.update(12345, 123, {
+             *   qtyRequired: 4,
+             *   description: 'Now requires 4 mounting screws for better stability'
+             * });
+             * ```
+             */
+            update: async (invMastUid, subpartUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/inv-mast/{invMastId}/subparts/{subpartId}',
+                    paramsSchema: schemas_1.UpdateSubPartRequestSchema,
+                    responseSchema: schemas_1.SubPartResponseSchema,
+                }, request, { invMastId: String(invMastUid), subpartId: String(subpartUid) });
+            },
+            /**
+             * Delete sub-part relationship
+             * @description Remove a sub-part relationship from a product
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param subpartUid Sub-part unique identifier
+             * @returns Success response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.subparts.delete(12345, 123);
+             * ```
+             */
+            delete: async (invMastUid, subpartUid) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/inv-mast/{invMastId}/subparts/{subpartId}',
+                    responseSchema: schemas_1.SubPartResponseSchema,
+                }, undefined, { invMastId: String(invMastUid), subpartId: String(subpartUid) });
+            },
+        };
+        /**
+         * Sub-parts data-only endpoints
+         * @description Data-only methods that return just the data portion of sub-parts responses
+         */
+        this.subpartsData = {
+            /**
+             * List product sub-parts data only
+             * @description Returns only the data portion of sub-parts response
+             * @param invMastUid Inventory master unique identifier (parent product)
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of sub-parts data
+             */
+            list: async (invMastUid, params) => {
+                const response = await this.subparts.list(invMastUid, params);
+                return response.data;
+            },
+        };
+        /**
+         * Location management endpoints
+         * @description Methods for managing warehouse locations and their bins
+         */
+        this.locations = {
+            /**
+             * Bin management within locations
+             * @description Methods for managing bins within specific locations
+             */
+            bins: {
+                /**
+                 * List location bins
+                 * @description Retrieve bins for a specific 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
+                 * @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})`);
+                 * });
+                 * ```
+                 */
+                list: async (locationId, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/locations/{id}/bins',
+                        paramsSchema: schemas_1.BinListParamsSchema,
+                        responseSchema: schemas_1.BinListResponseSchema,
+                    }, params, { id: 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);
+                 * ```
+                 */
+                get: async (locationId, bin) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/locations/{locationId}/bins/{bin}',
+                        responseSchema: schemas_1.BinResponseSchema,
+                    }, undefined, { locationId: String(locationId), bin });
+                },
+                /**
+                 * Create new bin
+                 * @description Create a new bin in a location
+                 * @param locationId Location unique identifier
+                 * @param request Bin creation data
+                 * @returns Created bin information
+                 * @throws ValidationError When request is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * const bin = await client.bins.create(123, {
+                 *   bin: 'A01-B02-S04',
+                 *   binDesc: 'New storage bin for electronics',
+                 *   binType: 'shelf',
+                 *   zone: 'A',
+                 *   aisle: '01',
+                 *   shelf: '04',
+                 *   maxCapacity: 100
+                 * });
+                 * ```
+                 */
+                create: async (locationId, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/locations/{id}/bins',
+                        paramsSchema: schemas_1.CreateBinRequestSchema,
+                        responseSchema: schemas_1.BinResponseSchema,
+                    }, request, { id: String(locationId) });
+                },
+                /**
+                 * Update bin
+                 * @description Update an existing bin's information
+                 * @param locationId Location unique identifier
+                 * @param bin Bin identifier
+                 * @param request Update data
+                 * @returns Updated bin information
+                 * @throws ValidationError When request is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * const updated = await client.bins.update(123, 'A01-B02-S03', {
+                 *   binDesc: 'Updated bin description',
+                 *   maxCapacity: 150
+                 * });
+                 * ```
+                 */
+                update: async (locationId, bin, request) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/locations/{locationId}/bins/{bin}',
+                        paramsSchema: schemas_1.UpdateBinRequestSchema,
+                        responseSchema: schemas_1.BinResponseSchema,
+                    }, request, { locationId: String(locationId), bin });
+                },
+                /**
+                 * Delete bin
+                 * @description Remove a bin from a location
+                 * @param locationId Location unique identifier
+                 * @param bin Bin identifier
+                 * @returns Success response
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * await client.bins.delete(123, 'A01-B02-S03');
+                 * ```
+                 */
+                delete: async (locationId, bin) => {
+                    return this.executeRequest({
+                        method: 'DELETE',
+                        path: '/locations/{locationId}/bins/{bin}',
+                        responseSchema: schemas_1.BinResponseSchema,
+                    }, undefined, { locationId: String(locationId), bin });
+                },
+                /**
+                 * Get inventory in bins
+                 * @description Retrieve inventory information for bins containing a specific item
+                 * @param invMastUid Inventory master unique identifier
+                 * @param locationId Location unique identifier
+                 * @param params Optional filtering and pagination parameters
+                 * @returns Array of inventory location bin information
+                 * @throws ValidationError When parameters are invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * const inventory = await client.bins.getInventory(12345, 123, { hasStock: true });
+                 * inventory.data.forEach(inv => {
+                 *   console.log(`Bin ${inv.bin}: ${inv.qtyOnHand} units (${inv.qtyAvailable} available)`);
+                 * });
+                 * ```
+                 */
+                getInventory: async (invMastUid, locationId, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{invMastId}/locations/{locationId}/bins',
+                        paramsSchema: schemas_1.InventoryLocationBinListParamsSchema,
+                        responseSchema: schemas_1.InventoryLocationBinListResponseSchema,
+                    }, params, { invMastId: String(invMastUid), locationId: String(locationId) });
+                },
+            },
+        };
+        /**
+         * Location bins data-only endpoints
+         * @description Data-only methods that return just the data portion of location bins responses
+         */
+        this.locationsData = {
+            /**
+             * Bin data-only methods within locations
+             * @description Data-only methods for bins within specific locations
+             */
+            bins: {
+                /**
+                 * List location bins data only
+                 * @description Returns only the data portion of bins list response
+                 * @param locationId Location unique identifier
+                 * @param params Optional filtering and pagination parameters
+                 * @returns Array of bins data
+                 */
+                list: async (locationId, params) => {
+                    const response = await this.locations.bins.list(locationId, params);
+                    return response.data;
+                },
+                /**
+                 * Get inventory in bins data only
+                 * @description Returns only the data portion of inventory bins response
+                 * @param invMastUid Inventory master unique identifier
+                 * @param locationId Location unique identifier
+                 * @param params Optional filtering and pagination parameters
+                 * @returns Array of inventory location bin data
+                 */
+                getInventory: async (invMastUid, locationId, params) => {
+                    const response = await this.locations.bins.getInventory(invMastUid, locationId, params);
+                    return response.data;
+                },
+            },
+        };
+        /**
+         * Additional attribute value endpoints
+         * @description Methods for managing attribute values within attributes
+         */
+        this.attributeSpecificValues = {
+            /**
+             * List attribute values for a specific attribute
+             * @description Retrieve all values for an attribute
+             * @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.attributeSpecificValues.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: common_schemas_1.StandardPaginationParamsSchema,
+                    responseSchema: schemas_1.AttributeValueListResponseSchema,
+                }, params, { attributeUid: String(attributeUid) });
+            },
+            /**
+             * Create attribute value
+             * @description Create a new value for an attribute
+             * @param attributeUid Attribute unique identifier
+             * @param request Attribute value data
+             * @returns Created attribute value
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const value = await client.attributeSpecificValues.create(123, {
+             *   value: 'Blue',
+             *   displayValue: 'Royal Blue',
+             *   sequenceNo: 10
+             * });
+             * ```
+             */
+            create: async (attributeUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/attributes/{attributeUid}/values',
+                    paramsSchema: zod_1.z.object({
+                        value: zod_1.z.string(),
+                        displayValue: zod_1.z.string().optional(),
+                        sequenceNo: zod_1.z.number().optional(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            attributeValueUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            value: zod_1.z.string(),
+                            displayValue: zod_1.z.string().optional(),
+                            sequenceNo: zod_1.z.number().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, { attributeUid: String(attributeUid) });
+            },
+            /**
+             * Get specific attribute value
+             * @description Get details of a specific attribute value
+             * @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.attributeValues.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: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            attributeValueUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            value: zod_1.z.string(),
+                            displayValue: zod_1.z.string().optional(),
+                            sequenceNo: zod_1.z.number().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, undefined, { attributeUid: String(attributeUid), attributeValueUid: String(attributeValueUid) });
+            },
+            /**
+             * Update attribute value
+             * @description Update an existing attribute value
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @param request Update data
+             * @returns Updated attribute value
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.attributeValues.update(123, 456, {
+             *   displayValue: 'Ocean Blue',
+             *   sequenceNo: 15
+             * });
+             * ```
+             */
+            update: async (attributeUid, attributeValueUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/attributes/{attributeUid}/values/{attributeValueUid}',
+                    paramsSchema: zod_1.z.object({
+                        value: zod_1.z.string().optional(),
+                        displayValue: zod_1.z.string().optional(),
+                        sequenceNo: zod_1.z.number().optional(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            attributeValueUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            value: zod_1.z.string(),
+                            displayValue: zod_1.z.string().optional(),
+                            sequenceNo: zod_1.z.number().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, { attributeUid: String(attributeUid), attributeValueUid: String(attributeValueUid) });
+            },
+            /**
+             * Delete attribute value
+             * @description Delete an attribute value
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @returns Success indication
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.attributeValues.delete(123, 456);
+             * ```
+             */
+            delete: async (attributeUid, attributeValueUid) => {
+                await this.executeRequest({
+                    method: 'DELETE',
+                    path: '/attributes/{attributeUid}/values/{attributeValueUid}',
+                    responseSchema: zod_1.z.undefined(),
+                }, undefined, { attributeUid: String(attributeUid), attributeValueUid: String(attributeValueUid) });
+                return true;
+            },
+        };
+        /**
+         * Attribute group attribute associations
+         * @description Methods for managing attribute associations within attribute groups
+         */
+        this.attributeGroupAttributes = {
+            /**
+             * List attributes in a group
+             * @description Retrieve all attributes associated with an attribute group
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of attributes in the group
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const groupAttrs = await client.attributeGroupAttributes.list(123);
+             * groupAttrs.data.forEach(attr => {
+             *   console.log(`${attr.attributeId}: ${attr.attributeDesc}`);
+             * });
+             * ```
+             */
+            list: async (attributeGroupUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/attribute-groups/{attributeGroupUid}/attributes',
+                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
+                    responseSchema: schemas_1.AttributeListResponseSchema,
+                }, params, { attributeGroupUid: String(attributeGroupUid) });
+            },
+            /**
+             * Add attribute to group
+             * @description Associate an attribute with an attribute group
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param request Association data
+             * @returns Created association
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.attributeGroupAttributes.create(123, {
+             *   attributeUid: 456,
+             *   sequenceNo: 10
+             * });
+             * ```
+             */
+            create: async (attributeGroupUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/attribute-groups/{attributeGroupUid}/attributes',
+                    paramsSchema: zod_1.z.object({
+                        attributeUid: zod_1.z.number(),
+                        sequenceNo: zod_1.z.number().optional(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            attributeXAttributeGroupUid: zod_1.z.number(),
+                            attributeGroupUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            sequenceNo: zod_1.z.number().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, { attributeGroupUid: String(attributeGroupUid) });
+            },
+            /**
+             * Get specific attribute in group
+             * @description Get details of a specific attribute association in a group
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param attributeXAttributeGroupUid Association unique identifier
+             * @returns Association details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.attributeGroupAttributes.get(123, 789);
+             * console.log(association.data.attributeUid, association.data.sequenceNo);
+             * ```
+             */
+            get: async (attributeGroupUid, attributeXAttributeGroupUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/attribute-groups/{attributeGroupUid}/attributes/{attributeXAttributeGroupUid}',
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            attributeXAttributeGroupUid: zod_1.z.number(),
+                            attributeGroupUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            sequenceNo: zod_1.z.number().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, undefined, {
+                    attributeGroupUid: String(attributeGroupUid),
+                    attributeXAttributeGroupUid: String(attributeXAttributeGroupUid),
+                });
+            },
+            /**
+             * Update attribute in group
+             * @description Update an attribute association in a group
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param attributeXAttributeGroupUid Association unique identifier
+             * @param request Update data
+             * @returns Updated association
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.attributeGroupAttributes.update(123, 789, {
+             *   sequenceNo: 20
+             * });
+             * ```
+             */
+            update: async (attributeGroupUid, attributeXAttributeGroupUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/attribute-groups/{attributeGroupUid}/attributes/{attributeXAttributeGroupUid}',
+                    paramsSchema: zod_1.z.object({
+                        sequenceNo: zod_1.z.number().optional(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            attributeXAttributeGroupUid: zod_1.z.number(),
+                            attributeGroupUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            sequenceNo: zod_1.z.number().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, {
+                    attributeGroupUid: String(attributeGroupUid),
+                    attributeXAttributeGroupUid: String(attributeXAttributeGroupUid),
+                });
+            },
+            /**
+             * Remove attribute from group
+             * @description Remove an attribute association from a group
+             * @param attributeGroupUid Attribute group unique identifier
+             * @param attributeXAttributeGroupUid Association unique identifier
+             * @returns Success indication
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.attributeGroupAttributes.delete(123, 789);
+             * ```
+             */
+            delete: async (attributeGroupUid, attributeXAttributeGroupUid) => {
+                await this.executeRequest({
+                    method: 'DELETE',
+                    path: '/attribute-groups/{attributeGroupUid}/attributes/{attributeXAttributeGroupUid}',
+                    responseSchema: zod_1.z.undefined(),
+                }, undefined, {
+                    attributeGroupUid: String(attributeGroupUid),
+                    attributeXAttributeGroupUid: String(attributeXAttributeGroupUid),
+                });
+                return true;
+            },
+        };
+        /**
+         * 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: common_schemas_1.StandardPaginationParamsSchema,
+                    responseSchema: schemas_1.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: zod_1.z.object({
+                        invMastUid: zod_1.z.number(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            brandsXItemsUid: zod_1.z.number(),
+                            brandsUid: zod_1.z.number(),
+                            invMastUid: zod_1.z.number(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.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: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            brandsXItemsUid: zod_1.z.number(),
+                            brandsUid: zod_1.z.number(),
+                            invMastUid: zod_1.z.number(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.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: schemas_1.UpdateBrandItemRequestSchema,
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            brandsXItemsUid: zod_1.z.number(),
+                            brandsUid: zod_1.z.number(),
+                            invMastUid: zod_1.z.number(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.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: zod_1.z.undefined(),
+                }, undefined, { brandsUid: String(brandsUid), brandsXItemsUid: String(brandsXItemsUid) });
+                return true;
+            },
+        };
+        /**
+         * Additional missing endpoints
+         * @description Methods for endpoints that were missing from the implementation
+         */
+        this.additional = {
+            /**
+             * Get health check status
+             * @description Get comprehensive health check information
+             * @returns Health check details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const health = await client.additional.healthCheck();
+             * console.log('Service health:', health.data.status);
+             * ```
+             */
+            healthCheck: async () => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/health-check',
+                    responseSchema: schemas_1.HealthCheckResponseSchema,
+                });
+            },
+            /**
+             * Category lookup
+             * @description Search and lookup categories by various criteria
+             * @param params Lookup parameters
+             * @returns Array of matching categories
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const categories = await client.additional.categoriesLookup({
+             *   q: 'electronics',
+             *   limit: 10
+             * });
+             * ```
+             */
+            categoriesLookup: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/lookup',
+                    paramsSchema: schemas_1.CategoryLookupParamsSchema,
+                    responseSchema: schemas_1.CategoryLookupResponseSchema,
+                }, params);
+            },
+            /**
+             * Get category items
+             * @description Get items in a specific category
+             * @param itemCategoryUid Category unique identifier
+             * @param params Optional filtering parameters
+             * @returns Array of items in the category
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const items = await client.additional.getCategoryItems(123);
+             * items.data.forEach(item => {
+             *   console.log(`${item.itemId}: ${item.itemDesc}`);
+             * });
+             * ```
+             */
+            getCategoryItems: async (itemCategoryUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/{itemCategoryUid}/item',
+                    paramsSchema: schemas_1.CategoryItemsParamsSchema,
+                    responseSchema: schemas_1.CategoryItemsResponseSchema,
+                }, params, { itemCategoryUid: String(itemCategoryUid) });
+            },
+            /**
+             * Get category documentation
+             * @description Get documentation for a specific category
+             * @param itemCategoryUid Category unique identifier
+             * @returns Category documentation
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const doc = await client.additional.getCategoryDoc(123);
+             * console.log('Category documentation:', doc.data.content);
+             * ```
+             */
+            getCategoryDoc: async (itemCategoryUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/item-category/{itemCategoryUid}/doc',
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            content: zod_1.z.string(),
+                            title: zod_1.z.string().optional(),
+                            lastModified: zod_1.z.string().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, undefined, { itemCategoryUid: String(itemCategoryUid) });
+            },
+            /**
+             * Create internal PDF
+             * @description Generate internal PDF documents
+             * @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.additional.createInternalPdf({
+             *   templateId: 'invoice',
+             *   data: { orderId: 12345 }
+             * });
+             * ```
+             */
+            createInternalPdf: async (request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/internal/pdf',
+                    paramsSchema: zod_1.z.object({
+                        templateId: zod_1.z.string(),
+                        data: zod_1.z.any(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            pdfUrl: zod_1.z.string(),
+                            pdfId: zod_1.z.string(),
+                            expiresAt: zod_1.z.string().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request);
+            },
+            /**
+             * Get product inventory sub-items
+             * @description Get sub-items for a product
+             * @param invMastUid Inventory master unique identifier
+             * @returns Array of product sub-items
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const subItems = await client.additional.getProductInvSub(12345);
+             * subItems.data.forEach(item => {
+             *   console.log(`Sub-item: ${item.itemId} - ${item.itemDesc}`);
+             * });
+             * ```
+             */
+            getProductInvSub: async (invMastUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastUid}/inv-sub',
+                    responseSchema: schemas_1.ProductListResponseSchema,
+                }, undefined, { invMastUid: String(invMastUid) });
+            },
+            /**
+             * List product attribute values
+             * @description List attribute values for a specific product and attribute
+             * @param invMastUid Product unique identifier
+             * @param attributeUid Attribute unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of attribute values for the product
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const values = await client.additional.listProductAttributeValues(12345, 678);
+             * values.data.forEach(value => {
+             *   console.log(`${value.attributeValueId}: ${value.value}`);
+             * });
+             * ```
+             */
+            listProductAttributeValues: async (invMastUid, attributeUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values',
+                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
+                    responseSchema: schemas_1.AttributeValueListResponseSchema,
+                }, params, { invMastUid: String(invMastUid), attributeUid: String(attributeUid) });
+            },
+            /**
+             * Create product attribute value
+             * @description Create an attribute value for a specific product
+             * @param invMastUid Product unique identifier
+             * @param attributeUid Attribute unique identifier
+             * @param request Attribute value data
+             * @returns Created attribute value
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const value = await client.additional.createProductAttributeValue(12345, 678, {
+             *   attributeValueUid: 999,
+             *   customValue: 'Custom Blue'
+             * });
+             * ```
+             */
+            createProductAttributeValue: async (invMastUid, attributeUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values',
+                    paramsSchema: zod_1.z.object({
+                        attributeValueUid: zod_1.z.number(),
+                        customValue: zod_1.z.string().optional(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            invMastUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            attributeValueUid: zod_1.z.number(),
+                            customValue: zod_1.z.string().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, { invMastUid: String(invMastUid), attributeUid: String(attributeUid) });
+            },
+            /**
+             * Update product attribute value
+             * @description Update an attribute value for a specific product
+             * @param invMastUid Product unique identifier
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @param request Update data
+             * @returns Updated attribute value
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.additional.updateProductAttributeValue(12345, 678, 999, {
+             *   customValue: 'Updated Custom Blue'
+             * });
+             * ```
+             */
+            updateProductAttributeValue: async (invMastUid, attributeUid, attributeValueUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values/{attributeValueUid}',
+                    paramsSchema: zod_1.z.object({
+                        customValue: zod_1.z.string().optional(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            invMastUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                            attributeValueUid: zod_1.z.number(),
+                            customValue: zod_1.z.string().optional(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, {
+                    invMastUid: String(invMastUid),
+                    attributeUid: String(attributeUid),
+                    attributeValueUid: String(attributeValueUid),
+                });
+            },
+            /**
+             * Delete product attribute value
+             * @description Delete an attribute value for a specific product
+             * @param invMastUid Product unique identifier
+             * @param attributeUid Attribute unique identifier
+             * @param attributeValueUid Attribute value unique identifier
+             * @returns Success indication
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * await client.additional.deleteProductAttributeValue(12345, 678, 999);
+             * ```
+             */
+            deleteProductAttributeValue: async (invMastUid, attributeUid, attributeValueUid) => {
+                await this.executeRequest({
+                    method: 'DELETE',
+                    path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values/{attributeValueUid}',
+                    responseSchema: zod_1.z.undefined(),
+                }, undefined, {
+                    invMastUid: String(invMastUid),
+                    attributeUid: String(attributeUid),
+                    attributeValueUid: String(attributeValueUid),
+                });
+                return true;
+            },
+            /**
+             * List product attributes
+             * @description List all attributes for a specific product
+             * @param invMastUid Product unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of attributes for the product
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const attributes = await client.additional.listProductAttributes(12345);
+             * attributes.data.forEach(attr => {
+             *   console.log(`${attr.attributeId}: ${attr.attributeDesc}`);
+             * });
+             * ```
+             */
+            listProductAttributes: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastUid}/attributes',
+                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
+                    responseSchema: schemas_1.AttributeListResponseSchema,
+                }, params, { invMastUid: String(invMastUid) });
+            },
+            /**
+             * Create product attribute
+             * @description Create an attribute association for a specific product
+             * @param invMastUid Product unique identifier
+             * @param request Attribute association data
+             * @returns Created attribute association
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const association = await client.additional.createProductAttribute(12345, {
+             *   attributeUid: 678
+             * });
+             * ```
+             */
+            createProductAttribute: async (invMastUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/inv-mast/{invMastUid}/attributes',
+                    paramsSchema: zod_1.z.object({
+                        attributeUid: zod_1.z.number(),
+                    }),
+                    responseSchema: zod_1.z.object({
+                        count: zod_1.z.number(),
+                        data: zod_1.z.object({
+                            invMastUid: zod_1.z.number(),
+                            attributeUid: zod_1.z.number(),
+                        }),
+                        message: zod_1.z.string(),
+                        options: zod_1.z.any(),
+                        params: zod_1.z.any(),
+                        status: zod_1.z.number(),
+                        total: zod_1.z.number(),
+                        totalResults: zod_1.z.number(),
+                    }),
+                }, request, { invMastUid: String(invMastUid) });
+            },
+        };
+        /**
+         * Inventory Master (inv-mast) endpoints
+         * @description Direct mapping to /inv-mast/* OpenAPI paths for inventory master operations
+         */
+        this.invMast = {
+            /**
+             * Get inventory master details by UID
+             * @description Retrieves comprehensive details for a specific inventory master including categories, attributes, images, and related data
+             * @fullPath api.items.invMast.get
+             * @service items
+             * @domain inventory-management
+             * @dataMethod invMastData.get
+             * @discoverable true
+             * @searchTerms ["inventory master details", "inv-mast info", "product lookup", "item by id"]
+             * @relatedEndpoints ["api.items.invMast.search", "api.items.categories.getItems", "api.commerce.cartHeaders.addItem"]
+             * @commonPatterns ["Get product by ID", "Product detail page", "Item information lookup"]
+             * @workflow ["product-detail-view", "add-to-cart-preparation", "inventory-verification"]
+             * @prerequisites ["Valid inventory master UID", "Product access permissions"]
+             * @nextSteps ["api.commerce.cartHeaders.addItem", "api.items.stock.getDetails", "api.items.invMast.invAccessory"]
+             * @businessRules ["Returns only accessible products", "Includes pricing if authorized", "Shows real-time stock if enabled"]
+             * @functionalArea "inventory-master-management"
+             * @caching "Cache for 10 minutes, invalidate on product updates"
+             * @performance "Single product lookup, optimized for product detail pages"
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional parameters for including additional data
+             * @returns Complete inventory master details with all related information
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const invMast = await client.invMast.get(12345);
+             * console.log(invMast.data.itemId, invMast.data.itemDesc, invMast.data.listPrice);
+             * ```
+             */
+            get: this.createGetMethod('/inv-mast/{id}', schemas_1.ProductResponseSchema),
+            /**
+             * List inventory masters with filtering and pagination
+             * @description Retrieve a paginated list of inventory masters with comprehensive filtering options
+             * @fullPath api.items.invMast.list
+             * @service items
+             * @domain inventory-management
+             * @dataMethod invMastData.list
+             * @discoverable true
+             * @searchTerms ["inventory masters", "inv-mast list", "products", "items"]
+             * @relatedEndpoints ["api.items.invMast.search", "api.items.invMast.lookup"]
+             * @commonPatterns ["Product catalog", "Inventory listing", "Product management"]
+             * @param params Optional filtering and pagination parameters
+             * @returns Paginated list of inventory masters
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const invMasts = await client.invMast.list({ statusCd: 704, limit: 50 });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast',
+                    paramsSchema: schemas_1.ProductListParamsSchema,
+                    responseSchema: schemas_1.ProductListResponseSchema,
+                }, params);
+            },
+            /**
+             * Search inventory masters
+             * @description Search inventory masters with query parameters
+             * @fullPath api.items.invMast.search
+             * @service items
+             * @domain inventory-management
+             * @dataMethod invMastData.search
+             * @discoverable true
+             * @searchTerms ["inv-mast search", "product search", "item search", "find products"]
+             * @relatedEndpoints ["api.items.invMast.list", "api.items.invMast.lookup"]
+             * @commonPatterns ["Search product catalog", "Find items by keyword", "Product discovery"]
+             * @param params Search parameters including required query string
+             * @returns Array of matching inventory masters
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const results = await client.invMast.search({ q: 'ethernet cable' });
+             * ```
+             */
+            search: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/search',
+                    paramsSchema: schemas_1.ProductSearchParamsSchema,
+                    responseSchema: schemas_1.ProductListResponseSchema,
+                }, params);
+            },
+            /**
+             * Lookup inventory masters with simplified data
+             * @description Lookup inventory masters with simplified response format for autocomplete and basic searches
+             * @fullPath api.items.invMast.lookup
+             * @service items
+             * @domain inventory-management
+             * @dataMethod invMastData.lookup
+             * @discoverable true
+             * @searchTerms ["inv-mast lookup", "product lookup", "item autocomplete"]
+             * @relatedEndpoints ["api.items.invMast.search", "api.items.invMast.list"]
+             * @commonPatterns ["Autocomplete", "Quick lookup", "Product picker"]
+             * @param params Lookup parameters
+             * @returns Array of simplified inventory master data
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const lookupResults = await client.invMast.lookup({ q: 'cable', limit: 10 });
+             * ```
+             */
+            lookup: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/lookup',
+                    paramsSchema: schemas_1.ProductLookupParamsSchema,
+                    responseSchema: schemas_1.ProductLookupResponseSchema,
+                }, params);
+            },
+            /**
+             * Get inventory master documentation
+             * @description Retrieve comprehensive documentation for a specific inventory master
+             * @fullPath api.items.invMast.doc.get
+             * @service items
+             * @domain inventory-management
+             * @discoverable true
+             * @searchTerms ["inv-mast documentation", "product docs", "item documentation"]
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional parameters
+             * @returns Documentation for the inventory master
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const doc = await client.invMast.doc.get(12345);
+             * ```
+             */
+            doc: {
+                get: async (invMastUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/doc',
+                        paramsSchema: zod_1.z
+                            .object({
+                            includePricing: zod_1.z.string().optional(),
+                            itemId: zod_1.z.string().optional(),
+                        })
+                            .optional(),
+                        responseSchema: schemas_1.ProductResponseSchema,
+                    }, params, { id: String(invMastUid) });
+                },
+            },
+            /**
+             * Get similar inventory masters
+             * @description Retrieve similar inventory masters to the specified one
+             * @fullPath api.items.invMast.similar.get
+             * @service items
+             * @domain inventory-management
+             * @discoverable true
+             * @searchTerms ["similar products", "related items", "product recommendations"]
+             * @param invMastUid Inventory master unique identifier
+             * @returns Array of similar inventory masters
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const similar = await client.invMast.similar.get(12345);
+             * ```
+             */
+            similar: {
+                get: async (invMastUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/similar',
+                        responseSchema: schemas_1.ProductListResponseSchema,
+                    }, undefined, { id: String(invMastUid) });
+                },
+            },
+            /**
+             * Get inventory master alternate codes
+             * @description Retrieve alternate codes for a specific inventory master
+             * @fullPath api.items.invMast.alternateCode.get
+             * @service items
+             * @domain inventory-management
+             * @discoverable true
+             * @searchTerms ["alternate codes", "product codes", "item codes", "SKU alternatives"]
+             * @param invMastUid Inventory master unique identifier
+             * @returns Array of alternate codes
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const altCodes = await client.invMast.alternateCode.get(12345);
+             * ```
+             */
+            alternateCode: {
+                get: async (invMastUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/alternate-code',
+                        responseSchema: zod_1.z.object({
+                            count: zod_1.z.number(),
+                            data: zod_1.z.array(zod_1.z.object({
+                                alternateCode: zod_1.z.string(),
+                                codeType: zod_1.z.string().optional(),
+                            })),
+                            message: zod_1.z.string(),
+                            options: zod_1.z.any(),
+                            params: zod_1.z.any(),
+                            status: zod_1.z.number(),
+                            total: zod_1.z.number(),
+                            totalResults: zod_1.z.number(),
+                        }),
+                    }, undefined, { id: String(invMastUid) });
+                },
+            },
+            /**
+             * Get inventory master accessories
+             * @description Retrieve accessories for a specific inventory master
+             * @fullPath api.items.invMast.invAccessory.get
+             * @service items
+             * @domain inventory-management
+             * @discoverable true
+             * @searchTerms ["accessories", "related products", "add-on items"]
+             * @param invMastUid Inventory master unique identifier
+             * @returns Array of accessories
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const accessories = await client.invMast.invAccessory.get(12345);
+             * ```
+             */
+            invAccessory: {
+                get: async (invMastUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/inv-accessory',
+                        responseSchema: schemas_1.AccessoryListResponseSchema,
+                    }, undefined, { id: String(invMastUid) });
+                },
+            },
+            /**
+             * Get inventory master sub-items
+             * @description Retrieve sub-items for a specific inventory master
+             * @fullPath api.items.invMast.invSub.get
+             * @service items
+             * @domain inventory-management
+             * @discoverable true
+             * @searchTerms ["sub-items", "component items", "parts"]
+             * @param invMastUid Inventory master unique identifier
+             * @returns Array of sub-items
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const subItems = await client.invMast.invSub.get(12345);
+             * ```
+             */
+            invSub: {
+                get: async (invMastUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/inv-sub',
+                        responseSchema: schemas_1.ProductListResponseSchema,
+                    }, undefined, { id: String(invMastUid) });
+                },
+            },
+            /**
+             * Get inventory master stock information
+             * @description Get comprehensive stock details for an inventory master
+             * @fullPath api.items.invMast.stock.get
+             * @service items
+             * @domain inventory-management
+             * @discoverable true
+             * @searchTerms ["stock", "inventory levels", "quantities", "availability"]
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional parameters for filtering and including additional data
+             * @returns Stock details with location breakdown
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const stockInfo = await client.invMast.stock.get(12345);
+             * ```
+             */
+            stock: {
+                get: async (invMastUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/stock',
+                        paramsSchema: schemas_1.GetStockParamsSchema,
+                        responseSchema: schemas_1.GetStockResponseSchema,
+                    }, params, { id: String(invMastUid) });
+                },
+            },
+            /**
+             * FAQ operations for inventory masters
+             * @description Methods for managing FAQs for inventory masters
+             */
+            faq: {
+                /**
+                 * List FAQs for an inventory master
+                 * @fullPath api.items.invMast.faq.list
+                 * @param invMastUid Inventory master unique identifier
+                 * @param params Optional filtering parameters
+                 * @returns Array of FAQs
+                 */
+                list: async (invMastUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/faq',
+                        paramsSchema: schemas_1.ItemFaqListParamsSchema,
+                        responseSchema: schemas_1.ItemFaqListResponseSchema,
+                    }, params, { id: String(invMastUid) });
+                },
+                /**
+                 * Create FAQ for an inventory master
+                 * @fullPath api.items.invMast.faq.create
+                 * @param invMastUid Inventory master unique identifier
+                 * @param request FAQ creation data
+                 * @returns Created FAQ
+                 */
+                create: async (invMastUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/inv-mast/{id}/faq',
+                        paramsSchema: schemas_1.CreateItemFaqRequestSchema,
+                        responseSchema: schemas_1.ItemFaqResponseSchema,
+                    }, request, { id: String(invMastUid) });
+                },
+                /**
+                 * Get specific FAQ for an inventory master
+                 * @fullPath api.items.invMast.faq.get
+                 * @param invMastUid Inventory master unique identifier
+                 * @param invMastFaqUid FAQ unique identifier
+                 * @returns FAQ details
+                 */
+                get: async (invMastUid, invMastFaqUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{invMastUid}/faq/{invMastFaqUid}',
+                        responseSchema: schemas_1.ItemFaqResponseSchema,
+                    }, undefined, { invMastUid: String(invMastUid), invMastFaqUid: String(invMastFaqUid) });
+                },
+                /**
+                 * Update FAQ for an inventory master
+                 * @fullPath api.items.invMast.faq.update
+                 * @param invMastUid Inventory master unique identifier
+                 * @param invMastFaqUid FAQ unique identifier
+                 * @param request FAQ update data
+                 * @returns Updated FAQ
+                 */
+                update: async (invMastUid, invMastFaqUid, request) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/inv-mast/{invMastUid}/faq/{invMastFaqUid}',
+                        paramsSchema: schemas_1.UpdateItemFaqRequestSchema,
+                        responseSchema: schemas_1.ItemFaqResponseSchema,
+                    }, request, { invMastUid: String(invMastUid), invMastFaqUid: String(invMastFaqUid) });
+                },
+                /**
+                 * Delete FAQ for an inventory master
+                 * @fullPath api.items.invMast.faq.delete
+                 * @param invMastUid Inventory master unique identifier
+                 * @param invMastFaqUid FAQ unique identifier
+                 * @returns Success indication
+                 */
+                delete: async (invMastUid, invMastFaqUid) => {
+                    await this.executeRequest({
+                        method: 'DELETE',
+                        path: '/inv-mast/{invMastUid}/faq/{invMastFaqUid}',
+                        responseSchema: zod_1.z.undefined(),
+                    }, undefined, { invMastUid: String(invMastUid), invMastFaqUid: String(invMastFaqUid) });
+                    return true;
+                },
+            },
+            /**
+             * Attribute operations for inventory masters
+             * @description Methods for managing attributes of inventory masters
+             */
+            attributes: {
+                /**
+                 * List attributes for an inventory master
+                 * @fullPath api.items.invMast.attributes.list
+                 * @param invMastUid Inventory master unique identifier
+                 * @param params Optional pagination parameters
+                 * @returns Array of attributes
+                 */
+                list: async (invMastUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{invMastUid}/attributes',
+                        paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
+                        responseSchema: schemas_1.AttributeListResponseSchema,
+                    }, params, { invMastUid: String(invMastUid) });
+                },
+                /**
+                 * Create attribute association for an inventory master
+                 * @fullPath api.items.invMast.attributes.create
+                 * @param invMastUid Inventory master unique identifier
+                 * @param request Attribute association data
+                 * @returns Created attribute association
+                 */
+                create: async (invMastUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/inv-mast/{invMastUid}/attributes',
+                        paramsSchema: zod_1.z.object({
+                            attributeUid: zod_1.z.number(),
+                        }),
+                        responseSchema: zod_1.z.object({
+                            count: zod_1.z.number(),
+                            data: zod_1.z.object({
+                                invMastUid: zod_1.z.number(),
+                                attributeUid: zod_1.z.number(),
+                            }),
+                            message: zod_1.z.string(),
+                            options: zod_1.z.any(),
+                            params: zod_1.z.any(),
+                            status: zod_1.z.number(),
+                            total: zod_1.z.number(),
+                            totalResults: zod_1.z.number(),
+                        }),
+                    }, request, { invMastUid: String(invMastUid) });
+                },
+                /**
+                 * Attribute values for inventory master attributes
+                 * @description Methods for managing attribute values for specific attributes on inventory masters
+                 */
+                values: {
+                    /**
+                     * List attribute values for an inventory master attribute
+                     * @fullPath api.items.invMast.attributes.values.list
+                     * @param invMastUid Inventory master unique identifier
+                     * @param attributeUid Attribute unique identifier
+                     * @param params Optional pagination parameters
+                     * @returns Array of attribute values
+                     */
+                    list: async (invMastUid, attributeUid, params) => {
+                        return this.executeRequest({
+                            method: 'GET',
+                            path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values',
+                            paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
+                            responseSchema: schemas_1.AttributeValueListResponseSchema,
+                        }, params, { invMastUid: String(invMastUid), attributeUid: String(attributeUid) });
+                    },
+                    /**
+                     * Create attribute value for an inventory master attribute
+                     * @fullPath api.items.invMast.attributes.values.create
+                     * @param invMastUid Inventory master unique identifier
+                     * @param attributeUid Attribute unique identifier
+                     * @param request Attribute value data
+                     * @returns Created attribute value
+                     */
+                    create: async (invMastUid, attributeUid, request) => {
+                        return this.executeRequest({
+                            method: 'POST',
+                            path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values',
+                            paramsSchema: zod_1.z.object({
+                                attributeValueUid: zod_1.z.number(),
+                                customValue: zod_1.z.string().optional(),
+                            }),
+                            responseSchema: zod_1.z.object({
+                                count: zod_1.z.number(),
+                                data: zod_1.z.object({
+                                    invMastUid: zod_1.z.number(),
+                                    attributeUid: zod_1.z.number(),
+                                    attributeValueUid: zod_1.z.number(),
+                                    customValue: zod_1.z.string().optional(),
+                                }),
+                                message: zod_1.z.string(),
+                                options: zod_1.z.any(),
+                                params: zod_1.z.any(),
+                                status: zod_1.z.number(),
+                                total: zod_1.z.number(),
+                                totalResults: zod_1.z.number(),
+                            }),
+                        }, request, { invMastUid: String(invMastUid), attributeUid: String(attributeUid) });
+                    },
+                    /**
+                     * Update attribute value for an inventory master attribute
+                     * @fullPath api.items.invMast.attributes.values.update
+                     * @param invMastUid Inventory master unique identifier
+                     * @param attributeUid Attribute unique identifier
+                     * @param attributeValueUid Attribute value unique identifier
+                     * @param request Update data
+                     * @returns Updated attribute value
+                     */
+                    update: async (invMastUid, attributeUid, attributeValueUid, request) => {
+                        return this.executeRequest({
+                            method: 'PUT',
+                            path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values/{attributeValueUid}',
+                            paramsSchema: zod_1.z.object({
+                                customValue: zod_1.z.string().optional(),
+                            }),
+                            responseSchema: zod_1.z.object({
+                                count: zod_1.z.number(),
+                                data: zod_1.z.object({
+                                    invMastUid: zod_1.z.number(),
+                                    attributeUid: zod_1.z.number(),
+                                    attributeValueUid: zod_1.z.number(),
+                                    customValue: zod_1.z.string().optional(),
+                                }),
+                                message: zod_1.z.string(),
+                                options: zod_1.z.any(),
+                                params: zod_1.z.any(),
+                                status: zod_1.z.number(),
+                                total: zod_1.z.number(),
+                                totalResults: zod_1.z.number(),
+                            }),
+                        }, request, {
+                            invMastUid: String(invMastUid),
+                            attributeUid: String(attributeUid),
+                            attributeValueUid: String(attributeValueUid),
+                        });
+                    },
+                    /**
+                     * Delete attribute value for an inventory master attribute
+                     * @fullPath api.items.invMast.attributes.values.delete
+                     * @param invMastUid Inventory master unique identifier
+                     * @param attributeUid Attribute unique identifier
+                     * @param attributeValueUid Attribute value unique identifier
+                     * @returns Success indication
+                     */
+                    delete: async (invMastUid, attributeUid, attributeValueUid) => {
+                        await this.executeRequest({
+                            method: 'DELETE',
+                            path: '/inv-mast/{invMastUid}/attributes/{attributeUid}/values/{attributeValueUid}',
+                            responseSchema: zod_1.z.undefined(),
+                        }, undefined, {
+                            invMastUid: String(invMastUid),
+                            attributeUid: String(attributeUid),
+                            attributeValueUid: String(attributeValueUid),
+                        });
+                        return true;
+                    },
+                },
+            },
+            /**
+             * Location-based operations for inventory masters
+             * @description Methods for managing inventory master data at specific locations
+             * Direct mapping to /inv-mast/{invMastUid}/locations/* paths
+             */
+            locations: {
+                /**
+                 * Bin-specific operations for inventory masters at locations
+                 * @description Methods for managing inventory master data in specific bins at locations
+                 * Direct mapping to /inv-mast/{invMastUid}/locations/{locationId}/bins/* paths
+                 */
+                bins: {
+                    /**
+                     * Get specific bin information for an inventory master at a location
+                     * @description Retrieve specific bin information for an inventory master at a particular location including quantities
+                     * @fullPath api.items.invMast.locations.bins.get
+                     * @service items
+                     * @domain inventory-management
+                     * @discoverable true
+                     * @searchTerms ["invMast bin", "inventory master bin", "bin quantities", "product location inventory", "bin stock levels"]
+                     * @relatedEndpoints ["api.items.invMast.locations.bins.list", "api.items.stock.getDetails", "api.nexus.inventory.movements"]
+                     * @commonPatterns ["Check product stock in specific bin", "Bin-level inventory tracking", "Location-specific quantities"]
+                     * @workflow ["inventory-management", "warehouse-operations", "stock-verification"]
+                     * @prerequisites ["Valid authentication token", "Product and location access permissions"]
+                     * @nextSteps ["api.nexus.inventory.movements for stock movements", "api.items.locations.bins.get for bin details"]
+                     * @businessRules ["Shows active inventory only", "Requires valid product-location-bin combination", "Real-time quantities"]
+                     * @functionalArea "inventory-master-management"
+                     * @caching "Not cached - real-time inventory data"
+                     * @performance "Fast lookup for specific bin, use list() for multiple bins"
+                     * @param invMastUid Inventory master unique identifier
+                     * @param locationId Location unique identifier
+                     * @param bin Bin identifier
+                     * @returns Bin information for the inventory master at the location
+                     * @throws ValidationError When response is malformed
+                     * @example
+                     * ```typescript
+                     * const binInfo = await client.invMast.locations.bins.get(12345, 1, 'A-01');
+                     * console.log(`Bin ${binInfo.bin}: ${binInfo.qtyOnHand} on hand`);
+                     * ```
+                     */
+                    get: async (invMastUid, locationId, bin) => {
+                        const response = await this.executeRequest({
+                            method: 'GET',
+                            path: '/inv-mast/{invMastUid}/locations/{locationId}/bins/{bin}',
+                            responseSchema: schemas_1.BinInfoListResponseSchema,
+                        }, undefined, {
+                            invMastUid: String(invMastUid),
+                            locationId: String(locationId),
+                            bin,
+                        });
+                        // Return first bin info from array response
+                        return response.data[0];
+                    },
+                    /**
+                     * List all bins for an inventory master at a specific location
+                     * @description Retrieve comprehensive bin information for an inventory master at a specific location including quantities and availability
+                     * @fullPath api.items.invMast.locations.bins.list
+                     * @service items
+                     * @domain inventory-management
+                     * @discoverable true
+                     * @searchTerms ["invMast bins at location", "inventory master location bins", "location inventory", "warehouse inventory"]
+                     * @relatedEndpoints ["api.items.invMast.locations.bins.get", "api.items.locations.bins.list", "api.items.stock.getDetails"]
+                     * @commonPatterns ["View all bins for product at location", "Location inventory summary", "Multi-bin inventory check"]
+                     * @workflow ["inventory-management", "warehouse-operations", "stock-verification"]
+                     * @prerequisites ["Valid authentication token", "Product and location access permissions"]
+                     * @nextSteps ["api.items.invMast.locations.bins.get for specific bin details", "api.nexus.inventory.movements for movements"]
+                     * @businessRules ["Shows active inventory only", "Groups by bin within location", "Real-time quantities"]
+                     * @functionalArea "inventory-master-management"
+                     * @caching "Not cached - real-time inventory data"
+                     * @performance "Paginated results for locations with many bins"
+                     * @param invMastUid Inventory master unique identifier
+                     * @param locationId Location unique identifier
+                     * @param params Optional pagination parameters
+                     * @returns Array of bin information for the inventory master at the location
+                     * @throws ValidationError When response is malformed
+                     * @example
+                     * ```typescript
+                     * const bins = await client.invMast.locations.bins.list(12345, 1);
+                     * bins.data.forEach(bin => {
+                     *   console.log(`Bin ${bin.bin}: ${bin.qtyOnHand} on hand, ${bin.qtyAvailable} available`);
+                     * });
+                     * ```
+                     */
+                    list: async (invMastUid, locationId, params) => {
+                        return this.executeRequest({
+                            method: 'GET',
+                            path: '/inv-mast/{invMastUid}/locations/{locationId}/bins',
+                            paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
+                            responseSchema: schemas_1.BinInfoListResponseSchema,
+                        }, params, {
+                            invMastUid: String(invMastUid),
+                            locationId: String(locationId),
+                        });
+                    },
+                },
+            },
+        };
     }
 }
 exports.ItemsClient = ItemsClient;