@simpleapps-com/augur-api 0.1.0

package/dist/cjs/services/open-search/client.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSearchClient = void 0;
+const base_client_1 = require("../../core/base-client");
+const schemas_1 = require("./schemas");
+/**
+ * OpenSearch service client for advanced product search capabilities
+ *
+ * Provides comprehensive search functionality including:
+ * - Advanced item search with filtering and facets
+ * - Search result attributes and faceted navigation
+ * - Item index management and refresh operations
+ * - Health monitoring and service status
+ */
+class OpenSearchClient extends base_client_1.BaseServiceClient {
+    /**
+     * Create a new OpenSearchClient instance
+     * @param http Configured HTTPClient instance
+     * @param baseUrl Base URL for the OpenSearch API (default: https://open-search.augur-api.com)
+     */
+    constructor(http, baseUrl = 'https://open-search.augur-api.com') {
+        super('open-search', http, baseUrl);
+        /**
+         * Health monitoring operations
+         */
+        this.health = {
+            /**
+             * Simple ping endpoint
+             * @returns Promise<"pong">
+             *
+             * @example
+             * ```typescript
+             * const pong = await api.opensearch.health.ping();
+             * console.log(pong); // "pong"
+             * ```
+             */
+            ping: this.createPingMethod(schemas_1.PingResponseSchema),
+            /**
+             * Comprehensive health check
+             * @returns Promise<HealthCheckData>
+             *
+             * @example
+             * ```typescript
+             * const health = await api.opensearch.health.check();
+             * console.log(`Site: ${health.siteId}, Hash: ${health.siteHash}`);
+             * ```
+             */
+            check: this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema),
+        };
+        /**
+         * Advanced item search operations
+         */
+        this.itemSearch = {
+            /**
+             * Perform comprehensive item search with advanced filtering
+             * @param params Search parameters including query, filters, and options
+             * @returns Promise<ItemSearchData>
+             *
+             * @example
+             * ```typescript
+             * // Basic search
+             * const results = await api.opensearch.itemSearch.search({
+             *   q: 'electrical wire',
+             *   searchType: 'query',
+             *   size: 20
+             * });
+             *
+             * // Advanced search with filtering
+             * const filtered = await api.opensearch.itemSearch.search({
+             *   q: 'tools',
+             *   searchType: 'query',
+             *   size: 50,
+             *   operator: 'AND',
+             *   filters: JSON.stringify([{attributeUid: 123, attributeValueUid: 456}]),
+             *   classId5List: '1,2,3',
+             *   from: 0
+             * });
+             *
+             * console.log(`Found ${results.totalResults} items`);
+             * results.items.forEach(item => {
+             *   console.log(`${item.itemId}: ${item.itemDesc} (score: ${item.score})`);
+             * });
+             * ```
+             */
+            search: this.createSearchMethod('/item-search', schemas_1.ItemSearchParamsSchema, schemas_1.ItemSearchResponseSchema),
+            /**
+             * Get search attributes for faceted navigation
+             * @param params Search parameters to determine available attributes
+             * @returns Promise<SearchAttributesData>
+             *
+             * @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})`);
+             *   });
+             * });
+             * ```
+             */
+            getAttributes: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/item-search/attributes',
+                    paramsSchema: schemas_1.SearchAttributesParamsSchema,
+                    responseSchema: schemas_1.SearchAttributesResponseSchema,
+                }, params);
+            },
+        };
+        /**
+         * Item index management operations
+         */
+        this.items = {
+            /**
+             * List items from the search index
+             * @param params Optional filtering parameters
+             * @returns Promise<ItemsListResponse>
+             *
+             * @example
+             * ```typescript
+             * // List all items (with default pagination)
+             * const items = await api.opensearch.items.list();
+             *
+             * // List items with filtering
+             * const filteredItems = await api.opensearch.items.list({
+             *   itemId: 'WIRE',  // Prefix filter
+             *   online: 'Y',     // Only online items
+             *   statusCd: 704,   // Active items only
+             *   limit: 50,
+             *   offset: 0
+             * });
+             *
+             * console.log(`Found ${filteredItems.total} total items`);
+             * filteredItems.data.forEach(item => {
+             *   console.log(`${item.itemId}: ${item.itemDesc}`);
+             * });
+             * ```
+             */
+            list: this.createListMethod('/items', schemas_1.ItemsListParamsSchema, schemas_1.ItemsListResponseSchema),
+            /**
+             * Get a specific item document from the search index
+             * @param invMastUid Inventory master unique identifier
+             * @returns Promise<ItemDetail>
+             *
+             * @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}`);
+             *
+             * if (item.keywords) {
+             *   console.log(`Keywords: ${item.keywords}`);
+             * }
+             * ```
+             */
+            get: this.createGetMethod('/items/{id}', schemas_1.ItemDetailResponseSchema),
+            /**
+             * Update a specific item document in the search index
+             * @param invMastUid Inventory master unique identifier
+             * @returns Promise<ItemOperationResult>
+             *
+             * @example
+             * ```typescript
+             * const result = await api.opensearch.items.update(123456);
+             * if (result.success) {
+             *   console.log('Item updated successfully');
+             * }
+             * ```
+             */
+            update: this.createActionMethod('/items/{id}', 'PUT', schemas_1.ItemOperationResponseSchema),
+            /**
+             * Refresh a specific item document from the source database
+             * @param invMastUid Inventory master unique identifier
+             * @returns Promise<ItemOperationResult>
+             *
+             * @example
+             * ```typescript
+             * const result = await api.opensearch.items.refresh(123456);
+             * if (result.success) {
+             *   console.log('Item refreshed from source database');
+             * }
+             * ```
+             */
+            refresh: this.createGetMethod('/items/{id}/refresh', schemas_1.ItemOperationResponseSchema),
+            /**
+             * 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: async () => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/items/refresh',
+                    responseSchema: schemas_1.ItemOperationResponseSchema,
+                });
+            },
+        };
+        /**
+         * @deprecated Use health.check() instead
+         */
+        this.getHealthCheck = this.health.check;
+        /**
+         * @deprecated Use health.ping() instead
+         */
+        this.ping = this.health.ping;
+    }
+}
+exports.OpenSearchClient = OpenSearchClient;
+//# sourceMappingURL=client.js.map

