@simpleapps-com/augur-api 0.5.0 → 0.6.0

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

@@ -2,12 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ItemsClient = void 0;
 const base_client_1 = require("../../core/base-client");
-const common_schemas_1 = require("../../core/common-schemas");
-const schemas_1 = require("./schemas");
+const resources_1 = require("./resources");
 /**
  * Items service client implementing OpenAPI Path Mirroring Pattern
  *
  * **CRITICAL**: All client structures follow exact OpenAPI path segments
+ *
+ * This client provides access to the Items API with full type safety and validation.
+ * All endpoints are organized by their OpenAPI path structure.
+ *
+ * @example
+ * ```typescript
+ * const client = new ItemsClient(httpClient);
+ *
+ * // Standard method - returns full response with metadata
+ * const response = await client.invMast.list({ limit: 10 });
+ * console.log(response.data); // Array of items
+ * console.log(response.total); // Total count
+ *
+ * // Data method - returns just the data
+ * const items = await client.invMastData.list({ limit: 10 });
+ * console.log(items); // Array of items directly
+ * ```
  */
 class ItemsClient extends base_client_1.BaseServiceClient {
     /**
@@ -17,2077 +33,59 @@ class ItemsClient extends base_client_1.BaseServiceClient {
      */
     constructor(http, baseUrl = 'https://items.augur-api.com') {
         super('items', http, baseUrl);
-        /**
-         * OpenAPI Path: /attribute-groups → attributeGroups.*
-         * @description Methods for managing attribute groups with CRUD operations
-         */
-        this.attributeGroups = {
-            /**
-             * List all attribute groups
-             * @description Retrieve a list of attribute groups with filtering options
-             * @fullPath api.items.attributeGroups.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @dataMethod attributeGroupsData.list
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/attribute-groups',
-                    paramsSchema: schemas_1.AttributeGroupListParamsSchema,
-                    responseSchema: schemas_1.AttributeGroupListResponseSchema,
-                }, params);
-            },
-            /**
-             * Create new attribute group
-             * @description Create a new attribute group
-             * @fullPath api.items.attributeGroups.create
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            create: async (data) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/attribute-groups',
-                    paramsSchema: schemas_1.CreateAttributeGroupRequestSchema,
-                    responseSchema: schemas_1.AttributeGroupResponseSchema,
-                }, data);
-            },
-            /**
-             * Get attribute group by ID
-             * @description Retrieve specific attribute group details
-             * @fullPath api.items.attributeGroups.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (attributeGroupUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/attribute-groups/${attributeGroupUid}`,
-                    responseSchema: schemas_1.AttributeGroupResponseSchema,
-                });
-            },
-            /**
-             * Update attribute group
-             * @description Update existing attribute group
-             * @fullPath api.items.attributeGroups.update
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            update: async (attributeGroupUid, data) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: `/attribute-groups/${attributeGroupUid}`,
-                    paramsSchema: schemas_1.UpdateAttributeGroupRequestSchema,
-                    responseSchema: schemas_1.AttributeGroupResponseSchema,
-                }, data);
-            },
-            /**
-             * Delete attribute group
-             * @description Delete existing attribute group
-             * @fullPath api.items.attributeGroups.delete
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            delete: async (attributeGroupUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: `/attribute-groups/${attributeGroupUid}`,
-                    responseSchema: schemas_1.AttributeGroupResponseSchema,
-                });
-            },
-            /**
-             * OpenAPI Path: /attribute-groups/{attributeGroupUid}/attributes → attributeGroups.attributes.*
-             * @description Nested path for managing attributes within attribute groups
-             */
-            attributes: {
-                /**
-                 * List attributes in attribute group
-                 * @description List all attributes associated with an attribute group
-                 * @fullPath api.items.attributeGroups.attributes.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (attributeGroupUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/attribute-groups/${attributeGroupUid}/attributes`,
-                        paramsSchema: schemas_1.AttributeGroupAttributesListParamsSchema,
-                        responseSchema: schemas_1.AttributeGroupAttributeListResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Add attribute to attribute group
-                 * @description Create association between attribute and attribute group
-                 * @fullPath api.items.attributeGroups.attributes.create
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                create: async (attributeGroupUid, data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: `/attribute-groups/${attributeGroupUid}/attributes`,
-                        paramsSchema: schemas_1.CreateAttributeGroupAttributeRequestSchema,
-                        responseSchema: schemas_1.AttributeGroupAttributeResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Get attribute group attribute association
-                 * @description Get specific attribute-group association details
-                 * @fullPath api.items.attributeGroups.attributes.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (attributeGroupUid, attributeXAttributeGroupUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/attribute-groups/${attributeGroupUid}/attributes/${attributeXAttributeGroupUid}`,
-                        responseSchema: schemas_1.AttributeGroupAttributeResponseSchema,
-                    });
-                },
-                /**
-                 * Update attribute group attribute association
-                 * @description Update existing attribute-group association
-                 * @fullPath api.items.attributeGroups.attributes.update
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                update: async (attributeGroupUid, attributeXAttributeGroupUid, data) => {
-                    return this.executeRequest({
-                        method: 'PUT',
-                        path: `/attribute-groups/${attributeGroupUid}/attributes/${attributeXAttributeGroupUid}`,
-                        paramsSchema: schemas_1.UpdateAttributeGroupAttributeRequestSchema,
-                        responseSchema: schemas_1.AttributeGroupAttributeResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Remove attribute from attribute group
-                 * @description Delete attribute-group association
-                 * @fullPath api.items.attributeGroups.attributes.delete
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                delete: async (attributeGroupUid, attributeXAttributeGroupUid) => {
-                    return this.executeRequest({
-                        method: 'DELETE',
-                        path: `/attribute-groups/${attributeGroupUid}/attributes/${attributeXAttributeGroupUid}`,
-                        responseSchema: schemas_1.AttributeGroupAttributeResponseSchema,
-                    });
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /attributes → attributes.*
-         * @description Methods for managing product attributes
-         */
-        this.attributes = {
-            /**
-             * List all attributes
-             * @description Retrieve a paginated list of available attributes
-             * @fullPath api.items.attributes.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @dataMethod attributesData.list
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/attributes',
-                    paramsSchema: schemas_1.AttributesListParamsSchema,
-                    responseSchema: schemas_1.AttributeListResponseSchema,
-                }, params);
-            },
-            /**
-             * Create new attribute
-             * @description Create a new product attribute
-             * @fullPath api.items.attributes.create
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            create: async (data) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/attributes',
-                    paramsSchema: schemas_1.CreateAttributeRequestSchema,
-                    responseSchema: schemas_1.AttributeResponseSchema,
-                }, data);
-            },
-            /**
-             * Get attribute by ID
-             * @description Retrieve specific attribute details
-             * @fullPath api.items.attributes.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (attributeUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/attributes/${attributeUid}`,
-                    responseSchema: schemas_1.AttributeResponseSchema,
-                });
-            },
-            /**
-             * Update attribute
-             * @description Update existing attribute
-             * @fullPath api.items.attributes.update
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            update: async (attributeUid, data) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: `/attributes/${attributeUid}`,
-                    paramsSchema: schemas_1.UpdateAttributeRequestSchema,
-                    responseSchema: schemas_1.AttributeResponseSchema,
-                }, data);
-            },
-            /**
-             * Delete attribute
-             * @description Delete existing attribute
-             * @fullPath api.items.attributes.delete
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            delete: async (attributeUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: `/attributes/${attributeUid}`,
-                    responseSchema: schemas_1.AttributeResponseSchema,
-                });
-            },
-            /**
-             * OpenAPI Path: /attributes/{attributeUid}/values → attributes.values.*
-             * @description Nested path for managing values within attributes
-             */
-            values: {
-                /**
-                 * List attribute values
-                 * @description List all values for a specific attribute
-                 * @fullPath api.items.attributes.values.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (attributeUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/attributes/${attributeUid}/values`,
-                        paramsSchema: schemas_1.AttributeValuesListParamsSchema,
-                        responseSchema: schemas_1.AttributeValueListResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Create attribute value
-                 * @description Create new value for an attribute
-                 * @fullPath api.items.attributes.values.create
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                create: async (attributeUid, data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: `/attributes/${attributeUid}/values`,
-                        paramsSchema: schemas_1.CreateAttributeValueRequestSchema,
-                        responseSchema: schemas_1.AttributeValueResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Get attribute value
-                 * @description Get specific attribute value details
-                 * @fullPath api.items.attributes.values.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (attributeUid, attributeValueUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/attributes/${attributeUid}/values/${attributeValueUid}`,
-                        responseSchema: schemas_1.AttributeValueResponseSchema,
-                    });
-                },
-                /**
-                 * Update attribute value
-                 * @description Update existing attribute value
-                 * @fullPath api.items.attributes.values.update
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                update: async (attributeUid, attributeValueUid, data) => {
-                    return this.executeRequest({
-                        method: 'PUT',
-                        path: `/attributes/${attributeUid}/values/${attributeValueUid}`,
-                        paramsSchema: schemas_1.UpdateAttributeValueRequestSchema,
-                        responseSchema: schemas_1.AttributeValueResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Delete attribute value
-                 * @description Delete existing attribute value
-                 * @fullPath api.items.attributes.values.delete
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                delete: async (attributeUid, attributeValueUid) => {
-                    return this.executeRequest({
-                        method: 'DELETE',
-                        path: `/attributes/${attributeUid}/values/${attributeValueUid}`,
-                        responseSchema: schemas_1.AttributeValueResponseSchema,
-                    });
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /brands → brands.*
-         * @description Methods for managing product brands
-         */
-        this.brands = {
-            /**
-             * List all brands
-             * @description Retrieve a paginated list of brands with filtering options
-             * @fullPath api.items.brands.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @dataMethod brandsData.list
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/brands',
-                    paramsSchema: schemas_1.BrandListParamsSchema,
-                    responseSchema: schemas_1.BrandListResponseSchema,
-                }, params);
-            },
-            /**
-             * Create new brand
-             * @description Create a new brand
-             * @fullPath api.items.brands.create
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            create: async (data) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/brands',
-                    paramsSchema: schemas_1.CreateBrandRequestSchema,
-                    responseSchema: schemas_1.BrandResponseSchema,
-                }, data);
-            },
-            /**
-             * Get brand by ID
-             * @description Retrieve specific brand details
-             * @fullPath api.items.brands.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (brandsUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/brands/${brandsUid}`,
-                    responseSchema: schemas_1.BrandResponseSchema,
-                });
-            },
-            /**
-             * Update brand
-             * @description Update existing brand
-             * @fullPath api.items.brands.update
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            update: async (brandsUid, data) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: `/brands/${brandsUid}`,
-                    paramsSchema: schemas_1.UpdateBrandRequestSchema,
-                    responseSchema: schemas_1.BrandResponseSchema,
-                }, data);
-            },
-            /**
-             * Delete brand
-             * @description Delete existing brand
-             * @fullPath api.items.brands.delete
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            delete: async (brandsUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: `/brands/${brandsUid}`,
-                    responseSchema: schemas_1.BrandResponseSchema,
-                });
-            },
-            /**
-             * OpenAPI Path: /brands/{brandsUid}/items → brands.items.*
-             * @description Nested path for managing items within brands
-             */
-            items: {
-                /**
-                 * List brand items
-                 * @description List all items associated with a brand
-                 * @fullPath api.items.brands.items.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (brandsUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/brands/${brandsUid}/items`,
-                        paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                        responseSchema: schemas_1.BrandItemListResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Add item to brand
-                 * @description Create association between item and brand
-                 * @fullPath api.items.brands.items.create
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                create: async (brandsUid, data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: `/brands/${brandsUid}/items`,
-                        paramsSchema: schemas_1.CreateBrandItemRequestSchema,
-                        responseSchema: schemas_1.BrandItemResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Get brand item association
-                 * @description Get specific brand-item association details
-                 * @fullPath api.items.brands.items.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (brandsUid, brandsXItemsUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/brands/${brandsUid}/items/${brandsXItemsUid}`,
-                        responseSchema: schemas_1.BrandItemResponseSchema,
-                    });
-                },
-                /**
-                 * Update brand item association
-                 * @description Update existing brand-item association
-                 * @fullPath api.items.brands.items.update
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                update: async (brandsUid, brandsXItemsUid, data) => {
-                    return this.executeRequest({
-                        method: 'PUT',
-                        path: `/brands/${brandsUid}/items/${brandsXItemsUid}`,
-                        paramsSchema: schemas_1.UpdateBrandItemRequestSchema,
-                        responseSchema: schemas_1.BrandItemResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Remove item from brand
-                 * @description Delete brand-item association
-                 * @fullPath api.items.brands.items.delete
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                delete: async (brandsUid, brandsXItemsUid) => {
-                    return this.executeRequest({
-                        method: 'DELETE',
-                        path: `/brands/${brandsUid}/items/${brandsXItemsUid}`,
-                        responseSchema: schemas_1.BrandItemResponseSchema,
-                    });
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /categories → categories.*
-         * @description Methods for managing categories
-         */
-        this.categories = {
-            /**
-             * OpenAPI Path: /categories/lookup → categories.lookup.get
-             * @description Lookup endpoint for categories
-             */
-            lookup: {
-                /**
-                 * Lookup categories
-                 * @description Search for categories using lookup functionality
-                 * @fullPath api.items.categories.lookup.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/categories/lookup',
-                        paramsSchema: schemas_1.CategoryLookupParamsSchema,
-                        responseSchema: schemas_1.CategoryLookupResponseSchema,
-                    }, params);
-                },
-            },
-            /**
-             * Get category details
-             * @description Retrieve comprehensive category information
-             * @fullPath api.items.categories.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (itemCategoryUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/categories/${itemCategoryUid}`,
-                    responseSchema: schemas_1.CategoryResponseSchema,
-                });
-            },
-            /**
-             * OpenAPI Path: /categories/{itemCategoryUid}/attributes → categories.attributes.list
-             * @description Nested path for category attributes
-             */
-            attributes: {
-                /**
-                 * List category attributes
-                 * @description Get attributes associated with a category
-                 * @fullPath api.items.categories.attributes.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (itemCategoryUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/categories/${itemCategoryUid}/attributes`,
-                        responseSchema: schemas_1.CategoryAttributesResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /categories/{itemCategoryUid}/images → categories.images.list
-             * @description Nested path for category images
-             */
-            images: {
-                /**
-                 * List category images
-                 * @description Get images associated with a category
-                 * @fullPath api.items.categories.images.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (itemCategoryUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/categories/${itemCategoryUid}/images`,
-                        responseSchema: schemas_1.CategoryImagesResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /categories/{itemCategoryUid}/items → categories.items.list
-             * @description Nested path for category items (plural)
-             */
-            items: {
-                /**
-                 * List category items
-                 * @description List items in a category with filtering and search capabilities
-                 * @fullPath api.items.categories.items.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 * @dataMethod categoriesData.items.list
-                 * @searchTerms ["category", "items", "products", "list", "filter"]
-                 * @relatedEndpoints ["categories.get", "invMast.list", "categories.attributes.list"]
-                 * @commonPatterns ["List items in category", "Filter category products", "Search category items"]
-                 * @workflow ["inventory-management", "product-discovery"]
-                 * @prerequisites ["Valid itemCategoryUid", "Bearer token", "x-site-id header", "Required q parameter"]
-                 * @nextSteps ["Use item details for product display", "Apply filters for refinement"]
-                 * @businessRules ["Returns array of items", "Requires q search parameter", "Supports pagination and filtering"]
-                 * @functionalArea "inventory-management"
-                 * @crossSite true
-                 * @caching "Variable TTL based on cacheTtl parameter"
-                 * @performance "Good - supports caching and filtering"
-                 */
-                list: async (itemCategoryUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/categories/${itemCategoryUid}/items`,
-                        paramsSchema: schemas_1.CategoryItemsParamsSchema,
-                        responseSchema: schemas_1.CategoryItemsResponseSchema,
-                    }, params);
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /contracts → contracts.*
-         * @description Methods for managing contract items
-         */
-        this.contracts = {
-            /**
-             * List contract item attributes
-             * @description List the attributes for contract items
-             * @fullPath api.items.contracts.attributes.list
-             * @service items
-             * @domain contract-management
-             * @discoverable true
-             * @dataMethod contractsData.attributes.list
-             */
-            attributes: {
-                /**
-                 * Get contract item attributes
-                 * @description List the attributes for contract items by job number
-                 * @fullPath api.items.contracts.attributes.list
-                 * @service items
-                 * @domain contract-management
-                 * @discoverable true
-                 * @dataMethod contractsData.attributes.list
-                 * @searchTerms ["contract", "attributes", "job", "items", "properties"]
-                 * @relatedEndpoints ["contracts.items.list", "attributes.list", "categories.attributes.list"]
-                 * @commonPatterns ["Get contract item attributes for job", "List contract properties"]
-                 * @workflow ["contract-management", "item-configuration"]
-                 * @prerequisites ["Valid job number", "Bearer token", "x-site-id header"]
-                 * @nextSteps ["Use attributes for filtering contract items", "Configure item properties"]
-                 * @businessRules ["Job number must exist", "Returns all available attributes for contract items"]
-                 * @functionalArea "contract-management"
-                 * @crossSite false
-                 * @caching "5 minutes - attributes change infrequently"
-                 * @performance "Fast - simple lookup operation"
-                 */
-                list: async (jobNo) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/contracts/${jobNo}/attributes`,
-                        responseSchema: schemas_1.ContractsAttributesResponseSchema,
-                    });
-                },
-            },
-            /**
-             * List contract items
-             * @description List contracts items for a job with filtering and search capabilities
-             * @fullPath api.items.contracts.items.list
-             * @service items
-             * @domain contract-management
-             * @discoverable true
-             * @dataMethod contractsData.items.list
-             */
-            items: {
-                /**
-                 * List contract items for a job
-                 * @description List contracts items for a job with extensive filtering options
-                 * @fullPath api.items.contracts.items.list
-                 * @service items
-                 * @domain contract-management
-                 * @discoverable true
-                 */
-                list: async (jobNo, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/contracts/${jobNo}/items`,
-                        paramsSchema: schemas_1.ContractsItemsParamsSchema,
-                        responseSchema: schemas_1.ContractsItemsResponseSchema,
-                    }, { ...params, jobNo });
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /health-check → healthCheck.get
-         * @description Health check endpoint
-         */
-        this.healthCheck = {
-            /**
-             * Service health check
-             * @description Verify service health and trigger seed jobs if needed
-             * @fullPath api.items.healthCheck.get
-             * @service items
-             * @domain system-health
-             * @discoverable true
-             * @dataMethod healthCheckData.get
-             */
-            get: async () => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/health-check',
-                    responseSchema: schemas_1.HealthCheckResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /internal → internal.*
-         * @description Internal service endpoints
-         */
-        this.internal = {
-            /**
-             * OpenAPI Path: /internal/pdf → internal.pdf.create
-             * @description PDF generation endpoints
-             */
-            pdf: {
-                /**
-                 * Generate PDF document
-                 * @description Create PDF document from template and data
-                 * @fullPath api.items.internal.pdf.create
-                 * @service items
-                 * @domain document-generation
-                 * @discoverable true
-                 */
-                create: async (data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: '/internal/pdf',
-                        paramsSchema: schemas_1.CreateInternalPdfRequestSchema,
-                        responseSchema: schemas_1.InternalPdfResponseSchema,
-                    }, data);
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /inv-mast → invMast.*
-         * @description Inventory Master endpoints
-         */
-        this.invMast = {
-            /**
-             * List inventory masters
-             * @description Retrieve a paginated list of inventory master items
-             * @fullPath api.items.invMast.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast',
-                    paramsSchema: schemas_1.ProductListParamsSchema,
-                    responseSchema: schemas_1.ProductListResponseSchema,
-                }, params);
-            },
-            /**
-             * OpenAPI Path: /inv-mast/lookup → invMast.lookup.get
-             * @description Lookup endpoint for inventory master
-             */
-            lookup: {
-                /**
-                 * Lookup inventory master items
-                 * @description Search for inventory master items using lookup functionality
-                 * @fullPath api.items.invMast.lookup.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/inv-mast/lookup',
-                        paramsSchema: schemas_1.InvMastLookupParamsSchema,
-                        responseSchema: schemas_1.InvMastLookupResponseSchema,
-                    }, params);
-                },
-            },
-            /**
-             * Get inventory master details
-             * @description Retrieve specific inventory master item details
-             * @fullPath api.items.invMast.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (invMastUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/inv-mast/${invMastUid}`,
-                    responseSchema: schemas_1.ProductResponseSchema,
-                });
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/alternate-code → invMast.alternateCode.list
-             * @description Nested path for alternate codes
-             */
-            alternateCode: {
-                /**
-                 * List alternate codes for inventory master
-                 * @description Get alternate codes for a specific inventory master item
-                 * @fullPath api.items.invMast.alternateCode.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/alternate-code`,
-                        responseSchema: schemas_1.AlternateCodeListResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/attributes → invMast.attributes.*
-             * @description Nested path for inventory master attributes
-             */
-            attributes: {
-                /**
-                 * List inventory master attributes
-                 * @description Get attributes for a specific inventory master item
-                 * @fullPath api.items.invMast.attributes.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/attributes`,
-                        paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                        responseSchema: schemas_1.ItemAttributeValueListResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Create inventory master attribute
-                 * @description Create attribute association for inventory master item
-                 * @fullPath api.items.invMast.attributes.create
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                create: async (invMastUid, data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: `/inv-mast/${invMastUid}/attributes`,
-                        paramsSchema: schemas_1.CreateItemAttributeValueRequestSchema,
-                        responseSchema: schemas_1.ItemAttributeValueResponseSchema,
-                    }, data);
-                },
-                /**
-                 * OpenAPI Path: /inv-mast/{invMastUid}/attributes/{attributeUid}/values → invMast.attributes.values.*
-                 * @description Deep nested path for inventory master attribute values
-                 */
-                values: {
-                    /**
-                     * List inventory master attribute values
-                     * @description Get attribute values for a specific attribute of an inventory master item
-                     * @fullPath api.items.invMast.attributes.values.list
-                     * @service items
-                     * @domain inventory-management
-                     * @discoverable true
-                     */
-                    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.ItemAttributeValueListResponseSchema,
-                        }, params);
-                    },
-                    /**
-                     * Create inventory master attribute value
-                     * @description Create attribute value for a specific attribute of an inventory master item
-                     * @fullPath api.items.invMast.attributes.values.create
-                     * @service items
-                     * @domain inventory-management
-                     * @discoverable true
-                     */
-                    create: async (invMastUid, attributeUid, data) => {
-                        return this.executeRequest({
-                            method: 'POST',
-                            path: `/inv-mast/${invMastUid}/attributes/${attributeUid}/values`,
-                            paramsSchema: schemas_1.CreateItemAttributeValueRequestSchema,
-                            responseSchema: schemas_1.ItemAttributeValueResponseSchema,
-                        }, data);
-                    },
-                    /**
-                     * Update inventory master attribute value
-                     * @description Update attribute value for a specific attribute of an inventory master item
-                     * @fullPath api.items.invMast.attributes.values.update
-                     * @service items
-                     * @domain inventory-management
-                     * @discoverable true
-                     */
-                    update: async (invMastUid, attributeUid, attributeValueUid, data) => {
-                        return this.executeRequest({
-                            method: 'PUT',
-                            path: `/inv-mast/${invMastUid}/attributes/${attributeUid}/values/${attributeValueUid}`,
-                            paramsSchema: schemas_1.UpdateItemAttributeValueRequestSchema,
-                            responseSchema: schemas_1.ItemAttributeValueResponseSchema,
-                        }, data);
-                    },
-                    /**
-                     * Delete inventory master attribute value
-                     * @description Delete attribute value for a specific attribute of an inventory master item
-                     * @fullPath api.items.invMast.attributes.values.delete
-                     * @service items
-                     * @domain inventory-management
-                     * @discoverable true
-                     */
-                    delete: async (invMastUid, attributeUid, attributeValueUid) => {
-                        return this.executeRequest({
-                            method: 'DELETE',
-                            path: `/inv-mast/${invMastUid}/attributes/${attributeUid}/values/${attributeValueUid}`,
-                            responseSchema: schemas_1.ItemAttributeValueResponseSchema,
-                        });
-                    },
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/doc → invMast.doc.list
-             * @description Nested path for inventory master documents
-             */
-            doc: {
-                /**
-                 * List inventory master documents
-                 * @description Get documents for a specific inventory master item
-                 * @fullPath api.items.invMast.doc.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/doc`,
-                        paramsSchema: schemas_1.InvMastDocParamsSchema,
-                        responseSchema: schemas_1.InvMastDocResponseSchema,
-                    }, params);
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/faq → invMast.faq.*
-             * @description Nested path for inventory master FAQs
-             */
-            faq: {
-                /**
-                 * List inventory master FAQs
-                 * @description Get FAQs for a specific inventory master item
-                 * @fullPath api.items.invMast.faq.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/faq`,
-                        paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                        responseSchema: schemas_1.InvMastFaqListResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Create inventory master FAQ
-                 * @description Create FAQ for a specific inventory master item
-                 * @fullPath api.items.invMast.faq.create
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                create: async (invMastUid, data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: `/inv-mast/${invMastUid}/faq`,
-                        paramsSchema: schemas_1.CreateInvMastFaqRequestSchema,
-                        responseSchema: schemas_1.InvMastFaqResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Get inventory master FAQ
-                 * @description Get specific FAQ for an inventory master item
-                 * @fullPath api.items.invMast.faq.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (invMastUid, invMastFaqUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/faq/${invMastFaqUid}`,
-                        responseSchema: schemas_1.InvMastFaqResponseSchema,
-                    });
-                },
-                /**
-                 * Update inventory master FAQ
-                 * @description Update FAQ for a specific inventory master item
-                 * @fullPath api.items.invMast.faq.update
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                update: async (invMastUid, invMastFaqUid, data) => {
-                    return this.executeRequest({
-                        method: 'PUT',
-                        path: `/inv-mast/${invMastUid}/faq/${invMastFaqUid}`,
-                        paramsSchema: schemas_1.UpdateInvMastFaqRequestSchema,
-                        responseSchema: schemas_1.InvMastFaqResponseSchema,
-                    }, data);
-                },
-                /**
-                 * Delete inventory master FAQ
-                 * @description Delete FAQ for a specific inventory master item
-                 * @fullPath api.items.invMast.faq.delete
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                delete: async (invMastUid, invMastFaqUid) => {
-                    return this.executeRequest({
-                        method: 'DELETE',
-                        path: `/inv-mast/${invMastUid}/faq/${invMastFaqUid}`,
-                        responseSchema: schemas_1.InvMastFaqResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/inv-accessory → invMast.invAccessory.list
-             * @description Nested path for inventory master accessories
-             */
-            invAccessory: {
-                /**
-                 * List inventory master accessories
-                 * @description Get accessories for a specific inventory master item
-                 * @fullPath api.items.invMast.invAccessory.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/inv-accessory`,
-                        responseSchema: schemas_1.AccessoryListResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/inv-sub → invMast.invSub.list
-             * @description Nested path for inventory master sub items
-             */
-            invSub: {
-                /**
-                 * List inventory master sub items
-                 * @description Get sub items for a specific inventory master item
-                 * @fullPath api.items.invMast.invSub.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/inv-sub`,
-                        responseSchema: schemas_1.InvMastSubPartsResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/locations → invMast.locations.*
-             * @description Deep nested path for inventory master locations
-             */
-            locations: {
-                /**
-                 * OpenAPI Path: /inv-mast/{invMastUid}/locations/{locationId}/bins → invMast.locations.bins.*
-                 * @description Deep nested path for inventory master location bins
-                 */
-                bins: {
-                    /**
-                     * List inventory master location bins
-                     * @description Get bins for a specific location of an inventory master item
-                     * @fullPath api.items.invMast.locations.bins.list
-                     * @service items
-                     * @domain inventory-management
-                     * @discoverable true
-                     */
-                    list: async (invMastUid, locationId, params) => {
-                        return this.executeRequest({
-                            method: 'GET',
-                            path: `/inv-mast/${invMastUid}/locations/${locationId}/bins`,
-                            paramsSchema: schemas_1.InvMastLocationsBinsParamsSchema,
-                            responseSchema: schemas_1.InvMastLocationBinListResponseSchema,
-                        }, params);
-                    },
-                    /**
-                     * Get inventory master location bin
-                     * @description Get specific bin for a location of an inventory master item
-                     * @fullPath api.items.invMast.locations.bins.get
-                     * @service items
-                     * @domain inventory-management
-                     * @discoverable true
-                     */
-                    get: async (invMastUid, locationId, bin) => {
-                        return this.executeRequest({
-                            method: 'GET',
-                            path: `/inv-mast/${invMastUid}/locations/${locationId}/bins/${bin}`,
-                            responseSchema: schemas_1.InvMastLocationBinResponseSchema,
-                        });
-                    },
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/similar → invMast.similar.list
-             * @description Nested path for similar inventory master items
-             */
-            similar: {
-                /**
-                 * List similar inventory master items
-                 * @description Get similar items for a specific inventory master item
-                 * @fullPath api.items.invMast.similar.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (invMastUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/similar`,
-                        responseSchema: schemas_1.SimilarProductListResponseSchema,
-                    });
-                },
-            },
-            /**
-             * OpenAPI Path: /inv-mast/{invMastUid}/stock → invMast.stock.get
-             * @description Nested path for inventory master stock (single object)
-             */
-            stock: {
-                /**
-                 * Get inventory master stock information
-                 * @description Get stock information for a specific inventory master item
-                 * @fullPath api.items.invMast.stock.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (invMastUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/inv-mast/${invMastUid}/stock`,
-                        paramsSchema: schemas_1.GetStockParamsSchema,
-                        responseSchema: schemas_1.GetStockResponseSchema,
-                    }, params);
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /inv-mast-links/{invMastUid} → invMastLinks.list
-         * @description Direct path mapping for inventory master links
-         */
-        this.invMastLinks = {
-            /**
-             * List inventory master links
-             * @description Get document links for an inventory master item
-             * @fullPath api.items.invMastLinks.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            list: async (invMastUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/inv-mast-links/${invMastUid}`,
-                    responseSchema: schemas_1.InvMastLinksResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /inv-mast-sub-parts/{invMastUid} → invMastSubParts.list
-         * @description Direct path mapping for inventory master sub parts
-         */
-        this.invMastSubParts = {
-            /**
-             * List inventory master sub parts
-             * @description Get sub parts for an inventory master item
-             * @fullPath api.items.invMastSubParts.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            list: async (invMastUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/inv-mast-sub-parts/${invMastUid}`,
-                    responseSchema: schemas_1.InvMastSubPartsResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /item-category → itemCategory.*
-         * @description Methods for managing item categories
-         */
-        this.itemCategory = {
-            /**
-             * List item categories
-             * @description Retrieve a paginated list of item categories with filtering options
-             * @fullPath api.items.itemCategory.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-category',
-                    paramsSchema: schemas_1.CategoryListParamsSchema,
-                    responseSchema: schemas_1.CategoryListResponseSchema,
-                }, params);
-            },
-            /**
-             * OpenAPI Path: /item-category/lookup → itemCategory.lookup.get
-             * @description Lookup endpoint for item categories
-             */
-            lookup: {
-                /**
-                 * Lookup item categories
-                 * @description Search for item categories using lookup functionality
-                 * @fullPath api.items.itemCategory.lookup.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/item-category/lookup',
-                        paramsSchema: schemas_1.CategoryLookupParamsSchema,
-                        responseSchema: schemas_1.CategoryLookupResponseSchema,
-                    }, params);
-                },
-            },
-            /**
-             * Get item category details
-             * @description Retrieve specific item category details
-             * @fullPath api.items.itemCategory.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (itemCategoryUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/item-category/${itemCategoryUid}`,
-                    responseSchema: schemas_1.CategoryResponseSchema,
-                });
-            },
-            /**
-             * OpenAPI Path: /item-category/{itemCategoryUid}/doc → itemCategory.doc.list
-             * @description Nested path for item category documents
-             */
-            doc: {
-                /**
-                 * List item category documents
-                 * @description Get documents for a specific item category
-                 * @fullPath api.items.itemCategory.doc.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (itemCategoryUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/item-category/${itemCategoryUid}/doc`,
-                        responseSchema: schemas_1.ItemCategoryDocListResponseSchema,
-                    });
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /item-favorites/{usersId} → itemFavorites.* (with required parameter)
-         * @description Methods for managing user item favorites
-         */
-        this.itemFavorites = {
-            /**
-             * List user favorites
-             * @description Get favorites for a specific user
-             * @fullPath api.items.itemFavorites.list
-             * @service items
-             * @domain user-preferences
-             * @discoverable true
-             */
-            list: async (usersId, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/item-favorites/${usersId}`,
-                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                    responseSchema: schemas_1.ItemFavoritesListResponseSchema,
-                }, params);
-            },
-            /**
-             * Create user favorite
-             * @description Add item to user's favorites
-             * @fullPath api.items.itemFavorites.create
-             * @service items
-             * @domain user-preferences
-             * @discoverable true
-             */
-            create: async (usersId, data) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: `/item-favorites/${usersId}`,
-                    paramsSchema: schemas_1.CreateItemFavoriteRequestSchema,
-                    responseSchema: schemas_1.ItemFavoritesItemResponseSchema,
-                }, data);
-            },
-            /**
-             * Update user favorite
-             * @description Update item in user's favorites
-             * @fullPath api.items.itemFavorites.update
-             * @service items
-             * @domain user-preferences
-             * @discoverable true
-             */
-            update: async (usersId, invMastUid, data) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: `/item-favorites/${usersId}/${invMastUid}`,
-                    paramsSchema: schemas_1.UpdateItemFavoriteRequestSchema,
-                    responseSchema: schemas_1.ItemFavoritesItemResponseSchema,
-                }, data);
-            },
-            /**
-             * Delete user favorite
-             * @description Remove item from user's favorites
-             * @fullPath api.items.itemFavorites.delete
-             * @service items
-             * @domain user-preferences
-             * @discoverable true
-             */
-            delete: async (usersId, invMastUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: `/item-favorites/${usersId}/${invMastUid}`,
-                    responseSchema: schemas_1.ItemFavoritesItemResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /item-uom → itemUom.*
-         * @description Methods for managing item units of measure (UOM)
-         */
-        this.itemUom = {
-            /**
-             * List item units of measure
-             * @description Retrieve a paginated list of item UOMs with filtering options
-             * @fullPath api.items.itemUom.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @dataMethod itemUomData.list
-             * @searchTerms ["uom", "unit", "measure", "items", "inventory"]
-             * @relatedEndpoints ["invMast.list", "attributes.list", "categories.list"]
-             * @commonPatterns ["Get item units of measure", "List UOMs for items", "Filter UOMs by item"]
-             * @workflow ["inventory-management", "product-configuration"]
-             * @prerequisites ["Bearer token", "x-site-id header"]
-             * @nextSteps ["Use UOM data for pricing calculations", "Configure item units"]
-             * @businessRules ["Returns paginated results", "Supports filtering by item and unit of measure"]
-             * @functionalArea "inventory-management"
-             * @crossSite true
-             * @caching "5 minutes - UOM data changes infrequently"
-             * @performance "Fast - indexed lookup operation"
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/item-uom',
-                    paramsSchema: schemas_1.ItemUomListParamsSchema,
-                    responseSchema: schemas_1.ItemUomListResponseSchema,
-                }, params);
-            },
-            /**
-             * Get item unit of measure details
-             * @description Retrieve specific item UOM details by ID
-             * @fullPath api.items.itemUom.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             * @dataMethod itemUomData.get
-             * @searchTerms ["uom", "unit", "measure", "details", "specific"]
-             * @relatedEndpoints ["itemUom.list", "invMast.get", "attributes.get"]
-             * @commonPatterns ["Get UOM details by ID", "Retrieve unit of measure information"]
-             * @workflow ["inventory-management", "product-configuration"]
-             * @prerequisites ["Valid itemUomUid", "Bearer token", "x-site-id header"]
-             * @nextSteps ["Use UOM details for calculations", "Update item configurations"]
-             * @businessRules ["Returns single UOM record", "Must provide valid itemUomUid"]
-             * @functionalArea "inventory-management"
-             * @crossSite true
-             * @caching "5 minutes - UOM data changes infrequently"
-             * @performance "Very fast - direct ID lookup"
-             */
-            get: async (itemUomUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/item-uom/${itemUomUid}`,
-                    responseSchema: schemas_1.ItemUomResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /item-wishlist/{usersId} → itemWishlist.* (with required parameter)
-         * @description Methods for managing user wishlists
-         */
-        this.itemWishlist = {
-            /**
-             * List user wishlists
-             * @description Get wishlists for a specific user
-             * @fullPath api.items.itemWishlist.list
-             * @service items
-             * @domain user-preferences
-             * @discoverable true
-             */
-            list: async (usersId, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/item-wishlist/${usersId}`,
-                    paramsSchema: common_schemas_1.StandardPaginationParamsSchema,
-                    responseSchema: schemas_1.ItemWishlistHeaderListResponseSchema,
-                }, params);
-            },
-            /**
-             * Create user wishlist
-             * @description Create new wishlist for a user
-             * @fullPath api.items.itemWishlist.create
-             * @service items
-             * @domain user-preferences
-             * @discoverable true
-             */
-            create: async (usersId, data) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: `/item-wishlist/${usersId}`,
-                    paramsSchema: schemas_1.CreateItemWishlistHeaderRequestSchema,
-                    responseSchema: schemas_1.ItemWishlistHeaderResponseSchema,
-                }, data);
-            },
-            /**
-             * OpenAPI Path: /item-wishlist/{usersId}/hdr/{itemWishlistHdrUid} → itemWishlist.hdr.*
-             * @description Nested path for wishlist headers
-             */
-            hdr: {
-                /**
-                 * Get wishlist header
-                 * @description Get specific wishlist header details
-                 * @fullPath api.items.itemWishlist.hdr.get
-                 * @service items
-                 * @domain user-preferences
-                 * @discoverable true
-                 */
-                get: async (usersId, itemWishlistHdrUid) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/item-wishlist/${usersId}/hdr/${itemWishlistHdrUid}`,
-                        responseSchema: schemas_1.ItemWishlistHdrResponseSchema,
-                    });
-                },
-                /**
-                 * Create wishlist header
-                 * @description Create new wishlist header
-                 * @fullPath api.items.itemWishlist.hdr.create
-                 * @service items
-                 * @domain user-preferences
-                 * @discoverable true
-                 */
-                create: async (usersId, itemWishlistHdrUid, data) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: `/item-wishlist/${usersId}/hdr/${itemWishlistHdrUid}`,
-                        paramsSchema: schemas_1.CreateItemWishlistHdrRequestSchema,
-                        responseSchema: schemas_1.ItemWishlistHdrResponseSchema,
-                    }, data);
-                },
-                /**
-                 * OpenAPI Path: /item-wishlist/{usersId}/hdr/{itemWishlistHdrUid}/line/{itemWishlistLineUid} → itemWishlist.hdr.line.*
-                 * @description Deep nested path for wishlist lines
-                 */
-                line: {
-                    /**
-                     * Delete wishlist line
-                     * @description Remove item from wishlist
-                     * @fullPath api.items.itemWishlist.hdr.line.delete
-                     * @service items
-                     * @domain user-preferences
-                     * @discoverable true
-                     */
-                    delete: async (usersId, itemWishlistHdrUid, itemWishlistLineUid) => {
-                        return this.executeRequest({
-                            method: 'DELETE',
-                            path: `/item-wishlist/${usersId}/hdr/${itemWishlistHdrUid}/line/${itemWishlistLineUid}`,
-                            responseSchema: schemas_1.ItemWishlistLineResponseSchema,
-                        });
-                    },
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /locations → locations.*
-         * @description Methods for managing locations
-         */
-        this.locations = {
-            /**
-             * OpenAPI Path: /locations/{locationId}/bins → locations.bins.*
-             * @description Nested path for location bins
-             */
-            bins: {
-                /**
-                 * List location bins
-                 * @description Get bins for a specific location
-                 * @fullPath api.items.locations.bins.list
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                list: async (locationId, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/locations/${locationId}/bins`,
-                        paramsSchema: schemas_1.LocationsBinsParamsSchema,
-                        responseSchema: schemas_1.LocationsBinsResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Get location bin
-                 * @description Get specific bin for a location
-                 * @fullPath api.items.locations.bins.get
-                 * @service items
-                 * @domain inventory-management
-                 * @discoverable true
-                 */
-                get: async (locationId, bin) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: `/locations/${locationId}/bins/${bin}`,
-                        responseSchema: schemas_1.LocationsBinsResponseSchema,
-                    });
-                },
-            },
-        };
-        /**
-         * OpenAPI Path: /ping → ping.get
-         * @description Ping endpoint for connectivity test
-         */
-        this.ping = {
-            /**
-             * Simple connectivity test
-             * @description Simple connectivity test endpoint (no authentication required)
-             * @fullPath api.items.ping.get
-             * @service items
-             * @domain system-health
-             * @discoverable true
-             * @dataMethod pingData.get
-             */
-            get: async () => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/ping',
-                    responseSchema: schemas_1.PingResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /variants → variants.*
-         * @description Methods for managing product variants
-         */
-        this.variants = {
-            /**
-             * List product variants
-             * @description Retrieve a list of product variants
-             * @fullPath api.items.variants.list
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            list: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/variants',
-                    paramsSchema: schemas_1.ItemVariantListParamsSchema,
-                    responseSchema: schemas_1.ItemVariantHeaderListResponseSchema,
-                }, params);
-            },
-            /**
-             * Create product variant
-             * @description Create new product variant
-             * @fullPath api.items.variants.create
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            create: async (data) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/variants',
-                    paramsSchema: schemas_1.CreateItemVariantHeaderRequestSchema,
-                    responseSchema: schemas_1.ItemVariantHeaderResponseSchema,
-                }, data);
-            },
-            /**
-             * Get product variant
-             * @description Get specific product variant details
-             * @fullPath api.items.variants.get
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            get: async (itemVariantHdrUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: `/variants/${itemVariantHdrUid}`,
-                    responseSchema: schemas_1.ItemVariantHeaderResponseSchema,
-                });
-            },
-            /**
-             * Update product variant
-             * @description Update existing product variant
-             * @fullPath api.items.variants.update
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            update: async (itemVariantHdrUid, data) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: `/variants/${itemVariantHdrUid}`,
-                    paramsSchema: schemas_1.UpdateItemVariantHeaderRequestSchema,
-                    responseSchema: schemas_1.ItemVariantHeaderResponseSchema,
-                }, data);
-            },
-            /**
-             * Delete product variant
-             * @description Delete existing product variant
-             * @fullPath api.items.variants.delete
-             * @service items
-             * @domain inventory-management
-             * @discoverable true
-             */
-            delete: async (itemVariantHdrUid) => {
-                return this.executeRequest({
-                    method: 'DELETE',
-                    path: `/variants/${itemVariantHdrUid}`,
-                    responseSchema: schemas_1.ItemVariantHeaderResponseSchema,
-                });
-            },
-        };
-        // Data-only methods for dual API pattern
-        // These methods call the standard methods and extract the .data portion
-        this.attributeGroupsData = {
-            list: async (params) => {
-                const response = await this.attributeGroups.list(params);
-                return response.data;
-            },
-            create: async (data) => {
-                const response = await this.attributeGroups.create(data);
-                return response.data;
-            },
-            get: async (attributeGroupUid) => {
-                const response = await this.attributeGroups.get(attributeGroupUid);
-                return response.data;
-            },
-            update: async (attributeGroupUid, data) => {
-                const response = await this.attributeGroups.update(attributeGroupUid, data);
-                return response.data;
-            },
-            delete: async (attributeGroupUid) => {
-                const response = await this.attributeGroups.delete(attributeGroupUid);
-                return response.data;
-            },
-            attributes: {
-                list: async (attributeGroupUid, params) => {
-                    const response = await this.attributeGroups.attributes.list(attributeGroupUid, params);
-                    return response.data;
-                },
-                create: async (attributeGroupUid, data) => {
-                    const response = await this.attributeGroups.attributes.create(attributeGroupUid, data);
-                    return response.data;
-                },
-                get: async (attributeGroupUid, attributeXAttributeGroupUid) => {
-                    const response = await this.attributeGroups.attributes.get(attributeGroupUid, attributeXAttributeGroupUid);
-                    return response.data;
-                },
-                update: async (attributeGroupUid, attributeXAttributeGroupUid, data) => {
-                    const response = await this.attributeGroups.attributes.update(attributeGroupUid, attributeXAttributeGroupUid, data);
-                    return response.data;
-                },
-                delete: async (attributeGroupUid, attributeXAttributeGroupUid) => {
-                    const response = await this.attributeGroups.attributes.delete(attributeGroupUid, attributeXAttributeGroupUid);
-                    return response.data;
-                },
-            },
-        };
-        this.attributesData = {
-            list: async (params) => {
-                const response = await this.attributes.list(params);
-                return response.data;
-            },
-            create: async (data) => {
-                const response = await this.attributes.create(data);
-                return response.data;
-            },
-            get: async (attributeUid) => {
-                const response = await this.attributes.get(attributeUid);
-                return response.data;
-            },
-            update: async (attributeUid, data) => {
-                const response = await this.attributes.update(attributeUid, data);
-                return response.data;
-            },
-            delete: async (attributeUid) => {
-                const response = await this.attributes.delete(attributeUid);
-                return response.data;
-            },
-            values: {
-                list: async (attributeUid, params) => {
-                    const response = await this.attributes.values.list(attributeUid, params);
-                    return response.data;
-                },
-                create: async (attributeUid, data) => {
-                    const response = await this.attributes.values.create(attributeUid, data);
-                    return response.data;
-                },
-                get: async (attributeUid, attributeValueUid) => {
-                    const response = await this.attributes.values.get(attributeUid, attributeValueUid);
-                    return response.data;
-                },
-                update: async (attributeUid, attributeValueUid, data) => {
-                    const response = await this.attributes.values.update(attributeUid, attributeValueUid, data);
-                    return response.data;
-                },
-                delete: async (attributeUid, attributeValueUid) => {
-                    const response = await this.attributes.values.delete(attributeUid, attributeValueUid);
-                    return response.data;
-                },
-            },
-        };
-        this.brandsData = {
-            list: async (params) => {
-                const response = await this.brands.list(params);
-                return response.data;
-            },
-            create: async (data) => {
-                const response = await this.brands.create(data);
-                return response.data;
-            },
-            get: async (brandsUid) => {
-                const response = await this.brands.get(brandsUid);
-                return response.data;
-            },
-            update: async (brandsUid, data) => {
-                const response = await this.brands.update(brandsUid, data);
-                return response.data;
-            },
-            delete: async (brandsUid) => {
-                const response = await this.brands.delete(brandsUid);
-                return response.data;
-            },
-            items: {
-                list: async (brandsUid, params) => {
-                    const response = await this.brands.items.list(brandsUid, params);
-                    return response.data;
-                },
-                create: async (brandsUid, data) => {
-                    const response = await this.brands.items.create(brandsUid, data);
-                    return response.data;
-                },
-                get: async (brandsUid, brandsXItemsUid) => {
-                    const response = await this.brands.items.get(brandsUid, brandsXItemsUid);
-                    return response.data;
-                },
-                update: async (brandsUid, brandsXItemsUid, data) => {
-                    const response = await this.brands.items.update(brandsUid, brandsXItemsUid, data);
-                    return response.data;
-                },
-                delete: async (brandsUid, brandsXItemsUid) => {
-                    const response = await this.brands.items.delete(brandsUid, brandsXItemsUid);
-                    return response.data;
-                },
-            },
-        };
-        this.healthCheckData = {
-            get: async () => {
-                const response = await this.healthCheck.get();
-                return response.data;
-            },
-        };
-        this.pingData = {
-            get: async () => {
-                const response = await this.ping.get();
-                return response.data;
-            },
-        };
-        this.categoriesData = {
-            lookup: {
-                get: async (params) => {
-                    const response = await this.categories.lookup.get(params);
-                    return response.data;
-                },
-            },
-            get: async (itemCategoryUid) => {
-                const response = await this.categories.get(itemCategoryUid);
-                return response.data;
-            },
-            attributes: {
-                list: async (itemCategoryUid) => {
-                    const response = await this.categories.attributes.list(itemCategoryUid);
-                    return response.data;
-                },
-            },
-            images: {
-                list: async (itemCategoryUid) => {
-                    const response = await this.categories.images.list(itemCategoryUid);
-                    return response.data;
-                },
-            },
-            items: {
-                list: async (itemCategoryUid, params) => {
-                    const response = await this.categories.items.list(itemCategoryUid, params);
-                    return response.data;
-                },
-            },
-        };
-        this.contractsData = {
-            attributes: {
-                list: async (jobNo) => {
-                    const response = await this.contracts.attributes.list(jobNo);
-                    return response.data;
-                },
-            },
-            items: {
-                list: async (jobNo, params) => {
-                    const response = await this.contracts.items.list(jobNo, params);
-                    return response.data;
-                },
-            },
-        };
-        this.internalData = {
-            pdf: {
-                create: async (data) => {
-                    const response = await this.internal.pdf.create(data);
-                    return response.data;
-                },
-            },
-        };
-        this.invMastData = {
-            list: async (params) => {
-                const response = await this.invMast.list(params);
-                return response.data;
-            },
-            lookup: {
-                get: async (params) => {
-                    const response = await this.invMast.lookup.get(params);
-                    return response.data;
-                },
-            },
-            get: async (invMastUid) => {
-                const response = await this.invMast.get(invMastUid);
-                return response.data;
-            },
-            alternateCode: {
-                list: async (invMastUid) => {
-                    const response = await this.invMast.alternateCode.list(invMastUid);
-                    return response.data;
-                },
-            },
-            attributes: {
-                list: async (invMastUid, params) => {
-                    const response = await this.invMast.attributes.list(invMastUid, params);
-                    return response.data;
-                },
-                values: {
-                    list: async (invMastUid, attributeUid, params) => {
-                        const response = await this.invMast.attributes.values.list(invMastUid, attributeUid, params);
-                        return response.data;
-                    },
-                },
-            },
-            doc: {
-                list: async (invMastUid, params) => {
-                    const response = await this.invMast.doc.list(invMastUid, params);
-                    return response.data;
-                },
-            },
-            faq: {
-                list: async (invMastUid, params) => {
-                    const response = await this.invMast.faq.list(invMastUid, params);
-                    return response.data;
-                },
-                get: async (invMastUid, invMastFaqUid) => {
-                    const response = await this.invMast.faq.get(invMastUid, invMastFaqUid);
-                    return response.data;
-                },
-            },
-            invAccessory: {
-                list: async (invMastUid) => {
-                    const response = await this.invMast.invAccessory.list(invMastUid);
-                    return response.data;
-                },
-            },
-            invSub: {
-                list: async (invMastUid) => {
-                    const response = await this.invMast.invSub.list(invMastUid);
-                    return response.data;
-                },
-            },
-            locations: {
-                bins: {
-                    list: async (invMastUid, locationId, params) => {
-                        const response = await this.invMast.locations.bins.list(invMastUid, locationId, params);
-                        return response.data;
-                    },
-                    get: async (invMastUid, locationId, bin) => {
-                        const response = await this.invMast.locations.bins.get(invMastUid, locationId, bin);
-                        return response.data;
-                    },
-                },
-            },
-            similar: {
-                list: async (invMastUid) => {
-                    const response = await this.invMast.similar.list(invMastUid);
-                    return response.data;
-                },
-            },
-            stock: {
-                get: async (invMastUid, params) => {
-                    const response = await this.invMast.stock.get(invMastUid, params);
-                    return response.data;
-                },
-            },
-        };
-        this.invMastLinksData = {
-            list: async (invMastUid) => {
-                const response = await this.invMastLinks.list(invMastUid);
-                return response.data;
-            },
-        };
-        this.invMastSubPartsData = {
-            list: async (invMastUid) => {
-                const response = await this.invMastSubParts.list(invMastUid);
-                return response.data;
-            },
-        };
-        this.itemCategoryData = {
-            list: async (params) => {
-                const response = await this.itemCategory.list(params);
-                return response.data;
-            },
-            lookup: {
-                get: async (params) => {
-                    const response = await this.itemCategory.lookup.get(params);
-                    return response.data;
-                },
-            },
-            get: async (itemCategoryUid) => {
-                const response = await this.itemCategory.get(itemCategoryUid);
-                return response.data;
-            },
-            doc: {
-                list: async (itemCategoryUid) => {
-                    const response = await this.itemCategory.doc.list(itemCategoryUid);
-                    return response.data;
-                },
-            },
-        };
-        this.itemFavoritesData = {
-            list: async (usersId, params) => {
-                const response = await this.itemFavorites.list(usersId, params);
-                return response.data;
-            },
-            create: async (usersId, data) => {
-                const response = await this.itemFavorites.create(usersId, data);
-                return response.data;
-            },
-            update: async (usersId, invMastUid, data) => {
-                const response = await this.itemFavorites.update(usersId, invMastUid, data);
-                return response.data;
-            },
-            delete: async (usersId, invMastUid) => {
-                const response = await this.itemFavorites.delete(usersId, invMastUid);
-                return response.data;
-            },
-        };
-        this.itemWishlistData = {
-            list: async (usersId, params) => {
-                const response = await this.itemWishlist.list(usersId, params);
-                return response.data;
-            },
-            create: async (usersId, data) => {
-                const response = await this.itemWishlist.create(usersId, data);
-                return response.data;
-            },
-            hdr: {
-                get: async (usersId, itemWishlistHdrUid) => {
-                    const response = await this.itemWishlist.hdr.get(usersId, itemWishlistHdrUid);
-                    return response.data;
-                },
-                create: async (usersId, itemWishlistHdrUid, data) => {
-                    const response = await this.itemWishlist.hdr.create(usersId, itemWishlistHdrUid, data);
-                    return response.data;
-                },
-                line: {
-                    delete: async (usersId, itemWishlistHdrUid, itemWishlistLineUid) => {
-                        const response = await this.itemWishlist.hdr.line.delete(usersId, itemWishlistHdrUid, itemWishlistLineUid);
-                        return response.data;
-                    },
-                },
-            },
-        };
-        this.locationsData = {
-            bins: {
-                list: async (locationId, params) => {
-                    const response = await this.locations.bins.list(locationId, params);
-                    return response.data;
-                },
-                get: async (locationId, bin) => {
-                    const response = await this.locations.bins.get(locationId, bin);
-                    return response.data;
-                },
-            },
-        };
-        this.itemUomData = {
-            list: async (params) => {
-                const response = await this.itemUom.list(params);
-                return response.data;
-            },
-            get: async (itemUomUid) => {
-                const response = await this.itemUom.get(itemUomUid);
-                return response.data;
-            },
-        };
-        this.variantsData = {
-            list: async (params) => {
-                const response = await this.variants.list(params);
-                return response.data;
-            },
-            create: async (data) => {
-                const response = await this.variants.create(data);
-                return response.data;
-            },
-            get: async (itemVariantHdrUid) => {
-                const response = await this.variants.get(itemVariantHdrUid);
-                return response.data;
-            },
-            update: async (itemVariantHdrUid, data) => {
-                const response = await this.variants.update(itemVariantHdrUid, data);
-                return response.data;
-            },
-            delete: async (itemVariantHdrUid) => {
-                const response = await this.variants.delete(itemVariantHdrUid);
-                return response.data;
-            },
-        };
+        // Create a wrapper function that calls executeRequest dynamically
+        // This allows tests to spy on executeRequest after construction
+        // Pass params when defined OR when there's a paramsSchema (for validation)
+        // Note: Resources build URLs directly, so pathParams is not used
+        const boundExecuteRequest = (config, params) => {
+            // Pass params if defined or if there's a paramsSchema (expects params)
+            if (params !== undefined || config.paramsSchema !== undefined) {
+                return this.executeRequest(config, params);
+            }
+            return this.executeRequest(config);
+        };
+        // Initialize standard API resources
+        this.attributeGroups = (0, resources_1.createAttributeGroupsResource)(boundExecuteRequest);
+        this.attributes = (0, resources_1.createAttributesResource)(boundExecuteRequest);
+        this.brands = (0, resources_1.createBrandsResource)(boundExecuteRequest);
+        this.categories = (0, resources_1.createCategoriesResource)(boundExecuteRequest);
+        this.contracts = (0, resources_1.createContractsResource)(boundExecuteRequest);
+        this.healthCheck = (0, resources_1.createHealthCheckResource)(boundExecuteRequest);
+        this.internal = (0, resources_1.createInternalResource)(boundExecuteRequest);
+        this.invMast = (0, resources_1.createInvMastResource)(boundExecuteRequest);
+        this.invMastLinks = (0, resources_1.createInvMastLinksResource)(boundExecuteRequest);
+        this.invMastSubParts = (0, resources_1.createInvMastSubPartsResource)(boundExecuteRequest);
+        this.itemCategory = (0, resources_1.createItemCategoryResource)(boundExecuteRequest);
+        this.itemFavorites = (0, resources_1.createItemFavoritesResource)(boundExecuteRequest);
+        this.itemUom = (0, resources_1.createItemUomResource)(boundExecuteRequest);
+        this.itemWishlist = (0, resources_1.createItemWishlistResource)(boundExecuteRequest);
+        this.locations = (0, resources_1.createLocationsResource)(boundExecuteRequest);
+        this.ping = (0, resources_1.createPingResource)(boundExecuteRequest);
+        this.variants = (0, resources_1.createVariantsResource)(boundExecuteRequest);
+        this.invLoc = (0, resources_1.createInvLocResource)(boundExecuteRequest);
+        this.invMastUd = (0, resources_1.createInvMastUdResource)(boundExecuteRequest);
+        this.p21 = (0, resources_1.createP21Resource)(boundExecuteRequest);
+        // Initialize data-only API resources (dual API pattern)
+        this.attributeGroupsData = (0, resources_1.createAttributeGroupsDataResource)(this.attributeGroups);
+        this.attributesData = (0, resources_1.createAttributesDataResource)(this.attributes);
+        this.brandsData = (0, resources_1.createBrandsDataResource)(this.brands);
+        this.categoriesData = (0, resources_1.createCategoriesDataResource)(this.categories);
+        this.contractsData = (0, resources_1.createContractsDataResource)(this.contracts);
+        this.healthCheckData = (0, resources_1.createHealthCheckDataResource)(this.healthCheck);
+        this.internalData = (0, resources_1.createInternalDataResource)(this.internal);
+        this.invMastData = (0, resources_1.createInvMastDataResource)(this.invMast);
+        this.invMastLinksData = (0, resources_1.createInvMastLinksDataResource)(this.invMastLinks);
+        this.invMastSubPartsData = (0, resources_1.createInvMastSubPartsDataResource)(this.invMastSubParts);
+        this.itemCategoryData = (0, resources_1.createItemCategoryDataResource)(this.itemCategory);
+        this.itemFavoritesData = (0, resources_1.createItemFavoritesDataResource)(this.itemFavorites);
+        this.itemUomData = (0, resources_1.createItemUomDataResource)(this.itemUom);
+        this.itemWishlistData = (0, resources_1.createItemWishlistDataResource)(this.itemWishlist);
+        this.locationsData = (0, resources_1.createLocationsDataResource)(this.locations);
+        this.pingData = (0, resources_1.createPingDataResource)(this.ping);
+        this.variantsData = (0, resources_1.createVariantsDataResource)(this.variants);
+        this.invLocData = (0, resources_1.createInvLocDataResource)(this.invLoc);
+        this.invMastUdData = (0, resources_1.createInvMastUdDataResource)(this.invMastUd);
+        this.p21Data = (0, resources_1.createP21DataResource)(this.p21);
     }
 }
 exports.ItemsClient = ItemsClient;