@webiny/api-opensearch 0.0.0-unstable.0d717d18dd

package/features/OpenSearchQueryBuilderOperator/operators/LesserThan.js

@@ -0,0 +1,23 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class LesserThanImpl {
+    getOperator() {
+        return "lt";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    lt: value
+                }
+            }
+        });
+    }
+}
+const LesserThan = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: LesserThanImpl,
+    dependencies: []
+});
+export { LesserThan };
+
+//# sourceMappingURL=LesserThan.js.map

package/features/OpenSearchQueryBuilderOperator/operators/LesserThan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/LesserThan.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/LesserThan.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass LesserThanImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"lt\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    lt: value\n                }\n            }\n        });\n    }\n}\n\nexport const LesserThan = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: LesserThanImpl,\n    dependencies: []\n});\n"],"names":["LesserThanImpl","query","params","value","basePath","LesserThan","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACR,IAAID;gBACR;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,aAAaC,+BAA+B,oBAAoB,CAAC;IAC1E,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class LesserThanOrEqualImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const LesserThanOrEqual: typeof LesserThanOrEqualImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.js

@@ -0,0 +1,23 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class LesserThanOrEqualImpl {
+    getOperator() {
+        return "lte";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    lte: value
+                }
+            }
+        });
+    }
+}
+const LesserThanOrEqual = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: LesserThanOrEqualImpl,
+    dependencies: []
+});
+export { LesserThanOrEqual };
+
+//# sourceMappingURL=LesserThanOrEqual.js.map

package/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass LesserThanOrEqualImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"lte\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    lte: value\n                }\n            }\n        });\n    }\n}\n\nexport const LesserThanOrEqual = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: LesserThanOrEqualImpl,\n    dependencies: []\n});\n"],"names":["LesserThanOrEqualImpl","query","params","value","basePath","LesserThanOrEqual","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACR,KAAKD;gBACT;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,oBAAoBC,+BAA+B,oBAAoB,CAAC;IACjF,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/Not.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class NotImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const Not: typeof NotImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/Not.js

@@ -0,0 +1,38 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotImpl {
+    getOperator() {
+        return "not";
+    }
+    apply(query, params) {
+        const { value, path, basePath } = params;
+        if (null == value) return void query.filter.push({
+            exists: {
+                field: path
+            }
+        });
+        const typeOf = typeof value;
+        if ("boolean" === typeOf) return void query.filter.push({
+            bool: {
+                must_not: {
+                    term: {
+                        [path]: value
+                    }
+                }
+            }
+        });
+        const useBasePath = "string" !== typeOf;
+        const valuePath = useBasePath ? basePath : path;
+        query.must_not.push({
+            term: {
+                [valuePath]: value
+            }
+        });
+    }
+}
+const Not = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotImpl,
+    dependencies: []
+});
+export { Not };
+
+//# sourceMappingURL=Not.js.map

package/features/OpenSearchQueryBuilderOperator/operators/Not.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/Not.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/Not.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, path, basePath } = params;\n\n        if (value === null || value === undefined) {\n            query.filter.push({\n                exists: {\n                    field: path\n                }\n            });\n            return;\n        }\n\n        const typeOf = typeof value;\n\n        if (typeOf === \"boolean\") {\n            query.filter.push({\n                bool: {\n                    must_not: {\n                        term: {\n                            [path]: value\n                        }\n                    }\n                }\n            });\n            return;\n        }\n\n        const useBasePath = typeOf !== \"string\";\n        const valuePath = useBasePath ? basePath : path;\n        query.must_not.push({\n            term: {\n                [valuePath]: value\n            }\n        });\n    }\n}\n\nexport const Not = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotImpl,\n    dependencies: []\n});\n"],"names":["NotImpl","query","params","value","path","basePath","typeOf","useBasePath","valuePath","Not","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGH;QAElC,IAAIC,QAAAA,OAAuC,YACvCF,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,QAAQ;gBACJ,OAAOG;YACX;QACJ;QAIJ,MAAME,SAAS,OAAOH;QAEtB,IAAIG,AAAW,cAAXA,QAAsB,YACtBL,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,UAAU;oBACN,MAAM;wBACF,CAACG,KAAK,EAAED;oBACZ;gBACJ;YACJ;QACJ;QAIJ,MAAMI,cAAcD,AAAW,aAAXA;QACpB,MAAME,YAAYD,cAAcF,WAAWD;QAC3CH,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,MAAM;gBACF,CAACO,UAAU,EAAEL;YACjB;QACJ;IACJ;AACJ;AAEO,MAAMM,MAAMC,+BAA+B,oBAAoB,CAAC;IACnE,gBAAgBV;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/NotBetween.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class NotBetweenImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const NotBetween: typeof NotBetweenImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/NotBetween.js

@@ -0,0 +1,27 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotBetweenImpl {
+    getOperator() {
+        return "not_between";
+    }
+    apply(query, params) {
+        const { value, basePath, name } = params;
+        if (false === Array.isArray(value)) throw new Error(`You cannot filter field path "${name}" with "not_between" query and not send an array of values.`);
+        if (2 !== value.length) throw new Error(`You must pass 2 values in the array for field path "${name}" filtering.`);
+        const [gte, lte] = value;
+        query.must_not.push({
+            range: {
+                [basePath]: {
+                    lte,
+                    gte
+                }
+            }
+        });
+    }
+}
+const NotBetween = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotBetweenImpl,
+    dependencies: []
+});
+export { NotBetween };
+
+//# sourceMappingURL=NotBetween.js.map