package/dist/cjs/services/open-search/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/open-search/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAE3D,uCAcmB;AAEnB;;;;;;;;GAQG;AACH,MAAa,gBAAiB,SAAQ,+BAAiB;IACrD;;;;OAIG;IACH,YAAY,IAAgB,EAAE,UAAkB,mCAAmC;QACjF,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAGtC;;WAEG;QACH,WAAM,GAAG;YACP;;;;;;;;;eASG;YACH,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,4BAAkB,CAAC;YAE/C;;;;;;;;;eASG;YACH,KAAK,EAAE,IAAI,CAAC,uBAAuB,CAAC,mCAAyB,CAAC;SAC/D,CAAC;QAEF;;WAEG;QACH,eAAU,GAAG;YACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA8BG;YACH,MAAM,EAAE,IAAI,CAAC,kBAAkB,CAC7B,cAAc,EACd,gCAAsB,EACtB,kCAAwB,CACzB;YAED;;;;;;;;;;;;;;;;;;;eAmBG;YACH,aAAa,EAAE,KAAK,EAAE,MAA8B,EAAqC,EAAE;gBACzF,OAAO,IAAI,CAAC,cAAc,CACxB;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,yBAAyB;oBAC/B,YAAY,EAAE,sCAA4B;oBAC1C,cAAc,EAAE,wCAA8B;iBAC/C,EACD,MAAM,CACP,CAAC;YACJ,CAAC;SACF,CAAC;QAEF;;WAEG;QACH,UAAK,GAAG;YACN;;;;;;;;;;;;;;;;;;;;;;;;eAwBG;YACH,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,+BAAqB,EAAE,iCAAuB,CAAC;YAErF;;;;;;;;;;;;;;;eAeG;YACH,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,kCAAwB,CAAC;YAElE;;;;;;;;;;;;eAYG;YACH,MAAM,EAAE,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,KAAK,EAAE,qCAA2B,CAAC;YAElF;;;;;;;;;;;;eAYG;YACH,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,qBAAqB,EAAE,qCAA2B,CAAC;YAEjF;;;;;;;;;;;eAWG;YACH,UAAU,EAAE,KAAK,IAAoC,EAAE;gBACrD,OAAO,IAAI,CAAC,cAAc,CAAC;oBACzB,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,gBAAgB;oBACtB,cAAc,EAAE,qCAA2B;iBAC5C,CAAC,CAAC;YACL,CAAC;SACF,CAAC;QAEF;;WAEG;QACH,mBAAc,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;QAEnC;;WAEG;QACH,SAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IArNxB,CAAC;CAsNF;AA9ND,4CA8NC"}

