@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/types/services/open-search/client.d.ts

@@ -1,6 +1,6 @@
 import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
-import { type SearchAttributesParams, type SearchAttributesResponse, type ItemOperationResponse } from './schemas';
+import { type PathItemSearchParams as ItemSearchParams, type PathSearchAttributesParams as SearchAttributesParams, type PathSearchAttributesResponse as SearchAttributesResponse, type ItemUpdateRequest, type ItemsListParams } from './schemas';
 /**
  * OpenSearch service client for advanced product search capabilities
  *
@@ -19,20 +19,27 @@ export declare class OpenSearchClient extends BaseServiceClient {
      */
     constructor(http: HTTPClient, baseUrl?: string);
     /**
-     * Health monitoring operations
+     * Simple ping endpoint - mirrors OpenAPI path /ping
+     *
+     * @fullPath api.openSearch.ping.get
+     * @service open-search
+     * @domain health-monitoring
+     * @dataMethod pingData.get
+     * @discoverable true
+     * @searchTerms ["ping", "health", "connectivity", "status"]
+     * @relatedEndpoints ["healthCheck.get"]
+     * @commonPatterns ["ping service", "test connectivity"]
+     *
+     * @returns Promise<PingResponse> Complete response with metadata
+     *
+     * @example
+     * ```typescript
+     * const response = await api.openSearch.ping.get();
+     * console.log(response.data); // "pong"
+     * ```
      */
