@sebspark/opensearch 0.3.3 → 1.0.0

package/dist/index.d.mts

@@ -1,289 +1,510 @@
-import { RequestParams, Client, ApiResponse, opensearchtypes } from '@opensearch-project/opensearch';
+import { Bulk_Request, Bulk_ResponseBody, Search_Request, Search_RequestBody, Search_Response, Search_ResponseBody, Index_Request, Index_Response, Indices_Exists_Request, Indices_Exists_Response } from '@opensearch-project/opensearch/api';
+import { Common_Mapping, Core_Bulk, Common as Common$1, Common_QueryDsl } from '@opensearch-project/opensearch/api/_types';
+import { Indices_Create_Request, Indices_Create_RequestBody } from '@opensearch-project/opensearch/api/';
+import OpenSearchAPI from '@opensearch-project/opensearch/api/OpenSearchApi';
+import * as Common from '@opensearch-project/opensearch/api/_types/_common';
+import * as CoreSearch from '@opensearch-project/opensearch/api/_types/_core.search';
+import { Client } from '@opensearch-project/opensearch';
+import { TransportRequestOptions, TransportRequestPromise } from '@opensearch-project/opensearch/lib/Transport';
 
 type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T[P] extends object ? DeepPartial<T[P]> : T[P];
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
-type NestedFields<T> = {
-    [P in keyof T]?: T[P] extends object ? NestedFields<T[P]> : T[P];
-};
-type NestedPaths<T> = T extends object ? {
-    [K in keyof T]: T[K] extends string | number | boolean | Date ? K : T[K] extends object ? `${K & string}.${NestedPaths<T[K]> & string}` : never;
-}[keyof T] : never;
-type NestedStringPaths<T, Prefix extends string = ''> = T extends object ? {
-    [K in keyof T & string]: NestedStringPaths<T[K], `${Prefix}${Prefix extends '' ? '' : '.'}${K}`>;
+type NestedPaths<T, Prefix extends string = ''> = T extends object ? {
+    [K in keyof T & string]: `${Prefix}${Prefix extends '' ? '' : '.'}${K}` | NestedPaths<T[K], `${Prefix}${Prefix extends '' ? '' : '.'}${K}`>;
+}[keyof T & string] : never;
+type NestedLeafPaths<T, Prefix extends string = ''> = T extends object ? {
+    [K in keyof T & string]: NestedLeafPaths<T[K], `${Prefix}${Prefix extends '' ? '' : '.'}${K}`>;
 }[keyof T & string] : Prefix;
-type NestedNumberPaths<T> = T extends object ? {
-    [K in keyof T]: T[K] extends number ? K : T[K] extends object ? `${K & string}.${NestedNumberPaths<T[K]> & string}` : never;
-}[keyof T] : never;
-type WithId = {
-    id: string;
-};
-type ExcludeId<T> = Omit<T, 'id'>;
-type SubstringOf<T extends string> = T extends `${infer Prefix}${infer _Rest}` ? Prefix | SubstringOf<Exclude<T, Prefix>> : never;
-type NotUndefined<T> = T extends undefined ? never : T;
+type Primitive = string | number | boolean;
 
-type FieldName<T> = NestedStringPaths<ExcludeId<T>> | '*' | (string & {});
-type FieldObject<T> = {
-    field: FieldName<T>;
-    format?: string;
-};
-type OpenSearchFields<T> = (FieldName<T> | FieldObject<T>)[];
-type FuzzyOptions = {
-    fuzziness?: string;
-    max_expansions?: number;
-    prefix_length?: number;
-    transpositions?: boolean;
-    rewrite?: string;
-};
-type Fuzzy<T> = {
-    [P in NestedStringPaths<T>]?: {
-        value: string;
-    } & FuzzyOptions;
-};
-type TermOptions<T> = T extends string | number | boolean ? {
-    value: T;
-    boost?: number;
-    case_insensitive?: boolean;
+/**
+ * Defines all possible field value types in OpenSearch.
+ */
+type FieldValue = Common.FieldValue;
+/**
+ * Defines an OpenSearch field with optional properties.
+ */
+type Property = Common_Mapping.Property;
+/**
+ * Defines an OpenSearch index mapping.
+ */
+type TypeMapping = Omit<Common_Mapping.TypeMapping, 'properties'> & {
+    properties: Record<string, Property>;
+};
+/**
+ * Defines an OpenSearch index mapping configuration.
+ */
+type IndicesCreateRequestBody = Omit<Indices_Create_RequestBody, 'mappings'> & {
+    mappings: TypeMapping;
+};
+/**
+ * Defines an OpenSearch index with body required.
+ */
+type IndexDefinition = Omit<Indices_Create_Request, 'body'> & {
+    body: IndicesCreateRequestBody;
+};
+/**
+ * Converts OpenSearch field definitions into TypeScript types.
+ */
+type MapOpenSearchTypes<T> = T extends Property ? T['type'] extends 'keyword' | 'text' ? string : T['type'] extends 'integer' | 'long' | 'short' | 'byte' | 'float' | 'double' ? number : T['type'] extends 'boolean' ? boolean : T['type'] extends 'date' | 'date_nanos' ? Date : T['type'] extends 'object' | 'nested' ? T extends {
+    properties: Record<string, Property>;
+} ? {
+    [K in keyof T['properties']]: MapOpenSearchTypes<T['properties'][K]>;
+} : never : never : T extends Record<string, Property> ? {
+    [K in keyof T]: MapOpenSearchTypes<T[K]>;
 } : never;
-type Term<T> = {
-    [P in NestedPaths<T>]?: TermOptions<any>;
-};
-type TermsProperty<T> = {
-    [P in NestedPaths<T>]?: any[];
-};
-type Terms<T> = TermsProperty<T> & {
-    boost?: number;
-};
-type Range<T> = {
-    [P in NestedNumberPaths<T>]: {
-        gte?: number;
-        lte?: number;
-        gt?: number;
-        lt?: number;
-        boost?: number;
+type MapQueryProperties<T extends IndexDefinition> = T extends {
+    body: {
+        mappings: {
+            properties: infer P;
+        };
     };
+} ? MapOpenSearchTypes<P> : never;
+type Indices = OpenSearchAPI['indices'];
+type Sort<T> = SortOptions<T> | SortOptions<T>[];
+type SortOptions<T> = '_score' | '_doc' | {
+    _doc?: Common.ScoreSort;
+    _geo_distance?: Common.GeoDistanceSort;
+    _score?: Common.ScoreSort;
+    _script?: Common.ScriptSort;
+} | Record<NestedPaths<T>, Common.FieldSort>;
+type BuiltinKeys = '_id' | '_index';
+
+type DocumentFor<T extends IndexDefinition> = {
+    [P in keyof T['body']['mappings']['properties']]: MapOpenSearchTypes<T['body']['mappings']['properties'][P]>;
+};
+
+type CreateOperation<T extends IndexDefinition> = Omit<WriteOperation<T>, '_id'> & {
+    _id: Common$1.Id;
+};
+type DeleteOperation<T extends IndexDefinition> = OperationBase<T>;
+type IndexOperation<T extends IndexDefinition> = WriteOperation<T>;
+type UpdateOperation<T extends IndexDefinition> = Omit<Core_Bulk.UpdateOperation, '_index' | '_id'> & {
+    _id: Common$1.Id;
+    _index?: T['index'];
+};
+type WriteOperation<T extends IndexDefinition> = Omit<Core_Bulk.WriteOperation, '_index'> & {
+    _index?: T['index'];
+};
+type OperationBase<T extends IndexDefinition> = Omit<Core_Bulk.OperationBase, '_index'> & {
+    _index?: T['index'];
+};
+type OperationContainer<T extends IndexDefinition> = {
+    create?: CreateOperation<T>;
+    delete?: DeleteOperation<T>;
+    index?: IndexOperation<T>;
+    update?: UpdateOperation<T>;
+};
+type UpdateAction<T extends IndexDefinition> = Omit<Core_Bulk.UpdateAction, 'doc' | 'upsert'> & ({
+    doc: DeepPartial<DocumentFor<T>>;
+    upsert?: DocumentFor<T>;
+} | {
+    doc?: DeepPartial<DocumentFor<T>>;
+    upsert: DocumentFor<T>;
+});
+type BulkRequest<T extends IndexDefinition> = Omit<Bulk_Request, 'index' | 'body' | '_source_excludes' | '_source_includes'> & {
+    index: T['index'];
+    body: BulkRequestBody<T>;
+    _source_excludes?: NestedLeafPaths<T> | Common$1.Fields;
+    _source_includes?: NestedLeafPaths<T> | Common$1.Fields;
+};
+type BulkRequestBody<T extends IndexDefinition> = (OperationContainer<T> | UpdateAction<T> | DocumentFor<T>)[];
+type ResponseItem<T extends IndexDefinition> = Omit<Core_Bulk.ResponseItem, '_index'> & {
+    _index: T['index'];
 };
-type Exists<T> = {
+type CustomOperation = string;
+type BulkOperation = 'index' | 'update' | 'delete' | 'create' | CustomOperation;
+type BulkResponseBody<T extends IndexDefinition> = Omit<Bulk_ResponseBody, 'items'> & {
+    items: Record<BulkOperation, ResponseItem<T>>[];
+};
+type BulkResponse<T extends IndexDefinition> = Omit<Bulk_ResponseBody, 'body'> & {
+    body: BulkResponseBody<T>;
+};
+
+type BoolQuery<T> = Omit<Common_QueryDsl.BoolQuery, 'must' | 'should' | 'filter' | 'must_not'> & {
+    must?: QueryContainer<T>[];
+    should?: QueryContainer<T>[];
+    filter?: QueryContainer<T>[];
+    must_not?: QueryContainer<T>[];
+};
+type BoostingQuery<T> = Omit<Common_QueryDsl.BoostingQuery, 'positive' | 'negative'> & {
+    positive: QueryContainer<T>;
+    negative: QueryContainer<T>;
+};
+type CombinedFieldsQuery<T> = Omit<Common_QueryDsl.CombinedFieldsQuery, 'fields'> & {
+    fields: NestedPaths<T>[];
+};
+type CommonTermsQuery = Common_QueryDsl.CommonTermsQuery;
+type ConstantScoreQuery<T> = Omit<Common_QueryDsl.ConstantScoreQuery, 'filter'> & {
+    filter: QueryContainer<T>;
+};
+type DateDecayFunction = Common_QueryDsl.DateDecayFunction;
+type DateDistanceFeatureQuery = Common_QueryDsl.DateDistanceFeatureQuery;
+type DateRangeQuery = Common_QueryDsl.DateRangeQuery;
+type DecayFunction = Common_QueryDsl.DecayFunction;
+type DecayFunctionBase = Common_QueryDsl.DecayFunctionBase;
+type DisMaxQuery<T> = Omit<Common_QueryDsl.DisMaxQuery, 'queries'> & {
+    queries: QueryContainer<T>[];
+};
+type DistanceFeatureQuery<T> = Omit<Common_QueryDsl.DistanceFeatureQuery, 'field'> & {
     field: NestedPaths<T>;
 };
-type Regexp<T> = {
-    [P in NestedStringPaths<T>]: string | {
-        value: string;
-        flags?: string;
-        max_determinized_states?: number;
-        boost?: number;
-    };
+type ExistsQuery<T> = Omit<Common_QueryDsl.ExistsQuery, 'field'> & {
+    field: NestedPaths<T>;
 };
-type StandardAnalyzer = 'standard' | 'simple' | 'whitespace' | 'stop' | 'keyword' | 'pattern' | 'fingerprint';
-type LanguageAnalyzer = 'arabic' | 'armenian' | 'basque' | 'bengali' | 'brazilian' | 'bulgarian' | 'catalan' | 'czech' | 'danish' | 'dutch' | 'english' | 'estonian' | 'finnish' | 'french' | 'galician' | 'german' | 'greek' | 'hindi' | 'hungarian' | 'indonesian' | 'irish' | 'italian' | 'latvian' | 'lithuanian' | 'norwegian' | 'persian' | 'portuguese' | 'romanian' | 'russian' | 'sorani' | 'spanish' | 'swedish' | 'turkish' | 'thai';
-type Analyzer = StandardAnalyzer | LanguageAnalyzer;
-type Match<T> = Partial<{
-    [P in NestedStringPaths<T>]: string | {
-        query: string;
-        operator?: 'and' | 'or';
-        minimum_should_match?: number;
-        analyzer?: Analyzer;
-    };
-}>;
-type MultiMatchParam<T extends string> = T | `${T}^${number}` | `${SubstringOf<T>}*`;
-type MultiMatch<T> = {
+type FieldAndFormat<T> = Omit<Common_QueryDsl.FieldAndFormat, 'field'> & {
+    field: NestedPaths<T>;
+};
+type FieldQuery<T, K> = Partial<Record<NestedLeafPaths<T> | BuiltinKeys, K>>;
+type FieldValueFactorScoreFunction<T> = Omit<Common_QueryDsl.FieldValueFactorScoreFunction, 'field'> & {
+    field: NestedPaths<T>;
+};
+type FunctionBoostMode = Common_QueryDsl.FunctionBoostMode;
+type FunctionScoreQuery<T> = Omit<Common_QueryDsl.FunctionScoreQuery, 'query'> & {
+    query?: QueryContainer<T> | undefined;
+};
+type FuzzyQuery = Common_QueryDsl.FuzzyQuery;
+type GeoBoundingBoxQuery = Common_QueryDsl.GeoBoundingBoxQuery;
+type GeoDecayFunction = Common_QueryDsl.GeoDecayFunction;
+type GeoDistanceFeatureQuery = Common_QueryDsl.GeoDistanceFeatureQuery;
+type GeoDistanceQuery = Common_QueryDsl.GeoDistanceQuery;
+type GeoExecution = Common_QueryDsl.GeoExecution;
+type GeoPolygonQuery<T> = Omit<Common_QueryDsl.GeoPolygonQuery, 'field'> & {
+    field: NestedPaths<T>;
+};
+type GeoShapeQuery<T> = Omit<Common_QueryDsl.GeoShapeQuery, 'ignore_unmapped' | 'field'> & {
+    field: NestedPaths<T>;
+};
+type GeoValidationMethod = Common_QueryDsl.GeoValidationMethod;
+type HasChildQuery<T> = Omit<Common_QueryDsl.HasChildQuery, 'query'> & {
+    query: QueryContainer<T>;
+};
+type HasParentQuery<T> = Omit<Common_QueryDsl.HasParentQuery, 'query'> & {
+    query: QueryContainer<T>;
+};
+type HybridQuery<T> = Omit<Common_QueryDsl.HybridQuery, 'queries'> & {
+    queries?: QueryContainer<T>[];
+};
+type IdsQuery = Common_QueryDsl.IdsQuery;
+type IntervalsQuery = Common_QueryDsl.IntervalsQuery;
+type KnnQuery<T> = Omit<Common_QueryDsl.KnnQuery, 'filter'> & {
+    filter?: QueryContainer<T>[];
+};
+type Like = Common_QueryDsl.Like;
+type LikeDocument = Common_QueryDsl.LikeDocument;
+type MatchAllQuery = Common_QueryDsl.MatchAllQuery;
+type MatchBoolPrefixQuery<T> = Omit<Common_QueryDsl.MatchBoolPrefixQuery, 'query' | 'fields'> & {
+    fields: NestedPaths<T>[];
     query: string;
-    fields: MultiMatchParam<NestedStringPaths<T>>[];
-    type?: 'best_fields' | 'most_fields' | 'cross_fields' | 'phrase' | 'phrase_prefix';
-    operator?: 'and' | 'or';
 };
-type SimpleFilterQueryString<T> = {
+type MatchNoneQuery = Common_QueryDsl.MatchNoneQuery;
+type MatchPhrasePrefixQuery<T> = Omit<Common_QueryDsl.MatchPhrasePrefixQuery, 'query' | 'field'> & {
+    field: NestedPaths<T>;
     query: string;
-    fields?: Array<keyof NestedFields<T>>;
-};
-type FilterQueryString<T> = SimpleFilterQueryString<T> & {
-    default_field?: keyof NestedFields<T>;
-};
-type FilterBool<T> = {
-    must?: OpenSearchFilter<T> | OpenSearchFilter<T>[];
-    filter?: OpenSearchFilter<T> | OpenSearchFilter<T>[];
-    should?: OpenSearchFilter<T> | OpenSearchFilter<T>[];
-    must_not?: OpenSearchFilter<T> | OpenSearchFilter<T>[];
-    minimum_should_match?: number;
-    boost?: number;
-};
-type OpenSearchFilter<T> = {
-    term?: Term<T>;
-    terms?: Terms<T>;
-    range?: Range<T>;
-    exists?: Exists<T>;
-    fuzzy?: Fuzzy<T>;
-    prefix?: Partial<NestedFields<T>>;
-    wildcard?: Wildcard<T>;
-    regexp?: Regexp<T>;
-    match?: Match<T>;
-    match_phrase?: Partial<NestedFields<T>>;
-    match_phrase_prefix?: Partial<NestedFields<T>>;
-    multi_match?: MultiMatch<T>;
-    query_string?: FilterQueryString<T>;
-    simple_query_string?: SimpleFilterQueryString<T>;
-    bool?: FilterBool<T>;
-};
-type Collapse<T> = {
-    field: keyof NestedFields<T>;
-};
-type ScriptScore = {
-    script: {
-        source: string;
-        params?: {
-            [key: string]: any;
-        };
-    };
 };
-type Highlight<T> = {
-    fields: {
-        [P in keyof NestedFields<T>]?: {};
-    };
+type MatchPhraseQuery<T> = Omit<Common_QueryDsl.MatchPhraseQuery, 'query' | 'field'> & {
+    field: NestedPaths<T>;
+    query: string;
 };
-type Prefix<T> = {
-    [P in keyof NestedFields<T>]?: NestedFields<T>[P] | {
-        value: NestedFields<T>[P];
-        boost?: number;
-    };
+type MatchQuery = FieldValue | Common_QueryDsl.MatchQuery;
+type MoreLikeThisQuery<T> = Omit<Common_QueryDsl.MoreLikeThisQuery, 'fields'> & {
+    fields?: NestedPaths<T>[];
 };
-type Wildcard<T> = {
-    [P in NestedPaths<T>]?: string | {
-        value: string;
-        boost?: number;
-    };
+type MultiMatchQuery<T> = Omit<Common_QueryDsl.MultiMatchQuery, 'fields'> & {
+    fields?: NestedPaths<T>[];
 };
-type MatchPhrase<T> = {
-    [P in keyof NestedFields<T>]?: NestedFields<T>[P] | {
-        query: NestedFields<T>[P];
-        analyzer?: string;
-        slop?: number;
-        boost?: number;
-    };
+type NestedQuery<T> = Omit<Common_QueryDsl.NestedQuery, 'query' | 'path'> & {
+    path: NestedPaths<T>;
+    query: QueryContainer<T>;
 };
-type MatchPhrasePrefix<T> = {
-    [P in keyof NestedFields<T>]?: NestedFields<T>[P] | {
-        query: NestedFields<T>[P];
-        max_expansions?: number;
-        slop?: number;
-        boost?: number;
-    };
+type NeuralQuery<T> = Omit<Common_QueryDsl.NeuralQuery, 'filter'> & {
+    filter?: QueryContainer<T>;
 };
-type MoreLikeThis<T> = {
-    fields: OpenSearchFields<T>;
-    like: string | string[] | {
-        _index: string;
-        _id: string;
-    }[];
-    unlike?: string | string[] | {
-        _index: string;
-        _id: string;
-    }[];
-    min_term_freq?: number;
-    max_query_terms?: number;
-    min_doc_freq?: number;
-    max_doc_freq?: number;
-    min_word_length?: number;
-    max_word_length?: number;
-    stop_words?: string[];
-    analyzer?: string;
-    minimum_should_match?: number;
-    boost?: number;
-    include?: boolean;
-    fail_on_unsupported_field?: boolean;
-};
-type OpenSearchQueryBody<T extends {
-    id: string;
-}, K = T> = K extends DeepPartial<T> ? {
-    query: {
-        ids?: {
-            values: string[];
-        };
-        filter?: OpenSearchFilter<T>;
-        match?: Match<T>;
-        match_all?: {
-            boost?: number;
-        };
-        multi_match?: MultiMatch<T>;
-        from?: number;
-        size?: number;
-        collapse?: Collapse<K>;
-        script_score?: ScriptScore;
-        highlight?: Highlight<K>;
-        bool?: FilterBool<T>;
-        range?: Range<T>;
-        exists?: Exists<T>;
-        terms?: Terms<T>;
-        term?: Term<T>;
-        fuzzy?: Fuzzy<T>;
-        prefix?: Prefix<T>;
-        wildcard?: Wildcard<T>;
-        regexp?: Regexp<T>;
-        match_phrase?: MatchPhrase<T>;
-        match_phrase_prefix?: MatchPhrasePrefix<T>;
-        more_like_this?: MoreLikeThis<T>;
-    };
-    sort?: Sort<T>[];
-    from?: number;
-    size?: number;
-    _source?: OpenSearchFields<K>;
-} : never;
-type Order = 'asc' | 'desc';
-type Mode = 'min' | 'max' | 'sum' | 'avg' | 'median';
-type Missing = '_first' | '_last' | 'custom_value';
-type Sort<T> = {
-    [P in NestedPaths<T>]?: Order | {
-        order?: Order;
-        mode?: Mode;
-        missing?: Missing;
-        unmapped_type?: BasicOpenSearchFieldTypes;
-        numeric_type?: NumberTypes;
-        format?: string;
-    };
+type NumberRangeQuery<T> = Omit<Common_QueryDsl.NumberRangeQuery, 'field'> & {
+    field: NestedPaths<T>;
 };
-type OpenSearchQuery<T extends {
-    id: string;
-}, K = T> = RequestParams.Search<OpenSearchQueryBody<T, K>> & K extends DeepPartial<T> ? {
-    index: string;
-    body: OpenSearchQueryBody<T, K>;
-} : never;
-type StringTypes = 'text' | 'keyword';
-type NumberTypes = 'long' | 'integer' | 'short' | 'byte' | 'double' | 'float';
-type BasicOpenSearchFieldTypes = StringTypes | NumberTypes | 'date' | 'boolean' | 'binary' | 'nested';
-type ElementType<T> = T extends Array<infer U> ? U : T;
-type OpenSearchFieldType<T> = ElementType<T> extends string ? StringTypes : ElementType<T> extends number ? NumberTypes : ElementType<T> extends boolean ? 'boolean' : ElementType<T> extends Date ? 'date' : BasicOpenSearchFieldTypes;
-type FieldOptions<T> = {
-    type: OpenSearchFieldType<NotUndefined<T>>;
-};
-type NestedFieldOptions<T> = {
-    type: 'nested';
-    properties: IndexProperties<T>;
-};
-type IndexProperties<T> = {
-    [K in keyof Partial<T>]: T[K] extends Date ? FieldOptions<T[K]> : NotUndefined<T[K]> extends object ? NotUndefined<T[K]> extends Array<infer U> ? U extends object ? NestedFieldOptions<U> : FieldOptions<T[K]> : IndexProperties<T[K]> : FieldOptions<T[K]>;
-};
-type IndexOptions<T extends WithId> = {
-    settings?: {
-        index?: {
-            number_of_shards: number;
-            number_of_replicas: number;
+type ParentIdQuery = Common_QueryDsl.ParentIdQuery;
+type PercolateQuery<T> = Omit<Common_QueryDsl.PercolateQuery, 'field'> & {
+    field: NestedPaths<T>;
+};
+type PinnedQuery = Common_QueryDsl.PinnedQuery;
+type PrefixQuery<T> = Omit<Common_QueryDsl.PrefixQuery, 'value' | 'field'> & {
+    field: NestedPaths<T>;
+    value: MapOpenSearchTypes<T>;
+};
+type QueryContainer<T> = Omit<Common_QueryDsl.QueryContainer, 'bool' | 'boosting' | 'combined_fields' | 'common' | 'constant_score' | 'dis_max' | 'distance_feature' | 'exists' | 'function_score' | 'fuzzy' | 'geo_bounding_box' | 'geo_distance' | 'geo_polygon' | 'geo_shape' | 'has_child' | 'has_parent' | 'hybrid' | 'ids' | 'intervals' | 'knn' | 'match' | 'match_all' | 'match_bool_prefix' | 'match_none' | 'match_phrase' | 'match_phrase_prefix' | 'more_like_this' | 'multi_match' | 'nested' | 'neural' | 'parent_id' | 'percolate' | 'pinned' | 'prefix' | 'query_string' | 'range' | 'rank_feature' | 'regexp' | 'script' | 'script_score' | 'simple_query_string' | 'span_containing' | 'span_first' | 'span_multi' | 'span_near' | 'span_not' | 'span_or' | 'span_term' | 'span_within' | 'term' | 'terms' | 'terms_set' | 'type' | 'wildcard' | 'wrapper' | 'xy_shape'> & {
+    bool?: BoolQuery<T>;
+    boosting?: BoostingQuery<T>;
+    combined_fields?: CombinedFieldsQuery<T>;
+    common?: FieldQuery<T, Common_QueryDsl.CommonTermsQuery>;
+    constant_score?: ConstantScoreQuery<T>;
+    dis_max?: DisMaxQuery<T>;
+    distance_feature?: DistanceFeatureQuery<T>;
+    exists?: ExistsQuery<T>;
+    function_score?: FunctionScoreQuery<T>;
+    fuzzy?: FieldQuery<T, Common_QueryDsl.FuzzyQuery>;
+    geo_bounding_box?: GeoBoundingBoxQuery;
+    geo_distance?: GeoDistanceQuery;
+    geo_polygon?: GeoPolygonQuery<T>;
+    geo_shape?: GeoShapeQuery<T>;
+    has_child?: HasChildQuery<T>;
+    has_parent?: HasParentQuery<T>;
+    hybrid?: HybridQuery<T>;
+    ids?: IdsQuery;
+    intervals?: FieldQuery<T, IntervalsQuery>;
+    knn?: FieldQuery<T, KnnQuery<T>>;
+    match?: FieldQuery<T, MatchQuery>;
+    match_all?: MatchAllQuery;
+    match_bool_prefix?: FieldQuery<T, MatchBoolPrefixQuery<T>>;
+    match_none?: MatchNoneQuery;
+    match_phrase?: FieldQuery<T, MatchPhraseQuery<T>>;
+    match_phrase_prefix?: FieldQuery<T, MatchPhrasePrefixQuery<T>>;
+    more_like_this?: MoreLikeThisQuery<T>;
+    multi_match?: MultiMatchQuery<T>;
+    nested?: NestedQuery<T>;
+    neural?: FieldQuery<T, NeuralQuery<T>>;
+    parent_id?: ParentIdQuery;
+    percolate?: PercolateQuery<T>;
+    pinned?: PinnedQuery;
+    prefix?: FieldQuery<T, PrefixQuery<T>>;
+    query_string?: QueryStringQuery;
+    range?: FieldQuery<T, RangeQuery<T>>;
+    rank_feature?: RankFeatureQuery;
+    regexp?: FieldQuery<T, RegexpQuery<T>>;
+    script?: ScriptQuery;
+    script_score?: ScriptScoreQuery<T>;
+    simple_query_string?: SimpleQueryStringQuery<T>;
+    span_containing?: SpanContainingQuery<T>;
+    span_first?: SpanFirstQuery<T>;
+    span_multi?: SpanMultiTermQuery<T>;
+    span_near?: SpanNearQuery<T>;
+    span_not?: SpanNotQuery<T>;
+    span_or?: SpanOrQuery<T>;
+    span_term?: FieldQuery<T, SpanTermQuery<T>>;
+    span_within?: SpanWithinQuery<T>;
+    term?: FieldQuery<T, TermQuery<T>>;
+    terms?: TermsQuery<T>;
+    terms_set?: FieldQuery<T, TermsSetQuery<T>>;
+    type?: TypeQuery;
+    wildcard?: FieldQuery<T, WildcardQuery<T>>;
+    wrapper?: WrapperQuery;
+    xy_shape?: XyShapeQuery<T>;
+};
+type QueryStringQuery = Common_QueryDsl.QueryStringQuery;
+type RangeQuery<T> = Omit<Common_QueryDsl.RangeQuery, 'field'> & {
+    field: NestedPaths<T>;
+};
+type RankFeatureQuery = Common_QueryDsl.RankFeatureQuery;
+type RegexpQuery<T> = Omit<Common_QueryDsl.RegexpQuery, 'value' | 'field'> & {
+    field: NestedPaths<T>;
+    value: MapOpenSearchTypes<T>;
+};
+type ScriptQuery = Common_QueryDsl.ScriptQuery;
+type ScriptScoreQuery<T> = Omit<Common_QueryDsl.ScriptScoreQuery, 'query'> & {
+    query?: QueryContainer<T>;
+};
+type SimpleQueryStringQuery<T> = Omit<Common_QueryDsl.SimpleQueryStringQuery, 'fields'> & {
+    fields: NestedLeafPaths<T>[];
+};
+type SpanQuery<T> = Omit<Common_QueryDsl.SpanQuery, 'field_masking_span' | 'span_containing' | 'span_first' | 'span_multi' | 'span_near' | 'span_not' | 'span_or' | 'span_term' | 'span_within'> & {
+    field_masking_span?: SpanFieldMaskingQuery<T>;
+    span_containing?: SpanContainingQuery<T>;
+    span_first?: SpanFirstQuery<T>;
+    span_multi?: SpanMultiTermQuery<T>;
+    span_near?: SpanNearQuery<T>;
+    span_not?: SpanNotQuery<T>;
+    span_or?: SpanOrQuery<T>;
+    span_term?: Record<NestedPaths<T>, SpanTermQuery<T>>;
+    span_within?: SpanWithinQuery<T>;
+};
+type SpanContainingQuery<T> = Omit<Common_QueryDsl.SpanContainingQuery, 'big' | 'little'> & {
+    big: SpanQuery<T>;
+    little: SpanQuery<T>;
+};
+type SpanFieldMaskingQuery<T> = Omit<Common_QueryDsl.SpanFieldMaskingQuery, 'field' | 'query'> & {
+    field: NestedPaths<T>;
+    query: SpanQuery<T>;
+};
+type SpanFirstQuery<T> = Omit<Common_QueryDsl.SpanFirstQuery, 'match'> & {
+    match: SpanQuery<T>;
+};
+type SpanMultiTermQuery<T> = Omit<Common_QueryDsl.SpanMultiTermQuery, 'match'> & {
+    match: QueryContainer<T>;
+};
+type SpanNearQuery<T> = Omit<Common_QueryDsl.SpanNearQuery, 'clauses'> & {
+    clauses: SpanQuery<T>[];
+};
+type SpanNotQuery<T> = Omit<Common_QueryDsl.SpanNotQuery, 'include' | 'exclude'> & {
+    include: SpanQuery<T>;
+    exclude: SpanQuery<T>;
+};
+type SpanOrQuery<T> = Omit<Common_QueryDsl.SpanOrQuery, 'clauses'> & {
+    clauses: SpanQuery<T>[];
+};
+type SpanTermQuery<T> = Omit<Common_QueryDsl.SpanTermQuery, 'value' | 'field'> & {
+    field: NestedPaths<T>;
+    value: MapOpenSearchTypes<T>;
+};
+type SpanWithinQuery<T> = Omit<Common_QueryDsl.SpanWithinQuery, 'big' | 'little'> & {
+    big: SpanQuery<T>;
+    little: SpanQuery<T>;
+};
+type TermQuery<T> = Omit<Common_QueryDsl.TermQuery, 'value' | 'field'> & {
+    field: NestedPaths<T>;
+    value: MapOpenSearchTypes<T>;
+};
+type TermsQuery<T> = Omit<Common_QueryDsl.TermsQuery, 'terms' | 'field'> & {
+    field: NestedPaths<T>;
+    terms: FieldValue[];
+};
+type TermsSetQuery<T> = Omit<Common_QueryDsl.TermsSetQuery, 'terms' | 'field'> & {
+    field: NestedPaths<T>;
+    terms: FieldValue[];
+};
+type TypeQuery = Common_QueryDsl.TypeQuery;
+type WildcardQuery<T> = Omit<Common_QueryDsl.WildcardQuery, 'value' | 'field'> & {
+    field: NestedPaths<T>;
+    value: MapOpenSearchTypes<T>;
+};
+type WrapperQuery = Common_QueryDsl.WrapperQuery;
+type XyShapeQuery<T> = Omit<Common_QueryDsl.XyShapeQuery, 'field'> & {
+    field: NestedPaths<T>;
+};
+
+type FieldCollapse<T> = Omit<CoreSearch.FieldCollapse, 'field'> & {
+    field: NestedPaths<T>;
+};
+type Highlight<T> = Omit<CoreSearch.Highlight, 'fields'> & {
+    fields: FieldQuery<T, CoreSearch.HighlightField>;
+};
+type Hit<T extends IndexDefinition> = Omit<CoreSearch.Hit, '_source'> & {
+    _source: DocumentFor<T>;
+};
+type HitsMetadata<T extends IndexDefinition> = Omit<CoreSearch.HitsMetadata, 'hits'> & {
+    hits: Hit<T>[];
+};
+type SourceConfig<T> = boolean | SourceFilter<T>;
+type SourceFilter<T> = NestedPaths<T>[] | {
+    excludes?: NestedPaths<T>[];
+    includes?: NestedPaths<T>[];
+};
+
+type SearchRequest<T extends IndexDefinition> = Omit<Search_Request, 'body' | 'index'> & {
+    index: T['index'];
+    body: SearchRequestBody<T>;
+};
+type SearchRequestBody<T extends IndexDefinition> = Omit<Search_RequestBody, 'query' | 'collapse' | 'highlight' | 'sort' | '_source'> & {
+    query?: QueryContainer<MapQueryProperties<T>>;
+    collapse?: FieldCollapse<MapQueryProperties<T>>;
+    highlight?: Highlight<MapQueryProperties<T>>;
+    sort?: Sort<MapQueryProperties<T>>;
+    _source?: SourceConfig<MapQueryProperties<T>>;
+};
+type SearchResponse<T extends IndexDefinition> = Omit<Search_Response, 'body'> & {
+    body: SearchResponseBody<T>;
+};
+type SearchResponseBody<T extends IndexDefinition> = Omit<Search_ResponseBody, 'hits'> & {
+    hits: HitsMetadata<T>;
+};
+
+interface IndexRequest<T> extends Omit<Index_Request, 'body' | 'index'> {
+    index: T extends {
+        index: infer I;
+    } ? I : never;
+    body: T extends {
+        body: {
+            mappings: {
+                properties: infer P;
+            };
         };
-    };
-    mappings?: {
-        properties?: IndexProperties<ExcludeId<T>>;
-    };
-    aliases?: Record<string, Record<string, never>>;
+    } ? MapOpenSearchTypes<P> : never;
+}
+interface IndexResponse extends Index_Response {
+}
+type IndicesExistsRequest<T extends IndexDefinition> = Omit<Indices_Exists_Request, 'index'> & {
+    index: Extract<T['index'], string>;
 };
 
-interface OpenSearchHelper extends Client {
-    typedSearch: <DataType extends WithId, ReturnType = DataType>(query: OpenSearchQuery<DataType, ReturnType>) => Promise<{
-        results: ReturnType[];
-        response: ApiResponse<opensearchtypes.SearchResponse<ExcludeId<ReturnType>>, unknown>;
-    }>;
-    typedIndex: <DataType extends WithId>(index: string, data: DataType) => Promise<ApiResponse<Record<string, any>, unknown> | undefined>;
-    typedUpsert: <DataType extends WithId>(index: string, data: DataType) => Promise<ApiResponse<Record<string, any>, unknown> | undefined>;
-    typedBulkUpsert: <DataType extends WithId>(index: string, data: DataType[]) => Promise<ApiResponse<Record<string, any>, unknown> | undefined>;
-    typedIndexCreate: <DataType extends WithId>(index: string, options: IndexOptions<DataType>) => Promise<ApiResponse<Record<string, any>, unknown> | undefined>;
+type TypedIndices = Omit<Indices, 'exists'> & {
+    exists<T extends IndexDefinition>(params: IndicesExistsRequest<T>, options?: TransportRequestOptions): TransportRequestPromise<Indices_Exists_Response>;
+};
+/**
+ * ✅ Constructor type that ensures `new OpenSearchClient()` works.
+ * - This type is necessary because `OpenSearchClient` is actually a function (not a class).
+ */
+type OpenSearchClientConstructor = new (...args: ConstructorParameters<typeof Client>) => OpenSearchClient;
+/**
+ * ✅ Custom interface that extends `Client`, but replaces the `search()` method signature.
+ * - Uses `Omit<Client, "search">` to remove `search()` from `Client`.
+ * - Defines a new `search<T>()` method with stricter type safety.
+ */
+interface OpenSearchClient extends Omit<Client, 'search' | 'index' | 'bulk' | 'indices'> {
+    search<T extends IndexDefinition>(params: SearchRequest<T>, options?: TransportRequestOptions): TransportRequestPromise<SearchResponse<T>>;
+    index<T extends IndexDefinition>(params: IndexRequest<T>, options?: TransportRequestOptions): TransportRequestPromise<Index_Response>;
+    bulk<T extends IndexDefinition>(params: BulkRequest<T>, options?: TransportRequestOptions): TransportRequestPromise<BulkResponse<T>>;
+    indices: TypedIndices;
 }
-declare const helper: (client: Client) => OpenSearchHelper;
+/**
+ * ✅ A function that behaves like a class constructor.
+ * - Instantiates a new `Client` internally.
+ * - Casts the instance to `OpenSearchClient` so TypeScript recognizes the new `search<T>()` signature.
+ * - The `as unknown as` trick ensures `new OpenSearchClient()` is valid.
+ */
+declare const OpenSearchClient: OpenSearchClientConstructor;
+
+type IdFunction<T extends IndexDefinition> = (doc: DocumentFor<T>) => Common$1.Id;
+/**
+ * Constructs a bulk request payload for indexing documents.
+ *
+ * For each document in the provided array, this helper creates a two‑line bulk operation:
+ *   1. An action object for an index operation. If an id generator is provided, its result is used as _id.
+ *   2. The document itself.
+ *
+ * @param index - The name of the index.
+ * @param docs  - An array of documents to insert.
+ * @param idFn  - Optional function that returns an _id for a given document.
+ * @returns A BulkRequest payload for insert operations.
+ */
+declare function bulkIndex<T extends IndexDefinition>(index: T['index'], docs: DocumentFor<T>[], idFn?: IdFunction<T>): BulkRequest<T>;
+/**
+ * Constructs a bulk request payload for creating documents.
+ *
+ * For each document in the provided array, this helper creates a two‑line bulk operation:
+ *   1. An action object for a create operation with a generated _id.
+ *   2. The document itself.
+ *
+ * @param index - The name of the index.
+ * @param docs  - An array of documents to create.
+ * @param idFn  - A function that returns a unique _id for each document.
+ * @returns A BulkRequest payload for create operations.
+ */
+declare function bulkCreate<T extends IndexDefinition>(index: T['index'], docs: DocumentFor<T>[], idFn: IdFunction<T>): BulkRequest<T>;
+/**
+ * Constructs a bulk request payload for update operations.
+ *
+ * This helper takes an array of update actions (of type UpdateAction<T>),
+ * splits each into its action metadata and payload (with the `doc` and/or `upsert` properties),
+ * and returns a BulkRequest payload formatted as a flat array.
+ *
+ * @param index - The name of the index.
+ * @param updates - An array of update actions.
+ * @param idFn  - A function that returns a unique _id for each document.
+ * @returns A BulkRequest payload for update operations.
+ */
+declare function bulkUpdate<T extends IndexDefinition>(index: T['index'], updates: UpdateAction<T>[], idFn: IdFunction<T>): BulkRequest<T>;
+/**
+ * Constructs a bulk request payload for deleting documents.
+ *
+ * For each document in the provided array, this helper creates a single‑line bulk operation:
+ *   { delete: { _id: <id> } }
+ * The provided id generator function is used to compute the _id for each document.
+ *
+ * @param index - The name of the index.
+ * @param docs  - An array of documents to delete.
+ * @param idFn  - A function that returns the _id for a given document.
+ * @returns A BulkRequest payload for delete operations.
+ */
+declare function bulkDelete<T extends IndexDefinition>(index: T['index'], ids: Common$1.Id[]): BulkRequest<T>;
 
-export { type OpenSearchHelper, helper };
+export { type BoolQuery, type BoostingQuery, type BulkRequest, type BulkResponse, type CombinedFieldsQuery, type CommonTermsQuery, type ConstantScoreQuery, type DateDecayFunction, type DateDistanceFeatureQuery, type DateRangeQuery, type DecayFunction, type DecayFunctionBase, type DeepPartial, type DisMaxQuery, type DistanceFeatureQuery, type DocumentFor, type ExistsQuery, type FieldAndFormat, type FieldQuery, type FieldValueFactorScoreFunction, type FunctionBoostMode, type FunctionScoreQuery, type FuzzyQuery, type GeoBoundingBoxQuery, type GeoDecayFunction, type GeoDistanceFeatureQuery, type GeoDistanceQuery, type GeoExecution, type GeoPolygonQuery, type GeoShapeQuery, type GeoValidationMethod, type HasChildQuery, type HasParentQuery, type HybridQuery, type IdFunction, type IdsQuery, type IndexDefinition, type IndexRequest, type IndexResponse, type IntervalsQuery, type KnnQuery, type Like, type LikeDocument, type MatchAllQuery, type MatchBoolPrefixQuery, type MatchNoneQuery, type MatchPhrasePrefixQuery, type MatchPhraseQuery, type MatchQuery, type MoreLikeThisQuery, type MultiMatchQuery, type NestedQuery, type NeuralQuery, type NumberRangeQuery, OpenSearchClient, type ParentIdQuery, type PercolateQuery, type PinnedQuery, type PrefixQuery, type Primitive, type QueryContainer, type QueryStringQuery, type RangeQuery, type RankFeatureQuery, type RegexpQuery, type ScriptQuery, type ScriptScoreQuery, type SearchRequest, type SearchResponse, type SimpleQueryStringQuery, type SpanContainingQuery, type SpanFieldMaskingQuery, type SpanFirstQuery, type SpanMultiTermQuery, type SpanNearQuery, type SpanNotQuery, type SpanOrQuery, type SpanQuery, type SpanTermQuery, type SpanWithinQuery, type TermQuery, type TermsQuery, type TermsSetQuery, type TypeQuery, type UpdateAction, type WildcardQuery, type WrapperQuery, type XyShapeQuery, bulkCreate, bulkDelete, bulkIndex, bulkUpdate };