package/dist/cjs/services/open-search/index.d.ts

@@ -0,0 +1,3 @@
+export { OpenSearchClient } from './client';
+export type { SearchType, Operator, OnlineStatus, StatusCd, ItemSearchParams, SearchItem, ItemSearchData, ItemSearchResponse, SearchAttributesParams, AttributeValue, Attribute, SearchAttributesData, SearchAttributesResponse, ItemsListParams, Item, ItemsListData, ItemsListResponse, ItemDetail, ItemDetailResponse, ItemOperationResult, ItemOperationResponse, } from './schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/open-search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/open-search/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,YAAY,EACV,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,SAAS,EACT,oBAAoB,EACpB,wBAAwB,EACxB,eAAe,EACf,IAAI,EACJ,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,WAAW,CAAC"}

package/dist/cjs/services/open-search/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSearchClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "OpenSearchClient", { enumerable: true, get: function () { return client_1.OpenSearchClient; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/services/open-search/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/open-search/index.ts"],"names":[],"mappings":";;;AAAA,mCAA4C;AAAnC,0GAAA,gBAAgB,OAAA"}

package/dist/cjs/services/open-search/schemas/attributes.d.ts

@@ -0,0 +1,234 @@
+import { z } from 'zod';
+export declare const SearchAttributesParamsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+} & {
+    edgeCache: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<8>]>>;
+} & {
+    q: z.ZodString;
+    searchType: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"similarity">, z.ZodLiteral<"query">]>>;
+    cacheSiteId: z.ZodOptional<z.ZodString>;
+    cacheTtl: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    filters: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    q: string;
+    cacheTtl: number;
+    searchType: "similarity" | "query";
+    edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    cacheSiteId?: string | undefined;
+    filters?: string | undefined;
+}, {
+    q: string;
+    edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    cacheTtl?: number | undefined;
+    searchType?: "similarity" | "query" | undefined;
+    cacheSiteId?: string | undefined;
+    filters?: string | undefined;
+}>;
+export declare const AttributeValueSchema: z.ZodObject<{
+    attributeValueUid: z.ZodNumber;
+    attributeValue: z.ZodString;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    attributeValueUid: number;
+    attributeValue: string;
+}, {
+    count: number;
+    attributeValueUid: number;
+    attributeValue: string;
+}>;
+export declare const AttributeSchema: z.ZodObject<{
+    attributeUid: z.ZodNumber;
+    attributeName: z.ZodString;
+    values: z.ZodArray<z.ZodObject<{
+        attributeValueUid: z.ZodNumber;
+        attributeValue: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+        attributeValueUid: number;
+        attributeValue: string;
+    }, {
+        count: number;
+        attributeValueUid: number;
+        attributeValue: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    values: {
+        count: number;
+        attributeValueUid: number;
+        attributeValue: string;
+    }[];
+    attributeUid: number;
+    attributeName: string;
+}, {
+    values: {
+        count: number;
+        attributeValueUid: number;
+        attributeValue: string;
+    }[];
+    attributeUid: number;
+    attributeName: string;
+}>;
+export declare const SearchAttributesDataSchema: z.ZodObject<{
+    attributes: z.ZodArray<z.ZodObject<{
+        attributeUid: z.ZodNumber;
+        attributeName: z.ZodString;
+        values: z.ZodArray<z.ZodObject<{
+            attributeValueUid: z.ZodNumber;
+            attributeValue: z.ZodString;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            attributeValueUid: number;
+            attributeValue: string;
+        }, {
+            count: number;
+            attributeValueUid: number;
+            attributeValue: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: {
+            count: number;
+            attributeValueUid: number;
+            attributeValue: string;
+        }[];
+        attributeUid: number;
+        attributeName: string;
+    }, {
+        values: {
+            count: number;
+            attributeValueUid: number;
+            attributeValue: string;
+        }[];
+        attributeUid: number;
+        attributeName: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    attributes: {
+        values: {
+            count: number;
+            attributeValueUid: number;
+            attributeValue: string;
+        }[];
+        attributeUid: number;
+        attributeName: string;
+    }[];
+}, {
+    attributes: {
+        values: {
+            count: number;
+            attributeValueUid: number;
+            attributeValue: string;
+        }[];
+        attributeUid: number;
+        attributeName: string;
+    }[];
+}>;
+export declare const SearchAttributesResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        attributes: z.ZodArray<z.ZodObject<{
+            attributeUid: z.ZodNumber;
+            attributeName: z.ZodString;
+            values: z.ZodArray<z.ZodObject<{
+                attributeValueUid: z.ZodNumber;
+                attributeValue: z.ZodString;
+                count: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }, {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }[];
+            attributeUid: number;
+            attributeName: string;
+        }, {
+            values: {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }[];
+            attributeUid: number;
+            attributeName: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        attributes: {
+            values: {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }[];
+            attributeUid: number;
+            attributeName: string;
+        }[];
+    }, {
+        attributes: {
+            values: {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }[];
+            attributeUid: number;
+            attributeName: string;
+        }[];
+    }>;
+    totalResults: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        attributes: {
+            values: {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }[];
+            attributeUid: number;
+            attributeName: string;
+        }[];
+    };
+    status: number;
+    options?: Record<string, unknown>[] | undefined;
+    message?: string | undefined;
+    totalResults?: number | undefined;
+    count?: number | undefined;
+}, {
+    data: {
+        attributes: {
+            values: {
+                count: number;
+                attributeValueUid: number;
+                attributeValue: string;
+            }[];
+            attributeUid: number;
+            attributeName: string;
+        }[];
+    };
+    status: number;
+    options?: Record<string, unknown>[] | undefined;
+    message?: string | undefined;
+    totalResults?: number | undefined;
+    count?: number | undefined;
+}>;
+export type SearchAttributesParams = z.infer<typeof SearchAttributesParamsSchema>;
+export type AttributeValue = z.infer<typeof AttributeValueSchema>;
+export type Attribute = z.infer<typeof AttributeSchema>;
+export type SearchAttributesData = z.infer<typeof SearchAttributesDataSchema>;
+export type SearchAttributesResponse = z.infer<typeof SearchAttributesResponseSchema>;
+//# sourceMappingURL=attributes.d.ts.map

package/dist/cjs/services/open-search/schemas/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/attributes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMvC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiD,CAAC;AAG7F,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}