package/features/OpenSearchQueryBuilderOperator/operators/NotBetween.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/NotBetween.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/NotBetween.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotBetweenImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not_between\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath, name } = params;\n        if (Array.isArray(value) === false) {\n            throw new Error(\n                `You cannot filter field path \"${name}\" with \"not_between\" query and not send an array of values.`\n            );\n        } else if (value.length !== 2) {\n            throw new Error(\n                `You must pass 2 values in the array for field path \"${name}\" filtering.`\n            );\n        }\n        const [gte, lte] = value;\n        query.must_not.push({\n            range: {\n                [basePath]: {\n                    lte,\n                    gte\n                }\n            }\n        });\n    }\n}\n\nexport const NotBetween = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotBetweenImpl,\n    dependencies: []\n});\n"],"names":["NotBetweenImpl","query","params","value","basePath","name","Array","Error","gte","lte","NotBetween","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,IAAI,EAAE,GAAGH;QAClC,IAAII,AAAyB,UAAzBA,MAAM,OAAO,CAACH,QACd,MAAM,IAAII,MACN,CAAC,8BAA8B,EAAEF,KAAK,2DAA2D,CAAC;QAEnG,IAAIF,AAAiB,MAAjBA,MAAM,MAAM,EACnB,MAAM,IAAII,MACN,CAAC,oDAAoD,EAAEF,KAAK,YAAY,CAAC;QAGjF,MAAM,CAACG,KAAKC,IAAI,GAAGN;QACnBF,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,OAAO;gBACH,CAACG,SAAS,EAAE;oBACRK;oBACAD;gBACJ;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,aAAaC,+BAA+B,oBAAoB,CAAC;IAC1E,gBAAgBX;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/NotContains.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class NotContainsImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const NotContains: typeof NotContainsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/NotContains.js

@@ -0,0 +1,27 @@
+import { normalizeValueWithAsterisk } from "../../../normalize.js";
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotContainsImpl {
+    getOperator() {
+        return "not_contains";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.must_not.push({
+            query_string: {
+                allow_leading_wildcard: true,
+                fields: [
+                    basePath
+                ],
+                query: normalizeValueWithAsterisk(value),
+                default_operator: "and"
+            }
+        });
+    }
+}
+const NotContains = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotContainsImpl,
+    dependencies: []
+});
+export { NotContains };
+
+//# sourceMappingURL=NotContains.js.map

package/features/OpenSearchQueryBuilderOperator/operators/NotContains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/NotContains.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/NotContains.ts"],"sourcesContent":["import { normalizeValueWithAsterisk } from \"~/normalize.js\";\nimport { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotContainsImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not_contains\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.must_not.push({\n            query_string: {\n                allow_leading_wildcard: true,\n                fields: [basePath],\n                query: normalizeValueWithAsterisk(value),\n                default_operator: \"and\"\n            }\n        });\n    }\n}\n\nexport const NotContains = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotContainsImpl,\n    dependencies: []\n});\n"],"names":["NotContainsImpl","query","params","value","basePath","normalizeValueWithAsterisk","NotContains","OpenSearchQueryBuilderOperator"],"mappings":";;AAGA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,cAAc;gBACV,wBAAwB;gBACxB,QAAQ;oBAACG;iBAAS;gBAClB,OAAOC,2BAA2BF;gBAClC,kBAAkB;YACtB;QACJ;IACJ;AACJ;AAEO,MAAMG,cAAcC,+BAA+B,oBAAoB,CAAC;IAC3E,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/NotIn.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class NotInImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const NotIn: typeof NotInImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/NotIn.js

