@distilled.cloud/typesense 0.30.3 → 1.0.0-rc.10

package/lib/services/typesense.d.ts

@@ -0,0 +1,2829 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type TypesenseOpError, type TypesenseOpContext } from "../protocol.ts";
+export type { TypesenseOpError, TypesenseOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+export interface ClearCacheRequest {
+}
+export declare const ClearCacheRequest: S.Schema<ClearCacheRequest>;
+export interface SuccessStatus {
+    success: boolean;
+}
+export declare const SuccessStatus: S.Schema<SuccessStatus>;
+export interface CompactDbRequest {
+}
+export declare const CompactDbRequest: S.Schema<CompactDbRequest>;
+export type CreateAnalyticsEventRequestDataDocIdsList = Array<string>;
+export declare const CreateAnalyticsEventRequestDataDocIdsList: S.Schema<CreateAnalyticsEventRequestDataDocIdsList>;
+/** Event payload */
+export interface CreateAnalyticsEventRequestData {
+    user_id?: string;
+    doc_id?: string;
+    doc_ids?: CreateAnalyticsEventRequestDataDocIdsList;
+    q?: string;
+    analytics_tag?: string;
+}
+export declare const CreateAnalyticsEventRequestData: S.Schema<CreateAnalyticsEventRequestData>;
+export interface CreateAnalyticsEventRequest {
+    /** Name of the analytics rule this event corresponds to */
+    name: string;
+    /** Type of event (e.g., click, conversion, query, visit) */
+    event_type: string;
+    /** Event payload */
+    data: CreateAnalyticsEventRequestData;
+}
+export declare const CreateAnalyticsEventRequest: S.Schema<CreateAnalyticsEventRequest>;
+export interface AnalyticsEventCreateResponse {
+    ok: boolean;
+}
+export declare const AnalyticsEventCreateResponse: S.Schema<AnalyticsEventCreateResponse>;
+export type AnalyticsRuleType = "popular_queries" | "nohits_queries" | "counter" | "log";
+export declare const AnalyticsRuleType: any;
+export type AnalyticsRuleCreateParamsMetaFieldsList = Array<string>;
+export declare const AnalyticsRuleCreateParamsMetaFieldsList: S.Schema<AnalyticsRuleCreateParamsMetaFieldsList>;
+export interface AnalyticsRuleCreateParams {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: AnalyticsRuleCreateParamsMetaFieldsList;
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+}
+export declare const AnalyticsRuleCreateParams: S.Schema<AnalyticsRuleCreateParams>;
+export interface AnalyticsRuleCreate {
+    name: string;
+    type: AnalyticsRuleType | (string & {});
+    collection: string;
+    event_type: string;
+    rule_tag?: string;
+    params?: AnalyticsRuleCreateParams;
+}
+export declare const AnalyticsRuleCreate: S.Schema<AnalyticsRuleCreate>;
+export type CreateAnalyticsRuleRequestBodyCase1List = Array<AnalyticsRuleCreate>;
+export declare const CreateAnalyticsRuleRequestBodyCase1List: S.Schema<CreateAnalyticsRuleRequestBodyCase1List>;
+export type CreateAnalyticsRuleRequestBody = AnalyticsRuleCreate | CreateAnalyticsRuleRequestBodyCase1List;
+export declare const CreateAnalyticsRuleRequestBody: any;
+export interface CreateAnalyticsRuleRequest {
+    body: CreateAnalyticsRuleRequestBody;
+}
+export declare const CreateAnalyticsRuleRequest: S.Schema<CreateAnalyticsRuleRequest>;
+export type AnalyticsRuleParamsMetaFieldsList = Array<string>;
+export declare const AnalyticsRuleParamsMetaFieldsList: S.Schema<AnalyticsRuleParamsMetaFieldsList>;
+export interface AnalyticsRuleParams {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: AnalyticsRuleParamsMetaFieldsList;
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+}
+export declare const AnalyticsRuleParams: S.Schema<AnalyticsRuleParams>;
+export interface AnalyticsRule {
+    name: string;
+    type: AnalyticsRuleType;
+    collection: string;
+    event_type: string;
+    rule_tag?: string;
+    params?: AnalyticsRuleParams;
+}
+export declare const AnalyticsRule: S.Schema<AnalyticsRule>;
+export interface CreateAnalyticsRuleResponseBodyCase1ItemCase1 {
+    error?: string;
+}
+export declare const CreateAnalyticsRuleResponseBodyCase1ItemCase1: S.Schema<CreateAnalyticsRuleResponseBodyCase1ItemCase1>;
+export type CreateAnalyticsRuleResponseBodyCase1Item = AnalyticsRule | CreateAnalyticsRuleResponseBodyCase1ItemCase1;
+export declare const CreateAnalyticsRuleResponseBodyCase1Item: any;
+export type CreateAnalyticsRuleResponseBodyCase1List = Array<CreateAnalyticsRuleResponseBodyCase1Item>;
+export declare const CreateAnalyticsRuleResponseBodyCase1List: S.Schema<CreateAnalyticsRuleResponseBodyCase1List>;
+export type CreateAnalyticsRuleResponseBody = AnalyticsRule | CreateAnalyticsRuleResponseBodyCase1List;
+export declare const CreateAnalyticsRuleResponseBody: any;
+export type CreateAnalyticsRuleResponse = CreateAnalyticsRuleResponseBody;
+export declare const CreateAnalyticsRuleResponse: S.Schema<CreateAnalyticsRuleResponse>;
+/** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+export type FieldTokenSeparatorsList = Array<string>;
+export declare const FieldTokenSeparatorsList: S.Schema<FieldTokenSeparatorsList>;
+/** List of symbols or special characters to be indexed. */
+export type FieldSymbolsToIndexList = Array<string>;
+export declare const FieldSymbolsToIndexList: S.Schema<FieldSymbolsToIndexList>;
+export type FieldEmbedFromList = Array<string>;
+export declare const FieldEmbedFromList: S.Schema<FieldEmbedFromList>;
+export interface FieldEmbedModelConfig {
+    model_name: string;
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    url?: string;
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    client_id?: string;
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    project_id?: string;
+    indexing_prefix?: string;
+    query_prefix?: string;
+}
+export declare const FieldEmbedModelConfig: S.Schema<FieldEmbedModelConfig>;
+export interface FieldEmbed {
+    from: FieldEmbedFromList;
+    model_config: FieldEmbedModelConfig;
+}
+export declare const FieldEmbed: S.Schema<FieldEmbed>;
+export interface Field {
+    name: string;
+    type: string;
+    optional?: boolean;
+    facet?: boolean;
+    index?: boolean;
+    locale?: string;
+    sort?: boolean;
+    infix?: boolean;
+    /** Name of a field in another collection that should be linked to this collection so that it can be joined during query. */
+    reference?: string;
+    /** Allow documents to be indexed successfully even when the referenced document doesn't exist yet. */
+    async_reference?: boolean;
+    num_dim?: number;
+    drop?: boolean;
+    /** When set to false, the field value will not be stored on disk. Default: true. */
+    store?: boolean;
+    /** The distance metric to be used for vector search. Default: `cosine`. You can also use `ip` for inner product. */
+    vec_dist?: string;
+    /** Enables an index optimized for range filtering on numerical fields (e.g. rating:>3.5). Default: false. */
+    range_index?: boolean;
+    /** Values are stemmed before indexing in-memory. Default: false. */
+    stem?: boolean;
+    /** Name of the stemming dictionary to use for this field */
+    stem_dictionary?: string;
+    /** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+    token_separators?: FieldTokenSeparatorsList;
+    /** List of symbols or special characters to be indexed. */
+    symbols_to_index?: FieldSymbolsToIndexList;
+    embed?: FieldEmbed;
+}
+export declare const Field: S.Schema<Field>;
+/** A list of fields for querying, filtering and faceting */
+export type CreateCollectionRequestFieldsList = Array<Field>;
+export declare const CreateCollectionRequestFieldsList: S.Schema<CreateCollectionRequestFieldsList>;
+/** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+export type CreateCollectionRequestTokenSeparatorsList = Array<string>;
+export declare const CreateCollectionRequestTokenSeparatorsList: S.Schema<CreateCollectionRequestTokenSeparatorsList>;
+/** List of synonym set names to associate with this collection */
+export type CreateCollectionRequestSynonymSetsList = Array<string>;
+export declare const CreateCollectionRequestSynonymSetsList: S.Schema<CreateCollectionRequestSynonymSetsList>;
+/** List of symbols or special characters to be indexed. */
+export type CreateCollectionRequestSymbolsToIndexList = Array<string>;
+export declare const CreateCollectionRequestSymbolsToIndexList: S.Schema<CreateCollectionRequestSymbolsToIndexList>;
+/** Configuration for the voice query model */
+export interface VoiceQueryModelCollectionConfig {
+    model_name?: string;
+}
+export declare const VoiceQueryModelCollectionConfig: S.Schema<VoiceQueryModelCollectionConfig>;
+export interface CreateCollectionRequest {
+    /** Name of the collection */
+    name: string;
+    /** A list of fields for querying, filtering and faceting */
+    fields: CreateCollectionRequestFieldsList;
+    /** The name of an int32 / float field that determines the order in which the search results are ranked when a sort_by clause is not provided during searching. This field must indicate some kind of popularity. */
+    default_sorting_field?: string;
+    /** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+    token_separators?: CreateCollectionRequestTokenSeparatorsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: CreateCollectionRequestSynonymSetsList;
+    /** Enables experimental support at a collection level for nested object or object array fields. This field is only available if the Typesense server is version `0.24.0.rcn34` or later. */
+    enable_nested_fields?: boolean;
+    /** List of symbols or special characters to be indexed. */
+    symbols_to_index?: CreateCollectionRequestSymbolsToIndexList;
+    voice_query_model?: VoiceQueryModelCollectionConfig;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+}
+export declare const CreateCollectionRequest: S.Schema<CreateCollectionRequest>;
+/** A list of fields for querying, filtering and faceting */
+export type CreateCollectionResponseFieldsList = Array<Field>;
+export declare const CreateCollectionResponseFieldsList: S.Schema<CreateCollectionResponseFieldsList>;
+/** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+export type CreateCollectionResponseTokenSeparatorsList = Array<string>;
+export declare const CreateCollectionResponseTokenSeparatorsList: S.Schema<CreateCollectionResponseTokenSeparatorsList>;
+/** List of synonym set names to associate with this collection */
+export type CreateCollectionResponseSynonymSetsList = Array<string>;
+export declare const CreateCollectionResponseSynonymSetsList: S.Schema<CreateCollectionResponseSynonymSetsList>;
+/** List of symbols or special characters to be indexed. */
+export type CreateCollectionResponseSymbolsToIndexList = Array<string>;
+export declare const CreateCollectionResponseSymbolsToIndexList: S.Schema<CreateCollectionResponseSymbolsToIndexList>;
+export interface CreateCollectionResponse {
+    /** Name of the collection */
+    name: string;
+    /** A list of fields for querying, filtering and faceting */
+    fields: CreateCollectionResponseFieldsList;
+    /** The name of an int32 / float field that determines the order in which the search results are ranked when a sort_by clause is not provided during searching. This field must indicate some kind of popularity. */
+    default_sorting_field?: string;
+    /** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+    token_separators?: CreateCollectionResponseTokenSeparatorsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: CreateCollectionResponseSynonymSetsList;
+    /** Enables experimental support at a collection level for nested object or object array fields. This field is only available if the Typesense server is version `0.24.0.rcn34` or later. */
+    enable_nested_fields?: boolean;
+    /** List of symbols or special characters to be indexed. */
+    symbols_to_index?: CreateCollectionResponseSymbolsToIndexList;
+    voice_query_model?: VoiceQueryModelCollectionConfig;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+    /** Number of documents in the collection */
+    num_documents: number;
+    /** Timestamp of when the collection was created (Unix epoch in seconds) */
+    created_at: number;
+}
+export declare const CreateCollectionResponse: S.Schema<CreateCollectionResponse>;
+export interface CreateConversationModelRequest {
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id?: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const CreateConversationModelRequest: S.Schema<CreateConversationModelRequest>;
+export interface CreateConversationModelResponse {
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const CreateConversationModelResponse: S.Schema<CreateConversationModelResponse>;
+export type CreateKeyRequestActionsList = Array<string>;
+export declare const CreateKeyRequestActionsList: S.Schema<CreateKeyRequestActionsList>;
+export type CreateKeyRequestCollectionsList = Array<string>;
+export declare const CreateKeyRequestCollectionsList: S.Schema<CreateKeyRequestCollectionsList>;
+export interface CreateKeyRequest {
+    value?: string;
+    description: string;
+    actions: CreateKeyRequestActionsList;
+    collections: CreateKeyRequestCollectionsList;
+    expires_at?: number;
+}
+export declare const CreateKeyRequest: S.Schema<CreateKeyRequest>;
+export type CreateKeyResponseActionsList = Array<string>;
+export declare const CreateKeyResponseActionsList: S.Schema<CreateKeyResponseActionsList>;
+export type CreateKeyResponseCollectionsList = Array<string>;
+export declare const CreateKeyResponseCollectionsList: S.Schema<CreateKeyResponseCollectionsList>;
+export interface CreateKeyResponse {
+    value?: string;
+    description: string;
+    actions: CreateKeyResponseActionsList;
+    collections: CreateKeyResponseCollectionsList;
+    expires_at?: number;
+    id?: number;
+    value_prefix?: string;
+}
+export declare const CreateKeyResponse: S.Schema<CreateKeyResponse>;
+/** Stop sequences for the NL model (Google-specific) */
+export type CreateNLSearchModelRequestStopSequencesList = Array<string>;
+export declare const CreateNLSearchModelRequestStopSequencesList: S.Schema<CreateNLSearchModelRequestStopSequencesList>;
+export interface CreateNLSearchModelRequest {
+    /** Name of the NL model to use */
+    model_name?: string;
+    /** API key for the NL model service */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Custom API URL for the NL model service */
+    api_url?: string;
+    /** Maximum number of bytes to process */
+    max_bytes?: number;
+    /** Temperature parameter for the NL model */
+    temperature?: number;
+    /** System prompt for the NL model */
+    system_prompt?: string;
+    /** Top-p parameter for the NL model (Google-specific) */
+    top_p?: number;
+    /** Top-k parameter for the NL model (Google-specific) */
+    top_k?: number;
+    /** Stop sequences for the NL model (Google-specific) */
+    stop_sequences?: CreateNLSearchModelRequestStopSequencesList;
+    /** API version for the NL model service */
+    api_version?: string;
+    /** Project ID for GCP Vertex AI */
+    project_id?: string;
+    /** Access token for GCP Vertex AI */
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Refresh token for GCP Vertex AI */
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Client ID for GCP Vertex AI */
+    client_id?: string;
+    /** Client secret for GCP Vertex AI */
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    /** Region for GCP Vertex AI */
+    region?: string;
+    /** Maximum output tokens for GCP Vertex AI */
+    max_output_tokens?: number;
+    /** Account ID for Cloudflare-specific models */
+    account_id?: string;
+    /** Optional ID for the NL search model */
+    id?: string;
+}
+export declare const CreateNLSearchModelRequest: S.Schema<CreateNLSearchModelRequest>;
+/** Stop sequences for the NL model (Google-specific) */
+export type CreateNLSearchModelResponseStopSequencesList = Array<string>;
+export declare const CreateNLSearchModelResponseStopSequencesList: S.Schema<CreateNLSearchModelResponseStopSequencesList>;
+export interface CreateNLSearchModelResponse {
+    /** Name of the NL model to use */
+    model_name?: string;
+    /** API key for the NL model service */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Custom API URL for the NL model service */
+    api_url?: string;
+    /** Maximum number of bytes to process */
+    max_bytes?: number;
+    /** Temperature parameter for the NL model */
+    temperature?: number;
+    /** System prompt for the NL model */
+    system_prompt?: string;
+    /** Top-p parameter for the NL model (Google-specific) */
+    top_p?: number;
+    /** Top-k parameter for the NL model (Google-specific) */
+    top_k?: number;
+    /** Stop sequences for the NL model (Google-specific) */
+    stop_sequences?: CreateNLSearchModelResponseStopSequencesList;
+    /** API version for the NL model service */
+    api_version?: string;
+    /** Project ID for GCP Vertex AI */
+    project_id?: string;
+    /** Access token for GCP Vertex AI */
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Refresh token for GCP Vertex AI */
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Client ID for GCP Vertex AI */
+    client_id?: string;
+    /** Client secret for GCP Vertex AI */
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    /** Region for GCP Vertex AI */
+    region?: string;
+    /** Maximum output tokens for GCP Vertex AI */
+    max_output_tokens?: number;
+    /** Account ID for Cloudflare-specific models */
+    account_id?: string;
+    /** Optional ID for the NL search model */
+    id: string;
+}
+export declare const CreateNLSearchModelResponse: S.Schema<CreateNLSearchModelResponse>;
+export interface DebugRequest {
+}
+export declare const DebugRequest: S.Schema<DebugRequest>;
+export interface DebugResponse {
+    version?: string;
+}
+export declare const DebugResponse: S.Schema<DebugResponse>;
+export interface DeleteAliasRequest {
+    /** The name of the alias to delete */
+    aliasName: string;
+}
+export declare const DeleteAliasRequest: S.Schema<DeleteAliasRequest>;
+export interface CollectionAlias {
+    /** Name of the collection alias */
+    name: string;
+    /** Name of the collection the alias mapped to */
+    collection_name: string;
+}
+export declare const CollectionAlias: S.Schema<CollectionAlias>;
+export interface DeleteAnalyticsRuleRequest {
+    /** The name of the analytics rule to delete */
+    ruleName: string;
+}
+export declare const DeleteAnalyticsRuleRequest: S.Schema<DeleteAnalyticsRuleRequest>;
+export type DeleteAnalyticsRuleResponseParamsMetaFieldsList = Array<string>;
+export declare const DeleteAnalyticsRuleResponseParamsMetaFieldsList: S.Schema<DeleteAnalyticsRuleResponseParamsMetaFieldsList>;
+export interface DeleteAnalyticsRuleResponseParams {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: DeleteAnalyticsRuleResponseParamsMetaFieldsList;
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+}
+export declare const DeleteAnalyticsRuleResponseParams: S.Schema<DeleteAnalyticsRuleResponseParams>;
+export interface DeleteAnalyticsRuleResponse {
+    name: string;
+    type: AnalyticsRuleType;
+    collection: string;
+    event_type: string;
+    rule_tag?: string;
+    params?: DeleteAnalyticsRuleResponseParams;
+}
+export declare const DeleteAnalyticsRuleResponse: S.Schema<DeleteAnalyticsRuleResponse>;
+export interface DeleteCollectionRequest {
+    /** The name of the collection to delete */
+    collectionName: string;
+}
+export declare const DeleteCollectionRequest: S.Schema<DeleteCollectionRequest>;
+/** A list of fields for querying, filtering and faceting */
+export type DeleteCollectionResponseFieldsList = Array<Field>;
+export declare const DeleteCollectionResponseFieldsList: S.Schema<DeleteCollectionResponseFieldsList>;
+/** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+export type DeleteCollectionResponseTokenSeparatorsList = Array<string>;
+export declare const DeleteCollectionResponseTokenSeparatorsList: S.Schema<DeleteCollectionResponseTokenSeparatorsList>;
+/** List of synonym set names to associate with this collection */
+export type DeleteCollectionResponseSynonymSetsList = Array<string>;
+export declare const DeleteCollectionResponseSynonymSetsList: S.Schema<DeleteCollectionResponseSynonymSetsList>;
+/** List of symbols or special characters to be indexed. */
+export type DeleteCollectionResponseSymbolsToIndexList = Array<string>;
+export declare const DeleteCollectionResponseSymbolsToIndexList: S.Schema<DeleteCollectionResponseSymbolsToIndexList>;
+export interface DeleteCollectionResponse {
+    /** Name of the collection */
+    name: string;
+    /** A list of fields for querying, filtering and faceting */
+    fields: DeleteCollectionResponseFieldsList;
+    /** The name of an int32 / float field that determines the order in which the search results are ranked when a sort_by clause is not provided during searching. This field must indicate some kind of popularity. */
+    default_sorting_field?: string;
+    /** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+    token_separators?: DeleteCollectionResponseTokenSeparatorsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: DeleteCollectionResponseSynonymSetsList;
+    /** Enables experimental support at a collection level for nested object or object array fields. This field is only available if the Typesense server is version `0.24.0.rcn34` or later. */
+    enable_nested_fields?: boolean;
+    /** List of symbols or special characters to be indexed. */
+    symbols_to_index?: DeleteCollectionResponseSymbolsToIndexList;
+    voice_query_model?: VoiceQueryModelCollectionConfig;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+    /** Number of documents in the collection */
+    num_documents: number;
+    /** Timestamp of when the collection was created (Unix epoch in seconds) */
+    created_at: number;
+}
+export declare const DeleteCollectionResponse: S.Schema<DeleteCollectionResponse>;
+export interface DeleteConversationModelRequest {
+    /** The id of the conversation model to delete */
+    modelId: string;
+}
+export declare const DeleteConversationModelRequest: S.Schema<DeleteConversationModelRequest>;
+export interface DeleteConversationModelResponse {
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const DeleteConversationModelResponse: S.Schema<DeleteConversationModelResponse>;
+export interface DeleteCurationSetRequest {
+    /** The name of the curation set to delete */
+    curationSetName: string;
+}
+export declare const DeleteCurationSetRequest: S.Schema<DeleteCurationSetRequest>;
+export interface CurationSetDeleteSchema {
+    /** Name of the deleted curation set */
+    name: string;
+}
+export declare const CurationSetDeleteSchema: S.Schema<CurationSetDeleteSchema>;
+export interface DeleteCurationSetItemRequest {
+    /** The name of the curation set */
+    curationSetName: string;
+    /** The id of the curation item to delete */
+    itemId: string;
+}
+export declare const DeleteCurationSetItemRequest: S.Schema<DeleteCurationSetItemRequest>;
+export interface CurationItemDeleteSchema {
+    /** ID of the deleted curation item */
+    id: string;
+}
+export declare const CurationItemDeleteSchema: S.Schema<CurationItemDeleteSchema>;
+export interface DeleteDocumentRequest {
+    /** The name of the collection to search for the document under */
+    collectionName: string;
+    /** The Document ID */
+    documentId: string;
+}
+export declare const DeleteDocumentRequest: S.Schema<DeleteDocumentRequest>;
+export type DeleteDocumentResponse = unknown;
+export declare const DeleteDocumentResponse: S.Schema<DeleteDocumentResponse>;
+export interface DeleteDocumentsRequestDeleteDocumentsParameters {
+    filter_by: string;
+    /** Batch size parameter controls the number of documents that should be deleted at a time. A larger value will speed up deletions, but will impact performance of other operations running on the server. */
+    batch_size?: number;
+    ignore_not_found?: boolean;
+    /** When true, removes all documents from the collection while preserving the collection and its schema. */
+    truncate?: boolean;
+}
+export declare const DeleteDocumentsRequestDeleteDocumentsParameters: S.Schema<DeleteDocumentsRequestDeleteDocumentsParameters>;
+export interface DeleteDocumentsRequest {
+    /** The name of the collection to delete documents from */
+    collectionName: string;
+    deleteDocumentsParameters?: DeleteDocumentsRequestDeleteDocumentsParameters;
+}
+export declare const DeleteDocumentsRequest: S.Schema<DeleteDocumentsRequest>;
+export interface DeleteDocumentsResponse {
+    num_deleted: number;
+}
+export declare const DeleteDocumentsResponse: S.Schema<DeleteDocumentsResponse>;
+export interface DeleteKeyRequest {
+    /** The ID of the key to delete */
+    keyId: number;
+}
+export declare const DeleteKeyRequest: S.Schema<DeleteKeyRequest>;
+export interface ApiKeyDeleteResponse {
+    /** The id of the API key that was deleted */
+    id: number;
+}
+export declare const ApiKeyDeleteResponse: S.Schema<ApiKeyDeleteResponse>;
+export interface DeleteNLSearchModelRequest {
+    /** The ID of the NL search model to delete */
+    modelId: string;
+}
+export declare const DeleteNLSearchModelRequest: S.Schema<DeleteNLSearchModelRequest>;
+export interface NLSearchModelDeleteSchema {
+    /** ID of the deleted NL search model */
+    id: string;
+}
+export declare const NLSearchModelDeleteSchema: S.Schema<NLSearchModelDeleteSchema>;
+export interface DeletePresetRequest {
+    /** The ID of the preset to delete. */
+    presetId: string;
+}
+export declare const DeletePresetRequest: S.Schema<DeletePresetRequest>;
+export interface PresetDeleteSchema {
+    name: string;
+}
+export declare const PresetDeleteSchema: S.Schema<PresetDeleteSchema>;
+export interface DeleteStopwordsSetRequest {
+    /** The ID of the stopwords set to delete. */
+    setId: string;
+}
+export declare const DeleteStopwordsSetRequest: S.Schema<DeleteStopwordsSetRequest>;
+export interface DeleteStopwordsSetResponse {
+    id: string;
+}
+export declare const DeleteStopwordsSetResponse: S.Schema<DeleteStopwordsSetResponse>;
+export interface DeleteSynonymSetRequest {
+    /** The name of the synonym set to delete */
+    synonymSetName: string;
+}
+export declare const DeleteSynonymSetRequest: S.Schema<DeleteSynonymSetRequest>;
+export interface SynonymSetDeleteSchema {
+    /** Name of the deleted synonym set */
+    name: string;
+}
+export declare const SynonymSetDeleteSchema: S.Schema<SynonymSetDeleteSchema>;
+export interface DeleteSynonymSetItemRequest {
+    /** The name of the synonym set */
+    synonymSetName: string;
+    /** The id of the synonym item to delete */
+    itemId: string;
+}
+export declare const DeleteSynonymSetItemRequest: S.Schema<DeleteSynonymSetItemRequest>;
+export interface SynonymItemDeleteSchema {
+    /** ID of the deleted synonym item */
+    id: string;
+}
+export declare const SynonymItemDeleteSchema: S.Schema<SynonymItemDeleteSchema>;
+export interface ExportDocumentsRequestExportDocumentsParameters {
+    /** Filter conditions for refining your search results. Separate multiple conditions with &&. */
+    filter_by?: string;
+    /** List of fields from the document to include in the search result */
+    include_fields?: string;
+    /** List of fields from the document to exclude in the search result */
+    exclude_fields?: string;
+}
+export declare const ExportDocumentsRequestExportDocumentsParameters: S.Schema<ExportDocumentsRequestExportDocumentsParameters>;
+export interface ExportDocumentsRequest {
+    /** The name of the collection */
+    collectionName: string;
+    exportDocumentsParameters?: ExportDocumentsRequestExportDocumentsParameters;
+}
+export declare const ExportDocumentsRequest: S.Schema<ExportDocumentsRequest>;
+export interface ExportDocumentsResponse {
+}
+export declare const ExportDocumentsResponse: S.Schema<ExportDocumentsResponse>;
+export interface FlushAnalyticsRequest {
+}
+export declare const FlushAnalyticsRequest: S.Schema<FlushAnalyticsRequest>;
+export interface GetAliasRequest {
+    /** The name of the alias to retrieve */
+    aliasName: string;
+}
+export declare const GetAliasRequest: S.Schema<GetAliasRequest>;
+export interface GetAliasesRequest {
+}
+export declare const GetAliasesRequest: S.Schema<GetAliasesRequest>;
+export type CollectionAliasesResponseAliasesList = Array<CollectionAlias>;
+export declare const CollectionAliasesResponseAliasesList: S.Schema<CollectionAliasesResponseAliasesList>;
+export interface CollectionAliasesResponse {
+    aliases: CollectionAliasesResponseAliasesList;
+}
+export declare const CollectionAliasesResponse: S.Schema<CollectionAliasesResponse>;
+export interface GetAllConversationModelsRequest {
+}
+export declare const GetAllConversationModelsRequest: S.Schema<GetAllConversationModelsRequest>;
+export interface ConversationModelSchema {
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const ConversationModelSchema: S.Schema<ConversationModelSchema>;
+export type GetAllConversationModelsResponseBodyList = Array<ConversationModelSchema>;
+export declare const GetAllConversationModelsResponseBodyList: S.Schema<GetAllConversationModelsResponseBodyList>;
+export type GetAllConversationModelsResponse = GetAllConversationModelsResponseBodyList;
+export declare const GetAllConversationModelsResponse: S.Schema<GetAllConversationModelsResponse>;
+export interface GetAllNLSearchModelsRequest {
+}
+export declare const GetAllNLSearchModelsRequest: S.Schema<GetAllNLSearchModelsRequest>;
+/** Stop sequences for the NL model (Google-specific) */
+export type NLSearchModelSchemaStopSequencesList = Array<string>;
+export declare const NLSearchModelSchemaStopSequencesList: S.Schema<NLSearchModelSchemaStopSequencesList>;
+export interface NLSearchModelSchema {
+    /** Name of the NL model to use */
+    model_name?: string;
+    /** API key for the NL model service */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Custom API URL for the NL model service */
+    api_url?: string;
+    /** Maximum number of bytes to process */
+    max_bytes?: number;
+    /** Temperature parameter for the NL model */
+    temperature?: number;
+    /** System prompt for the NL model */
+    system_prompt?: string;
+    /** Top-p parameter for the NL model (Google-specific) */
+    top_p?: number;
+    /** Top-k parameter for the NL model (Google-specific) */
+    top_k?: number;
+    /** Stop sequences for the NL model (Google-specific) */
+    stop_sequences?: NLSearchModelSchemaStopSequencesList;
+    /** API version for the NL model service */
+    api_version?: string;
+    /** Project ID for GCP Vertex AI */
+    project_id?: string;
+    /** Access token for GCP Vertex AI */
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Refresh token for GCP Vertex AI */
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Client ID for GCP Vertex AI */
+    client_id?: string;
+    /** Client secret for GCP Vertex AI */
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    /** Region for GCP Vertex AI */
+    region?: string;
+    /** Maximum output tokens for GCP Vertex AI */
+    max_output_tokens?: number;
+    /** Account ID for Cloudflare-specific models */
+    account_id?: string;
+    /** Optional ID for the NL search model */
+    id: string;
+}
+export declare const NLSearchModelSchema: S.Schema<NLSearchModelSchema>;
+export type GetAllNLSearchModelsResponseBodyList = Array<NLSearchModelSchema>;
+export declare const GetAllNLSearchModelsResponseBodyList: S.Schema<GetAllNLSearchModelsResponseBodyList>;
+export type GetAllNLSearchModelsResponse = GetAllNLSearchModelsResponseBodyList;
+export declare const GetAllNLSearchModelsResponse: S.Schema<GetAllNLSearchModelsResponse>;
+export interface GetAllPresetsRequest {
+}
+export declare const GetAllPresetsRequest: S.Schema<GetAllPresetsRequest>;
+/** Dictates the direction in which the words in the query must be dropped when the original words in the query do not appear in any document. Values: right_to_left (default), left_to_right, both_sides:3 A note on both_sides:3 - for queries up to 3 tokens (words) in length, this mode will drop tokens from both sides and exhaustively rank all matching results. If query length is greater than 3 words, Typesense will just fallback to default behavior of right_to_left */
+export type DropTokensMode = "right_to_left" | "left_to_right" | "both_sides:3";
+export declare const DropTokensMode: any;
+export interface SearchParameters {
+    /** The query text to search for in the collection. Use * as the search string to return all documents. This is typically useful when used in conjunction with filter_by. */
+    q?: string;
+    /** A list of `string` fields that should be queried against. Multiple fields are separated with a comma. */
+    query_by?: string;
+    /** Controls whether Typesense should validate if the fields exist in the schema. When set to false, Typesense will not throw an error if a field is missing. This is useful for programmatic grouping where not all fields may exist. */
+    validate_field_names?: boolean;
+    /** Whether to use natural language processing to parse the query. */
+    nl_query?: boolean;
+    /** The ID of the natural language model to use. */
+    nl_model_id?: string;
+    /** The relative weight to give each `query_by` field when ranking results. This can be used to boost fields in priority, when looking for matches. Multiple fields are separated with a comma. */
+    query_by_weights?: string;
+    /** In a multi-field matching context, this parameter determines how the representative text match score of a record is calculated. Possible values are max_score (default) or max_weight. */
+    text_match_type?: string;
+    /** Boolean field to indicate that the last word in the query should be treated as a prefix, and not as a whole word. This is used for building autocomplete and instant search interfaces. Defaults to true. */
+    prefix?: string;
+    /** If infix index is enabled for this field, infix searching can be done on a per-field basis by sending a comma separated string parameter called infix to the search query. This parameter can have 3 values; `off` infix search is disabled, which is default `always` infix search is performed along with regular search `fallback` infix search is performed if regular search does not produce results */
+    infix?: string;
+    /** There are also 2 parameters that allow you to control the extent of infix searching max_extra_prefix and max_extra_suffix which specify the maximum number of symbols before or after the query that can be present in the token. For example query "K2100" has 2 extra symbols in "6PK2100". By default, any number of prefixes/suffixes can be present for a match. */
+    max_extra_prefix?: number;
+    /** There are also 2 parameters that allow you to control the extent of infix searching max_extra_prefix and max_extra_suffix which specify the maximum number of symbols before or after the query that can be present in the token. For example query "K2100" has 2 extra symbols in "6PK2100". By default, any number of prefixes/suffixes can be present for a match. */
+    max_extra_suffix?: number;
+    /** Filter conditions for refining your open api validator search results. Separate multiple conditions with &&. */
+    filter_by?: string;
+    /** Controls the number of similar words that Typesense considers during fuzzy search on filter_by values. Useful for controlling prefix matches like company_name:Acm*. */
+    max_filter_by_candidates?: number;
+    /** A list of numerical fields and their corresponding sort orders that will be used for ordering your results. Up to 3 sort fields can be specified. The text similarity score is exposed as a special `_text_match` field that you can use in the list of sorting fields. If no `sort_by` parameter is specified, results are sorted by `_text_match:desc,default_sorting_field:desc` */
+    sort_by?: string;
+    /** A list of fields that will be used for faceting your results on. Separate multiple fields with a comma. */
+    facet_by?: string;
+    /** Maximum number of facet values to be returned. */
+    max_facet_values?: number;
+    /** Facet values that are returned can now be filtered via this parameter. The matching facet text is also highlighted. For example, when faceting by `category`, you can set `facet_query=category:shoe` to return only facet values that contain the prefix "shoe". */
+    facet_query?: string;
+    /** The number of typographical errors (1 or 2) that would be tolerated. Default: 2 */
+    num_typos?: string;
+    /** Results from this specific page number would be fetched. */
+    page?: number;
+    /** Number of results to fetch per page. Default: 10 */
+    per_page?: number;
+    /** Number of hits to fetch. Can be used as an alternative to the per_page parameter. Default: 10. */
+    limit?: number;
+    /** Identifies the starting point to return hits from a result set. Can be used as an alternative to the page parameter. */
+    offset?: number;
+    /** You can aggregate search results into groups or buckets by specify one or more `group_by` fields. Separate multiple fields with a comma. To group on a particular field, it must be a faceted field. */
+    group_by?: string;
+    /** Maximum number of hits to be returned for every group. If the `group_limit` is set as `K` then only the top K hits in each group are returned in the response. Default: 3 */
+    group_limit?: number;
+    /** Setting this parameter to true will place all documents that have a null value in the group_by field, into a single group. Setting this parameter to false, will cause each document with a null value in the group_by field to not be grouped with other documents. Default: true */
+    group_missing_values?: boolean;
+    /** List of fields from the document to include in the search result */
+    include_fields?: string;
+    /** List of fields from the document to exclude in the search result */
+    exclude_fields?: string;
+    /** List of fields which should be highlighted fully without snippeting */
+    highlight_full_fields?: string;
+    /** The number of tokens that should surround the highlighted text on each side. Default: 4 */
+    highlight_affix_num_tokens?: number;
+    /** The start tag used for the highlighted snippets. Default: `<mark>` */
+    highlight_start_tag?: string;
+    /** The end tag used for the highlighted snippets. Default: `</mark>` */
+    highlight_end_tag?: string;
+    /** Flag for enabling/disabling the deprecated, old highlight structure in the response. Default: true */
+    enable_highlight_v1?: boolean;
+    /** Flag for enabling/disabling analytics aggregation for specific search queries (for e.g. those originating from a test script). */
+    enable_analytics?: boolean;
+    /** Field values under this length will be fully highlighted, instead of showing a snippet of relevant portion. Default: 30 */
+    snippet_threshold?: number;
+    /** List of synonym set names to associate with this search query */
+    synonym_sets?: string;
+    /** If the number of results found for a specific query is less than this number, Typesense will attempt to drop the tokens in the query until enough results are found. Tokens that have the least individual hits are dropped first. Set to 0 to disable. Default: 10 */
+    drop_tokens_threshold?: number;
+    drop_tokens_mode?: DropTokensMode | (string & {});
+    /** If the number of results found for a specific query is less than this number, Typesense will attempt to look for tokens with more typos until enough results are found. Default: 100 */
+    typo_tokens_threshold?: number;
+    /** Set this parameter to false to disable typos on alphanumerical query tokens. Default: true. */
+    enable_typos_for_alpha_numerical_tokens?: boolean;
+    /** Whether the filter_by condition of the search query should be applicable to curated results (curation definitions, pinned hits, hidden hits, etc.). Default: false */
+    filter_curated_hits?: boolean;
+    /** If you have some synonyms defined but want to disable all of them for a particular search query, set enable_synonyms to false. Default: true */
+    enable_synonyms?: boolean;
+    /** Allow synonym resolution on word prefixes in the query. Default: false */
+    synonym_prefix?: boolean;
+    /** Allow synonym resolution on typo-corrected words in the query. Default: 0 */
+    synonym_num_typos?: number;
+    /** A list of records to unconditionally include in the search results at specific positions. An example use case would be to feature or promote certain items on the top of search results. A list of `record_id:hit_position`. Eg: to include a record with ID 123 at Position 1 and another record with ID 456 at Position 5, you'd specify `123:1,456:5`. You could also use the Curation feature to override search results based on rules. Curations are applied first, followed by `pinned_hits` and finally `hidden_hits`. */
+    pinned_hits?: string;
+    /** A list of records to unconditionally hide from search results. A list of `record_id`s to hide. Eg: to hide records with IDs 123 and 456, you'd specify `123,456`. You could also use the Curation feature to override search results based on rules. Curations are applied first, followed by `pinned_hits` and finally `hidden_hits`. */
+    hidden_hits?: string;
+    /** Comma separated list of tags to trigger the curations rules that match the tags. */
+    curation_tags?: string;
+    /** A list of custom fields that must be highlighted even if you don't query for them */
+    highlight_fields?: string;
+    /** Treat space as typo: search for q=basket ball if q=basketball is not found or vice-versa. Splitting/joining of tokens will only be attempted if the original query produces no results. To always trigger this behavior, set value to `always``. To disable, set value to `off`. Default is `fallback`. */
+    split_join_tokens?: string;
+    /** You can index content from any logographic language into Typesense if you are able to segment / split the text into space-separated words yourself before indexing and querying. Set this parameter to true to do the same */
+    pre_segmented_query?: boolean;
+    /** Search using a bunch of search parameters by setting this parameter to the name of the existing Preset. */
+    preset?: string;
+    /** If you have some curation sets defined but want to disable all of them during query time, you can do that by setting this parameter to false */
+    enable_curations?: boolean;
+    /** Set this parameter to true to ensure that an exact match is ranked above the others */
+    prioritize_exact_match?: boolean;
+    /** Control the number of words that Typesense considers for typo and prefix searching. */
+    max_candidates?: number;
+    /** Make Typesense prioritize documents where the query words appear earlier in the text. */
+    prioritize_token_position?: boolean;
+    /** Make Typesense prioritize documents where the query words appear in more number of fields. */
+    prioritize_num_matching_fields?: boolean;
+    /** Make Typesense disable typos for numerical tokens. */
+    enable_typos_for_numerical_tokens?: boolean;
+    /** Setting this to true will make Typesense consider all prefixes and typo corrections of the words in the query without stopping early when enough results are found (drop_tokens_threshold and typo_tokens_threshold configurations are ignored). */
+    exhaustive_search?: boolean;
+    /** Typesense will attempt to return results early if the cutoff time has elapsed. This is not a strict guarantee and facet computation is not bound by this parameter. */
+    search_cutoff_ms?: number;
+    /** Enable server side caching of search query results. By default, caching is disabled. */
+    use_cache?: boolean;
+    /** The duration (in seconds) that determines how long the search query is cached. This value can be set on a per-query basis. Default: 60. */
+    cache_ttl?: number;
+    /** Minimum word length for 1-typo correction to be applied. The value of num_typos is still treated as the maximum allowed typos. */
+    min_len_1typo?: number;
+    /** Minimum word length for 2-typo correction to be applied. The value of num_typos is still treated as the maximum allowed typos. */
+    min_len_2typo?: number;
+    /** Vector query expression for fetching documents "closest" to a given query/document vector. */
+    vector_query?: string;
+    /** Timeout (in milliseconds) for fetching remote embeddings. */
+    remote_embedding_timeout_ms?: number;
+    /** Number of times to retry fetching remote embeddings. */
+    remote_embedding_num_tries?: number;
+    /** Choose the underlying faceting strategy used. Comma separated string of allows values: exhaustive, top_values or automatic (default). */
+    facet_strategy?: string;
+    /** Name of the stopwords set to apply for this search, the keywords present in the set will be removed from the search query. */
+    stopwords?: string;
+    /** Comma separated string of nested facet fields whose parent object should be returned in facet response. */
+    facet_return_parent?: string;
+    /** The base64 encoded audio file in 16 khz 16-bit WAV format. */
+    voice_query?: string;
+    /** Enable conversational search. */
+    conversation?: boolean;
+    /** The Id of Conversation Model to be used. */
+    conversation_model_id?: string;
+    /** The Id of a previous conversation to continue, this tells Typesense to include prior context when communicating with the LLM. */
+    conversation_id?: string;
+}
+export declare const SearchParameters: S.Schema<SearchParameters>;
+export interface MultiSearchCollectionParameters {
+    /** The query text to search for in the collection. Use * as the search string to return all documents. This is typically useful when used in conjunction with filter_by. */
+    q?: string;
+    /** A list of `string` fields that should be queried against. Multiple fields are separated with a comma. */
+    query_by?: string;
+    /** The relative weight to give each `query_by` field when ranking results. This can be used to boost fields in priority, when looking for matches. Multiple fields are separated with a comma. */
+    query_by_weights?: string;
+    /** In a multi-field matching context, this parameter determines how the representative text match score of a record is calculated. Possible values are max_score (default) or max_weight. */
+    text_match_type?: string;
+    /** Boolean field to indicate that the last word in the query should be treated as a prefix, and not as a whole word. This is used for building autocomplete and instant search interfaces. Defaults to true. */
+    prefix?: string;
+    /** If infix index is enabled for this field, infix searching can be done on a per-field basis by sending a comma separated string parameter called infix to the search query. This parameter can have 3 values; `off` infix search is disabled, which is default `always` infix search is performed along with regular search `fallback` infix search is performed if regular search does not produce results */
+    infix?: string;
+    /** There are also 2 parameters that allow you to control the extent of infix searching max_extra_prefix and max_extra_suffix which specify the maximum number of symbols before or after the query that can be present in the token. For example query "K2100" has 2 extra symbols in "6PK2100". By default, any number of prefixes/suffixes can be present for a match. */
+    max_extra_prefix?: number;
+    /** There are also 2 parameters that allow you to control the extent of infix searching max_extra_prefix and max_extra_suffix which specify the maximum number of symbols before or after the query that can be present in the token. For example query "K2100" has 2 extra symbols in "6PK2100". By default, any number of prefixes/suffixes can be present for a match. */
+    max_extra_suffix?: number;
+    /** Filter conditions for refining youropen api validator search results. Separate multiple conditions with &&. */
+    filter_by?: string;
+    /** A list of numerical fields and their corresponding sort orders that will be used for ordering your results. Up to 3 sort fields can be specified. The text similarity score is exposed as a special `_text_match` field that you can use in the list of sorting fields. If no `sort_by` parameter is specified, results are sorted by `_text_match:desc,default_sorting_field:desc` */
+    sort_by?: string;
+    /** A list of fields that will be used for faceting your results on. Separate multiple fields with a comma. */
+    facet_by?: string;
+    /** Maximum number of facet values to be returned. */
+    max_facet_values?: number;
+    /** Facet values that are returned can now be filtered via this parameter. The matching facet text is also highlighted. For example, when faceting by `category`, you can set `facet_query=category:shoe` to return only facet values that contain the prefix "shoe". */
+    facet_query?: string;
+    /** The number of typographical errors (1 or 2) that would be tolerated. Default: 2 */
+    num_typos?: string;
+    /** Results from this specific page number would be fetched. */
+    page?: number;
+    /** Number of results to fetch per page. Default: 10 */
+    per_page?: number;
+    /** Number of hits to fetch. Can be used as an alternative to the per_page parameter. Default: 10. */
+    limit?: number;
+    /** Identifies the starting point to return hits from a result set. Can be used as an alternative to the page parameter. */
+    offset?: number;
+    /** You can aggregate search results into groups or buckets by specify one or more `group_by` fields. Separate multiple fields with a comma. To group on a particular field, it must be a faceted field. */
+    group_by?: string;
+    /** Maximum number of hits to be returned for every group. If the `group_limit` is set as `K` then only the top K hits in each group are returned in the response. Default: 3 */
+    group_limit?: number;
+    /** Setting this parameter to true will place all documents that have a null value in the group_by field, into a single group. Setting this parameter to false, will cause each document with a null value in the group_by field to not be grouped with other documents. Default: true */
+    group_missing_values?: boolean;
+    /** List of fields from the document to include in the search result */
+    include_fields?: string;
+    /** List of fields from the document to exclude in the search result */
+    exclude_fields?: string;
+    /** List of fields which should be highlighted fully without snippeting */
+    highlight_full_fields?: string;
+    /** The number of tokens that should surround the highlighted text on each side. Default: 4 */
+    highlight_affix_num_tokens?: number;
+    /** The start tag used for the highlighted snippets. Default: `<mark>` */
+    highlight_start_tag?: string;
+    /** The end tag used for the highlighted snippets. Default: `</mark>` */
+    highlight_end_tag?: string;
+    /** Field values under this length will be fully highlighted, instead of showing a snippet of relevant portion. Default: 30 */
+    snippet_threshold?: number;
+    /** If the number of results found for a specific query is less than this number, Typesense will attempt to drop the tokens in the query until enough results are found. Tokens that have the least individual hits are dropped first. Set to 0 to disable. Default: 10 */
+    drop_tokens_threshold?: number;
+    drop_tokens_mode?: DropTokensMode | (string & {});
+    /** If the number of results found for a specific query is less than this number, Typesense will attempt to look for tokens with more typos until enough results are found. Default: 100 */
+    typo_tokens_threshold?: number;
+    /** Set this parameter to false to disable typos on alphanumerical query tokens. Default: true. */
+    enable_typos_for_alpha_numerical_tokens?: boolean;
+    /** Whether the filter_by condition of the search query should be applicable to curated results (curation definitions, pinned hits, hidden hits, etc.). Default: false */
+    filter_curated_hits?: boolean;
+    /** If you have some synonyms defined but want to disable all of them for a particular search query, set enable_synonyms to false. Default: true */
+    enable_synonyms?: boolean;
+    /** Flag for enabling/disabling analytics aggregation for specific search queries (for e.g. those originating from a test script). */
+    enable_analytics?: boolean;
+    /** Allow synonym resolution on word prefixes in the query. Default: false */
+    synonym_prefix?: boolean;
+    /** Allow synonym resolution on typo-corrected words in the query. Default: 0 */
+    synonym_num_typos?: number;
+    /** A list of records to unconditionally include in the search results at specific positions. An example use case would be to feature or promote certain items on the top of search results. A list of `record_id:hit_position`. Eg: to include a record with ID 123 at Position 1 and another record with ID 456 at Position 5, you'd specify `123:1,456:5`. You could also use the Curation feature to override search results based on rules. Curations are applied first, followed by `pinned_hits` and finally `hidden_hits`. */
+    pinned_hits?: string;
+    /** A list of records to unconditionally hide from search results. A list of `record_id`s to hide. Eg: to hide records with IDs 123 and 456, you'd specify `123,456`. You could also use the Curation feature to override search results based on rules. Curations are applied first, followed by `pinned_hits` and finally `hidden_hits`. */
+    hidden_hits?: string;
+    /** Comma separated list of tags to trigger the curations rules that match the tags. */
+    curation_tags?: string;
+    /** A list of custom fields that must be highlighted even if you don't query for them */
+    highlight_fields?: string;
+    /** You can index content from any logographic language into Typesense if you are able to segment / split the text into space-separated words yourself before indexing and querying. Set this parameter to true to do the same */
+    pre_segmented_query?: boolean;
+    /** Search using a bunch of search parameters by setting this parameter to the name of the existing Preset. */
+    preset?: string;
+    /** If you have some curation sets defined but want to disable all of them during query time, you can do that by setting this parameter to false */
+    enable_curations?: boolean;
+    /** Set this parameter to true to ensure that an exact match is ranked above the others */
+    prioritize_exact_match?: boolean;
+    /** Make Typesense prioritize documents where the query words appear earlier in the text. */
+    prioritize_token_position?: boolean;
+    /** Make Typesense prioritize documents where the query words appear in more number of fields. */
+    prioritize_num_matching_fields?: boolean;
+    /** Make Typesense disable typos for numerical tokens. */
+    enable_typos_for_numerical_tokens?: boolean;
+    /** Setting this to true will make Typesense consider all prefixes and typo corrections of the words in the query without stopping early when enough results are found (drop_tokens_threshold and typo_tokens_threshold configurations are ignored). */
+    exhaustive_search?: boolean;
+    /** Typesense will attempt to return results early if the cutoff time has elapsed. This is not a strict guarantee and facet computation is not bound by this parameter. */
+    search_cutoff_ms?: number;
+    /** Enable server side caching of search query results. By default, caching is disabled. */
+    use_cache?: boolean;
+    /** The duration (in seconds) that determines how long the search query is cached. This value can be set on a per-query basis. Default: 60. */
+    cache_ttl?: number;
+    /** Minimum word length for 1-typo correction to be applied. The value of num_typos is still treated as the maximum allowed typos. */
+    min_len_1typo?: number;
+    /** Minimum word length for 2-typo correction to be applied. The value of num_typos is still treated as the maximum allowed typos. */
+    min_len_2typo?: number;
+    /** Vector query expression for fetching documents "closest" to a given query/document vector. */
+    vector_query?: string;
+    /** Timeout (in milliseconds) for fetching remote embeddings. */
+    remote_embedding_timeout_ms?: number;
+    /** Number of times to retry fetching remote embeddings. */
+    remote_embedding_num_tries?: number;
+    /** Choose the underlying faceting strategy used. Comma separated string of allows values: exhaustive, top_values or automatic (default). */
+    facet_strategy?: string;
+    /** Name of the stopwords set to apply for this search, the keywords present in the set will be removed from the search query. */
+    stopwords?: string;
+    /** Comma separated string of nested facet fields whose parent object should be returned in facet response. */
+    facet_return_parent?: string;
+    /** The base64 encoded audio file in 16 khz 16-bit WAV format. */
+    voice_query?: string;
+    /** Enable conversational search. */
+    conversation?: boolean;
+    /** The Id of Conversation Model to be used. */
+    conversation_model_id?: string;
+    /** The Id of a previous conversation to continue, this tells Typesense to include prior context when communicating with the LLM. */
+    conversation_id?: string;
+    /** Controls whether Typesense should validate if the fields exist in the schema. When set to false, Typesense will not throw an error if a field is missing. This is useful for programmatic grouping where not all fields may exist. */
+    validate_field_names?: boolean;
+    /** The collection to search in. */
+    collection?: string;
+    /** A separate search API key for each search within a multi_search request */
+    x_typesense_api_key?: string;
+    /** When true, computes both text match and vector distance scores for all matches in hybrid search. Documents found only through keyword search will get a vector distance score, and documents found only through vector search will get a text match score. */
+    rerank_hybrid_matches?: boolean;
+}
+export declare const MultiSearchCollectionParameters: S.Schema<MultiSearchCollectionParameters>;
+export type MultiSearchSearchesParameterSearchesList = Array<MultiSearchCollectionParameters>;
+export declare const MultiSearchSearchesParameterSearchesList: S.Schema<MultiSearchSearchesParameterSearchesList>;
+export interface MultiSearchSearchesParameter {
+    /** When true, merges the search results from each search query into a single ordered set of hits. */
+    union?: boolean;
+    searches: MultiSearchSearchesParameterSearchesList;
+}
+export declare const MultiSearchSearchesParameter: S.Schema<MultiSearchSearchesParameter>;
+export type PresetSchemaValue = SearchParameters | MultiSearchSearchesParameter;
+export declare const PresetSchemaValue: any;
+export interface PresetSchema {
+    value: PresetSchemaValue;
+    name: string;
+}
+export declare const PresetSchema: S.Schema<PresetSchema>;
+export type PresetsRetrieveSchemaPresetsList = Array<PresetSchema>;
+export declare const PresetsRetrieveSchemaPresetsList: S.Schema<PresetsRetrieveSchemaPresetsList>;
+export interface PresetsRetrieveSchema {
+    presets: PresetsRetrieveSchemaPresetsList;
+}
+export declare const PresetsRetrieveSchema: S.Schema<PresetsRetrieveSchema>;
+export interface GetAnalyticsEventsRequest {
+    user_id: string;
+    /** Analytics rule name */
+    name: string;
+    /** Number of events to return (max 1000) */
+    n: number;
+}
+export declare const GetAnalyticsEventsRequest: S.Schema<GetAnalyticsEventsRequest>;
+export type AnalyticsEventsResponseEventsItemDocIdsList = Array<string>;
+export declare const AnalyticsEventsResponseEventsItemDocIdsList: S.Schema<AnalyticsEventsResponseEventsItemDocIdsList>;
+export interface AnalyticsEventsResponseEventsItem {
+    name?: string;
+    event_type?: string;
+    collection?: string;
+    timestamp?: number;
+    user_id?: string;
+    doc_id?: string;
+    doc_ids?: AnalyticsEventsResponseEventsItemDocIdsList;
+    query?: string;
+}
+export declare const AnalyticsEventsResponseEventsItem: S.Schema<AnalyticsEventsResponseEventsItem>;
+export type AnalyticsEventsResponseEventsList = Array<AnalyticsEventsResponseEventsItem>;
+export declare const AnalyticsEventsResponseEventsList: S.Schema<AnalyticsEventsResponseEventsList>;
+export interface AnalyticsEventsResponse {
+    events: AnalyticsEventsResponseEventsList;
+}
+export declare const AnalyticsEventsResponse: S.Schema<AnalyticsEventsResponse>;
+export interface GetAnalyticsRuleRequest {
+    /** The name of the analytics rule to retrieve */
+    ruleName: string;
+}
+export declare const GetAnalyticsRuleRequest: S.Schema<GetAnalyticsRuleRequest>;
+export type GetAnalyticsRuleResponseParamsMetaFieldsList = Array<string>;
+export declare const GetAnalyticsRuleResponseParamsMetaFieldsList: S.Schema<GetAnalyticsRuleResponseParamsMetaFieldsList>;
+export interface GetAnalyticsRuleResponseParams {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: GetAnalyticsRuleResponseParamsMetaFieldsList;
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+}
+export declare const GetAnalyticsRuleResponseParams: S.Schema<GetAnalyticsRuleResponseParams>;
+export interface GetAnalyticsRuleResponse {
+    name: string;
+    type: AnalyticsRuleType;
+    collection: string;
+    event_type: string;
+    rule_tag?: string;
+    params?: GetAnalyticsRuleResponseParams;
+}
+export declare const GetAnalyticsRuleResponse: S.Schema<GetAnalyticsRuleResponse>;
+export interface GetAnalyticsRulesRequest {
+    /** Filter rules by rule_tag */
+    rule_tag?: string;
+}
+export declare const GetAnalyticsRulesRequest: S.Schema<GetAnalyticsRulesRequest>;
+export type GetAnalyticsRulesResponseBodyList = Array<AnalyticsRule>;
+export declare const GetAnalyticsRulesResponseBodyList: S.Schema<GetAnalyticsRulesResponseBodyList>;
+export type GetAnalyticsRulesResponse = GetAnalyticsRulesResponseBodyList;
+export declare const GetAnalyticsRulesResponse: S.Schema<GetAnalyticsRulesResponse>;
+export interface GetAnalyticsStatusRequest {
+}
+export declare const GetAnalyticsStatusRequest: S.Schema<GetAnalyticsStatusRequest>;
+export interface AnalyticsStatus {
+    popular_prefix_queries?: number;
+    nohits_prefix_queries?: number;
+    log_prefix_queries?: number;
+    query_log_events?: number;
+    query_counter_events?: number;
+    doc_log_events?: number;
+    doc_counter_events?: number;
+}
+export declare const AnalyticsStatus: S.Schema<AnalyticsStatus>;
+export interface GetAPIStatsRequest {
+}
+export declare const GetAPIStatsRequest: S.Schema<GetAPIStatsRequest>;
+export interface APIStatsResponse {
+    delete_latency_ms?: number;
+    delete_requests_per_second?: number;
+    import_latency_ms?: number;
+    import_requests_per_second?: number;
+    latency_ms?: unknown;
+    overloaded_requests_per_second?: number;
+    pending_write_batches?: number;
+    requests_per_second?: unknown;
+    search_latency_ms?: number;
+    search_requests_per_second?: number;
+    total_requests_per_second?: number;
+    write_latency_ms?: number;
+    write_requests_per_second?: number;
+}
+export declare const APIStatsResponse: S.Schema<APIStatsResponse>;
+export interface GetCollectionRequest {
+    /** The name of the collection to retrieve */
+    collectionName: string;
+}
+export declare const GetCollectionRequest: S.Schema<GetCollectionRequest>;
+/** A list of fields for querying, filtering and faceting */
+export type GetCollectionResponseFieldsList = Array<Field>;
+export declare const GetCollectionResponseFieldsList: S.Schema<GetCollectionResponseFieldsList>;
+/** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+export type GetCollectionResponseTokenSeparatorsList = Array<string>;
+export declare const GetCollectionResponseTokenSeparatorsList: S.Schema<GetCollectionResponseTokenSeparatorsList>;
+/** List of synonym set names to associate with this collection */
+export type GetCollectionResponseSynonymSetsList = Array<string>;
+export declare const GetCollectionResponseSynonymSetsList: S.Schema<GetCollectionResponseSynonymSetsList>;
+/** List of symbols or special characters to be indexed. */
+export type GetCollectionResponseSymbolsToIndexList = Array<string>;
+export declare const GetCollectionResponseSymbolsToIndexList: S.Schema<GetCollectionResponseSymbolsToIndexList>;
+export interface GetCollectionResponse {
+    /** Name of the collection */
+    name: string;
+    /** A list of fields for querying, filtering and faceting */
+    fields: GetCollectionResponseFieldsList;
+    /** The name of an int32 / float field that determines the order in which the search results are ranked when a sort_by clause is not provided during searching. This field must indicate some kind of popularity. */
+    default_sorting_field?: string;
+    /** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+    token_separators?: GetCollectionResponseTokenSeparatorsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: GetCollectionResponseSynonymSetsList;
+    /** Enables experimental support at a collection level for nested object or object array fields. This field is only available if the Typesense server is version `0.24.0.rcn34` or later. */
+    enable_nested_fields?: boolean;
+    /** List of symbols or special characters to be indexed. */
+    symbols_to_index?: GetCollectionResponseSymbolsToIndexList;
+    voice_query_model?: VoiceQueryModelCollectionConfig;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+    /** Number of documents in the collection */
+    num_documents: number;
+    /** Timestamp of when the collection was created (Unix epoch in seconds) */
+    created_at: number;
+}
+export declare const GetCollectionResponse: S.Schema<GetCollectionResponse>;
+export interface GetCollectionsRequestGetCollectionsParameters {
+    /** Comma-separated list of fields from the collection to exclude from the response */
+    exclude_fields?: string;
+    /** Number of collections to fetch. Default: returns all collections. */
+    limit?: number;
+    /** Identifies the starting point to return collections when paginating. */
+    offset?: number;
+}
+export declare const GetCollectionsRequestGetCollectionsParameters: S.Schema<GetCollectionsRequestGetCollectionsParameters>;
+export interface GetCollectionsRequest {
+    getCollectionsParameters?: GetCollectionsRequestGetCollectionsParameters;
+}
+export declare const GetCollectionsRequest: S.Schema<GetCollectionsRequest>;
+/** A list of fields for querying, filtering and faceting */
+export type CollectionResponseFieldsList = Array<Field>;
+export declare const CollectionResponseFieldsList: S.Schema<CollectionResponseFieldsList>;
+/** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+export type CollectionResponseTokenSeparatorsList = Array<string>;
+export declare const CollectionResponseTokenSeparatorsList: S.Schema<CollectionResponseTokenSeparatorsList>;
+/** List of synonym set names to associate with this collection */
+export type CollectionResponseSynonymSetsList = Array<string>;
+export declare const CollectionResponseSynonymSetsList: S.Schema<CollectionResponseSynonymSetsList>;
+/** List of symbols or special characters to be indexed. */
+export type CollectionResponseSymbolsToIndexList = Array<string>;
+export declare const CollectionResponseSymbolsToIndexList: S.Schema<CollectionResponseSymbolsToIndexList>;
+export interface CollectionResponse {
+    /** Name of the collection */
+    name: string;
+    /** A list of fields for querying, filtering and faceting */
+    fields: CollectionResponseFieldsList;
+    /** The name of an int32 / float field that determines the order in which the search results are ranked when a sort_by clause is not provided during searching. This field must indicate some kind of popularity. */
+    default_sorting_field?: string;
+    /** List of symbols or special characters to be used for splitting the text into individual words in addition to space and new-line characters. */
+    token_separators?: CollectionResponseTokenSeparatorsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: CollectionResponseSynonymSetsList;
+    /** Enables experimental support at a collection level for nested object or object array fields. This field is only available if the Typesense server is version `0.24.0.rcn34` or later. */
+    enable_nested_fields?: boolean;
+    /** List of symbols or special characters to be indexed. */
+    symbols_to_index?: CollectionResponseSymbolsToIndexList;
+    voice_query_model?: VoiceQueryModelCollectionConfig;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+    /** Number of documents in the collection */
+    num_documents: number;
+    /** Timestamp of when the collection was created (Unix epoch in seconds) */
+    created_at: number;
+}
+export declare const CollectionResponse: S.Schema<CollectionResponse>;
+export type GetCollectionsResponseBodyList = Array<CollectionResponse>;
+export declare const GetCollectionsResponseBodyList: S.Schema<GetCollectionsResponseBodyList>;
+export type GetCollectionsResponse = GetCollectionsResponseBodyList;
+export declare const GetCollectionsResponse: S.Schema<GetCollectionsResponse>;
+export interface GetConversationModelRequest {
+    /** The id of the conversation model to retrieve */
+    modelId: string;
+}
+export declare const GetConversationModelRequest: S.Schema<GetConversationModelRequest>;
+export interface GetConversationModelResponse {
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const GetConversationModelResponse: S.Schema<GetConversationModelResponse>;
+export interface GetCurationSetRequest {
+    /** The name of the curation set to retrieve */
+    curationSetName: string;
+}
+export declare const GetCurationSetRequest: S.Schema<GetCurationSetRequest>;
+/** List of tag values to associate with this curation rule. */
+export type CurationRuleTagsList = Array<string>;
+export declare const CurationRuleTagsList: S.Schema<CurationRuleTagsList>;
+/** Indicates whether the match on the query term should be `exact` or `contains`. If we want to match all queries that contained the word `apple`, we will use the `contains` match instead. */
+export type CurationRuleMatch = "exact" | "contains";
+export declare const CurationRuleMatch: any;
+export interface CurationRule {
+    /** List of tag values to associate with this curation rule. */
+    tags?: CurationRuleTagsList;
+    /** Indicates what search queries should be curated */
+    query?: string;
+    /** Indicates whether the match on the query term should be `exact` or `contains`. If we want to match all queries that contained the word `apple`, we will use the `contains` match instead. */
+    match?: CurationRuleMatch | (string & {});
+    /** Indicates that the curation should apply when the filter_by parameter in a search query exactly matches the string specified here (including backticks, spaces, brackets, etc). */
+    filter_by?: string;
+}
+export declare const CurationRule: S.Schema<CurationRule>;
+export interface CurationInclude {
+    /** document id that should be included */
+    id: string;
+    /** position number where document should be included in the search results */
+    position: number;
+}
+export declare const CurationInclude: S.Schema<CurationInclude>;
+/** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+export type CurationItemCreateSchemaIncludesList = Array<CurationInclude>;
+export declare const CurationItemCreateSchemaIncludesList: S.Schema<CurationItemCreateSchemaIncludesList>;
+export interface CurationExclude {
+    /** document id that should be excluded from the search results. */
+    id: string;
+}
+export declare const CurationExclude: S.Schema<CurationExclude>;
+/** List of document `id`s that should be excluded from the search results. */
+export type CurationItemCreateSchemaExcludesList = Array<CurationExclude>;
+export declare const CurationItemCreateSchemaExcludesList: S.Schema<CurationItemCreateSchemaExcludesList>;
+export interface CurationItemCreateSchema {
+    rule: CurationRule;
+    /** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+    includes?: CurationItemCreateSchemaIncludesList;
+    /** List of document `id`s that should be excluded from the search results. */
+    excludes?: CurationItemCreateSchemaExcludesList;
+    /** A filter by clause that is applied to any search query that matches the curation rule. */
+    filter_by?: string;
+    /** Indicates whether search query tokens that exist in the curation's rule should be removed from the search query. */
+    remove_matched_tokens?: boolean;
+    /** Return a custom JSON object in the Search API response, when this rule is triggered. This can can be used to display a pre-defined message (eg: a promotion banner) on the front-end when a particular rule is triggered. */
+    metadata?: unknown;
+    /** A sort by clause that is applied to any search query that matches the curation rule. */
+    sort_by?: string;
+    /** Replaces the current search query with this value, when the search query matches the curation rule. */
+    replace_query?: string;
+    /** When set to true, the filter conditions of the query is applied to the curated records as well. Default: false. */
+    filter_curated_hits?: boolean;
+    /** A Unix timestamp that indicates the date/time from which the curation will be active. You can use this to create rules that start applying from a future point in time. */
+    effective_from_ts?: number;
+    /** A Unix timestamp that indicates the date/time until which the curation will be active. You can use this to create rules that stop applying after a period of time. */
+    effective_to_ts?: number;
+    /** When set to true, curation processing will stop at the first matching rule. When set to false curation processing will continue and multiple curation actions will be triggered in sequence. Curations are processed in the lexical sort order of their id field. */
+    stop_processing?: boolean;
+    /** ID of the curation item */
+    id?: string;
+}
+export declare const CurationItemCreateSchema: S.Schema<CurationItemCreateSchema>;
+/** Array of curation items */
+export type GetCurationSetResponseItemsList = Array<CurationItemCreateSchema>;
+export declare const GetCurationSetResponseItemsList: S.Schema<GetCurationSetResponseItemsList>;
+export interface GetCurationSetResponse {
+    /** Array of curation items */
+    items: GetCurationSetResponseItemsList;
+    /** Optional description for the curation set */
+    description?: string;
+    name: string;
+}
+export declare const GetCurationSetResponse: S.Schema<GetCurationSetResponse>;
+export interface GetCurationSetItemRequest {
+    /** The name of the curation set */
+    curationSetName: string;
+    /** The id of the curation item to retrieve */
+    itemId: string;
+}
+export declare const GetCurationSetItemRequest: S.Schema<GetCurationSetItemRequest>;
+/** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+export type GetCurationSetItemResponseIncludesList = Array<CurationInclude>;
+export declare const GetCurationSetItemResponseIncludesList: S.Schema<GetCurationSetItemResponseIncludesList>;
+/** List of document `id`s that should be excluded from the search results. */
+export type GetCurationSetItemResponseExcludesList = Array<CurationExclude>;
+export declare const GetCurationSetItemResponseExcludesList: S.Schema<GetCurationSetItemResponseExcludesList>;
+export interface GetCurationSetItemResponse {
+    rule: CurationRule;
+    /** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+    includes?: GetCurationSetItemResponseIncludesList;
+    /** List of document `id`s that should be excluded from the search results. */
+    excludes?: GetCurationSetItemResponseExcludesList;
+    /** A filter by clause that is applied to any search query that matches the curation rule. */
+    filter_by?: string;
+    /** Indicates whether search query tokens that exist in the curation's rule should be removed from the search query. */
+    remove_matched_tokens?: boolean;
+    /** Return a custom JSON object in the Search API response, when this rule is triggered. This can can be used to display a pre-defined message (eg: a promotion banner) on the front-end when a particular rule is triggered. */
+    metadata?: unknown;
+    /** A sort by clause that is applied to any search query that matches the curation rule. */
+    sort_by?: string;
+    /** Replaces the current search query with this value, when the search query matches the curation rule. */
+    replace_query?: string;
+    /** When set to true, the filter conditions of the query is applied to the curated records as well. Default: false. */
+    filter_curated_hits?: boolean;
+    /** A Unix timestamp that indicates the date/time from which the curation will be active. You can use this to create rules that start applying from a future point in time. */
+    effective_from_ts?: number;
+    /** A Unix timestamp that indicates the date/time until which the curation will be active. You can use this to create rules that stop applying after a period of time. */
+    effective_to_ts?: number;
+    /** When set to true, curation processing will stop at the first matching rule. When set to false curation processing will continue and multiple curation actions will be triggered in sequence. Curations are processed in the lexical sort order of their id field. */
+    stop_processing?: boolean;
+    /** ID of the curation item */
+    id: string;
+}
+export declare const GetCurationSetItemResponse: S.Schema<GetCurationSetItemResponse>;
+export interface GetCurationSetItemsRequest {
+    /** The name of the curation set to retrieve items for */
+    curationSetName: string;
+}
+export declare const GetCurationSetItemsRequest: S.Schema<GetCurationSetItemsRequest>;
+/** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+export type CurationItemSchemaIncludesList = Array<CurationInclude>;
+export declare const CurationItemSchemaIncludesList: S.Schema<CurationItemSchemaIncludesList>;
+/** List of document `id`s that should be excluded from the search results. */
+export type CurationItemSchemaExcludesList = Array<CurationExclude>;
+export declare const CurationItemSchemaExcludesList: S.Schema<CurationItemSchemaExcludesList>;
+export interface CurationItemSchema {
+    rule: CurationRule;
+    /** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+    includes?: CurationItemSchemaIncludesList;
+    /** List of document `id`s that should be excluded from the search results. */
+    excludes?: CurationItemSchemaExcludesList;
+    /** A filter by clause that is applied to any search query that matches the curation rule. */
+    filter_by?: string;
+    /** Indicates whether search query tokens that exist in the curation's rule should be removed from the search query. */
+    remove_matched_tokens?: boolean;
+    /** Return a custom JSON object in the Search API response, when this rule is triggered. This can can be used to display a pre-defined message (eg: a promotion banner) on the front-end when a particular rule is triggered. */
+    metadata?: unknown;
+    /** A sort by clause that is applied to any search query that matches the curation rule. */
+    sort_by?: string;
+    /** Replaces the current search query with this value, when the search query matches the curation rule. */
+    replace_query?: string;
+    /** When set to true, the filter conditions of the query is applied to the curated records as well. Default: false. */
+    filter_curated_hits?: boolean;
+    /** A Unix timestamp that indicates the date/time from which the curation will be active. You can use this to create rules that start applying from a future point in time. */
+    effective_from_ts?: number;
+    /** A Unix timestamp that indicates the date/time until which the curation will be active. You can use this to create rules that stop applying after a period of time. */
+    effective_to_ts?: number;
+    /** When set to true, curation processing will stop at the first matching rule. When set to false curation processing will continue and multiple curation actions will be triggered in sequence. Curations are processed in the lexical sort order of their id field. */
+    stop_processing?: boolean;
+    /** ID of the curation item */
+    id: string;
+}
+export declare const CurationItemSchema: S.Schema<CurationItemSchema>;
+export type GetCurationSetItemsResponseBodyList = Array<CurationItemSchema>;
+export declare const GetCurationSetItemsResponseBodyList: S.Schema<GetCurationSetItemsResponseBodyList>;
+export type GetCurationSetItemsResponse = GetCurationSetItemsResponseBodyList;
+export declare const GetCurationSetItemsResponse: S.Schema<GetCurationSetItemsResponse>;
+export interface GetCurationSetsRequest {
+}
+export declare const GetCurationSetsRequest: S.Schema<GetCurationSetsRequest>;
+/** Array of curation items */
+export type CurationSetSchemaItemsList = Array<CurationItemCreateSchema>;
+export declare const CurationSetSchemaItemsList: S.Schema<CurationSetSchemaItemsList>;
+export interface CurationSetSchema {
+    /** Array of curation items */
+    items: CurationSetSchemaItemsList;
+    /** Optional description for the curation set */
+    description?: string;
+    name: string;
+}
+export declare const CurationSetSchema: S.Schema<CurationSetSchema>;
+export type GetCurationSetsResponseBodyList = Array<CurationSetSchema>;
+export declare const GetCurationSetsResponseBodyList: S.Schema<GetCurationSetsResponseBodyList>;
+export type GetCurationSetsResponse = GetCurationSetsResponseBodyList;
+export declare const GetCurationSetsResponse: S.Schema<GetCurationSetsResponse>;
+export interface GetDocumentRequest {
+    /** The name of the collection to search for the document under */
+    collectionName: string;
+    /** The Document ID */
+    documentId: string;
+}
+export declare const GetDocumentRequest: S.Schema<GetDocumentRequest>;
+export type GetDocumentResponse = unknown;
+export declare const GetDocumentResponse: S.Schema<GetDocumentResponse>;
+export interface GetKeyRequest {
+    /** The ID of the key to retrieve */
+    keyId: number;
+}
+export declare const GetKeyRequest: S.Schema<GetKeyRequest>;
+export type GetKeyResponseActionsList = Array<string>;
+export declare const GetKeyResponseActionsList: S.Schema<GetKeyResponseActionsList>;
+export type GetKeyResponseCollectionsList = Array<string>;
+export declare const GetKeyResponseCollectionsList: S.Schema<GetKeyResponseCollectionsList>;
+export interface GetKeyResponse {
+    value?: string;
+    description: string;
+    actions: GetKeyResponseActionsList;
+    collections: GetKeyResponseCollectionsList;
+    expires_at?: number;
+    id?: number;
+    value_prefix?: string;
+}
+export declare const GetKeyResponse: S.Schema<GetKeyResponse>;
+export interface GetKeysRequest {
+}
+export declare const GetKeysRequest: S.Schema<GetKeysRequest>;
+export type ApiKeyActionsList = Array<string>;
+export declare const ApiKeyActionsList: S.Schema<ApiKeyActionsList>;
+export type ApiKeyCollectionsList = Array<string>;
+export declare const ApiKeyCollectionsList: S.Schema<ApiKeyCollectionsList>;
+export interface ApiKey {
+    value?: string;
+    description: string;
+    actions: ApiKeyActionsList;
+    collections: ApiKeyCollectionsList;
+    expires_at?: number;
+    id?: number;
+    value_prefix?: string;
+}
+export declare const ApiKey: S.Schema<ApiKey>;
+export type ApiKeysResponseKeysList = Array<ApiKey>;
+export declare const ApiKeysResponseKeysList: S.Schema<ApiKeysResponseKeysList>;
+export interface ApiKeysResponse {
+    keys: ApiKeysResponseKeysList;
+}
+export declare const ApiKeysResponse: S.Schema<ApiKeysResponse>;
+export interface GetMetricsRequest {
+}
+export declare const GetMetricsRequest: S.Schema<GetMetricsRequest>;
+export type GetMetricsResponse = unknown;
+export declare const GetMetricsResponse: S.Schema<GetMetricsResponse>;
+export interface GetNLSearchModelRequest {
+    /** The ID of the NL search model to retrieve */
+    modelId: string;
+}
+export declare const GetNLSearchModelRequest: S.Schema<GetNLSearchModelRequest>;
+/** Stop sequences for the NL model (Google-specific) */
+export type GetNLSearchModelResponseStopSequencesList = Array<string>;
+export declare const GetNLSearchModelResponseStopSequencesList: S.Schema<GetNLSearchModelResponseStopSequencesList>;
+export interface GetNLSearchModelResponse {
+    /** Name of the NL model to use */
+    model_name?: string;
+    /** API key for the NL model service */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Custom API URL for the NL model service */
+    api_url?: string;
+    /** Maximum number of bytes to process */
+    max_bytes?: number;
+    /** Temperature parameter for the NL model */
+    temperature?: number;
+    /** System prompt for the NL model */
+    system_prompt?: string;
+    /** Top-p parameter for the NL model (Google-specific) */
+    top_p?: number;
+    /** Top-k parameter for the NL model (Google-specific) */
+    top_k?: number;
+    /** Stop sequences for the NL model (Google-specific) */
+    stop_sequences?: GetNLSearchModelResponseStopSequencesList;
+    /** API version for the NL model service */
+    api_version?: string;
+    /** Project ID for GCP Vertex AI */
+    project_id?: string;
+    /** Access token for GCP Vertex AI */
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Refresh token for GCP Vertex AI */
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Client ID for GCP Vertex AI */
+    client_id?: string;
+    /** Client secret for GCP Vertex AI */
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    /** Region for GCP Vertex AI */
+    region?: string;
+    /** Maximum output tokens for GCP Vertex AI */
+    max_output_tokens?: number;
+    /** Account ID for Cloudflare-specific models */
+    account_id?: string;
+    /** Optional ID for the NL search model */
+    id: string;
+}
+export declare const GetNLSearchModelResponse: S.Schema<GetNLSearchModelResponse>;
+export interface GetPresetRequest {
+    /** The ID of the preset to retrieve. */
+    presetId: string;
+}
+export declare const GetPresetRequest: S.Schema<GetPresetRequest>;
+export type GetPresetResponseValue = SearchParameters | MultiSearchSearchesParameter;
+export declare const GetPresetResponseValue: any;
+export interface GetPresetResponse {
+    value: GetPresetResponseValue;
+    name: string;
+}
+export declare const GetPresetResponse: S.Schema<GetPresetResponse>;
+export interface GetSchemaChangesRequest {
+}
+export declare const GetSchemaChangesRequest: S.Schema<GetSchemaChangesRequest>;
+export interface SchemaChangeStatus {
+    /** Name of the collection being modified */
+    collection?: string;
+    /** Number of documents that have been validated */
+    validated_docs?: number;
+    /** Number of documents that have been altered */
+    altered_docs?: number;
+}
+export declare const SchemaChangeStatus: S.Schema<SchemaChangeStatus>;
+export type GetSchemaChangesResponseBodyList = Array<SchemaChangeStatus>;
+export declare const GetSchemaChangesResponseBodyList: S.Schema<GetSchemaChangesResponseBodyList>;
+export type GetSchemaChangesResponse = GetSchemaChangesResponseBodyList;
+export declare const GetSchemaChangesResponse: S.Schema<GetSchemaChangesResponse>;
+export interface GetStemmingDictionaryRequest {
+    /** The ID of the dictionary to retrieve */
+    dictionaryId: string;
+}
+export declare const GetStemmingDictionaryRequest: S.Schema<GetStemmingDictionaryRequest>;
+export interface StemmingDictionaryWordsItem {
+    /** The word form to be stemmed */
+    word: string;
+    /** The root form of the word */
+    root: string;
+}
+export declare const StemmingDictionaryWordsItem: S.Schema<StemmingDictionaryWordsItem>;
+/** List of word mappings in the dictionary */
+export type StemmingDictionaryWordsList = Array<StemmingDictionaryWordsItem>;
+export declare const StemmingDictionaryWordsList: S.Schema<StemmingDictionaryWordsList>;
+export interface StemmingDictionary {
+    /** Unique identifier for the dictionary */
+    id: string;
+    /** List of word mappings in the dictionary */
+    words: StemmingDictionaryWordsList;
+}
+export declare const StemmingDictionary: S.Schema<StemmingDictionary>;
+export interface GetStopwordsSetRequest {
+    /** The ID of the stopwords set to retrieve. */
+    setId: string;
+}
+export declare const GetStopwordsSetRequest: S.Schema<GetStopwordsSetRequest>;
+export type StopwordsSetSchemaStopwordsList = Array<string>;
+export declare const StopwordsSetSchemaStopwordsList: S.Schema<StopwordsSetSchemaStopwordsList>;
+export interface StopwordsSetSchema {
+    id: string;
+    stopwords: StopwordsSetSchemaStopwordsList;
+    locale?: string;
+}
+export declare const StopwordsSetSchema: S.Schema<StopwordsSetSchema>;
+export interface StopwordsSetRetrieveSchema {
+    stopwords: StopwordsSetSchema;
+}
+export declare const StopwordsSetRetrieveSchema: S.Schema<StopwordsSetRetrieveSchema>;
+export interface GetStopwordsSetsRequest {
+}
+export declare const GetStopwordsSetsRequest: S.Schema<GetStopwordsSetsRequest>;
+export type StopwordsSetsRetrieveAllSchemaStopwordsList = Array<StopwordsSetSchema>;
+export declare const StopwordsSetsRetrieveAllSchemaStopwordsList: S.Schema<StopwordsSetsRetrieveAllSchemaStopwordsList>;
+export interface StopwordsSetsRetrieveAllSchema {
+    stopwords: StopwordsSetsRetrieveAllSchemaStopwordsList;
+}
+export declare const StopwordsSetsRetrieveAllSchema: S.Schema<StopwordsSetsRetrieveAllSchema>;
+export interface GetSynonymSetRequest {
+    /** The name of the synonym set to retrieve */
+    synonymSetName: string;
+}
+export declare const GetSynonymSetRequest: S.Schema<GetSynonymSetRequest>;
+/** Array of words that should be considered as synonyms */
+export type SynonymItemSchemaSynonymsList = Array<string>;
+export declare const SynonymItemSchemaSynonymsList: S.Schema<SynonymItemSchemaSynonymsList>;
+/** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+export type SynonymItemSchemaSymbolsToIndexList = Array<string>;
+export declare const SynonymItemSchemaSymbolsToIndexList: S.Schema<SynonymItemSchemaSymbolsToIndexList>;
+export interface SynonymItemSchema {
+    /** Unique identifier for the synonym item */
+    id: string;
+    /** Array of words that should be considered as synonyms */
+    synonyms: SynonymItemSchemaSynonymsList;
+    /** For 1-way synonyms, indicates the root word that words in the synonyms parameter map to */
+    root?: string;
+    /** Locale for the synonym, leave blank to use the standard tokenizer */
+    locale?: string;
+    /** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+    symbols_to_index?: SynonymItemSchemaSymbolsToIndexList;
+}
+export declare const SynonymItemSchema: S.Schema<SynonymItemSchema>;
+/** Array of synonym items */
+export type GetSynonymSetResponseItemsList = Array<SynonymItemSchema>;
+export declare const GetSynonymSetResponseItemsList: S.Schema<GetSynonymSetResponseItemsList>;
+export interface GetSynonymSetResponse {
+    /** Array of synonym items */
+    items: GetSynonymSetResponseItemsList;
+    /** Name of the synonym set */
+    name: string;
+}
+export declare const GetSynonymSetResponse: S.Schema<GetSynonymSetResponse>;
+export interface GetSynonymSetItemRequest {
+    /** The name of the synonym set */
+    synonymSetName: string;
+    /** The id of the synonym item to retrieve */
+    itemId: string;
+}
+export declare const GetSynonymSetItemRequest: S.Schema<GetSynonymSetItemRequest>;
+/** Array of words that should be considered as synonyms */
+export type GetSynonymSetItemResponseSynonymsList = Array<string>;
+export declare const GetSynonymSetItemResponseSynonymsList: S.Schema<GetSynonymSetItemResponseSynonymsList>;
+/** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+export type GetSynonymSetItemResponseSymbolsToIndexList = Array<string>;
+export declare const GetSynonymSetItemResponseSymbolsToIndexList: S.Schema<GetSynonymSetItemResponseSymbolsToIndexList>;
+export interface GetSynonymSetItemResponse {
+    /** Unique identifier for the synonym item */
+    id: string;
+    /** Array of words that should be considered as synonyms */
+    synonyms: GetSynonymSetItemResponseSynonymsList;
+    /** For 1-way synonyms, indicates the root word that words in the synonyms parameter map to */
+    root?: string;
+    /** Locale for the synonym, leave blank to use the standard tokenizer */
+    locale?: string;
+    /** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+    symbols_to_index?: GetSynonymSetItemResponseSymbolsToIndexList;
+}
+export declare const GetSynonymSetItemResponse: S.Schema<GetSynonymSetItemResponse>;
+export interface GetSynonymSetItemsRequest {
+    /** The name of the synonym set to retrieve items for */
+    synonymSetName: string;
+}
+export declare const GetSynonymSetItemsRequest: S.Schema<GetSynonymSetItemsRequest>;
+export type GetSynonymSetItemsResponseBodyList = Array<SynonymItemSchema>;
+export declare const GetSynonymSetItemsResponseBodyList: S.Schema<GetSynonymSetItemsResponseBodyList>;
+export type GetSynonymSetItemsResponse = GetSynonymSetItemsResponseBodyList;
+export declare const GetSynonymSetItemsResponse: S.Schema<GetSynonymSetItemsResponse>;
+export interface GetSynonymSetsRequest {
+}
+export declare const GetSynonymSetsRequest: S.Schema<GetSynonymSetsRequest>;
+/** Array of synonym items */
+export type SynonymSetSchemaItemsList = Array<SynonymItemSchema>;
+export declare const SynonymSetSchemaItemsList: S.Schema<SynonymSetSchemaItemsList>;
+export interface SynonymSetSchema {
+    /** Array of synonym items */
+    items: SynonymSetSchemaItemsList;
+    /** Name of the synonym set */
+    name: string;
+}
+export declare const SynonymSetSchema: S.Schema<SynonymSetSchema>;
+export type GetSynonymSetsResponseBodyList = Array<SynonymSetSchema>;
+export declare const GetSynonymSetsResponseBodyList: S.Schema<GetSynonymSetsResponseBodyList>;
+export type GetSynonymSetsResponse = GetSynonymSetsResponseBodyList;
+export declare const GetSynonymSetsResponse: S.Schema<GetSynonymSetsResponse>;
+export interface HealthRequest {
+}
+export declare const HealthRequest: S.Schema<HealthRequest>;
+export interface HealthStatus {
+    ok: boolean;
+}
+export declare const HealthStatus: S.Schema<HealthStatus>;
+export type IndexAction = "create" | "update" | "upsert" | "emplace";
+export declare const IndexAction: any;
+export type DirtyValues = "coerce_or_reject" | "coerce_or_drop" | "drop" | "reject";
+export declare const DirtyValues: any;
+export interface ImportDocumentsRequestImportDocumentsParameters {
+    batch_size?: number;
+    /** Returning the id of the imported documents. If you want the import response to return the ingested document's id in the response, you can use the return_id parameter. */
+    return_id?: boolean;
+    remote_embedding_batch_size?: number;
+    return_doc?: boolean;
+    action?: IndexAction | (string & {});
+    dirty_values?: DirtyValues | (string & {});
+}
+export declare const ImportDocumentsRequestImportDocumentsParameters: S.Schema<ImportDocumentsRequestImportDocumentsParameters>;
+export interface ImportDocumentsRequest {
+    /** The name of the collection */
+    collectionName: string;
+    importDocumentsParameters?: ImportDocumentsRequestImportDocumentsParameters;
+}
+export declare const ImportDocumentsRequest: S.Schema<ImportDocumentsRequest>;
+export interface ImportDocumentsResponse {
+}
+export declare const ImportDocumentsResponse: S.Schema<ImportDocumentsResponse>;
+export interface ImportStemmingDictionaryRequest {
+    /** The ID to assign to the dictionary */
+    id: string;
+    body: string;
+}
+export declare const ImportStemmingDictionaryRequest: S.Schema<ImportStemmingDictionaryRequest>;
+export interface ImportStemmingDictionaryResponse {
+}
+export declare const ImportStemmingDictionaryResponse: S.Schema<ImportStemmingDictionaryResponse>;
+export interface ListDocumentRequest {
+    /** The name of the collection to add the document to */
+    collectionName: string;
+    /** Additional action to perform */
+    action?: IndexAction | (string & {});
+    /** Dealing with Dirty Data */
+    dirty_values?: DirtyValues | (string & {});
+}
+export declare const ListDocumentRequest: S.Schema<ListDocumentRequest>;
+export type ListDocumentResponse = unknown;
+export declare const ListDocumentResponse: S.Schema<ListDocumentResponse>;
+export interface ListStemmingDictionariesRequest {
+}
+export declare const ListStemmingDictionariesRequest: S.Schema<ListStemmingDictionariesRequest>;
+export type ListStemmingDictionariesResponseDictionariesList = Array<string>;
+export declare const ListStemmingDictionariesResponseDictionariesList: S.Schema<ListStemmingDictionariesResponseDictionariesList>;
+export interface ListStemmingDictionariesResponse {
+    dictionaries?: ListStemmingDictionariesResponseDictionariesList;
+}
+export declare const ListStemmingDictionariesResponse: S.Schema<ListStemmingDictionariesResponse>;
+export interface SearchCollectionRequest {
+    /** The name of the collection to search for the document under */
+    collectionName: string;
+    searchParameters: SearchParameters;
+}
+export declare const SearchCollectionRequest: S.Schema<SearchCollectionRequest>;
+export interface FacetCountsCountsItem {
+    count?: number;
+    highlighted?: string;
+    value?: string;
+    parent?: unknown;
+}
+export declare const FacetCountsCountsItem: S.Schema<FacetCountsCountsItem>;
+export type FacetCountsCountsList = Array<FacetCountsCountsItem>;
+export declare const FacetCountsCountsList: S.Schema<FacetCountsCountsList>;
+export interface FacetCountsStats {
+    max?: number;
+    min?: number;
+    sum?: number;
+    total_values?: number;
+    avg?: number;
+}
+export declare const FacetCountsStats: S.Schema<FacetCountsStats>;
+export interface FacetCounts {
+    counts?: FacetCountsCountsList;
+    field_name?: string;
+    sampled?: boolean;
+    stats?: FacetCountsStats;
+}
+export declare const FacetCounts: S.Schema<FacetCounts>;
+export type SearchResultFacetCountsList = Array<FacetCounts>;
+export declare const SearchResultFacetCountsList: S.Schema<SearchResultFacetCountsList>;
+export type SearchGroupedHitGroupKeyList = Array<unknown>;
+export declare const SearchGroupedHitGroupKeyList: S.Schema<SearchGroupedHitGroupKeyList>;
+/** Present only for (array) string[] fields */
+export type SearchHighlightSnippetsList = Array<string>;
+export declare const SearchHighlightSnippetsList: S.Schema<SearchHighlightSnippetsList>;
+/** Full field value with highlighting, present only for (array) string[] fields */
+export type SearchHighlightValuesList = Array<string>;
+export declare const SearchHighlightValuesList: S.Schema<SearchHighlightValuesList>;
+/** The indices property will be present only for string[] fields and will contain the corresponding indices of the snippets in the search field */
+export type SearchHighlightIndicesList = Array<number>;
+export declare const SearchHighlightIndicesList: S.Schema<SearchHighlightIndicesList>;
+export type SearchHighlightMatchedTokensList = Array<unknown>;
+export declare const SearchHighlightMatchedTokensList: S.Schema<SearchHighlightMatchedTokensList>;
+export interface SearchHighlight {
+    field?: string;
+    /** Present only for (non-array) string fields */
+    snippet?: string;
+    /** Present only for (array) string[] fields */
+    snippets?: SearchHighlightSnippetsList;
+    /** Full field value with highlighting, present only for (non-array) string fields */
+    value?: string;
+    /** Full field value with highlighting, present only for (array) string[] fields */
+    values?: SearchHighlightValuesList;
+    /** The indices property will be present only for string[] fields and will contain the corresponding indices of the snippets in the search field */
+    indices?: SearchHighlightIndicesList;
+    matched_tokens?: SearchHighlightMatchedTokensList;
+}
+export declare const SearchHighlight: S.Schema<SearchHighlight>;
+/** (Deprecated) Contains highlighted portions of the search fields */
+export type SearchResultHitHighlightsList = Array<SearchHighlight>;
+export declare const SearchResultHitHighlightsList: S.Schema<SearchResultHitHighlightsList>;
+/** Highlighted version of the matching document */
+export type SearchResultHitHighlightMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const SearchResultHitHighlightMap: S.Schema<SearchResultHitHighlightMap>;
+/** Can be any key-value pair */
+export type SearchResultHitDocumentMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const SearchResultHitDocumentMap: S.Schema<SearchResultHitDocumentMap>;
+export interface SearchResultHitTextMatchInfo {
+    best_field_score?: string;
+    best_field_weight?: number;
+    fields_matched?: number;
+    num_tokens_dropped?: number;
+    score?: string;
+    tokens_matched?: number;
+    typo_prefix_score?: number;
+}
+export declare const SearchResultHitTextMatchInfo: S.Schema<SearchResultHitTextMatchInfo>;
+/** Can be any key-value pair */
+export type SearchResultHitGeoDistanceMetersMap = {
+    [key: string]: number | undefined;
+};
+export declare const SearchResultHitGeoDistanceMetersMap: S.Schema<SearchResultHitGeoDistanceMetersMap>;
+/** Information about hybrid search scoring */
+export interface SearchResultHitHybridSearchInfo {
+    /** Combined score from rank fusion of text and vector search */
+    rank_fusion_score?: number;
+}
+export declare const SearchResultHitHybridSearchInfo: S.Schema<SearchResultHitHybridSearchInfo>;
+export interface SearchResultHit {
+    /** (Deprecated) Contains highlighted portions of the search fields */
+    highlights?: SearchResultHitHighlightsList;
+    /** Highlighted version of the matching document */
+    highlight?: SearchResultHitHighlightMap;
+    /** Can be any key-value pair */
+    document?: SearchResultHitDocumentMap;
+    text_match?: number;
+    text_match_info?: SearchResultHitTextMatchInfo;
+    /** Can be any key-value pair */
+    geo_distance_meters?: SearchResultHitGeoDistanceMetersMap;
+    /** Distance between the query vector and matching document's vector value */
+    vector_distance?: number;
+    /** Information about hybrid search scoring */
+    hybrid_search_info?: SearchResultHitHybridSearchInfo;
+    /** Returned only for union query response. Indicates the index of the query which this document matched to. */
+    search_index?: number;
+}
+export declare const SearchResultHit: S.Schema<SearchResultHit>;
+/** The documents that matched the search query */
+export type SearchGroupedHitHitsList = Array<SearchResultHit>;
+export declare const SearchGroupedHitHitsList: S.Schema<SearchGroupedHitHitsList>;
+export interface SearchGroupedHit {
+    found?: number;
+    group_key: SearchGroupedHitGroupKeyList;
+    /** The documents that matched the search query */
+    hits: SearchGroupedHitHitsList;
+}
+export declare const SearchGroupedHit: S.Schema<SearchGroupedHit>;
+export type SearchResultGroupedHitsList = Array<SearchGroupedHit>;
+export declare const SearchResultGroupedHitsList: S.Schema<SearchResultGroupedHitsList>;
+/** The documents that matched the search query */
+export type SearchResultHitsList = Array<SearchResultHit>;
+export declare const SearchResultHitsList: S.Schema<SearchResultHitsList>;
+export interface SearchRequestParamsVoiceQuery {
+    transcribed_query?: string;
+}
+export declare const SearchRequestParamsVoiceQuery: S.Schema<SearchRequestParamsVoiceQuery>;
+export interface SearchRequestParams {
+    collection_name: string;
+    first_q?: string;
+    q: string;
+    per_page: number;
+    voice_query?: SearchRequestParamsVoiceQuery;
+}
+export declare const SearchRequestParams: S.Schema<SearchRequestParams>;
+export type SearchResultConversationConversationHistoryList = Array<unknown>;
+export declare const SearchResultConversationConversationHistoryList: S.Schema<SearchResultConversationConversationHistoryList>;
+export interface SearchResultConversation {
+    answer: string;
+    conversation_history: SearchResultConversationConversationHistoryList;
+    conversation_id: string;
+    query: string;
+}
+export declare const SearchResultConversation: S.Schema<SearchResultConversation>;
+/** Returned only for union query response. */
+export type SearchResultUnionRequestParamsList = Array<SearchRequestParams>;
+export declare const SearchResultUnionRequestParamsList: S.Schema<SearchResultUnionRequestParamsList>;
+/** Custom JSON object that can be returned in the search response */
+export type SearchResultMetadataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const SearchResultMetadataMap: S.Schema<SearchResultMetadataMap>;
+export interface SearchResult {
+    facet_counts?: SearchResultFacetCountsList;
+    /** The number of documents found */
+    found?: number;
+    found_docs?: number;
+    /** The number of milliseconds the search took */
+    search_time_ms?: number;
+    /** The total number of documents in the collection */
+    out_of?: number;
+    /** Whether the search was cut off */
+    search_cutoff?: boolean;
+    /** The search result page number */
+    page?: number;
+    grouped_hits?: SearchResultGroupedHitsList;
+    /** The documents that matched the search query */
+    hits?: SearchResultHitsList;
+    request_params?: SearchRequestParams;
+    conversation?: SearchResultConversation;
+    /** Returned only for union query response. */
+    union_request_params?: SearchResultUnionRequestParamsList;
+    /** Custom JSON object that can be returned in the search response */
+    metadata?: SearchResultMetadataMap;
+}
+export declare const SearchResult: S.Schema<SearchResult>;
+/** Parameters for the multi search API. */
+export interface MultiSearchParameters {
+    /** The query text to search for in the collection. Use * as the search string to return all documents. This is typically useful when used in conjunction with filter_by. */
+    q?: string;
+    /** A list of `string` fields that should be queried against. Multiple fields are separated with a comma. */
+    query_by?: string;
+    /** The relative weight to give each `query_by` field when ranking results. This can be used to boost fields in priority, when looking for matches. Multiple fields are separated with a comma. */
+    query_by_weights?: string;
+    /** In a multi-field matching context, this parameter determines how the representative text match score of a record is calculated. Possible values are max_score (default) or max_weight. */
+    text_match_type?: string;
+    /** Boolean field to indicate that the last word in the query should be treated as a prefix, and not as a whole word. This is used for building autocomplete and instant search interfaces. Defaults to true. */
+    prefix?: string;
+    /** If infix index is enabled for this field, infix searching can be done on a per-field basis by sending a comma separated string parameter called infix to the search query. This parameter can have 3 values; `off` infix search is disabled, which is default `always` infix search is performed along with regular search `fallback` infix search is performed if regular search does not produce results */
+    infix?: string;
+    /** There are also 2 parameters that allow you to control the extent of infix searching max_extra_prefix and max_extra_suffix which specify the maximum number of symbols before or after the query that can be present in the token. For example query "K2100" has 2 extra symbols in "6PK2100". By default, any number of prefixes/suffixes can be present for a match. */
+    max_extra_prefix?: number;
+    /** There are also 2 parameters that allow you to control the extent of infix searching max_extra_prefix and max_extra_suffix which specify the maximum number of symbols before or after the query that can be present in the token. For example query "K2100" has 2 extra symbols in "6PK2100". By default, any number of prefixes/suffixes can be present for a match. */
+    max_extra_suffix?: number;
+    /** Filter conditions for refining youropen api validator search results. Separate multiple conditions with &&. */
+    filter_by?: string;
+    /** A list of numerical fields and their corresponding sort orders that will be used for ordering your results. Up to 3 sort fields can be specified. The text similarity score is exposed as a special `_text_match` field that you can use in the list of sorting fields. If no `sort_by` parameter is specified, results are sorted by `_text_match:desc,default_sorting_field:desc` */
+    sort_by?: string;
+    /** A list of fields that will be used for faceting your results on. Separate multiple fields with a comma. */
+    facet_by?: string;
+    /** Maximum number of facet values to be returned. */
+    max_facet_values?: number;
+    /** Facet values that are returned can now be filtered via this parameter. The matching facet text is also highlighted. For example, when faceting by `category`, you can set `facet_query=category:shoe` to return only facet values that contain the prefix "shoe". */
+    facet_query?: string;
+    /** The number of typographical errors (1 or 2) that would be tolerated. Default: 2 */
+    num_typos?: string;
+    /** Results from this specific page number would be fetched. */
+    page?: number;
+    /** Number of results to fetch per page. Default: 10 */
+    per_page?: number;
+    /** Number of hits to fetch. Can be used as an alternative to the per_page parameter. Default: 10. */
+    limit?: number;
+    /** Identifies the starting point to return hits from a result set. Can be used as an alternative to the page parameter. */
+    offset?: number;
+    /** You can aggregate search results into groups or buckets by specify one or more `group_by` fields. Separate multiple fields with a comma. To group on a particular field, it must be a faceted field. */
+    group_by?: string;
+    /** Maximum number of hits to be returned for every group. If the `group_limit` is set as `K` then only the top K hits in each group are returned in the response. Default: 3 */
+    group_limit?: number;
+    /** Setting this parameter to true will place all documents that have a null value in the group_by field, into a single group. Setting this parameter to false, will cause each document with a null value in the group_by field to not be grouped with other documents. Default: true */
+    group_missing_values?: boolean;
+    /** List of fields from the document to include in the search result */
+    include_fields?: string;
+    /** List of fields from the document to exclude in the search result */
+    exclude_fields?: string;
+    /** List of fields which should be highlighted fully without snippeting */
+    highlight_full_fields?: string;
+    /** The number of tokens that should surround the highlighted text on each side. Default: 4 */
+    highlight_affix_num_tokens?: number;
+    /** The start tag used for the highlighted snippets. Default: `<mark>` */
+    highlight_start_tag?: string;
+    /** The end tag used for the highlighted snippets. Default: `</mark>` */
+    highlight_end_tag?: string;
+    /** Field values under this length will be fully highlighted, instead of showing a snippet of relevant portion. Default: 30 */
+    snippet_threshold?: number;
+    /** If the number of results found for a specific query is less than this number, Typesense will attempt to drop the tokens in the query until enough results are found. Tokens that have the least individual hits are dropped first. Set to 0 to disable. Default: 10 */
+    drop_tokens_threshold?: number;
+    drop_tokens_mode?: DropTokensMode | (string & {});
+    /** If the number of results found for a specific query is less than this number, Typesense will attempt to look for tokens with more typos until enough results are found. Default: 100 */
+    typo_tokens_threshold?: number;
+    /** Set this parameter to false to disable typos on alphanumerical query tokens. Default: true. */
+    enable_typos_for_alpha_numerical_tokens?: boolean;
+    /** Whether the filter_by condition of the search query should be applicable to curated results (curation definitions, pinned hits, hidden hits, etc.). Default: false */
+    filter_curated_hits?: boolean;
+    /** If you have some synonyms defined but want to disable all of them for a particular search query, set enable_synonyms to false. Default: true */
+    enable_synonyms?: boolean;
+    /** Flag for enabling/disabling analytics aggregation for specific search queries (for e.g. those originating from a test script). */
+    enable_analytics?: boolean;
+    /** Allow synonym resolution on word prefixes in the query. Default: false */
+    synonym_prefix?: boolean;
+    /** Allow synonym resolution on typo-corrected words in the query. Default: 0 */
+    synonym_num_typos?: number;
+    /** A list of records to unconditionally include in the search results at specific positions. An example use case would be to feature or promote certain items on the top of search results. A list of `record_id:hit_position`. Eg: to include a record with ID 123 at Position 1 and another record with ID 456 at Position 5, you'd specify `123:1,456:5`. You could also use the Curation feature to override search results based on rules. Curations are applied first, followed by `pinned_hits` and finally `hidden_hits`. */
+    pinned_hits?: string;
+    /** A list of records to unconditionally hide from search results. A list of `record_id`s to hide. Eg: to hide records with IDs 123 and 456, you'd specify `123,456`. You could also use the Curation feature to override search results based on rules. Curations are applied first, followed by `pinned_hits` and finally `hidden_hits`. */
+    hidden_hits?: string;
+    /** Comma separated list of tags to trigger the curations rules that match the tags. */
+    curation_tags?: string;
+    /** A list of custom fields that must be highlighted even if you don't query for them */
+    highlight_fields?: string;
+    /** You can index content from any logographic language into Typesense if you are able to segment / split the text into space-separated words yourself before indexing and querying. Set this parameter to true to do the same */
+    pre_segmented_query?: boolean;
+    /** Search using a bunch of search parameters by setting this parameter to the name of the existing Preset. */
+    preset?: string;
+    /** If you have some curation sets defined but want to disable all of them during query time, you can do that by setting this parameter to false */
+    enable_curations?: boolean;
+    /** Set this parameter to true to ensure that an exact match is ranked above the others */
+    prioritize_exact_match?: boolean;
+    /** Make Typesense prioritize documents where the query words appear earlier in the text. */
+    prioritize_token_position?: boolean;
+    /** Make Typesense prioritize documents where the query words appear in more number of fields. */
+    prioritize_num_matching_fields?: boolean;
+    /** Make Typesense disable typos for numerical tokens. */
+    enable_typos_for_numerical_tokens?: boolean;
+    /** Setting this to true will make Typesense consider all prefixes and typo corrections of the words in the query without stopping early when enough results are found (drop_tokens_threshold and typo_tokens_threshold configurations are ignored). */
+    exhaustive_search?: boolean;
+    /** Typesense will attempt to return results early if the cutoff time has elapsed. This is not a strict guarantee and facet computation is not bound by this parameter. */
+    search_cutoff_ms?: number;
+    /** Enable server side caching of search query results. By default, caching is disabled. */
+    use_cache?: boolean;
+    /** The duration (in seconds) that determines how long the search query is cached. This value can be set on a per-query basis. Default: 60. */
+    cache_ttl?: number;
+    /** Minimum word length for 1-typo correction to be applied. The value of num_typos is still treated as the maximum allowed typos. */
+    min_len_1typo?: number;
+    /** Minimum word length for 2-typo correction to be applied. The value of num_typos is still treated as the maximum allowed typos. */
+    min_len_2typo?: number;
+    /** Vector query expression for fetching documents "closest" to a given query/document vector. */
+    vector_query?: string;
+    /** Timeout (in milliseconds) for fetching remote embeddings. */
+    remote_embedding_timeout_ms?: number;
+    /** Number of times to retry fetching remote embeddings. */
+    remote_embedding_num_tries?: number;
+    /** Choose the underlying faceting strategy used. Comma separated string of allows values: exhaustive, top_values or automatic (default). */
+    facet_strategy?: string;
+    /** Name of the stopwords set to apply for this search, the keywords present in the set will be removed from the search query. */
+    stopwords?: string;
+    /** Comma separated string of nested facet fields whose parent object should be returned in facet response. */
+    facet_return_parent?: string;
+    /** The base64 encoded audio file in 16 khz 16-bit WAV format. */
+    voice_query?: string;
+    /** Enable conversational search. */
+    conversation?: boolean;
+    /** The Id of Conversation Model to be used. */
+    conversation_model_id?: string;
+    /** The Id of a previous conversation to continue, this tells Typesense to include prior context when communicating with the LLM. */
+    conversation_id?: string;
+    /** Controls whether Typesense should validate if the fields exist in the schema. When set to false, Typesense will not throw an error if a field is missing. This is useful for programmatic grouping where not all fields may exist. */
+    validate_field_names?: boolean;
+}
+export declare const MultiSearchParameters: S.Schema<MultiSearchParameters>;
+export type SearchMultiRequestSearchesList = Array<MultiSearchCollectionParameters>;
+export declare const SearchMultiRequestSearchesList: S.Schema<SearchMultiRequestSearchesList>;
+export interface SearchMultiRequest {
+    multiSearchParameters: MultiSearchParameters;
+    /** When true, merges the search results from each search query into a single ordered set of hits. */
+    union?: boolean;
+    searches: SearchMultiRequestSearchesList;
+}
+export declare const SearchMultiRequest: S.Schema<SearchMultiRequest>;
+export type MultiSearchResultItemFacetCountsList = Array<FacetCounts>;
+export declare const MultiSearchResultItemFacetCountsList: S.Schema<MultiSearchResultItemFacetCountsList>;
+export type MultiSearchResultItemGroupedHitsList = Array<SearchGroupedHit>;
+export declare const MultiSearchResultItemGroupedHitsList: S.Schema<MultiSearchResultItemGroupedHitsList>;
+/** The documents that matched the search query */
+export type MultiSearchResultItemHitsList = Array<SearchResultHit>;
+export declare const MultiSearchResultItemHitsList: S.Schema<MultiSearchResultItemHitsList>;
+/** Returned only for union query response. */
+export type MultiSearchResultItemUnionRequestParamsList = Array<SearchRequestParams>;
+export declare const MultiSearchResultItemUnionRequestParamsList: S.Schema<MultiSearchResultItemUnionRequestParamsList>;
+/** Custom JSON object that can be returned in the search response */
+export type MultiSearchResultItemMetadataMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const MultiSearchResultItemMetadataMap: S.Schema<MultiSearchResultItemMetadataMap>;
+export interface MultiSearchResultItem {
+    facet_counts?: MultiSearchResultItemFacetCountsList;
+    /** The number of documents found */
+    found?: number;
+    found_docs?: number;
+    /** The number of milliseconds the search took */
+    search_time_ms?: number;
+    /** The total number of documents in the collection */
+    out_of?: number;
+    /** Whether the search was cut off */
+    search_cutoff?: boolean;
+    /** The search result page number */
+    page?: number;
+    grouped_hits?: MultiSearchResultItemGroupedHitsList;
+    /** The documents that matched the search query */
+    hits?: MultiSearchResultItemHitsList;
+    request_params?: SearchRequestParams;
+    conversation?: SearchResultConversation;
+    /** Returned only for union query response. */
+    union_request_params?: MultiSearchResultItemUnionRequestParamsList;
+    /** Custom JSON object that can be returned in the search response */
+    metadata?: MultiSearchResultItemMetadataMap;
+    /** HTTP error code */
+    code?: number;
+    /** Error description */
+    error?: string;
+}
+export declare const MultiSearchResultItem: S.Schema<MultiSearchResultItem>;
+export type MultiSearchResultResultsList = Array<MultiSearchResultItem>;
+export declare const MultiSearchResultResultsList: S.Schema<MultiSearchResultResultsList>;
+export interface MultiSearchResult {
+    results: MultiSearchResultResultsList;
+    conversation?: SearchResultConversation;
+}
+export declare const MultiSearchResult: S.Schema<MultiSearchResult>;
+export interface TakeSnapshotRequest {
+    /** The directory on the server where the snapshot should be saved. */
+    snapshot_path: string;
+}
+export declare const TakeSnapshotRequest: S.Schema<TakeSnapshotRequest>;
+export interface ToggleSlowRequestLogRequest {
+    log_slow_requests_time_ms: number;
+}
+export declare const ToggleSlowRequestLogRequest: S.Schema<ToggleSlowRequestLogRequest>;
+/** A list of fields for querying, filtering and faceting */
+export type UpdateCollectionRequestFieldsList = Array<Field>;
+export declare const UpdateCollectionRequestFieldsList: S.Schema<UpdateCollectionRequestFieldsList>;
+/** List of synonym set names to associate with this collection */
+export type UpdateCollectionRequestSynonymSetsList = Array<string>;
+export declare const UpdateCollectionRequestSynonymSetsList: S.Schema<UpdateCollectionRequestSynonymSetsList>;
+export interface UpdateCollectionRequest {
+    /** The name of the collection to update */
+    collectionName: string;
+    /** A list of fields for querying, filtering and faceting */
+    fields?: UpdateCollectionRequestFieldsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: UpdateCollectionRequestSynonymSetsList;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+}
+export declare const UpdateCollectionRequest: S.Schema<UpdateCollectionRequest>;
+/** A list of fields for querying, filtering and faceting */
+export type CollectionUpdateSchemaFieldsList = Array<Field>;
+export declare const CollectionUpdateSchemaFieldsList: S.Schema<CollectionUpdateSchemaFieldsList>;
+/** List of synonym set names to associate with this collection */
+export type CollectionUpdateSchemaSynonymSetsList = Array<string>;
+export declare const CollectionUpdateSchemaSynonymSetsList: S.Schema<CollectionUpdateSchemaSynonymSetsList>;
+export interface CollectionUpdateSchema {
+    /** A list of fields for querying, filtering and faceting */
+    fields?: CollectionUpdateSchemaFieldsList;
+    /** List of synonym set names to associate with this collection */
+    synonym_sets?: CollectionUpdateSchemaSynonymSetsList;
+    /** Optional details about the collection, e.g., when it was created, who created it etc. */
+    metadata?: unknown;
+}
+export declare const CollectionUpdateSchema: S.Schema<CollectionUpdateSchema>;
+export interface UpdateConversationModelRequest {
+    /** The id of the conversation model to update */
+    modelId: string;
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id?: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name?: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection?: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes?: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const UpdateConversationModelRequest: S.Schema<UpdateConversationModelRequest>;
+export interface UpdateConversationModelResponse {
+    /** An explicit id for the model, otherwise the API will return a response with an auto-generated conversation model id. */
+    id: string;
+    /** Name of the LLM model offered by OpenAI, Cloudflare or vLLM */
+    model_name: string;
+    /** The LLM service's API Key */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Typesense collection that stores the historical conversations */
+    history_collection: string;
+    /** LLM service's account ID (only applicable for Cloudflare) */
+    account_id?: string;
+    /** The system prompt that contains special instructions to the LLM */
+    system_prompt?: string;
+    /** Time interval in seconds after which the messages would be deleted. Default: 86400 (24 hours) */
+    ttl?: number;
+    /** The maximum number of bytes to send to the LLM in every API call. Consult the LLM's documentation on the number of bytes supported in the context window. */
+    max_bytes: number;
+    /** URL of vLLM service */
+    vllm_url?: string;
+}
+export declare const UpdateConversationModelResponse: S.Schema<UpdateConversationModelResponse>;
+export interface UpdateDocumentRequest {
+    /** The name of the collection to search for the document under */
+    collectionName: string;
+    /** The Document ID */
+    documentId: string;
+    /** Dealing with Dirty Data */
+    dirty_values?: DirtyValues | (string & {});
+}
+export declare const UpdateDocumentRequest: S.Schema<UpdateDocumentRequest>;
+export type UpdateDocumentResponse = unknown;
+export declare const UpdateDocumentResponse: S.Schema<UpdateDocumentResponse>;
+export interface UpdateDocumentsRequestUpdateDocumentsParameters {
+    filter_by?: string;
+}
+export declare const UpdateDocumentsRequestUpdateDocumentsParameters: S.Schema<UpdateDocumentsRequestUpdateDocumentsParameters>;
+export interface UpdateDocumentsRequest {
+    /** The name of the collection to update documents in */
+    collectionName: string;
+    updateDocumentsParameters?: UpdateDocumentsRequestUpdateDocumentsParameters;
+}
+export declare const UpdateDocumentsRequest: S.Schema<UpdateDocumentsRequest>;
+export interface UpdateDocumentsResponse {
+    /** The number of documents that have been updated */
+    num_updated: number;
+}
+export declare const UpdateDocumentsResponse: S.Schema<UpdateDocumentsResponse>;
+/** Stop sequences for the NL model (Google-specific) */
+export type UpdateNLSearchModelRequestStopSequencesList = Array<string>;
+export declare const UpdateNLSearchModelRequestStopSequencesList: S.Schema<UpdateNLSearchModelRequestStopSequencesList>;
+export interface UpdateNLSearchModelRequest {
+    /** The ID of the NL search model to update */
+    modelId: string;
+    /** Name of the NL model to use */
+    model_name?: string;
+    /** API key for the NL model service */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Custom API URL for the NL model service */
+    api_url?: string;
+    /** Maximum number of bytes to process */
+    max_bytes?: number;
+    /** Temperature parameter for the NL model */
+    temperature?: number;
+    /** System prompt for the NL model */
+    system_prompt?: string;
+    /** Top-p parameter for the NL model (Google-specific) */
+    top_p?: number;
+    /** Top-k parameter for the NL model (Google-specific) */
+    top_k?: number;
+    /** Stop sequences for the NL model (Google-specific) */
+    stop_sequences?: UpdateNLSearchModelRequestStopSequencesList;
+    /** API version for the NL model service */
+    api_version?: string;
+    /** Project ID for GCP Vertex AI */
+    project_id?: string;
+    /** Access token for GCP Vertex AI */
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Refresh token for GCP Vertex AI */
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Client ID for GCP Vertex AI */
+    client_id?: string;
+    /** Client secret for GCP Vertex AI */
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    /** Region for GCP Vertex AI */
+    region?: string;
+    /** Maximum output tokens for GCP Vertex AI */
+    max_output_tokens?: number;
+    /** Account ID for Cloudflare-specific models */
+    account_id?: string;
+    /** Optional ID for the NL search model */
+    id?: string;
+}
+export declare const UpdateNLSearchModelRequest: S.Schema<UpdateNLSearchModelRequest>;
+/** Stop sequences for the NL model (Google-specific) */
+export type UpdateNLSearchModelResponseStopSequencesList = Array<string>;
+export declare const UpdateNLSearchModelResponseStopSequencesList: S.Schema<UpdateNLSearchModelResponseStopSequencesList>;
+export interface UpdateNLSearchModelResponse {
+    /** Name of the NL model to use */
+    model_name?: string;
+    /** API key for the NL model service */
+    api_key?: string | import("effect/Redacted").Redacted<string>;
+    /** Custom API URL for the NL model service */
+    api_url?: string;
+    /** Maximum number of bytes to process */
+    max_bytes?: number;
+    /** Temperature parameter for the NL model */
+    temperature?: number;
+    /** System prompt for the NL model */
+    system_prompt?: string;
+    /** Top-p parameter for the NL model (Google-specific) */
+    top_p?: number;
+    /** Top-k parameter for the NL model (Google-specific) */
+    top_k?: number;
+    /** Stop sequences for the NL model (Google-specific) */
+    stop_sequences?: UpdateNLSearchModelResponseStopSequencesList;
+    /** API version for the NL model service */
+    api_version?: string;
+    /** Project ID for GCP Vertex AI */
+    project_id?: string;
+    /** Access token for GCP Vertex AI */
+    access_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Refresh token for GCP Vertex AI */
+    refresh_token?: string | import("effect/Redacted").Redacted<string>;
+    /** Client ID for GCP Vertex AI */
+    client_id?: string;
+    /** Client secret for GCP Vertex AI */
+    client_secret?: string | import("effect/Redacted").Redacted<string>;
+    /** Region for GCP Vertex AI */
+    region?: string;
+    /** Maximum output tokens for GCP Vertex AI */
+    max_output_tokens?: number;
+    /** Account ID for Cloudflare-specific models */
+    account_id?: string;
+    /** Optional ID for the NL search model */
+    id: string;
+}
+export declare const UpdateNLSearchModelResponse: S.Schema<UpdateNLSearchModelResponse>;
+export interface UpsertAliasRequest {
+    /** The name of the alias to create/update */
+    aliasName: string;
+    /** Name of the collection you wish to map the alias to */
+    collection_name: string;
+}
+export declare const UpsertAliasRequest: S.Schema<UpsertAliasRequest>;
+export type UpsertAnalyticsRuleRequestParamsMetaFieldsList = Array<string>;
+export declare const UpsertAnalyticsRuleRequestParamsMetaFieldsList: S.Schema<UpsertAnalyticsRuleRequestParamsMetaFieldsList>;
+export interface UpsertAnalyticsRuleRequestParams {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: UpsertAnalyticsRuleRequestParamsMetaFieldsList;
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+}
+export declare const UpsertAnalyticsRuleRequestParams: S.Schema<UpsertAnalyticsRuleRequestParams>;
+export interface UpsertAnalyticsRuleRequest {
+    /** The name of the analytics rule to upsert */
+    ruleName: string;
+    name?: string;
+    rule_tag?: string;
+    params?: UpsertAnalyticsRuleRequestParams;
+}
+export declare const UpsertAnalyticsRuleRequest: S.Schema<UpsertAnalyticsRuleRequest>;
+export type UpsertAnalyticsRuleResponseParamsMetaFieldsList = Array<string>;
+export declare const UpsertAnalyticsRuleResponseParamsMetaFieldsList: S.Schema<UpsertAnalyticsRuleResponseParamsMetaFieldsList>;
+export interface UpsertAnalyticsRuleResponseParams {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: UpsertAnalyticsRuleResponseParamsMetaFieldsList;
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+}
+export declare const UpsertAnalyticsRuleResponseParams: S.Schema<UpsertAnalyticsRuleResponseParams>;
+export interface UpsertAnalyticsRuleResponse {
+    name: string;
+    type: AnalyticsRuleType;
+    collection: string;
+    event_type: string;
+    rule_tag?: string;
+    params?: UpsertAnalyticsRuleResponseParams;
+}
+export declare const UpsertAnalyticsRuleResponse: S.Schema<UpsertAnalyticsRuleResponse>;
+/** Array of curation items */
+export type UpsertCurationSetRequestItemsList = Array<CurationItemCreateSchema>;
+export declare const UpsertCurationSetRequestItemsList: S.Schema<UpsertCurationSetRequestItemsList>;
+export interface UpsertCurationSetRequest {
+    /** The name of the curation set to create/update */
+    curationSetName: string;
+    /** Array of curation items */
+    items: UpsertCurationSetRequestItemsList;
+    /** Optional description for the curation set */
+    description?: string;
+}
+export declare const UpsertCurationSetRequest: S.Schema<UpsertCurationSetRequest>;
+/** Array of curation items */
+export type UpsertCurationSetResponseItemsList = Array<CurationItemCreateSchema>;
+export declare const UpsertCurationSetResponseItemsList: S.Schema<UpsertCurationSetResponseItemsList>;
+export interface UpsertCurationSetResponse {
+    /** Array of curation items */
+    items: UpsertCurationSetResponseItemsList;
+    /** Optional description for the curation set */
+    description?: string;
+    name: string;
+}
+export declare const UpsertCurationSetResponse: S.Schema<UpsertCurationSetResponse>;
+/** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+export type UpsertCurationSetItemRequestIncludesList = Array<CurationInclude>;
+export declare const UpsertCurationSetItemRequestIncludesList: S.Schema<UpsertCurationSetItemRequestIncludesList>;
+/** List of document `id`s that should be excluded from the search results. */
+export type UpsertCurationSetItemRequestExcludesList = Array<CurationExclude>;
+export declare const UpsertCurationSetItemRequestExcludesList: S.Schema<UpsertCurationSetItemRequestExcludesList>;
+export interface UpsertCurationSetItemRequest {
+    /** The name of the curation set */
+    curationSetName: string;
+    /** The id of the curation item to upsert */
+    itemId: string;
+    rule: CurationRule;
+    /** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+    includes?: UpsertCurationSetItemRequestIncludesList;
+    /** List of document `id`s that should be excluded from the search results. */
+    excludes?: UpsertCurationSetItemRequestExcludesList;
+    /** A filter by clause that is applied to any search query that matches the curation rule. */
+    filter_by?: string;
+    /** Indicates whether search query tokens that exist in the curation's rule should be removed from the search query. */
+    remove_matched_tokens?: boolean;
+    /** Return a custom JSON object in the Search API response, when this rule is triggered. This can can be used to display a pre-defined message (eg: a promotion banner) on the front-end when a particular rule is triggered. */
+    metadata?: unknown;
+    /** A sort by clause that is applied to any search query that matches the curation rule. */
+    sort_by?: string;
+    /** Replaces the current search query with this value, when the search query matches the curation rule. */
+    replace_query?: string;
+    /** When set to true, the filter conditions of the query is applied to the curated records as well. Default: false. */
+    filter_curated_hits?: boolean;
+    /** A Unix timestamp that indicates the date/time from which the curation will be active. You can use this to create rules that start applying from a future point in time. */
+    effective_from_ts?: number;
+    /** A Unix timestamp that indicates the date/time until which the curation will be active. You can use this to create rules that stop applying after a period of time. */
+    effective_to_ts?: number;
+    /** When set to true, curation processing will stop at the first matching rule. When set to false curation processing will continue and multiple curation actions will be triggered in sequence. Curations are processed in the lexical sort order of their id field. */
+    stop_processing?: boolean;
+    /** ID of the curation item */
+    id?: string;
+}
+export declare const UpsertCurationSetItemRequest: S.Schema<UpsertCurationSetItemRequest>;
+/** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+export type UpsertCurationSetItemResponseIncludesList = Array<CurationInclude>;
+export declare const UpsertCurationSetItemResponseIncludesList: S.Schema<UpsertCurationSetItemResponseIncludesList>;
+/** List of document `id`s that should be excluded from the search results. */
+export type UpsertCurationSetItemResponseExcludesList = Array<CurationExclude>;
+export declare const UpsertCurationSetItemResponseExcludesList: S.Schema<UpsertCurationSetItemResponseExcludesList>;
+export interface UpsertCurationSetItemResponse {
+    rule: CurationRule;
+    /** List of document `id`s that should be included in the search results with their corresponding `position`s. */
+    includes?: UpsertCurationSetItemResponseIncludesList;
+    /** List of document `id`s that should be excluded from the search results. */
+    excludes?: UpsertCurationSetItemResponseExcludesList;
+    /** A filter by clause that is applied to any search query that matches the curation rule. */
+    filter_by?: string;
+    /** Indicates whether search query tokens that exist in the curation's rule should be removed from the search query. */
+    remove_matched_tokens?: boolean;
+    /** Return a custom JSON object in the Search API response, when this rule is triggered. This can can be used to display a pre-defined message (eg: a promotion banner) on the front-end when a particular rule is triggered. */
+    metadata?: unknown;
+    /** A sort by clause that is applied to any search query that matches the curation rule. */
+    sort_by?: string;
+    /** Replaces the current search query with this value, when the search query matches the curation rule. */
+    replace_query?: string;
+    /** When set to true, the filter conditions of the query is applied to the curated records as well. Default: false. */
+    filter_curated_hits?: boolean;
+    /** A Unix timestamp that indicates the date/time from which the curation will be active. You can use this to create rules that start applying from a future point in time. */
+    effective_from_ts?: number;
+    /** A Unix timestamp that indicates the date/time until which the curation will be active. You can use this to create rules that stop applying after a period of time. */
+    effective_to_ts?: number;
+    /** When set to true, curation processing will stop at the first matching rule. When set to false curation processing will continue and multiple curation actions will be triggered in sequence. Curations are processed in the lexical sort order of their id field. */
+    stop_processing?: boolean;
+    /** ID of the curation item */
+    id: string;
+}
+export declare const UpsertCurationSetItemResponse: S.Schema<UpsertCurationSetItemResponse>;
+export type UpsertPresetRequestValue = SearchParameters | MultiSearchSearchesParameter;
+export declare const UpsertPresetRequestValue: any;
+export interface UpsertPresetRequest {
+    /** The name of the preset set to upsert. */
+    presetId: string;
+    value: UpsertPresetRequestValue;
+}
+export declare const UpsertPresetRequest: S.Schema<UpsertPresetRequest>;
+export type UpsertPresetResponseValue = SearchParameters | MultiSearchSearchesParameter;
+export declare const UpsertPresetResponseValue: any;
+export interface UpsertPresetResponse {
+    value: UpsertPresetResponseValue;
+    name: string;
+}
+export declare const UpsertPresetResponse: S.Schema<UpsertPresetResponse>;
+export type UpsertStopwordsSetRequestStopwordsList = Array<string>;
+export declare const UpsertStopwordsSetRequestStopwordsList: S.Schema<UpsertStopwordsSetRequestStopwordsList>;
+export interface UpsertStopwordsSetRequest {
+    /** The ID of the stopwords set to upsert. */
+    setId: string;
+    stopwords: UpsertStopwordsSetRequestStopwordsList;
+    locale?: string;
+}
+export declare const UpsertStopwordsSetRequest: S.Schema<UpsertStopwordsSetRequest>;
+/** Array of synonym items */
+export type UpsertSynonymSetRequestItemsList = Array<SynonymItemSchema>;
+export declare const UpsertSynonymSetRequestItemsList: S.Schema<UpsertSynonymSetRequestItemsList>;
+export interface UpsertSynonymSetRequest {
+    /** The name of the synonym set to create/update */
+    synonymSetName: string;
+    /** Array of synonym items */
+    items: UpsertSynonymSetRequestItemsList;
+}
+export declare const UpsertSynonymSetRequest: S.Schema<UpsertSynonymSetRequest>;
+/** Array of synonym items */
+export type UpsertSynonymSetResponseItemsList = Array<SynonymItemSchema>;
+export declare const UpsertSynonymSetResponseItemsList: S.Schema<UpsertSynonymSetResponseItemsList>;
+export interface UpsertSynonymSetResponse {
+    /** Array of synonym items */
+    items: UpsertSynonymSetResponseItemsList;
+    /** Name of the synonym set */
+    name: string;
+}
+export declare const UpsertSynonymSetResponse: S.Schema<UpsertSynonymSetResponse>;
+/** Array of words that should be considered as synonyms */
+export type UpsertSynonymSetItemRequestSynonymsList = Array<string>;
+export declare const UpsertSynonymSetItemRequestSynonymsList: S.Schema<UpsertSynonymSetItemRequestSynonymsList>;
+/** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+export type UpsertSynonymSetItemRequestSymbolsToIndexList = Array<string>;
+export declare const UpsertSynonymSetItemRequestSymbolsToIndexList: S.Schema<UpsertSynonymSetItemRequestSymbolsToIndexList>;
+export interface UpsertSynonymSetItemRequest {
+    /** The name of the synonym set */
+    synonymSetName: string;
+    /** The id of the synonym item to upsert */
+    itemId: string;
+    /** Array of words that should be considered as synonyms */
+    synonyms: UpsertSynonymSetItemRequestSynonymsList;
+    /** For 1-way synonyms, indicates the root word that words in the synonyms parameter map to */
+    root?: string;
+    /** Locale for the synonym, leave blank to use the standard tokenizer */
+    locale?: string;
+    /** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+    symbols_to_index?: UpsertSynonymSetItemRequestSymbolsToIndexList;
+}
+export declare const UpsertSynonymSetItemRequest: S.Schema<UpsertSynonymSetItemRequest>;
+/** Array of words that should be considered as synonyms */
+export type UpsertSynonymSetItemResponseSynonymsList = Array<string>;
+export declare const UpsertSynonymSetItemResponseSynonymsList: S.Schema<UpsertSynonymSetItemResponseSynonymsList>;
+/** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+export type UpsertSynonymSetItemResponseSymbolsToIndexList = Array<string>;
+export declare const UpsertSynonymSetItemResponseSymbolsToIndexList: S.Schema<UpsertSynonymSetItemResponseSymbolsToIndexList>;
+export interface UpsertSynonymSetItemResponse {
+    /** Unique identifier for the synonym item */
+    id: string;
+    /** Array of words that should be considered as synonyms */
+    synonyms: UpsertSynonymSetItemResponseSynonymsList;
+    /** For 1-way synonyms, indicates the root word that words in the synonyms parameter map to */
+    root?: string;
+    /** Locale for the synonym, leave blank to use the standard tokenizer */
+    locale?: string;
+    /** By default, special characters are dropped from synonyms. Use this attribute to specify which special characters should be indexed as is */
+    symbols_to_index?: UpsertSynonymSetItemResponseSymbolsToIndexList;
+}
+export declare const UpsertSynonymSetItemResponse: S.Schema<UpsertSynonymSetItemResponse>;
+export interface VoteRequest {
+}
+export declare const VoteRequest: S.Schema<VoteRequest>;
+export type ClearCacheError = TypesenseOpError;
+/** Clear the cached responses of search requests in the LRU cache. Clear the cached responses of search requests that are sent with `use_cache` parameter in the LRU cache. */
+export declare const clearCache: API.OperationMethod<ClearCacheRequest, SuccessStatus, ClearCacheError, TypesenseOpContext>;
+export type CompactDbError = TypesenseOpError;
+/** Compacting the on-disk database Typesense uses RocksDB to store your documents on the disk. If you do frequent writes or updates, you could benefit from running a compaction of the underlying RocksDB database. This could reduce the size of the database and decrease read latency. While the database will not block during this operation, we recommend running it during off-peak hours. */
+export declare const compactDb: API.OperationMethod<CompactDbRequest, SuccessStatus, CompactDbError, TypesenseOpContext>;
+export type CreateAnalyticsEventError = BadRequest | TypesenseOpError;
+/** Create an analytics event Submit a single analytics event. The event must correspond to an existing analytics rule by name. */
+export declare const createAnalyticsEvent: API.OperationMethod<CreateAnalyticsEventRequest, AnalyticsEventCreateResponse, CreateAnalyticsEventError, TypesenseOpContext>;
+export type CreateAnalyticsRuleError = BadRequest | TypesenseOpError;
+/** Create analytics rule(s) Create one or more analytics rules. You can send a single rule object or an array of rule objects. */
+export declare const createAnalyticsRule: API.OperationMethod<CreateAnalyticsRuleRequest, CreateAnalyticsRuleResponse, CreateAnalyticsRuleError, TypesenseOpContext>;
+export type CreateCollectionError = BadRequest | Conflict | TypesenseOpError;
+/** Create a new collection When a collection is created, we give it a name and describe the fields that will be indexed from the documents added to the collection. */
+export declare const createCollection: API.OperationMethod<CreateCollectionRequest, CreateCollectionResponse, CreateCollectionError, TypesenseOpContext>;
+export type CreateConversationModelError = BadRequest | TypesenseOpError;
+/** Create a conversation model Create a Conversation Model */
+export declare const createConversationModel: API.OperationMethod<CreateConversationModelRequest, CreateConversationModelResponse, CreateConversationModelError, TypesenseOpContext>;
+export type CreateKeyError = BadRequest | Conflict | TypesenseOpError;
+/** Create an API Key Create an API Key with fine-grain access control. You can restrict access on both a per-collection and per-action level. The generated key is returned only during creation. You want to store this key carefully in a secure place. */
+export declare const createKey: API.OperationMethod<CreateKeyRequest, CreateKeyResponse, CreateKeyError, TypesenseOpContext>;
+export type CreateNLSearchModelError = BadRequest | TypesenseOpError;
+/** Create a NL search model Create a new NL search model. */
+export declare const createNLSearchModel: API.OperationMethod<CreateNLSearchModelRequest, CreateNLSearchModelResponse, CreateNLSearchModelError, TypesenseOpContext>;
+export type DebugError = TypesenseOpError;
+/** Print debugging information Print debugging information */
+export declare const debug: API.OperationMethod<DebugRequest, DebugResponse, DebugError, TypesenseOpContext>;
+export type DeleteAliasError = NotFound | TypesenseOpError;
+/** Delete an alias */
+export declare const deleteAlias: API.OperationMethod<DeleteAliasRequest, CollectionAlias, DeleteAliasError, TypesenseOpContext>;
+export type DeleteAnalyticsRuleError = NotFound | TypesenseOpError;
+/** Delete an analytics rule Permanently deletes an analytics rule, given it's name */
+export declare const deleteAnalyticsRule: API.OperationMethod<DeleteAnalyticsRuleRequest, DeleteAnalyticsRuleResponse, DeleteAnalyticsRuleError, TypesenseOpContext>;
+export type DeleteCollectionError = NotFound | TypesenseOpError;
+/** Delete a collection Permanently drops a collection. This action cannot be undone. For large collections, this might have an impact on read latencies. */
+export declare const deleteCollection: API.OperationMethod<DeleteCollectionRequest, DeleteCollectionResponse, DeleteCollectionError, TypesenseOpContext>;
+export type DeleteConversationModelError = NotFound | TypesenseOpError;
+/** Delete a conversation model Delete a conversation model */
+export declare const deleteConversationModel: API.OperationMethod<DeleteConversationModelRequest, DeleteConversationModelResponse, DeleteConversationModelError, TypesenseOpContext>;
+export type DeleteCurationSetError = NotFound | TypesenseOpError;
+/** Delete a curation set Delete a specific curation set by its name */
+export declare const deleteCurationSet: API.OperationMethod<DeleteCurationSetRequest, CurationSetDeleteSchema, DeleteCurationSetError, TypesenseOpContext>;
+export type DeleteCurationSetItemError = NotFound | TypesenseOpError;
+/** Delete a curation set item Delete a specific curation item by its id */
+export declare const deleteCurationSetItem: API.OperationMethod<DeleteCurationSetItemRequest, CurationItemDeleteSchema, DeleteCurationSetItemError, TypesenseOpContext>;
+export type DeleteDocumentError = NotFound | TypesenseOpError;
+/** Delete a document Delete an individual document from a collection by using its ID. */
+export declare const deleteDocument: API.OperationMethod<DeleteDocumentRequest, DeleteDocumentResponse, DeleteDocumentError, TypesenseOpContext>;
+export type DeleteDocumentsError = NotFound | TypesenseOpError;
+/** Delete a bunch of documents Delete a bunch of documents that match a specific filter condition. Use the `batch_size` parameter to control the number of documents that should deleted at a time. A larger value will speed up deletions, but will impact performance of other operations running on the server. */
+export declare const deleteDocuments: API.OperationMethod<DeleteDocumentsRequest, DeleteDocumentsResponse, DeleteDocumentsError, TypesenseOpContext>;
+export type DeleteKeyError = BadRequest | NotFound | TypesenseOpError;
+/** Delete an API key given its ID. */
+export declare const deleteKey: API.OperationMethod<DeleteKeyRequest, ApiKeyDeleteResponse, DeleteKeyError, TypesenseOpContext>;
+export type DeleteNLSearchModelError = NotFound | TypesenseOpError;
+/** Delete a NL search model Delete a specific NL search model by its ID. */
+export declare const deleteNLSearchModel: API.OperationMethod<DeleteNLSearchModelRequest, NLSearchModelDeleteSchema, DeleteNLSearchModelError, TypesenseOpContext>;
+export type DeletePresetError = NotFound | TypesenseOpError;
+/** Delete a preset. Permanently deletes a preset, given it's name. */
+export declare const deletePreset: API.OperationMethod<DeletePresetRequest, PresetDeleteSchema, DeletePresetError, TypesenseOpContext>;
+export type DeleteStopwordsSetError = NotFound | TypesenseOpError;
+/** Delete a stopwords set. Permanently deletes a stopwords set, given it's name. */
+export declare const deleteStopwordsSet: API.OperationMethod<DeleteStopwordsSetRequest, DeleteStopwordsSetResponse, DeleteStopwordsSetError, TypesenseOpContext>;
+export type DeleteSynonymSetError = NotFound | TypesenseOpError;
+/** Delete a synonym set Delete a specific synonym set by its name */
+export declare const deleteSynonymSet: API.OperationMethod<DeleteSynonymSetRequest, SynonymSetDeleteSchema, DeleteSynonymSetError, TypesenseOpContext>;
+export type DeleteSynonymSetItemError = NotFound | TypesenseOpError;
+/** Delete a synonym set item Delete a specific synonym item by its id */
+export declare const deleteSynonymSetItem: API.OperationMethod<DeleteSynonymSetItemRequest, SynonymItemDeleteSchema, DeleteSynonymSetItemError, TypesenseOpContext>;
+export type ExportDocumentsError = NotFound | TypesenseOpError;
+/** Export all documents in a collection Export all documents in a collection in JSON lines format. */
+export declare const exportDocuments: API.OperationMethod<ExportDocumentsRequest, ExportDocumentsResponse, ExportDocumentsError, TypesenseOpContext>;
+export type FlushAnalyticsError = TypesenseOpError;
+/** Flush in-memory analytics to disk Triggers a flush of analytics data to persistent storage. */
+export declare const flushAnalytics: API.OperationMethod<FlushAnalyticsRequest, AnalyticsEventCreateResponse, FlushAnalyticsError, TypesenseOpContext>;
+export type GetAliasError = NotFound | TypesenseOpError;
+/** Retrieve an alias Find out which collection an alias points to by fetching it */
+export declare const getAlias: API.OperationMethod<GetAliasRequest, CollectionAlias, GetAliasError, TypesenseOpContext>;
+export type GetAliasesError = TypesenseOpError;
+/** List all aliases List all aliases and the corresponding collections that they map to. */
+export declare const getAliases: API.OperationMethod<GetAliasesRequest, CollectionAliasesResponse, GetAliasesError, TypesenseOpContext>;
+export type GetAllConversationModelsError = TypesenseOpError;
+/** List all conversation models Retrieve all conversation models */
+export declare const getAllConversationModels: API.OperationMethod<GetAllConversationModelsRequest, GetAllConversationModelsResponse, GetAllConversationModelsError, TypesenseOpContext>;
+export type GetAllNLSearchModelsError = TypesenseOpError;
+/** List all NL search models Retrieve all NL search models. */
+export declare const getAllNLSearchModels: API.OperationMethod<GetAllNLSearchModelsRequest, GetAllNLSearchModelsResponse, GetAllNLSearchModelsError, TypesenseOpContext>;
+export type GetAllPresetsError = TypesenseOpError;
+/** Retrieves all presets. Retrieve the details of all presets */
+export declare const getAllPresets: API.OperationMethod<GetAllPresetsRequest, PresetsRetrieveSchema, GetAllPresetsError, TypesenseOpContext>;
+export type GetAnalyticsEventsError = BadRequest | TypesenseOpError;
+/** Retrieve analytics events Retrieve the most recent events for a user and rule. */
+export declare const getAnalyticsEvents: API.OperationMethod<GetAnalyticsEventsRequest, AnalyticsEventsResponse, GetAnalyticsEventsError, TypesenseOpContext>;
+export type GetAnalyticsRuleError = NotFound | TypesenseOpError;
+/** Retrieves an analytics rule Retrieve the details of an analytics rule, given it's name */
+export declare const getAnalyticsRule: API.OperationMethod<GetAnalyticsRuleRequest, GetAnalyticsRuleResponse, GetAnalyticsRuleError, TypesenseOpContext>;
+export type GetAnalyticsRulesError = TypesenseOpError;
+/** Retrieve analytics rules Retrieve all analytics rules. Use the optional rule_tag filter to narrow down results. */
+export declare const getAnalyticsRules: API.OperationMethod<GetAnalyticsRulesRequest, GetAnalyticsRulesResponse, GetAnalyticsRulesError, TypesenseOpContext>;
+export type GetAnalyticsStatusError = TypesenseOpError;
+/** Get analytics subsystem status Returns sizes of internal analytics buffers and queues. */
+export declare const getAnalyticsStatus: API.OperationMethod<GetAnalyticsStatusRequest, AnalyticsStatus, GetAnalyticsStatusError, TypesenseOpContext>;
+export type GetAPIStatsError = TypesenseOpError;
+/** Get stats about API endpoints. Retrieve the stats about API endpoints. */
+export declare const getAPIStats: API.OperationMethod<GetAPIStatsRequest, APIStatsResponse, GetAPIStatsError, TypesenseOpContext>;
+export type GetCollectionError = NotFound | TypesenseOpError;
+/** Retrieve a single collection Retrieve the details of a collection, given its name. */
+export declare const getCollection: API.OperationMethod<GetCollectionRequest, GetCollectionResponse, GetCollectionError, TypesenseOpContext>;
+export type GetCollectionsError = TypesenseOpError;
+/** List all collections Returns a summary of all your collections. The collections are returned sorted by creation date, with the most recent collections appearing first. */
+export declare const getCollections: API.OperationMethod<GetCollectionsRequest, GetCollectionsResponse, GetCollectionsError, TypesenseOpContext>;
+export type GetConversationModelError = NotFound | TypesenseOpError;
+/** Retrieve a conversation model Retrieve a conversation model */
+export declare const getConversationModel: API.OperationMethod<GetConversationModelRequest, GetConversationModelResponse, GetConversationModelError, TypesenseOpContext>;
+export type GetCurationSetError = NotFound | TypesenseOpError;
+/** Retrieve a curation set Retrieve a specific curation set by its name */
+export declare const getCurationSet: API.OperationMethod<GetCurationSetRequest, GetCurationSetResponse, GetCurationSetError, TypesenseOpContext>;
+export type GetCurationSetItemError = NotFound | TypesenseOpError;
+/** Retrieve a curation set item Retrieve a specific curation item by its id */
+export declare const getCurationSetItem: API.OperationMethod<GetCurationSetItemRequest, GetCurationSetItemResponse, GetCurationSetItemError, TypesenseOpContext>;
+export type GetCurationSetItemsError = NotFound | TypesenseOpError;
+/** List items in a curation set Retrieve all curation items in a set */
+export declare const getCurationSetItems: API.OperationMethod<GetCurationSetItemsRequest, GetCurationSetItemsResponse, GetCurationSetItemsError, TypesenseOpContext>;
+export type GetCurationSetsError = TypesenseOpError;
+/** List all curation sets Retrieve all curation sets */
+export declare const getCurationSets: API.OperationMethod<GetCurationSetsRequest, GetCurationSetsResponse, GetCurationSetsError, TypesenseOpContext>;
+export type GetDocumentError = NotFound | TypesenseOpError;
+/** Retrieve a document Fetch an individual document from a collection by using its ID. */
+export declare const getDocument: API.OperationMethod<GetDocumentRequest, GetDocumentResponse, GetDocumentError, TypesenseOpContext>;
+export type GetKeyError = NotFound | TypesenseOpError;
+/** Retrieve (metadata about) a key Retrieve (metadata about) a key. Only the key prefix is returned when you retrieve a key. Due to security reasons, only the create endpoint returns the full API key. */
+export declare const getKey: API.OperationMethod<GetKeyRequest, GetKeyResponse, GetKeyError, TypesenseOpContext>;
+export type GetKeysError = TypesenseOpError;
+/** Retrieve (metadata about) all keys. */
+export declare const getKeys: API.OperationMethod<GetKeysRequest, ApiKeysResponse, GetKeysError, TypesenseOpContext>;
+export type GetMetricsError = TypesenseOpError;
+/** Get current RAM, CPU, Disk & Network usage metrics. Retrieve the metrics. */
+export declare const getMetrics: API.OperationMethod<GetMetricsRequest, GetMetricsResponse, GetMetricsError, TypesenseOpContext>;
+export type GetNLSearchModelError = NotFound | TypesenseOpError;
+/** Retrieve a NL search model Retrieve a specific NL search model by its ID. */
+export declare const getNLSearchModel: API.OperationMethod<GetNLSearchModelRequest, GetNLSearchModelResponse, GetNLSearchModelError, TypesenseOpContext>;
+export type GetPresetError = NotFound | TypesenseOpError;
+/** Retrieves a preset. Retrieve the details of a preset, given it's name. */
+export declare const getPreset: API.OperationMethod<GetPresetRequest, GetPresetResponse, GetPresetError, TypesenseOpContext>;
+export type GetSchemaChangesError = TypesenseOpError;
+/** Get the status of in-progress schema change operations Returns the status of any ongoing schema change operations. If no schema changes are in progress, returns an empty response. */
+export declare const getSchemaChanges: API.OperationMethod<GetSchemaChangesRequest, GetSchemaChangesResponse, GetSchemaChangesError, TypesenseOpContext>;
+export type GetStemmingDictionaryError = NotFound | TypesenseOpError;
+/** Retrieve a stemming dictionary Fetch details of a specific stemming dictionary. */
+export declare const getStemmingDictionary: API.OperationMethod<GetStemmingDictionaryRequest, StemmingDictionary, GetStemmingDictionaryError, TypesenseOpContext>;
+export type GetStopwordsSetError = NotFound | TypesenseOpError;
+/** Retrieves a stopwords set. Retrieve the details of a stopwords set, given it's name. */
+export declare const getStopwordsSet: API.OperationMethod<GetStopwordsSetRequest, StopwordsSetRetrieveSchema, GetStopwordsSetError, TypesenseOpContext>;
+export type GetStopwordsSetsError = TypesenseOpError;
+/** Retrieves all stopwords sets. Retrieve the details of all stopwords sets */
+export declare const getStopwordsSets: API.OperationMethod<GetStopwordsSetsRequest, StopwordsSetsRetrieveAllSchema, GetStopwordsSetsError, TypesenseOpContext>;
+export type GetSynonymSetError = NotFound | TypesenseOpError;
+/** Retrieve a synonym set Retrieve a specific synonym set by its name */
+export declare const getSynonymSet: API.OperationMethod<GetSynonymSetRequest, GetSynonymSetResponse, GetSynonymSetError, TypesenseOpContext>;
+export type GetSynonymSetItemError = NotFound | TypesenseOpError;
+/** Retrieve a synonym set item Retrieve a specific synonym item by its id */
+export declare const getSynonymSetItem: API.OperationMethod<GetSynonymSetItemRequest, GetSynonymSetItemResponse, GetSynonymSetItemError, TypesenseOpContext>;
+export type GetSynonymSetItemsError = NotFound | TypesenseOpError;
+/** List items in a synonym set Retrieve all synonym items in a set */
+export declare const getSynonymSetItems: API.OperationMethod<GetSynonymSetItemsRequest, GetSynonymSetItemsResponse, GetSynonymSetItemsError, TypesenseOpContext>;
+export type GetSynonymSetsError = TypesenseOpError;
+/** List all synonym sets Retrieve all synonym sets */
+export declare const getSynonymSets: API.OperationMethod<GetSynonymSetsRequest, GetSynonymSetsResponse, GetSynonymSetsError, TypesenseOpContext>;
+export type HealthError = TypesenseOpError;
+/** Checks if Typesense server is ready to accept requests. Checks if Typesense server is ready to accept requests. */
+export declare const health: API.OperationMethod<HealthRequest, HealthStatus, HealthError, TypesenseOpContext>;
+export type ImportDocumentsError = BadRequest | NotFound | TypesenseOpError;
+/** Import documents into a collection The documents to be imported must be formatted in a newline delimited JSON structure. You can feed the output file from a Typesense export operation directly as import. */
+export declare const importDocuments: API.OperationMethod<ImportDocumentsRequest, ImportDocumentsResponse, ImportDocumentsError, TypesenseOpContext>;
+export type ImportStemmingDictionaryError = BadRequest | TypesenseOpError;
+/** Import a stemming dictionary Upload a JSONL file containing word mappings to create or update a stemming dictionary. */
+export declare const importStemmingDictionary: API.OperationMethod<ImportStemmingDictionaryRequest, ImportStemmingDictionaryResponse, ImportStemmingDictionaryError, TypesenseOpContext>;
+export type ListDocumentError = NotFound | TypesenseOpError;
+/** Index a document A document to be indexed in a given collection must conform to the schema of the collection. */
+export declare const listDocument: API.OperationMethod<ListDocumentRequest, ListDocumentResponse, ListDocumentError, TypesenseOpContext>;
+export type ListStemmingDictionariesError = TypesenseOpError;
+/** List all stemming dictionaries Retrieve a list of all available stemming dictionaries. */
+export declare const listStemmingDictionaries: API.OperationMethod<ListStemmingDictionariesRequest, ListStemmingDictionariesResponse, ListStemmingDictionariesError, TypesenseOpContext>;
+export type SearchCollectionError = BadRequest | NotFound | TypesenseOpError;
+/** Search for documents in a collection Search for documents in a collection that match the search criteria. */
+export declare const searchCollection: API.OperationMethod<SearchCollectionRequest, SearchResult, SearchCollectionError, TypesenseOpContext>;
+export type SearchMultiError = BadRequest | TypesenseOpError;
+/** send multiple search requests in a single HTTP request This is especially useful to avoid round-trip network latencies incurred otherwise if each of these requests are sent in separate HTTP requests. You can also use this feature to do a federated search across multiple collections in a single HTTP request. */
+export declare const searchMulti: API.OperationMethod<SearchMultiRequest, MultiSearchResult, SearchMultiError, TypesenseOpContext>;
+export type TakeSnapshotError = TypesenseOpError;
+/** Creates a point-in-time snapshot of a Typesense node's state and data in the specified directory. Creates a point-in-time snapshot of a Typesense node's state and data in the specified directory. You can then backup the snapshot directory that gets created and later restore it as a data directory, as needed. */
+export declare const takeSnapshot: API.OperationMethod<TakeSnapshotRequest, SuccessStatus, TakeSnapshotError, TypesenseOpContext>;
+export type ToggleSlowRequestLogError = TypesenseOpError;
+/** Toggle Slow Request Log Enable logging of requests that take over a defined threshold of time. Default is `-1` which disables slow request logging. Slow requests are logged to the primary log file, with the prefix SLOW REQUEST. */
+export declare const toggleSlowRequestLog: API.OperationMethod<ToggleSlowRequestLogRequest, SuccessStatus, ToggleSlowRequestLogError, TypesenseOpContext>;
+export type UpdateCollectionError = BadRequest | NotFound | TypesenseOpError;
+/** Update a collection Update a collection's schema to modify the fields and their types. */
+export declare const updateCollection: API.OperationMethod<UpdateCollectionRequest, CollectionUpdateSchema, UpdateCollectionError, TypesenseOpContext>;
+export type UpdateConversationModelError = BadRequest | NotFound | TypesenseOpError;
+/** Update a conversation model Update a conversation model */
+export declare const updateConversationModel: API.OperationMethod<UpdateConversationModelRequest, UpdateConversationModelResponse, UpdateConversationModelError, TypesenseOpContext>;
+export type UpdateDocumentError = NotFound | TypesenseOpError;
+/** Update a document Update an individual document from a collection by using its ID. The update can be partial. */
+export declare const updateDocument: API.OperationMethod<UpdateDocumentRequest, UpdateDocumentResponse, UpdateDocumentError, TypesenseOpContext>;
+export type UpdateDocumentsError = BadRequest | NotFound | TypesenseOpError;
+/** Update documents with conditional query The filter_by query parameter is used to filter to specify a condition against which the documents are matched. The request body contains the fields that should be updated for any documents that match the filter condition. This endpoint is only available if the Typesense server is version `0.25.0.rc12` or later. */
+export declare const updateDocuments: API.OperationMethod<UpdateDocumentsRequest, UpdateDocumentsResponse, UpdateDocumentsError, TypesenseOpContext>;
+export type UpdateNLSearchModelError = BadRequest | NotFound | TypesenseOpError;
+/** Update a NL search model Update an existing NL search model. */
+export declare const updateNLSearchModel: API.OperationMethod<UpdateNLSearchModelRequest, UpdateNLSearchModelResponse, UpdateNLSearchModelError, TypesenseOpContext>;
+export type UpsertAliasError = BadRequest | NotFound | TypesenseOpError;
+/** Create or update a collection alias Create or update a collection alias. An alias is a virtual collection name that points to a real collection. If you're familiar with symbolic links on Linux, it's very similar to that. Aliases are useful when you want to reindex your data in the background on a new collection and switch your application to it without any changes to your code. */
+export declare const upsertAlias: API.OperationMethod<UpsertAliasRequest, CollectionAlias, UpsertAliasError, TypesenseOpContext>;
+export type UpsertAnalyticsRuleError = BadRequest | TypesenseOpError;
+/** Upserts an analytics rule Upserts an analytics rule with the given name. */
+export declare const upsertAnalyticsRule: API.OperationMethod<UpsertAnalyticsRuleRequest, UpsertAnalyticsRuleResponse, UpsertAnalyticsRuleError, TypesenseOpContext>;
+export type UpsertCurationSetError = BadRequest | TypesenseOpError;
+/** Create or update a curation set Create or update a curation set with the given name */
+export declare const upsertCurationSet: API.OperationMethod<UpsertCurationSetRequest, UpsertCurationSetResponse, UpsertCurationSetError, TypesenseOpContext>;
+export type UpsertCurationSetItemError = BadRequest | TypesenseOpError;
+/** Create or update a curation set item Create or update a curation set item with the given id */
+export declare const upsertCurationSetItem: API.OperationMethod<UpsertCurationSetItemRequest, UpsertCurationSetItemResponse, UpsertCurationSetItemError, TypesenseOpContext>;
+export type UpsertPresetError = BadRequest | TypesenseOpError;
+/** Upserts a preset. Create or update an existing preset. */
+export declare const upsertPreset: API.OperationMethod<UpsertPresetRequest, UpsertPresetResponse, UpsertPresetError, TypesenseOpContext>;
+export type UpsertStopwordsSetError = BadRequest | TypesenseOpError;
+/** Upserts a stopwords set. When an analytics rule is created, we give it a name and describe the type, the source collections and the destination collection. */
+export declare const upsertStopwordsSet: API.OperationMethod<UpsertStopwordsSetRequest, StopwordsSetSchema, UpsertStopwordsSetError, TypesenseOpContext>;
+export type UpsertSynonymSetError = BadRequest | TypesenseOpError;
+/** Create or update a synonym set Create or update a synonym set with the given name */
+export declare const upsertSynonymSet: API.OperationMethod<UpsertSynonymSetRequest, UpsertSynonymSetResponse, UpsertSynonymSetError, TypesenseOpContext>;
+export type UpsertSynonymSetItemError = BadRequest | TypesenseOpError;
+/** Create or update a synonym set item Create or update a synonym set item with the given id */
+export declare const upsertSynonymSetItem: API.OperationMethod<UpsertSynonymSetItemRequest, UpsertSynonymSetItemResponse, UpsertSynonymSetItemError, TypesenseOpContext>;
+export type VoteError = TypesenseOpError;
+/** Triggers a follower node to initiate the raft voting process, which triggers leader re-election. Triggers a follower node to initiate the raft voting process, which triggers leader re-election. The follower node that you run this operation against will become the new leader, once this command succeeds. */
+export declare const vote: API.OperationMethod<VoteRequest, SuccessStatus, VoteError, TypesenseOpContext>;
+//# sourceMappingURL=typesense.d.ts.map