package/dist/cjs/services/open-search/schemas/attributes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchAttributesResponseSchema = exports.SearchAttributesDataSchema = exports.AttributeSchema = exports.AttributeValueSchema = exports.SearchAttributesParamsSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../core/schemas");
+const common_1 = require("./common");
+// Search attributes schemas
+exports.SearchAttributesParamsSchema = schemas_1.BaseGetParamsSchema.extend({
+    q: zod_1.z.string().min(1, 'Search query is required'),
+    searchType: common_1.SearchTypeSchema,
+    cacheSiteId: zod_1.z.string().optional(),
+    cacheTtl: zod_1.z.number().optional().default(0),
+    filters: zod_1.z.string().optional(),
+});
+exports.AttributeValueSchema = zod_1.z.object({
+    attributeValueUid: zod_1.z.number(),
+    attributeValue: zod_1.z.string(),
+    count: zod_1.z.number(),
+});
+exports.AttributeSchema = zod_1.z.object({
+    attributeUid: zod_1.z.number(),
+    attributeName: zod_1.z.string(),
+    values: zod_1.z.array(exports.AttributeValueSchema),
+});
+exports.SearchAttributesDataSchema = zod_1.z.object({
+    attributes: zod_1.z.array(exports.AttributeSchema),
+});
+exports.SearchAttributesResponseSchema = (0, schemas_1.BaseResponseSchema)(exports.SearchAttributesDataSchema);
+//# sourceMappingURL=attributes.js.map