@@ -0,0 +1,24 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotInImpl {
+    getOperator() {
+        return "not_in";
+    }
+    apply(query, params) {
+        const { value: values, path, basePath, name } = params;
+        const isArray = Array.isArray(values);
+        if (false === isArray || 0 === values.length) throw new Error(`You cannot filter field "${name}" with "not_in" operator and not send an array of values.`);
+        const useBasePath = values.some((value)=>"string" != typeof value);
+        query.must_not.push({
+            terms: {
+                [useBasePath ? basePath : path]: values
+            }
+        });
+    }
+}
+const NotIn = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotInImpl,
+    dependencies: []
+});
+export { NotIn };
+
+//# sourceMappingURL=NotIn.js.map

package/features/OpenSearchQueryBuilderOperator/operators/NotIn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/NotIn.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/NotIn.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotInImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not_in\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value: values, path, basePath, name } = params;\n        const isArray = Array.isArray(values);\n        if (isArray === false || values.length === 0) {\n            throw new Error(\n                `You cannot filter field \"${name}\" with \"not_in\" operator and not send an array of values.`\n            );\n        }\n\n        const useBasePath = values.some(\n            (value: string | number | boolean | null | undefined) => typeof value !== \"string\"\n        );\n\n        query.must_not.push({\n            terms: {\n                [useBasePath ? basePath : path]: values\n            }\n        });\n    }\n}\n\nexport const NotIn = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotInImpl,\n    dependencies: []\n});\n"],"names":["NotInImpl","query","params","values","path","basePath","name","isArray","Array","Error","useBasePath","value","NotIn","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAE,OAAOC,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,IAAI,EAAE,GAAGJ;QAChD,MAAMK,UAAUC,MAAM,OAAO,CAACL;QAC9B,IAAII,AAAY,UAAZA,WAAqBJ,AAAkB,MAAlBA,OAAO,MAAM,EAClC,MAAM,IAAIM,MACN,CAAC,yBAAyB,EAAEH,KAAK,yDAAyD,CAAC;QAInG,MAAMI,cAAcP,OAAO,IAAI,CAC3B,CAACQ,QAAwD,AAAiB,YAAjB,OAAOA;QAGpEV,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,OAAO;gBACH,CAACS,cAAcL,WAAWD,KAAK,EAAED;YACrC;QACJ;IACJ;AACJ;AAEO,MAAMS,QAAQC,+BAA+B,oBAAoB,CAAC;IACrE,gBAAgBb;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/NotStartsWith.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class NotStartsWithImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const NotStartsWith: typeof NotStartsWithImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/NotStartsWith.js

@@ -0,0 +1,22 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotStartsWithImpl {
+    getOperator() {
+        return "not_startsWith";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        if ("" === value || null == value) return;
+        query.must_not.push({
+            match_phrase_prefix: {
+                [basePath]: value
+            }
+        });
+    }
+}
+const NotStartsWith = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotStartsWithImpl,
+    dependencies: []
+});
+export { NotStartsWith };
+
+//# sourceMappingURL=NotStartsWith.js.map

package/features/OpenSearchQueryBuilderOperator/operators/NotStartsWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/NotStartsWith.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/NotStartsWith.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotStartsWithImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not_startsWith\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        if (value === \"\" || value === null || value === undefined) {\n            return;\n        }\n        query.must_not.push({\n            match_phrase_prefix: {\n                [basePath]: value\n            }\n        });\n    }\n}\n\nexport const NotStartsWith = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotStartsWithImpl,\n    dependencies: []\n});\n"],"names":["NotStartsWithImpl","query","params","value","basePath","NotStartsWith","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5B,IAAIC,AAAU,OAAVA,SAAkCA,QAAlBA,OAChB;QAEJF,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,qBAAqB;gBACjB,CAACG,SAAS,EAAED;YAChB;QACJ;IACJ;AACJ;AAEO,MAAME,gBAAgBC,+BAA+B,oBAAoB,CAAC;IAC7E,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/StartsWith.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class StartsWithImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const StartsWith: typeof StartsWithImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/StartsWith.js

@@ -0,0 +1,22 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class StartsWithImpl {
+    getOperator() {
+        return "startsWith";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        if ("" === value || null == value) return;
+        query.filter.push({
+            match_phrase_prefix: {
+                [basePath]: value
+            }
+        });
+    }
+}
+const StartsWith = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: StartsWithImpl,
+    dependencies: []
+});
+export { StartsWith };
+
+//# sourceMappingURL=StartsWith.js.map

