@simpleapps-com/augur-api 0.1.0

package/dist/types/services/items/client.d.ts

@@ -0,0 +1,809 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import { PingResponse, ProductSearchParams, ProductListParams, CategoryDetailsParams, CategoryItemsParams } 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 declare 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: HTTPClient, baseUrl?: string);
+    /**
+     * Product catalog endpoints (Inventory Master - inv_mast)
+     * @description Methods for product management including search, details, alternate codes, and accessories
+     */
+    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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                statusCd: number;
+                invMastUid: number;
+                itemId: string;
+                itemDesc: string;
+                images?: unknown[] | undefined;
+                unitOfMeasure?: string | undefined;
+                attributes?: unknown[] | undefined;
+                upc?: string | undefined;
+                listPrice?: number | undefined;
+                stdPrice?: number | undefined;
+                onlineCd?: number | undefined;
+                displayOnWebFlag?: string | undefined;
+                categories?: unknown[] | undefined;
+                accessories?: unknown[] | undefined;
+                alternateCode?: unknown[] | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (params: ProductSearchParams) => Promise<any>;
+        /**
+         * 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: (params?: ProductListParams) => Promise<any>;
+        /**
+         * 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: (invMastUid: number, params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * 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: (invMastUid: number, params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * 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: (invMastUid: number, locationId: number, bin: string) => Promise<any>;
+        /**
+         * 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: (invMastUid: number, locationId: number, params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+    };
+    /**
+     * Category management endpoints
+     * @description Methods for hierarchical product categorization including category details, items, attributes, and filtering
+     */
+    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: (itemCategoryUid: number, params?: CategoryDetailsParams) => Promise<any>;
+        /**
+         * 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: (itemCategoryUid: number, params?: CategoryItemsParams) => Promise<any>;
+        /**
+         * 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: (itemCategoryUid: number) => Promise<any>;
+        /**
+         * 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: (itemCategoryUid: number) => Promise<any>;
+        /**
+         * 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: (itemCategoryUid: number) => Promise<any>;
+    };
+    /**
+     * Attribute management endpoints
+     * @description Methods for managing product attributes including CRUD operations
+     */
+    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: (params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                statusCd: number;
+                attributeUid: number;
+                attributeId: string;
+                attributeDesc: string;
+                dataType: string;
+                maxLength?: number | undefined;
+                sequenceNo?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (data: {
+            attributeId: string;
+            attributeDesc: string;
+            dataType: string;
+            maxLength?: number | undefined;
+            sequenceNo?: number | undefined;
+        }) => Promise<{
+            data: {
+                statusCd: number;
+                attributeUid: number;
+                attributeId: string;
+                attributeDesc: string;
+                dataType: string;
+                maxLength?: number | undefined;
+                sequenceNo?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (id: string | number, data: {
+            maxLength?: number | undefined;
+            attributeId?: string | undefined;
+            attributeDesc?: string | undefined;
+            dataType?: string | undefined;
+            sequenceNo?: number | undefined;
+        }) => Promise<{
+            data: {
+                statusCd: number;
+                attributeUid: number;
+                attributeId: string;
+                attributeDesc: string;
+                dataType: string;
+                maxLength?: number | undefined;
+                sequenceNo?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (attributeUid: number) => Promise<boolean>;
+    };
+    /**
+     * Stock and location management endpoints
+     * @description Methods for inventory stock information across locations
+     */
+    stock: {
+        /**
+         * Get comprehensive stock details for an item
+         * @description Retrieve comprehensive stock information for an item across all locations
+         * @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: (invMastUid: number) => Promise<any>;
+    };
+    /**
+     * Brand management endpoints
+     * @description Methods for managing product brands including CRUD operations
+     */
+    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: (params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                statusCd: number;
+                brandUid: number;
+                brandId: string;
+                brandDesc: string;
+                website?: string | undefined;
+                logoPath?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (data: {
+            brandId: string;
+            brandDesc: string;
+            website?: string | undefined;
+            logoPath?: string | undefined;
+        }) => Promise<{
+            data: {
+                statusCd: number;
+                brandUid: number;
+                brandId: string;
+                brandDesc: string;
+                website?: string | undefined;
+                logoPath?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (id: string | number, data: {
+            brandId?: string | undefined;
+            brandDesc?: string | undefined;
+            website?: string | undefined;
+            logoPath?: string | undefined;
+        }) => Promise<{
+            data: {
+                statusCd: number;
+                brandUid: number;
+                brandId: string;
+                brandDesc: string;
+                website?: string | undefined;
+                logoPath?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (brandUid: number) => Promise<boolean>;
+    };
+    /**
+     * Attribute group management endpoints
+     * @description Methods for managing attribute groups
+     */
+    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: (params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                attributeGroupUid: number;
+                attributeGroupId: string;
+                attributeGroupDesc: string;
+                attributes?: {
+                    statusCd: number;
+                    attributeUid: number;
+                    attributeId: string;
+                    attributeDesc: string;
+                    dataType: string;
+                    maxLength?: number | undefined;
+                    sequenceNo?: number | undefined;
+                }[] | undefined;
+                sequenceNo?: number | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+    };
+    /**
+     * Attribute value management endpoints
+     * @description Methods for managing attribute values
+     */
+    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: (params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * Get attribute value details by ID
+         * @description Retrieve details for a specific attribute value
+         * @param attributeValueUid Attribute value unique identifier
+         * @returns Attribute value details
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const value = await client.attributeValues.get(123);
+         * console.log(value.attributeValue, value.displayValue);
+         * ```
+         */
+        get: (attributeValueUid: number) => Promise<any>;
+    };
+    /**
+     * Item attribute value management endpoints
+     * @description Methods for managing item-specific attribute values
+     */
+    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: (params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<any>;
+        /**
+         * 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: (data: {
+            invMastUid: number;
+            attributeValue: string;
+            attributeUid: number;
+            displayValue?: string | undefined;
+        }) => Promise<{
+            data: {
+                invMastUid: number;
+                attributeValue: string;
+                attributeUid: number;
+                itemAttributeValueUid: number;
+                displayValue?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+    };
+    /**
+     * Health monitoring endpoints
+     * @description Service health monitoring and connectivity testing
+     */
+    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: () => Promise<{
+            data: {
+                siteHash: string;
+                siteId: string;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: () => Promise<PingResponse>;
+    };
+}
+//# sourceMappingURL=client.d.ts.map