package/dist/cjs/services/open-search/schemas/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.js","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/attributes.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,mDAAgF;AAChF,qCAA4C;AAE5C,4BAA4B;AACf,QAAA,4BAA4B,GAAG,6BAAmB,CAAC,MAAM,CAAC;IACrE,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,0BAA0B,CAAC;IAChD,UAAU,EAAE,yBAAgB;IAC5B,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1C,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEU,QAAA,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,iBAAiB,EAAE,OAAC,CAAC,MAAM,EAAE;IAC7B,cAAc,EAAE,OAAC,CAAC,MAAM,EAAE;IAC1B,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;CAClB,CAAC,CAAC;AAEU,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE;IACxB,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE;IACzB,MAAM,EAAE,OAAC,CAAC,KAAK,CAAC,4BAAoB,CAAC;CACtC,CAAC,CAAC;AAEU,QAAA,0BAA0B,GAAG,OAAC,CAAC,MAAM,CAAC;IACjD,UAAU,EAAE,OAAC,CAAC,KAAK,CAAC,uBAAe,CAAC;CACrC,CAAC,CAAC;AAEU,QAAA,8BAA8B,GAAG,IAAA,4BAAkB,EAAC,kCAA0B,CAAC,CAAC"}

package/dist/cjs/services/open-search/schemas/common.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const SearchTypeSchema: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"similarity">, z.ZodLiteral<"query">]>>;
+export declare const OperatorSchema: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"AND">, z.ZodLiteral<"OR">]>>;
+export declare const OnlineStatusSchema: z.ZodUnion<[z.ZodLiteral<"Y">, z.ZodLiteral<"N">]>;
+export declare const StatusCdSchema: z.ZodUnion<[z.ZodLiteral<700>, z.ZodLiteral<704>, z.ZodLiteral<705>]>;
+export type SearchType = z.infer<typeof SearchTypeSchema>;
+export type Operator = z.infer<typeof OperatorSchema>;
+export type OnlineStatus = z.infer<typeof OnlineStatusSchema>;
+export type StatusCd = z.infer<typeof StatusCdSchema>;
+//# sourceMappingURL=common.d.ts.map

package/dist/cjs/services/open-search/schemas/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB,+EAEV,CAAC;AACpB,eAAO,MAAM,cAAc,qEAA6D,CAAC;AACzF,eAAO,MAAM,kBAAkB,oDAA4C,CAAC;AAC5E,eAAO,MAAM,cAAc,uEAA4D,CAAC;AAGxF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/cjs/services/open-search/schemas/common.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCdSchema = exports.OnlineStatusSchema = exports.OperatorSchema = exports.SearchTypeSchema = void 0;
+const zod_1 = require("zod");
+// Common OpenSearch field patterns
+exports.SearchTypeSchema = zod_1.z
+    .union([zod_1.z.literal('similarity'), zod_1.z.literal('query')])
+    .default('query');
+exports.OperatorSchema = zod_1.z.union([zod_1.z.literal('AND'), zod_1.z.literal('OR')]).default('OR');
+exports.OnlineStatusSchema = zod_1.z.union([zod_1.z.literal('Y'), zod_1.z.literal('N')]);
+exports.StatusCdSchema = zod_1.z.union([zod_1.z.literal(700), zod_1.z.literal(704), zod_1.z.literal(705)]);
+//# sourceMappingURL=common.js.map