package/features/OpenSearchQueryBuilderOperator/operators/StartsWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/StartsWith.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/StartsWith.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass StartsWithImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"startsWith\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        if (value === \"\" || value === null || value === undefined) {\n            return;\n        }\n        query.filter.push({\n            match_phrase_prefix: {\n                [basePath]: value\n            }\n        });\n    }\n}\n\nexport const StartsWith = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: StartsWithImpl,\n    dependencies: []\n});\n"],"names":["StartsWithImpl","query","params","value","basePath","StartsWith","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5B,IAAIC,AAAU,OAAVA,SAAkCA,QAAlBA,OAChB;QAEJF,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,qBAAqB;gBACjB,CAACG,SAAS,EAAED;YAChB;QACJ;IACJ;AACJ;AAEO,MAAME,aAAaC,+BAA+B,oBAAoB,CAAC;IAC1E,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/index.d.ts

@@ -0,0 +1,14 @@
+export { registerOpenSearchCore } from "./registerOpenSearchCore.js";
+export { getCommonMappings, getBaseConfiguration } from "./indexConfiguration/index.js";
+export * from "./sort.js";
+export * from "./where.js";
+export * from "./limit.js";
+export * from "./normalize.js";
+export * from "./cursors.js";
+export { createOpenSearchClient, type Client, type ClientOptions, type OpenSearchClientOptions } from "./client.js";
+export * from "./utils/index.js";
+export * from "./operations/index.js";
+export * from "./sharedIndex.js";
+export * from "./indexPrefix.js";
+export * from "./db/index.js";
+export * from "./types.js";

package/index.js

@@ -0,0 +1,14 @@
+export * from "./sort.js";
+export * from "./where.js";
+export * from "./limit.js";
+export * from "./normalize.js";
+export * from "./cursors.js";
+export * from "./utils/index.js";
+export * from "./operations/index.js";
+export * from "./sharedIndex.js";
+export * from "./indexPrefix.js";
+export * from "./db/index.js";
+export * from "./types.js";
+export { registerOpenSearchCore } from "./registerOpenSearchCore.js";
+export { getBaseConfiguration, getCommonMappings } from "./indexConfiguration/index.js";
+export { createOpenSearchClient } from "./client.js";

package/indexConfiguration/base.d.ts

@@ -0,0 +1,6 @@
+import type { OpenSearchIndexRequestBody } from "../types.js";
+interface Modifier {
+    (config: OpenSearchIndexRequestBody): OpenSearchIndexRequestBody;
+}
+export declare const getBaseConfiguration: (modifier?: Modifier) => import("@opensearch-project/opensearch/api/index.js").Indices_Create_RequestBody;
+export {};

package/indexConfiguration/base.js

@@ -0,0 +1,34 @@
+import { getCommonMappings } from "./common.js";
+const config = {
+    mappings: {
+        dynamic_templates: getCommonMappings((mappings)=>mappings.concat([
+                {
+                    strings: {
+                        match_mapping_type: "string",
+                        mapping: {
+                            type: "text",
+                            fields: {
+                                keyword: {
+                                    type: "keyword",
+                                    ignore_above: 256
+                                }
+                            }
+                        }
+                    }
+                }
+            ])),
+        properties: {
+            rawValues: {
+                type: "object",
+                enabled: false
+            }
+        }
+    }
+};
+const getBaseConfiguration = (modifier)=>{
+    if (!modifier) return config;
+    return modifier(config);
+};
+export { getBaseConfiguration };
+
+//# sourceMappingURL=base.js.map

package/indexConfiguration/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexConfiguration/base.js","sources":["../../src/indexConfiguration/base.ts"],"sourcesContent":["import type { OpenSearchIndexRequestBody } from \"~/types.js\";\nimport { getCommonMappings } from \"./common.js\";\n\nconst config: OpenSearchIndexRequestBody = {\n    mappings: {\n        dynamic_templates: getCommonMappings(mappings => {\n            return mappings.concat([\n                {\n                    strings: {\n                        match_mapping_type: \"string\",\n                        mapping: {\n                            type: \"text\",\n                            fields: {\n                                keyword: {\n                                    type: \"keyword\",\n                                    ignore_above: 256\n                                }\n                            }\n                        }\n                    }\n                }\n            ]);\n        }),\n        properties: {\n            rawValues: {\n                type: \"object\",\n                enabled: false\n            }\n        }\n    }\n};\n\ninterface Modifier {\n    (config: OpenSearchIndexRequestBody): OpenSearchIndexRequestBody;\n}\nexport const getBaseConfiguration = (modifier?: Modifier) => {\n    if (!modifier) {\n        return config;\n    }\n    return modifier(config);\n};\n"],"names":["config","getCommonMappings","mappings","getBaseConfiguration","modifier"],"mappings":";AAGA,MAAMA,SAAqC;IACvC,UAAU;QACN,mBAAmBC,kBAAkBC,CAAAA,WAC1BA,SAAS,MAAM,CAAC;gBACnB;oBACI,SAAS;wBACL,oBAAoB;wBACpB,SAAS;4BACL,MAAM;4BACN,QAAQ;gCACJ,SAAS;oCACL,MAAM;oCACN,cAAc;gCAClB;4BACJ;wBACJ;oBACJ;gBACJ;aACH;QAEL,YAAY;YACR,WAAW;gBACP,MAAM;gBACN,SAAS;YACb;QACJ;IACJ;AACJ;AAKO,MAAMC,uBAAuB,CAACC;IACjC,IAAI,CAACA,UACD,OAAOJ;IAEX,OAAOI,SAASJ;AACpB"}

