@simpleapps-com/augur-api 0.1.0

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

@@ -0,0 +1,773 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BaseServiceClient } from '../../core/base-client';
+import { StandardPaginationParamsSchema } from '../../core/common-schemas';
+import { z } from 'zod';
+import { 
+// Health check schemas
+HealthCheckResponseSchema, PingResponseSchema, 
+// Product schemas
+ProductSearchParamsSchema, ProductListParamsSchema, ProductResponseSchema, ProductListResponseSchema, AlternateCodeListResponseSchema, AccessoryListResponseSchema, BinInfoListResponseSchema, 
+// Category schemas
+CategoryDetailsParamsSchema, CategoryItemsParamsSchema, CategoryResponseSchema, CategoryItemsResponseSchema, CategoryAttributesResponseSchema, CategoryFiltersResponseSchema, CategoryImagesResponseSchema, 
+// Attribute schemas
+CreateAttributeRequestSchema, UpdateAttributeRequestSchema, AttributeResponseSchema, AttributeListResponseSchema, AttributeGroupResponseSchema, AttributeGroupListResponseSchema, AttributeValueListResponseSchema, 
+// Stock schemas
+StockDetailsResponseSchema, 
+// Brand schemas
+CreateBrandRequestSchema, UpdateBrandRequestSchema, BrandResponseSchema, BrandListResponseSchema, 
+// Item attribute value schemas
+CreateItemAttributeValueRequestSchema, ItemAttributeValueListResponseSchema, ItemAttributeValueResponseSchema, } from './schemas';
+/**
+ * Items API Client
+ * @description Client for interacting with Items microservice API endpoints for product catalog, inventory, categories, and attributes management
+ * @example
+ * ```typescript
+ * import { HTTPClient } from '@augur/api-client/core';
+ * import { ItemsClient } from '@augur/api-client/services/items';
+ *
+ * const http = new HTTPClient('items', { siteId: 'your-site-id', bearerToken: 'your-token' });
+ * const items = new ItemsClient(http);
+ *
+ * // Get product details
+ * const product = await items.products.get(12345);
+ *
+ * // Search products
+ * const results = await items.products.search({ q: 'cable', limit: 20 });
+ *
+ * // Get category with items
+ * const category = await items.categories.get(100);
+ * const categoryItems = await items.categories.getItems(100, { limit: 12 });
+ * ```
+ */
+export class ItemsClient extends BaseServiceClient {
+    /**
+     * Create a new ItemsClient instance
+     * @param http Configured HTTPClient instance
+     * @param baseUrl Base URL for the Items API (default: https://items.augur-api.com)
+     */
+    constructor(http, baseUrl = 'https://items.augur-api.com') {
+        super('items', http, baseUrl);
+        /**
+         * Product catalog endpoints (Inventory Master - inv_mast)
+         * @description Methods for product management including search, details, alternate codes, and accessories
+         */
+        this.products = {
+            /**
+             * Get product details by inventory master UID
+             * @description Retrieves comprehensive details for a specific inventory item including categories, attributes, images, and related data
+             * @param invMastUid Inventory master unique identifier
+             * @returns Complete product details with all related information
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const product = await client.products.get(12345);
+             * console.log(product.itemId, product.itemDesc, product.listPrice);
+             * console.log('Categories:', product.categories);
+             * console.log('Attributes:', product.attributes);
+             * ```
+             */
+            get: this.createGetMethod('/inv-mast/{id}', ProductResponseSchema),
+            /**
+             * Search products using various criteria
+             * @description Search for products by item ID, description, UPC, or other criteria with filtering and pagination
+             * @param params Search parameters including required query string
+             * @returns Array of matching products with basic information
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Basic product search
+             * const results = await client.products.search({ q: 'ethernet cable' });
+             *
+             * // Advanced search with filters
+             * const filtered = await client.products.search({
+             *   q: 'cable',
+             *   limit: 20,
+             *   statusCd: 704, // Active only
+             *   onlineCd: 704  // Online only
+             * });
+             *
+             * results.forEach(product => {
+             *   console.log(`${product.itemId}: ${product.itemDesc} - $${product.listPrice}`);
+             * });
+             * ```
+             */
+            search: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/lookup',
+                    paramsSchema: ProductSearchParamsSchema,
+                    responseSchema: ProductListResponseSchema,
+                }, params);
+            },
+            /**
+             * List products with filtering and pagination
+             * @description Retrieve a paginated list of products with comprehensive filtering options
+             * @param params Optional filtering and pagination parameters
+             * @returns Paginated list of products
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get all active products
+             * const products = await client.products.list({ statusCd: 704, limit: 50 });
+             *
+             * // Get online products only
+             * const onlineProducts = await client.products.list({
+             *   onlineCd: 704,
+             *   displayOnWebFlag: 'Y',
+             *   orderBy: 'item_id|ASC'
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/list',
+                    paramsSchema: ProductListParamsSchema,
+                    responseSchema: ProductListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get alternate codes for a product
+             * @description List alternate codes (UPC, manufacturer codes, etc.) for a specific product
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of alternate codes for the product
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const alternateCodes = await client.products.getAlternateCodes(12345);
+             * alternateCodes.forEach(code => {
+             *   console.log(`${code.codeType}: ${code.codeValue}`);
+             * });
+             * ```
+             */
+            getAlternateCodes: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{id}/alternate-code',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: AlternateCodeListResponseSchema,
+                }, params, { id: String(invMastUid) });
+            },
+            /**
+             * Get accessory items for a product
+             * @description List accessory items associated with a specific product
+             * @param invMastUid Inventory master unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of accessory items
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const accessories = await client.products.getAccessories(12345);
+             * accessories.forEach(accessory => {
+             *   console.log(`Accessory: ${accessory.itemId} - ${accessory.itemDesc}`);
+             * });
+             * ```
+             */
+            getAccessories: async (invMastUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{id}/inv-accessory',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: AccessoryListResponseSchema,
+                }, params, { id: String(invMastUid) });
+            },
+            /**
+             * Get bin information for a product at a specific location
+             * @description Get specific bin information for an inventory item at a location
+             * @param invMastUid Inventory master unique identifier
+             * @param locationId Location ID
+             * @param bin Bin identifier
+             * @returns Bin information for the product at the location
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const binInfo = await client.products.getBinInfo(12345, 1, 'A-01');
+             * console.log(`Bin ${binInfo.bin}: ${binInfo.qtyOnHand} on hand`);
+             * ```
+             */
+            getBinInfo: async (invMastUid, locationId, bin) => {
+                const response = await this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastUid}/locations/{locationId}/bins/{bin}',
+                    responseSchema: BinInfoListResponseSchema,
+                }, undefined, {
+                    invMastUid: String(invMastUid),
+                    locationId: String(locationId),
+                    bin,
+                });
+                // Return first bin info from array response
+                return response.data[0];
+            },
+            /**
+             * List all bins for a product at a specific location
+             * @description List all bins for an inventory item at a specific location
+             * @param invMastUid Inventory master unique identifier
+             * @param locationId Location ID
+             * @param params Optional pagination parameters
+             * @returns Array of bin information for the product at the location
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const bins = await client.products.getBinsByLocation(12345, 1);
+             * bins.forEach(bin => {
+             *   console.log(`Bin ${bin.bin}: ${bin.qtyOnHand} on hand, ${bin.qtyAvailable} available`);
+             * });
+             * ```
+             */
+            getBinsByLocation: async (invMastUid, locationId, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-mast/{invMastUid}/locations/{locationId}/bins',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: BinInfoListResponseSchema,
+                }, params, {
+                    invMastUid: String(invMastUid),
+                    locationId: String(locationId),
+                });
+            },
+        };
+        /**
+         * Category management endpoints
+         * @description Methods for hierarchical product categorization including category details, items, attributes, and filtering
+         */
+        this.categories = {
+            /**
+             * Get category details by ID or path
+             * @description Retrieve comprehensive category information including children, attributes, and metadata
+             * @param itemCategoryUid Category unique identifier (use 0 for path-based lookup)
+             * @param params Optional parameters for path lookup, filtering, and children pagination
+             * @returns Complete category details with children and attributes
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get category by ID
+             * const category = await client.categories.get(100);
+             * console.log(category.itemCategoryDesc, category.path);
+             *
+             * // Get category by path
+             * const categoryByPath = await client.categories.get(0, {
+             *   path: '/Electronics/Cables'
+             * });
+             *
+             * // Get category with filtered children
+             * const categoryWithChildren = await client.categories.get(100, {
+             *   childrenLimit: 10,
+             *   childrenFilter: 'audio'
+             * });
+             * ```
+             */
+            get: async (itemCategoryUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/{id}',
+                    paramsSchema: CategoryDetailsParamsSchema,
+                    responseSchema: CategoryResponseSchema,
+                }, params, { id: String(itemCategoryUid) });
+            },
+            /**
+             * Get items within a category
+             * @description Retrieve items within a specific category with advanced filtering, sorting, and pagination
+             * @param itemCategoryUid Category unique identifier
+             * @param params Optional filtering, sorting, and pagination parameters
+             * @returns Array of category items with optional stock information
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Get category items with basic pagination
+             * const items = await client.categories.getItems(100, { limit: 12 });
+             *
+             * // Get items with filtering and stock information
+             * const filteredItems = await client.categories.getItems(100, {
+             *   limit: 20,
+             *   sortBy: 'listPrice|ASC',
+             *   includeStock: 'Y',
+             *   displayOnWebFlag: 'Y',
+             *   filters: JSON.stringify([
+             *     { attributeId: 'color', values: ['red', 'blue'], operator: 'IN' }
+             *   ])
+             * });
+             *
+             * // Search within category
+             * const searchResults = await client.categories.getItems(100, {
+             *   q: 'wireless',
+             *   limit: 10
+             * });
+             * ```
+             */
+            getItems: async (itemCategoryUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/{id}/items',
+                    paramsSchema: CategoryItemsParamsSchema,
+                    responseSchema: CategoryItemsResponseSchema,
+                }, params, { id: String(itemCategoryUid) });
+            },
+            /**
+             * Get attributes available for a category
+             * @description Retrieve attributes available for filtering within a category
+             * @param itemCategoryUid Category unique identifier
+             * @returns Array of category attributes with their available values
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const attributes = await client.categories.getAttributes(100);
+             * attributes.forEach(attr => {
+             *   console.log(`${attr.attributeDesc}: ${attr.values?.join(', ')}`);
+             * });
+             * ```
+             */
+            getAttributes: async (itemCategoryUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/{id}/attributes',
+                    responseSchema: CategoryAttributesResponseSchema,
+                }, undefined, { id: String(itemCategoryUid) });
+            },
+            /**
+             * Get available filter options for a category
+             * @description Get available filter options for a category based on its items
+             * @param itemCategoryUid Category unique identifier
+             * @returns Array of filter options with values and counts
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const filters = await client.categories.getFilters(100);
+             * filters.forEach(filter => {
+             *   console.log(`${filter.attributeDesc}:`);
+             *   filter.values.forEach(value => {
+             *     console.log(`  ${value.value} (${value.count})`);
+             *   });
+             * });
+             * ```
+             */
+            getFilters: async (itemCategoryUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/{id}/filters',
+                    responseSchema: CategoryFiltersResponseSchema,
+                }, undefined, { id: String(itemCategoryUid) });
+            },
+            /**
+             * Get images for a category
+             * @description Retrieve images associated with a category
+             * @param itemCategoryUid Category unique identifier
+             * @returns Array of category images
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const images = await client.categories.getImages(100);
+             * images.forEach(image => {
+             *   console.log(`Image: ${image.imagePath} (${image.imageType})`);
+             * });
+             * ```
+             */
+            getImages: async (itemCategoryUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/categories/{id}/images',
+                    responseSchema: CategoryImagesResponseSchema,
+                }, undefined, { id: String(itemCategoryUid) });
+            },
+        };
+        /**
+         * Attribute management endpoints
+         * @description Methods for managing product attributes including CRUD operations
+         */
+        this.attributes = {
+            /**
+             * List all attributes
+             * @description Retrieve a paginated list of available attributes
+             * @param params Optional pagination parameters
+             * @returns Array of attributes
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const attributes = await client.attributes.list({ limit: 50 });
+             * attributes.forEach(attr => {
+             *   console.log(`${attr.attributeId}: ${attr.attributeDesc} (${attr.dataType})`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/attributes',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: AttributeListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get attribute details by ID
+             * @description Retrieve details for a specific attribute
+             * @param attributeUid Attribute unique identifier
+             * @returns Attribute details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const attribute = await client.attributes.get(123);
+             * console.log(attribute.attributeDesc, attribute.dataType, attribute.maxLength);
+             * ```
+             */
+            get: this.createGetMethod('/attributes/{id}', AttributeResponseSchema),
+            /**
+             * Create a new attribute
+             * @description Create a new attribute with specified properties
+             * @param request Attribute creation data
+             * @returns Created attribute information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const newAttribute = await client.attributes.create({
+             *   attributeId: 'material',
+             *   attributeDesc: 'Material Type',
+             *   dataType: 'string',
+             *   maxLength: 100,
+             *   sequenceNo: 10
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/attributes', CreateAttributeRequestSchema, AttributeResponseSchema),
+            /**
+             * Update an existing attribute
+             * @description Update an existing attribute with new information
+             * @param attributeUid Attribute unique identifier
+             * @param request Attribute update data
+             * @returns Updated attribute information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.attributes.update(123, {
+             *   attributeDesc: 'Updated Material Type',
+             *   maxLength: 150
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/attributes/{id}', UpdateAttributeRequestSchema, AttributeResponseSchema),
+            /**
+             * Delete an attribute
+             * @description Soft delete an attribute (sets status to inactive)
+             * @param attributeUid Attribute unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.attributes.delete(123);
+             * if (deleted) {
+             *   console.log('Attribute successfully deleted');
+             * }
+             * ```
+             */
+            delete: async (attributeUid) => {
+                await this.executeRequest({
+                    method: 'DELETE',
+                    path: '/attributes/{id}',
+                    responseSchema: z.undefined(),
+                }, undefined, { id: String(attributeUid) });
+                return true;
+            },
+        };
+        /**
+         * Stock and location management endpoints
+         * @description Methods for inventory stock information across locations
+         */
+        this.stock = {
+            /**
+             * Get comprehensive stock details for an item
+             * @description Retrieve comprehensive stock information for an item across all locations
+             * @param invMastUid Inventory master unique identifier
+             * @returns Stock details with location breakdown and company summary
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const stockInfo = await client.stock.getDetails(12345);
+             * console.log('Total on hand:', stockInfo.companySummary.totalQtyOnHand);
+             * console.log('Total available:', stockInfo.companySummary.totalQtyAvailable);
+             *
+             * stockInfo.stocks.forEach(location => {
+             *   console.log(`Location ${location.locationId}: ${location.qtyOnHand} on hand, ${location.qtyAvailable} available`);
+             * });
+             * ```
+             */
+            getDetails: async (invMastUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/inv-loc/{id}/stock',
+                    responseSchema: StockDetailsResponseSchema,
+                }, undefined, { id: String(invMastUid) });
+            },
+        };
+        /**
+         * Brand management endpoints
+         * @description Methods for managing product brands including CRUD operations
+         */
+        this.brands = {
+            /**
+             * List all brands
+             * @description Retrieve a paginated list of brands
+             * @param params Optional pagination parameters
+             * @returns Array of brands
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const brands = await client.brands.list({ limit: 50 });
+             * brands.forEach(brand => {
+             *   console.log(`${brand.brandId}: ${brand.brandDesc}`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/brands',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: BrandListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get brand details by ID
+             * @description Retrieve details for a specific brand
+             * @param brandUid Brand unique identifier
+             * @returns Brand details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const brand = await client.brands.get(123);
+             * console.log(brand.brandDesc, brand.website, brand.logoPath);
+             * ```
+             */
+            get: this.createGetMethod('/brands/{id}', BrandResponseSchema),
+            /**
+             * Create a new brand
+             * @description Create a new brand with specified properties
+             * @param request Brand creation data
+             * @returns Created brand information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const newBrand = await client.brands.create({
+             *   brandId: 'ACME',
+             *   brandDesc: 'ACME Corporation',
+             *   website: 'https://acme.com',
+             *   logoPath: '/images/acme-logo.png'
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/brands', CreateBrandRequestSchema, BrandResponseSchema),
+            /**
+             * Update an existing brand
+             * @description Update an existing brand with new information
+             * @param brandUid Brand unique identifier
+             * @param request Brand update data
+             * @returns Updated brand information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.brands.update(123, {
+             *   brandDesc: 'ACME Corporation LLC',
+             *   website: 'https://acme-corp.com'
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/brands/{id}', UpdateBrandRequestSchema, BrandResponseSchema),
+            /**
+             * Delete a brand
+             * @description Soft delete a brand (sets status to inactive)
+             * @param brandUid Brand unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.brands.delete(123);
+             * if (deleted) {
+             *   console.log('Brand successfully deleted');
+             * }
+             * ```
+             */
+            delete: async (brandUid) => {
+                await this.executeRequest({
+                    method: 'DELETE',
+                    path: '/brands/{id}',
+                    responseSchema: z.undefined(),
+                }, undefined, { id: String(brandUid) });
+                return true;
+            },
+        };
+        /**
+         * Attribute group management endpoints
+         * @description Methods for managing attribute groups
+         */
+        this.attributeGroups = {
+            /**
+             * List all attribute groups
+             * @description Retrieve a list of attribute groups
+             * @param params Optional pagination parameters
+             * @returns Array of attribute groups
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const groups = await client.attributeGroups.list();
+             * groups.forEach(group => {
+             *   console.log(`${group.attributeGroupId}: ${group.attributeGroupDesc}`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/attribute-groups',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: AttributeGroupListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get attribute group details by ID
+             * @description Retrieve details for a specific attribute group
+             * @param attributeGroupUid Attribute group unique identifier
+             * @returns Attribute group details with associated attributes
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const group = await client.attributeGroups.get(123);
+             * console.log(group.attributeGroupDesc);
+             * group.attributes?.forEach(attr => {
+             *   console.log(`  - ${attr.attributeDesc}`);
+             * });
+             * ```
+             */
+            get: this.createGetMethod('/attribute-groups/{id}', AttributeGroupResponseSchema),
+        };
+        /**
+         * Attribute value management endpoints
+         * @description Methods for managing attribute values
+         */
+        this.attributeValues = {
+            /**
+             * List all attribute values
+             * @description Retrieve a list of attribute values
+             * @param params Optional pagination parameters
+             * @returns Array of attribute values
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const values = await client.attributeValues.list();
+             * values.forEach(value => {
+             *   console.log(`${value.attributeValue} (${value.displayValue})`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/attribute-values',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: AttributeValueListResponseSchema,
+                }, params);
+            },
+            /**
+             * Get attribute value details by ID
+             * @description Retrieve details for a specific attribute value
+             * @param attributeValueUid Attribute value unique identifier
+             * @returns Attribute value details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const value = await client.attributeValues.get(123);
+             * console.log(value.attributeValue, value.displayValue);
+             * ```
+             */
+            get: async (attributeValueUid) => {
+                const response = await this.executeRequest({
+                    method: 'GET',
+                    path: '/attribute-values/{id}',
+                    responseSchema: AttributeValueListResponseSchema,
+                }, undefined, { id: String(attributeValueUid) });
+                return response.data[0];
+            },
+        };
+        /**
+         * Item attribute value management endpoints
+         * @description Methods for managing item-specific attribute values
+         */
+        this.itemAttributeValues = {
+            /**
+             * List item attribute values
+             * @description Retrieve a list of item attribute values
+             * @param params Optional pagination parameters
+             * @returns Array of item attribute values
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const itemValues = await client.itemAttributeValues.list();
+             * itemValues.forEach(value => {
+             *   console.log(`Item ${value.invMastUid}, Attribute ${value.attributeUid}: ${value.attributeValue}`);
+             * });
+             * ```
+             */
+            list: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/item-attribute-values',
+                    paramsSchema: StandardPaginationParamsSchema,
+                    responseSchema: ItemAttributeValueListResponseSchema,
+                }, params);
+            },
+            /**
+             * Create item attribute value
+             * @description Create a new item attribute value relationship
+             * @param request Item attribute value creation data
+             * @returns Created item attribute value information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const newValue = await client.itemAttributeValues.create({
+             *   invMastUid: 12345,
+             *   attributeUid: 456,
+             *   attributeValue: 'red',
+             *   displayValue: 'Red'
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/item-attribute-values', CreateItemAttributeValueRequestSchema, ItemAttributeValueResponseSchema),
+        };
+        /**
+         * Health monitoring endpoints
+         * @description Service health monitoring and connectivity testing
+         */
+        this.health = {
+            /**
+             * Service health check
+             * @description Verify service health and trigger seed jobs if needed
+             * @returns Health check response with site information
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const health = await client.health.check();
+             * console.log('Site ID:', health.data.siteId);
+             * console.log('Site Hash:', health.data.siteHash);
+             * ```
+             */
+            check: this.createHealthCheckMethod(HealthCheckResponseSchema),
+            /**
+             * Simple connectivity test
+             * @description Simple connectivity test endpoint (no authentication required)
+             * @returns Ping response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const pong = await client.health.ping();
+             * console.log(pong.data); // "pong"
+             * ```
+             */
+            ping: async () => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/health-check/ping',
+                    responseSchema: PingResponseSchema,
+                    requiresAuth: false,
+                });
+            },
+        };
+    }
+}
+//# sourceMappingURL=client.js.map