package/dist/cjs/services/open-search/schemas/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/common.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,mCAAmC;AACtB,QAAA,gBAAgB,GAAG,OAAC;KAC9B,KAAK,CAAC,CAAC,OAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,OAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;KACpD,OAAO,CAAC,OAAO,CAAC,CAAC;AACP,QAAA,cAAc,GAAG,OAAC,CAAC,KAAK,CAAC,CAAC,OAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,OAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC5E,QAAA,kBAAkB,GAAG,OAAC,CAAC,KAAK,CAAC,CAAC,OAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,OAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC/D,QAAA,cAAc,GAAG,OAAC,CAAC,KAAK,CAAC,CAAC,OAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,OAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,OAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC"}

package/dist/cjs/services/open-search/schemas/health.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const PingResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+    data: z.ZodLiteral<"pong">;
+    totalResults: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data: "pong";
+    status: number;
+    options?: Record<string, unknown>[] | undefined;
+    message?: string | undefined;
+    totalResults?: number | undefined;
+    count?: number | undefined;
+}, {
+    data: "pong";
+    status: number;
+    options?: Record<string, unknown>[] | undefined;
+    message?: string | undefined;
+    totalResults?: number | undefined;
+    count?: number | undefined;
+}>;
+export declare const HealthCheckResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        siteHash: z.ZodString;
+        siteId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        siteHash: string;
+        siteId: string;
+    }, {
+        siteHash: string;
+        siteId: string;
+    }>;
+    totalResults: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        siteHash: string;
+        siteId: string;
+    };
+    status: number;
+    options?: Record<string, unknown>[] | undefined;
+    message?: string | undefined;
+    totalResults?: number | undefined;
+    count?: number | undefined;
+}, {
+    data: {
+        siteHash: string;
+        siteId: string;
+    };
+    status: number;
+    options?: Record<string, unknown>[] | undefined;
+    message?: string | undefined;
+    totalResults?: number | undefined;
+    count?: number | undefined;
+}>;
+export type PingResponse = z.infer<typeof PingResponseSchema>;
+//# sourceMappingURL=health.d.ts.map

package/dist/cjs/services/open-search/schemas/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAA2B,CAAC;AAC3D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkC,CAAC;AAGzE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/cjs/services/open-search/schemas/health.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheckResponseSchema = exports.PingResponseSchema = void 0;
+const common_schemas_1 = require("../../../core/common-schemas");
+// Health monitoring schemas
+exports.PingResponseSchema = common_schemas_1.CommonPingResponseSchema;
+exports.HealthCheckResponseSchema = common_schemas_1.CommonHealthCheckResponseSchema;
+//# sourceMappingURL=health.js.map

package/dist/cjs/services/open-search/schemas/health.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.js","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/health.ts"],"names":[],"mappings":";;;AACA,iEAGsC;AAEtC,4BAA4B;AACf,QAAA,kBAAkB,GAAG,yCAAwB,CAAC;AAC9C,QAAA,yBAAyB,GAAG,gDAA+B,CAAC"}

package/dist/cjs/services/open-search/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common';
+export * from './search';
+export * from './attributes';
+export * from './items';
+export * from './health';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/open-search/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/open-search/schemas/index.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/cjs/services/open-search/schemas/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all schemas for backward compatibility
+__exportStar(require("./common"), exports);
+__exportStar(require("./search"), exports);
+__exportStar(require("./attributes"), exports);
+__exportStar(require("./items"), exports);
+__exportStar(require("./health"), exports);
+//# sourceMappingURL=index.js.map