package/indexConfiguration/common.d.ts

@@ -0,0 +1,9 @@
+import type { OpenSearchIndexRequestBodyMappingsDynamicTemplate } from "../types.js";
+interface Modifier {
+    (mappings: OpenSearchIndexRequestBodyMappingsDynamicTemplate[]): OpenSearchIndexRequestBodyMappingsDynamicTemplate[];
+}
+/**
+ * @internal
+ */
+export declare const getCommonMappings: (cb?: Modifier) => OpenSearchIndexRequestBodyMappingsDynamicTemplate[];
+export {};

package/indexConfiguration/common.js

@@ -0,0 +1,42 @@
+const getDefaultMappings = ()=>[
+        {
+            ids: {
+                match: "^id|entryId$",
+                mapping: {
+                    type: "keyword"
+                }
+            }
+        },
+        {
+            dates: {
+                match: "^createdOn|savedOn|publishedOn$",
+                mapping: {
+                    type: "date"
+                }
+            }
+        },
+        {
+            numbers: {
+                match: "number@*",
+                mapping: {
+                    type: "scaled_float",
+                    scaling_factor: 10000
+                }
+            }
+        },
+        {
+            booleans: {
+                match: "boolean@*",
+                mapping: {
+                    type: "boolean"
+                }
+            }
+        }
+    ];
+const getCommonMappings = (cb)=>{
+    if (!cb) return getDefaultMappings();
+    return cb(getDefaultMappings());
+};
+export { getCommonMappings };
+
+//# sourceMappingURL=common.js.map