-    health: {
-        /**
-         * Simple ping endpoint
-         * @returns Promise<"pong">
-         *
-         * @example
-         * ```typescript
-         * const pong = await api.opensearch.health.ping();
-         * console.log(pong); // "pong"
-         * ```
-         */
-        ping: () => Promise<{
+    ping: {
+        get: () => Promise<{
             params: Record<string, unknown> | unknown[];
             data: "pong";
             options: Record<string, unknown> | unknown[];
@@ -42,17 +49,29 @@ export declare class OpenSearchClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
-        /**
-         * Comprehensive health check
-         * @returns Promise<HealthCheckData>
-         *
-         * @example
-         * ```typescript
-         * const health = await api.opensearch.health.check();
-         * console.log(`Site: ${health.siteId}, Hash: ${health.siteHash}`);
-         * ```
-         */
-        check: () => Promise<{
+    };
+    /**
+     * Health check endpoint - mirrors OpenAPI path /health-check
+     *
+     * @fullPath api.openSearch.healthCheck.get
+     * @service open-search
+     * @domain health-monitoring
+     * @dataMethod healthCheckData.get
+     * @discoverable true
+     * @searchTerms ["health", "status", "monitoring", "check"]
+     * @relatedEndpoints ["ping.get"]
+     * @commonPatterns ["check service health", "service status"]
+     *
+     * @returns Promise<HealthCheckResponse> Complete response with health data
+     *
+     * @example
+     * ```typescript
+     * const response = await api.openSearch.healthCheck.get();
+     * console.log(`Site: ${response.data.siteId}, Hash: ${response.data.siteHash}`);
+     * ```
+     */
+    healthCheck: {
+        get: () => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 siteHash: string;
@@ -67,44 +86,59 @@ export declare class OpenSearchClient extends BaseServiceClient {
         }>;
     };
     /**
-     * Health Data Operations
+     * Data-only access to ping endpoint
+     * @description Direct access to ping data without response metadata
+     */
+    pingData: {
+        /**
+         * Get ping data without response metadata
+         * @returns Promise<unknown> Ping response data directly
+         */
+        get: () => Promise<"pong">;
+    };
+    /**
+     * Data-only access to health check endpoint
      * @description Direct access to health check data without response metadata
      */
-    healthData: {
+    healthCheckData: {
         /**
          * Get health check data without response metadata
          * @returns Promise<unknown> Health status data directly
          */
-        check: () => Promise<{
+        get: () => Promise<{
             siteHash: string;
             siteId: string;
         }>;
-        /**
-         * Get ping data without response metadata
-         * @returns Promise<unknown> Ping response data directly
-         */
-        ping: () => Promise<"pong">;
     };
     /**
-     * Advanced item search operations
+     * Item search operations - mirrors OpenAPI path /item-search
+     *
+     * @fullPath api.openSearch.itemSearch.list
+     * @service open-search
+     * @domain product-search
+     * @dataMethod itemSearchData.list
+     * @discoverable true
+     * @searchTerms ["search", "items", "products", "query", "elasticsearch"]
+     * @relatedEndpoints ["itemSearch.attributes.list", "items.list"]
+     * @commonPatterns ["search products", "find items", "product search"]
      */
     itemSearch: {
         /**
          * Perform comprehensive item search with advanced filtering
          * @param params Search parameters including query, filters, and options
-         * @returns Promise<ItemSearchData>
+         * @returns Promise<ItemSearchResponse> Complete response with search results
          *
          * @example
          * ```typescript
          * // Basic search
-         * const results = await api.opensearch.itemSearch.search({
+         * const response = await api.openSearch.itemSearch.list({
          *   q: 'electrical wire',
          *   searchType: 'query',
          *   size: 20
          * });
          *
          * // Advanced search with filtering
-         * const filtered = await api.opensearch.itemSearch.search({
+         * const filtered = await api.openSearch.itemSearch.list({
          *   q: 'tools',
          *   searchType: 'query',
          *   size: 50,
@@ -114,19 +148,16 @@ export declare class OpenSearchClient extends BaseServiceClient {
          *   from: 0
          * });
          *
-         * console.log(`Found ${results.totalResults} items`);
-         * results.items.forEach(item => {
+         * console.log(`Found ${response.data.totalResults} items`);
+         * response.data.items.forEach(item => {
          *   console.log(`${item.itemId}: ${item.itemDesc} (score: ${item.score})`);
          * });
          * ```
          */
-        search: (params: {
+        list: (params: {
             q: string;
-            edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
+            searchType: "query" | "similarity";
             sort?: string | undefined;
-            limit?: number | undefined;
-            offset?: number | undefined;
-            searchType?: "query" | "similarity" | undefined;
             cacheTtl?: number | undefined;
             cacheSiteId?: string | undefined;
             classId5ExcludeList?: string | undefined;
@@ -147,25 +178,19 @@ export declare class OpenSearchClient extends BaseServiceClient {
                 totalResults: number;
                 items: {
                     invMastUid: number;
+                    itemId: string;
+                    score: number;
                     scoreInt: number;
-                    itemId?: string | null | undefined;
-                    itemDesc?: string | null | undefined;
-                    score?: number | null | undefined;
-                    sourceFields?: Record<string, unknown> | unknown[] | undefined;
+                    itemDesc?: string | undefined;
                     brandFolder?: {
-                        assets?: {
-                            id?: string | number | undefined;
-                            name?: string | null | undefined;
-                            attachmentName?: string | null | undefined;
-                            cdnLink?: string | null | undefined;
-                            layout?: Record<string, unknown> | null | undefined;
-                        }[] | undefined;
+                        description?: string | undefined;
+                        logo?: string | undefined;
                     } | undefined;
                 }[];
                 maxScore: number;
                 took: number;
-                queryStringUid?: number | null | undefined;
-                queryStringRedirectLink?: string | boolean | undefined;
+                queryStringUid?: number | undefined;
+                queryStringRedirectLink?: boolean | undefined;
             };
             options: Record<string, unknown> | unknown[];
             status: number;
@@ -175,43 +200,66 @@ export declare class OpenSearchClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Get search attributes for faceted navigation
-         * @param params Search parameters to determine available attributes
-         * @returns Promise<SearchAttributesData>
+         * Search attributes operations - mirrors OpenAPI path /item-search/attributes
          *
-         * @example
-         * ```typescript
-         * const attributes = await api.opensearch.itemSearch.getAttributes({
-         *   q: 'electrical components',
-         *   searchType: 'query'
-         * });
-         *
-         * attributes.attributes.forEach(attr => {
-         *   console.log(`${attr.attributeName}:`);
-         *   attr.values.forEach(value => {
-         *     console.log(`  ${value.attributeValue} (${value.count})`);
-         *   });
-         * });
-         * ```
+         * @fullPath api.openSearch.itemSearch.attributes.list
+         * @service open-search
+         * @domain product-search
+         * @dataMethod itemSearchData.attributes.list
+         * @discoverable true
+         * @searchTerms ["attributes", "facets", "filters", "search facets"]
+         * @relatedEndpoints ["itemSearch.list"]
+         * @commonPatterns ["get search facets", "filter attributes"]
          */
-        getAttributes: (params: SearchAttributesParams) => Promise<SearchAttributesResponse>;
+        attributes: {
+            /**
+             * Get search attributes for faceted navigation
+             * @param params Search parameters to determine available attributes
+             * @returns Promise<SearchAttributesResponse> Complete response with attribute data
+             *
+             * @example
+             * ```typescript
+             * const response = await api.openSearch.itemSearch.attributes.list({
+             *   q: 'electrical components',
+             *   searchType: 'query'
+             * });
+             *
+             * response.data.attributes.forEach(attr => {
+             *   console.log(`${attr.attributeName}:`);
+             *   attr.values.forEach(value => {
+             *     console.log(`  ${value.attributeValue} (${value.count})`);
+             *   });
+             * });
+             * ```
+             */
+            list: (params: SearchAttributesParams) => Promise<SearchAttributesResponse>;
+        };
     };
     /**
-     * Item index management operations
+     * Item index management operations - mirrors OpenAPI path /items
+     *
+     * @fullPath api.openSearch.items
+     * @service open-search
+     * @domain product-management
+     * @dataMethod itemsData
+     * @discoverable true
+     * @searchTerms ["items", "products", "inventory", "index", "management"]
+     * @relatedEndpoints ["itemSearch.list"]
+     * @commonPatterns ["manage items", "item operations", "product index"]
      */
     items: {
         /**
-         * List items from the search index
+         * List items from the search index - mirrors GET /items
          * @param params Optional filtering parameters
-         * @returns Promise<ItemsListResponse>
+         * @returns Promise<ItemsListResponse> Complete response with item list
          *
          * @example
          * ```typescript
          * // List all items (with default pagination)
-         * const items = await api.opensearch.items.list();
+         * const response = await api.openSearch.items.list();
          *
          * // List items with filtering
-         * const filteredItems = await api.opensearch.items.list({
+         * const filtered = await api.openSearch.items.list({
          *   itemId: 'WIRE',  // Prefix filter
          *   online: 'Y',     // Only online items
          *   statusCd: 704,   // Active items only
@@ -219,8 +267,8 @@ export declare class OpenSearchClient extends BaseServiceClient {
          *   offset: 0
          * });
          *
-         * console.log(`Found ${filteredItems.total} total items`);
-         * filteredItems.data.forEach(item => {
+         * console.log(`Found ${response.data.total} total items`);
+         * response.data.data.forEach(item => {
          *   console.log(`${item.itemId}: ${item.itemDesc}`);
          * });
          * ```
@@ -294,18 +342,18 @@ export declare class OpenSearchClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Get a specific item document from the search index
+         * Get a specific item document - mirrors GET /items/{invMastUid}
          * @param invMastUid Inventory master unique identifier
-         * @returns Promise<ItemDetail>
+         * @returns Promise<ItemDetailResponse> Complete response with item details
          *
          * @example
          * ```typescript
-         * const item = await api.opensearch.items.get(123456);
-         * console.log(`Item: ${item.itemId} - ${item.itemDesc}`);
-         * console.log(`Online: ${item.online}, Status: ${item.statusCd}`);
+         * const response = await api.openSearch.items.get(123456);
+         * console.log(`Item: ${response.data.itemId} - ${response.data.itemDesc}`);
+         * console.log(`Online: ${response.data.online}, Status: ${response.data.statusCd}`);
          *
-         * if (item.keywords) {
-         *   console.log(`Keywords: ${item.keywords}`);
+         * if (response.data.keywords) {
+         *   console.log(`Keywords: ${response.data.keywords}`);
          * }
          * ```
          */
@@ -339,18 +387,18 @@ export declare class OpenSearchClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Update a specific item document in the search index
+         * Update a specific item document - mirrors PUT /items/{invMastUid}
          * @param invMastUid Inventory master unique identifier
          * @param data Update data (statusCd and/or processCd)
-         * @returns Promise<ItemOperationResponse>
+         * @returns Promise<ItemOperationResponse> Complete response with update result
          *
          * @example
          * ```typescript
-         * const result = await api.opensearch.items.update(123456, {
+         * const response = await api.openSearch.items.update(123456, {
          *   statusCd: 704,
          *   processCd: 704
          * });
-         * console.log(`Updated item: ${result.data.itemId}`);
+         * console.log(`Updated item: ${response.data.itemId}`);
          * ```
          */
         update: (id: string | number, data: {
@@ -386,87 +434,311 @@ export declare class OpenSearchClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Refresh a specific item document from the source database
+         * Item refresh operations - mirrors OpenAPI path /items/{invMastUid}/refresh and /items/refresh
+         */
+        refresh: {
+            /**
+             * Refresh a specific item document - mirrors GET /items/{invMastUid}/refresh
+             * @param invMastUid Inventory master unique identifier
+             * @returns Promise<ItemRefreshResponse> Complete response with refresh result
+             *
+             * @example
+             * ```typescript
+             * const response = await api.openSearch.items.refresh.get(123456);
+             * console.log(`Refreshed item: ${response.data.itemId}`);
+             * ```
+             */
+            get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    dateCreated: string;
+                    dateLastModified: string;
+                    statusCd: number;
+                    updateCd: number;
+                    processCd: number;
+                    invMastUid: number;
+                    itemId: string | null;
+                    classId5: string | null;
+                    online: string;
+                    doc: string | null;
+                    indexCd: number;
+                    indexStatusCd: number;
+                    dateLastChecked: string;
+                    embeddingCd: number;
+                    docHash: string | null;
+                    indexHash: string | null;
+                    location: string;
+                    uuid: string | null;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Trigger batch refresh of items - mirrors PUT /items/refresh
+             * @returns Promise<BatchRefreshResponse> Complete response with batch refresh result
+             *
+             * @example
+             * ```typescript
+             * const response = await api.openSearch.items.refresh.update();
+             * if (response.data.status === 'success') {
+             *   console.log('Batch refresh initiated');
+             * }
+             * ```
+             */
+            update: () => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    status: string;
+                    message: string;
+                    dateCreated: string;
+                    dateLastModified: string;
+                    statusCd: number;
+                    updateCd: number;
+                    processCd: number;
+                    itemId: string | null;
+                    classId5: string | null;
+                    doc: string | null;
+                    indexCd: number;
+                    indexStatusCd: number;
+                    dateLastChecked: string;
+                    embeddingCd: number;
+                    docHash: string | null;
+                    indexHash: string | null;
+                    location: string;
+                    uuid: string | null;
+                    invMastUid?: number | undefined;
+                    online?: string | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
+    };
+    /**
+     * Data-only access to item search operations
+     * @description Direct access to search data without response metadata
+     */
+    itemSearchData: {
+        /**
+         * Get item search data without response metadata
+         * @param params Search parameters
+         * @returns Promise<ItemSearchData> Search results data directly
+         */
+        list: (params: ItemSearchParams) => Promise<{
+            totalResults: number;
+            items: {
+                invMastUid: number;
+                itemId: string;
+                score: number;
+                scoreInt: number;
+                itemDesc?: string | undefined;
+                brandFolder?: {
+                    description?: string | undefined;
+                    logo?: string | undefined;
+                } | undefined;
+            }[];
+            maxScore: number;
+            took: number;
+            queryStringUid?: number | undefined;
+            queryStringRedirectLink?: boolean | undefined;
+        }>;
+        attributes: {
+            /**
+             * Get search attributes data without response metadata
+             * @param params Search parameters
+             * @returns Promise<SearchAttributesData> Attributes data directly
+             */
+            list: (params: SearchAttributesParams) => Promise<{
+                attributes: {
+                    values: {
+                        sequenceNo: number;
+                        attributeValueUid: number;
+                        attributeValue: string;
+                        count?: number | undefined;
+                    }[];
+                    sequenceNo: number;
+                    attributeUid: number;
+                    attributeId: string;
+                    attributeDesc: string;
+                    valueCount: number;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Data-only access to items operations
+     * @description Direct access to items data without response metadata
+     */
+    itemsData: {
+        /**
+         * Get items list data without response metadata
+         * @param params Optional filtering parameters
+         * @returns Promise<ItemsListData> Items data directly
+         */
+        list: (params?: ItemsListParams) => Promise<{
+            inv_mast_uid: number;
+            online: "Y" | "N";
+            stock_status: "in_stock" | "out_of_stock";
+            combo: string;
+            combo_hash: string;
+            class_id1?: string | null | undefined;
+            class_id2?: string | null | undefined;
+            class_id3?: string | null | undefined;
+            class_id4?: string | null | undefined;
+            class_id5?: string | null | undefined;
+            attributes?: {
+                name_string: string;
+                value_string: string;
+                value_original?: string | null | undefined;
+            }[] | undefined;
+            item_id?: string | null | undefined;
+            tags?: string[] | undefined;
+            item_desc?: string | null | undefined;
+            extended_desc?: string | null | undefined;
+            display_desc?: string | null | undefined;
+            price1?: number | null | undefined;
+            price2?: number | null | undefined;
+            price3?: number | null | undefined;
+            price4?: number | null | undefined;
+            price5?: number | null | undefined;
+            price6?: number | null | undefined;
+            price7?: number | null | undefined;
+            price8?: number | null | undefined;
+            price9?: number | null | undefined;
+            price10?: number | null | undefined;
+            keywords?: string | null | undefined;
+            brand_name?: string | null | undefined;
+            manufacturer_name?: string | null | undefined;
+            part_number?: string | null | undefined;
+            unspsc_code?: string | null | undefined;
+            upc_or_ean_id?: string | null | undefined;
+            supplier_name?: string | null | undefined;
+            qty_shipped_in_past_12_months?: number | null | undefined;
+            order_in_past_12_months?: number | null | undefined;
+            customer_part_numbers?: string | string[] | undefined;
+            supplier_part_numbers?: string | null | undefined;
+            alternate_codes?: string | null | undefined;
+            item_categories?: number[] | undefined;
+            item_category_tree?: string[] | undefined;
+            category_score?: number | undefined;
+            user_defined_fields?: {
+                name_string: string;
+                value_string: string;
+            }[] | undefined;
+            names?: string[] | undefined;
+        }[]>;
+        /**
+         * Get item data without response metadata
+         * @param invMastUid Inventory master unique identifier
+         * @returns Promise<ItemDetail> Item data directly
+         */
+        get: (invMastUid: number) => Promise<{
+            dateCreated: string;
+            dateLastModified: string;
+            statusCd: number;
+            updateCd: number;
+            processCd: number;
+            invMastUid: number;
+            online: "Y" | "N";
+            indexCd: number;
+            indexStatusCd: number;
+            dateLastChecked: string;
+            embeddingCd: number;
+            itemId?: string | null | undefined;
+            classId5?: string | null | undefined;
+            doc?: string | null | undefined;
+            docHash?: string | null | undefined;
+            indexHash?: string | null | undefined;
+            location?: string | null | undefined;
+            uuid?: string | null | undefined;
+        }>;
+        /**
+         * Update item and get data without response metadata
          * @param invMastUid Inventory master unique identifier
-         * @returns Promise<ItemRefreshResponse>
-         *
-         * @example
-         * ```typescript
-         * const result = await api.opensearch.items.refresh(123456);
-         * console.log(`Refreshed item: ${result.data.itemId}`);
-         * ```
+         * @param data Update data
+         * @returns Promise<unknown> Update result data directly
          */
-        refresh: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
+        update: (invMastUid: number, data: ItemUpdateRequest) => Promise<{
+            dateCreated: string;
+            dateLastModified: string;
+            statusCd: number;
+            updateCd: number;
+            processCd: number;
+            invMastUid: number;
+            online: "Y" | "N";
+            indexCd: number;
+            indexStatusCd: number;
+            dateLastChecked: string;
+            embeddingCd: number;
+            itemId?: string | null | undefined;
+            classId5?: string | null | undefined;
+            doc?: string | null | undefined;
+            docHash?: string | null | undefined;
+            indexHash?: string | null | undefined;
+            location?: string | null | undefined;
+            uuid?: string | null | undefined;
+        }>;
+        refresh: {
+            /**
+             * Refresh item and get data without response metadata
+             * @param invMastUid Inventory master unique identifier
+             * @returns Promise<unknown> Refresh result data directly
+             */
+            get: (invMastUid: number) => Promise<{
                 dateCreated: string;
                 dateLastModified: string;
                 statusCd: number;
                 updateCd: number;
                 processCd: number;
                 invMastUid: number;
-                online: "Y" | "N";
+                itemId: string | null;
+                classId5: string | null;
+                online: string;
+                doc: string | null;
                 indexCd: number;
                 indexStatusCd: number;
                 dateLastChecked: string;
                 embeddingCd: number;
-                itemId?: string | null | undefined;
-                classId5?: string | null | undefined;
-                doc?: string | null | undefined;
-                docHash?: string | null | undefined;
-                indexHash?: string | null | undefined;
-                location?: string | null | undefined;
-                uuid?: string | null | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Trigger batch refresh of items in the search index
-         * @returns Promise<ItemOperationResult>
-         *
-         * @example
-         * ```typescript
-         * const result = await api.opensearch.items.refreshAll();
-         * if (result.success) {
-         *   console.log('Batch refresh initiated');
-         * }
-         * ```
-         */
-        refreshAll: () => Promise<ItemOperationResponse>;
-    };
-    /**
-     * @deprecated Use health.check() instead
-     */
-    getHealthCheck: () => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: {
-            siteHash: string;
-            siteId: string;
+                docHash: string | null;
+                indexHash: string | null;
+                location: string;
+                uuid: string | null;
+            }>;
+            /**
+             * Trigger batch refresh and get data without response metadata
+             * @returns Promise<unknown> Batch refresh result data directly
+             */
+            update: () => Promise<{
+                status: string;
+                message: string;
+                dateCreated: string;
+                dateLastModified: string;
+                statusCd: number;
+                updateCd: number;
+                processCd: number;
+                itemId: string | null;
+                classId5: string | null;
+                doc: string | null;
+                indexCd: number;
+                indexStatusCd: number;
+                dateLastChecked: string;
+                embeddingCd: number;
+                docHash: string | null;
+                indexHash: string | null;
+                location: string;
+                uuid: string | null;
+                invMastUid?: number | undefined;
+                online?: string | undefined;
+            }>;
         };
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
-    /**
-     * @deprecated Use health.ping() instead
-     */
-    ping: () => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: "pong";
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
+    };
 }
 //# sourceMappingURL=client.d.ts.map