package/indexConfiguration/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexConfiguration/common.js","sources":["../../src/indexConfiguration/common.ts"],"sourcesContent":["import type { OpenSearchIndexRequestBodyMappingsDynamicTemplate } from \"~/types.js\";\n\nconst getDefaultMappings = (): OpenSearchIndexRequestBodyMappingsDynamicTemplate[] => {\n    return [\n        {\n            ids: {\n                match: \"^id|entryId$\",\n                mapping: {\n                    type: \"keyword\"\n                }\n            }\n        },\n        {\n            /* Update with the correct date fields. */\n            dates: {\n                match: \"^createdOn|savedOn|publishedOn$\",\n                mapping: {\n                    type: \"date\"\n                }\n            }\n        },\n        {\n            numbers: {\n                match: \"number@*\",\n                mapping: {\n                    type: \"scaled_float\",\n                    scaling_factor: 10000\n                }\n            }\n        },\n        {\n            booleans: {\n                match: \"boolean@*\",\n                mapping: {\n                    type: \"boolean\"\n                }\n            }\n        }\n    ];\n};\n\ninterface Modifier {\n    (\n        mappings: OpenSearchIndexRequestBodyMappingsDynamicTemplate[]\n    ): OpenSearchIndexRequestBodyMappingsDynamicTemplate[];\n}\n/**\n * @internal\n */\nexport const getCommonMappings = (\n    cb?: Modifier\n): OpenSearchIndexRequestBodyMappingsDynamicTemplate[] => {\n    if (!cb) {\n        return getDefaultMappings();\n    }\n\n    return cb(getDefaultMappings());\n};\n"],"names":["getDefaultMappings","getCommonMappings","cb"],"mappings":"AAEA,MAAMA,qBAAqB,IAChB;QACH;YACI,KAAK;gBACD,OAAO;gBACP,SAAS;oBACL,MAAM;gBACV;YACJ;QACJ;QACA;YAEI,OAAO;gBACH,OAAO;gBACP,SAAS;oBACL,MAAM;gBACV;YACJ;QACJ;QACA;YACI,SAAS;gBACL,OAAO;gBACP,SAAS;oBACL,MAAM;oBACN,gBAAgB;gBACpB;YACJ;QACJ;QACA;YACI,UAAU;gBACN,OAAO;gBACP,SAAS;oBACL,MAAM;gBACV;YACJ;QACJ;KACH;AAWE,MAAMC,oBAAoB,CAC7BC;IAEA,IAAI,CAACA,IACD,OAAOF;IAGX,OAAOE,GAAGF;AACd"}

package/indexConfiguration/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./common.js";

package/indexConfiguration/index.js

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./common.js";

package/indexPrefix.d.ts

@@ -0,0 +1 @@
+export declare const getOpenSearchIndexPrefix: () => string;

package/indexPrefix.js

@@ -0,0 +1,4 @@
+const getOpenSearchIndexPrefix = ()=>process.env.OPENSEARCH_INDEX_PREFIX || process.env.ELASTICSEARCH_INDEX_PREFIX || process.env.WEBINY_OPENSEARCH_INDEX_PREFIX || process.env.WEBINY_ELASTICSEARCH_INDEX_PREFIX || "";
+export { getOpenSearchIndexPrefix };
+
+//# sourceMappingURL=indexPrefix.js.map

package/indexPrefix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexPrefix.js","sources":["../src/indexPrefix.ts"],"sourcesContent":["export const getOpenSearchIndexPrefix = (): string => {\n    return (\n        process.env.OPENSEARCH_INDEX_PREFIX ||\n        process.env.ELASTICSEARCH_INDEX_PREFIX ||\n        process.env.WEBINY_OPENSEARCH_INDEX_PREFIX ||\n        process.env.WEBINY_ELASTICSEARCH_INDEX_PREFIX ||\n        \"\"\n    );\n};\n"],"names":["getOpenSearchIndexPrefix","process"],"mappings":"AAAO,MAAMA,2BAA2B,IAEhCC,QAAQ,GAAG,CAAC,uBAAuB,IACnCA,QAAQ,GAAG,CAAC,0BAA0B,IACtCA,QAAQ,GAAG,CAAC,8BAA8B,IAC1CA,QAAQ,GAAG,CAAC,iCAAiC,IAC7C"}

package/indices.d.ts

@@ -0,0 +1,2 @@
+import { OpenSearchIndexRegistry } from "./features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js";
+export { OpenSearchIndexRegistry };

package/indices.js

@@ -0,0 +1 @@
+export { OpenSearchIndexRegistry } from "./features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js";

package/limit.d.ts

@@ -0,0 +1 @@
+export declare const createLimit: (limit?: number, defaultValue?: number) => number;

package/limit.js

@@ -0,0 +1,10 @@
+const ES_LIMIT_MAX = 10000;
+const ES_LIMIT_DEFAULT = 50;
+const createLimit = (limit, defaultValue = ES_LIMIT_DEFAULT)=>{
+    if (!limit || limit < 1) return defaultValue;
+    if (limit < ES_LIMIT_MAX) return limit;
+    return ES_LIMIT_MAX - 1;
+};
+export { createLimit };
+
+//# sourceMappingURL=limit.js.map

package/limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit.js","sources":["../src/limit.ts"],"sourcesContent":["/**\n * This is the max limit of the OpenSearch.\n * Change here if it changes (and if it is necessary).\n */\nconst ES_LIMIT_MAX = 10000;\n/**\n * Our system default limit.\n */\nconst ES_LIMIT_DEFAULT = 50;\n\nexport const createLimit = (limit?: number, defaultValue = ES_LIMIT_DEFAULT): number => {\n    /**\n     * Limit can possibly be null/undefined or less than 1.\n     * In that case return the defaults.\n     */\n    if (!limit || limit < 1) {\n        return defaultValue;\n    }\n    /**\n     * Users input limit cannot be greater than the OpenSearch one.\n     * OpenSearch query breaks because of that.\n     */\n    if (limit < ES_LIMIT_MAX) {\n        return limit;\n    }\n    /**\n     * Always reduce by 1 because we check if there are more items by adding 1 to the limit\n     * and then remove that last one loaded.\n     */\n    return ES_LIMIT_MAX - 1;\n};\n"],"names":["ES_LIMIT_MAX","ES_LIMIT_DEFAULT","createLimit","limit","defaultValue"],"mappings":"AAIA,MAAMA,eAAe;AAIrB,MAAMC,mBAAmB;AAElB,MAAMC,cAAc,CAACC,OAAgBC,eAAeH,gBAAgB;IAKvE,IAAI,CAACE,SAASA,QAAQ,GAClB,OAAOC;IAMX,IAAID,QAAQH,cACR,OAAOG;IAMX,OAAOH,eAAe;AAC1B"}

package/normalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Before performing the query, we need to escape all special characters.
+ * @see https://opensearch.org/docs/latest/query-dsl/full-text/query-string/
+ */
+export declare const normalizeValue: (value: string) => string;
+export declare const normalizeValueWithAsterisk: (initial: string) => string;

package/normalize.js

@@ -0,0 +1,55 @@
+const specialCharactersToRemove = [
+    "\\?"
+];
+const specialCharacterToSpace = [
+    "-",
+    "\\\\"
+];
+const specialCharacters = [
+    "\\\\",
+    "\\+",
+    "\\=",
+    "&",
+    "\\|",
+    ">",
+    "<",
+    "!",
+    "\\(",
+    "\\)",
+    "\\{",
+    "\\}",
+    "\\[",
+    "\\]",
+    "\\^",
+    '\\"',
+    "\\~",
+    "\\*",
+    ":",
+    "/",
+    "\\#"
+];
+const normalizeValue = (value)=>{
+    let result = value || "";
+    if (!result) return result;
+    for (const character of specialCharactersToRemove)result = result.replace(new RegExp(character, "g"), "");
+    for (const character of specialCharacterToSpace)result = result.replace(new RegExp(character, "g"), " ");
+    for (const character of specialCharacters)result = result.replace(new RegExp(character, "g"), `\\${character}`);
+    return result || "";
+};
+const hasSpecialChar = (value)=>{
+    if (!value) return null;
+    return null === value.match(/^([0-9a-zA-Z]+)$/i);
+};
+const normalizeValueWithAsterisk = (initial)=>{
+    const value = normalizeValue(initial);
+    const results = value.split(" ");
+    let result = value;
+    const firstWord = results[0];
+    if (false === hasSpecialChar(firstWord)) result = `*${result}`;
+    const lastWord = results[results.length - 1];
+    if (false === hasSpecialChar(lastWord)) result = `${result}*`;
+    return result;
+};
+export { normalizeValue, normalizeValueWithAsterisk };
+
+//# sourceMappingURL=normalize.js.map

package/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sources":["../src/normalize.ts"],"sourcesContent":["/**\n * Before performing the query, we need to escape all special characters.\n * @see https://opensearch.org/docs/latest/query-dsl/full-text/query-string/\n */\n\nconst specialCharactersToRemove = [`\\\\?`];\n\nconst specialCharacterToSpace = [\"-\", \"\\\\\\\\\"];\n\nconst specialCharacters = [\n    \"\\\\\\\\\",\n    \"\\\\+\",\n    // \"\\\\-\",\n    \"\\\\=\",\n    `&`,\n    `\\\\|`,\n    \">\",\n    \"<\",\n    `!`,\n    \"\\\\(\",\n    \"\\\\)\",\n    \"\\\\{\",\n    \"\\\\}\",\n    \"\\\\[\",\n    \"\\\\]\",\n    \"\\\\^\",\n    '\\\\\"',\n    \"\\\\~\",\n    \"\\\\*\",\n    `:`,\n    `/`,\n    \"\\\\#\"\n];\n\nexport const normalizeValue = (value: string) => {\n    let result = value || \"\";\n    if (!result) {\n        return result;\n    }\n    for (const character of specialCharactersToRemove) {\n        result = result.replace(new RegExp(character, \"g\"), \"\");\n    }\n    for (const character of specialCharacterToSpace) {\n        result = result.replace(new RegExp(character, \"g\"), \" \");\n    }\n\n    for (const character of specialCharacters) {\n        result = result.replace(new RegExp(character, \"g\"), `\\\\${character}`);\n    }\n\n    return result || \"\";\n};\n\nconst hasSpecialChar = (value: string): boolean | null => {\n    if (!value) {\n        return null;\n    }\n    return value.match(/^([0-9a-zA-Z]+)$/i) === null;\n};\n\nexport const normalizeValueWithAsterisk = (initial: string) => {\n    const value = normalizeValue(initial);\n    const results = value.split(\" \");\n\n    let result = value;\n    /**\n     * If there is a / in the first word, do not put asterisk in front of it.\n     */\n    const firstWord = results[0];\n    if (hasSpecialChar(firstWord) === false) {\n        result = `*${result}`;\n    }\n    /**\n     * If there is a / in the last word, do not put asterisk at the end of it.\n     */\n    const lastWord = results[results.length - 1];\n    if (hasSpecialChar(lastWord) === false) {\n        result = `${result}*`;\n    }\n\n    return result;\n};\n"],"names":["specialCharactersToRemove","specialCharacterToSpace","specialCharacters","normalizeValue","value","result","character","RegExp","hasSpecialChar","normalizeValueWithAsterisk","initial","results","firstWord","lastWord"],"mappings":"AAKA,MAAMA,4BAA4B;IAAC;CAAM;AAEzC,MAAMC,0BAA0B;IAAC;IAAK;CAAO;AAE7C,MAAMC,oBAAoB;IACtB;IACA;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACH;AAEM,MAAMC,iBAAiB,CAACC;IAC3B,IAAIC,SAASD,SAAS;IACtB,IAAI,CAACC,QACD,OAAOA;IAEX,KAAK,MAAMC,aAAaN,0BACpBK,SAASA,OAAO,OAAO,CAAC,IAAIE,OAAOD,WAAW,MAAM;IAExD,KAAK,MAAMA,aAAaL,wBACpBI,SAASA,OAAO,OAAO,CAAC,IAAIE,OAAOD,WAAW,MAAM;IAGxD,KAAK,MAAMA,aAAaJ,kBACpBG,SAASA,OAAO,OAAO,CAAC,IAAIE,OAAOD,WAAW,MAAM,CAAC,EAAE,EAAEA,WAAW;IAGxE,OAAOD,UAAU;AACrB;AAEA,MAAMG,iBAAiB,CAACJ;IACpB,IAAI,CAACA,OACD,OAAO;IAEX,OAAOA,AAAqC,SAArCA,MAAM,KAAK,CAAC;AACvB;AAEO,MAAMK,6BAA6B,CAACC;IACvC,MAAMN,QAAQD,eAAeO;IAC7B,MAAMC,UAAUP,MAAM,KAAK,CAAC;IAE5B,IAAIC,SAASD;IAIb,MAAMQ,YAAYD,OAAO,CAAC,EAAE;IAC5B,IAAIH,AAA8B,UAA9BA,eAAeI,YACfP,SAAS,CAAC,CAAC,EAAEA,QAAQ;IAKzB,MAAMQ,WAAWF,OAAO,CAACA,QAAQ,MAAM,GAAG,EAAE;IAC5C,IAAIH,AAA6B,UAA7BA,eAAeK,WACfR,SAAS,GAAGA,OAAO,CAAC,CAAC;IAGzB,OAAOA;AACX"}

package/operations/OpenSearchCatHealth.d.ts

@@ -0,0 +1,7 @@
+import type { Client } from "../client.js";
+import type { IOpenSearchCatHealthResponse } from "./types.js";
+export declare class OpenSearchCatHealth {
+    private readonly client;
+    constructor(client: Client);
+    getHealth(): Promise<IOpenSearchCatHealthResponse>;
+}