@distilled.cloud/typesense 0.27.0 → 0.28.0

package/src/operations/importStemmingDictionary.ts

@@ -4,18 +4,20 @@ import * as T from "../traits.ts";
 import { BadRequest } from "../errors.ts";
 
 // Input Schema
+export interface ImportStemmingDictionaryInput {
+  id: string;
+}
 export const ImportStemmingDictionaryInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  }).pipe(T.Http({ method: "POST", path: "/stemming/dictionaries/import" }));
-export type ImportStemmingDictionaryInput =
-  typeof ImportStemmingDictionaryInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/stemming/dictionaries/import" }),
+  ) as unknown as Schema.Codec<ImportStemmingDictionaryInput>;
 
 // Output Schema
+export type ImportStemmingDictionaryOutput = void;
 export const ImportStemmingDictionaryOutput =
-  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type ImportStemmingDictionaryOutput =
-  typeof ImportStemmingDictionaryOutput.Type;
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<ImportStemmingDictionaryOutput>;
 
 // The operation
 /**

package/src/operations/indexDocument.ts

@@ -4,18 +4,23 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface IndexDocumentInput {
+  collectionName: string;
+  action?: string;
+  dirty_values?: string;
+}
 export const IndexDocumentInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   collectionName: Schema.String.pipe(T.PathParam()),
   action: Schema.optional(Schema.String),
   dirty_values: Schema.optional(Schema.String),
 }).pipe(
   T.Http({ method: "POST", path: "/collections/{collectionName}/documents" }),
-);
-export type IndexDocumentInput = typeof IndexDocumentInput.Type;
+) as unknown as Schema.Codec<IndexDocumentInput>;
 
 // Output Schema
-export const IndexDocumentOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
-export type IndexDocumentOutput = typeof IndexDocumentOutput.Type;
+export type IndexDocumentOutput = unknown;
+export const IndexDocumentOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Codec<IndexDocumentOutput>;
 
 // The operation
 /**

package/src/operations/listStemmingDictionaries.ts

@@ -3,20 +3,20 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ListStemmingDictionariesInput {}
 export const ListStemmingDictionariesInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/stemming/dictionaries" }),
-  );
-export type ListStemmingDictionariesInput =
-  typeof ListStemmingDictionariesInput.Type;
+  ) as unknown as Schema.Codec<ListStemmingDictionariesInput>;
 
 // Output Schema
+export interface ListStemmingDictionariesOutput {
+  dictionaries?: string[];
+}
 export const ListStemmingDictionariesOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     dictionaries: Schema.optional(Schema.Array(Schema.String)),
-  });
-export type ListStemmingDictionariesOutput =
-  typeof ListStemmingDictionariesOutput.Type;
+  }) as unknown as Schema.Codec<ListStemmingDictionariesOutput>;
 
 // The operation
 /**

package/src/operations/multiSearch.ts

@@ -4,6 +4,80 @@ import * as T from "../traits.ts";
 import { BadRequest } from "../errors.ts";
 
 // Input Schema
+export interface MultiSearchInput {
+  multiSearchParameters: string;
+  union?: boolean;
+  searches: {
+    q?: string;
+    query_by?: string;
+    query_by_weights?: string;
+    text_match_type?: string;
+    prefix?: string;
+    infix?: string;
+    max_extra_prefix?: number;
+    max_extra_suffix?: number;
+    filter_by?: string;
+    sort_by?: string;
+    facet_by?: string;
+    max_facet_values?: number;
+    facet_query?: string;
+    num_typos?: string;
+    page?: number;
+    per_page?: number;
+    limit?: number;
+    offset?: number;
+    group_by?: string;
+    group_limit?: number;
+    group_missing_values?: boolean;
+    include_fields?: string;
+    exclude_fields?: string;
+    highlight_full_fields?: string;
+    highlight_affix_num_tokens?: number;
+    highlight_start_tag?: string;
+    highlight_end_tag?: string;
+    snippet_threshold?: number;
+    drop_tokens_threshold?: number;
+    drop_tokens_mode?: "right_to_left" | "left_to_right" | "both_sides:3";
+    typo_tokens_threshold?: number;
+    enable_typos_for_alpha_numerical_tokens?: boolean;
+    filter_curated_hits?: boolean;
+    enable_synonyms?: boolean;
+    enable_analytics?: boolean;
+    synonym_prefix?: boolean;
+    synonym_num_typos?: number;
+    pinned_hits?: string;
+    hidden_hits?: string;
+    curation_tags?: string;
+    highlight_fields?: string;
+    pre_segmented_query?: boolean;
+    preset?: string;
+    enable_curations?: boolean;
+    prioritize_exact_match?: boolean;
+    prioritize_token_position?: boolean;
+    prioritize_num_matching_fields?: boolean;
+    enable_typos_for_numerical_tokens?: boolean;
+    exhaustive_search?: boolean;
+    search_cutoff_ms?: number;
+    use_cache?: boolean;
+    cache_ttl?: number;
+    min_len_1typo?: number;
+    min_len_2typo?: number;
+    vector_query?: string;
+    remote_embedding_timeout_ms?: number;
+    remote_embedding_num_tries?: number;
+    facet_strategy?: string;
+    stopwords?: string;
+    facet_return_parent?: string;
+    voice_query?: string;
+    conversation?: boolean;
+    conversation_model_id?: string;
+    conversation_id?: string;
+    validate_field_names?: boolean;
+    collection?: string;
+    "x-typesense-api-key"?: string;
+    rerank_hybrid_matches?: boolean;
+  }[];
+}
 export const MultiSearchInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   multiSearchParameters: Schema.String,
   union: Schema.optional(Schema.Boolean),
@@ -81,10 +155,125 @@ export const MultiSearchInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       rerank_hybrid_matches: Schema.optional(Schema.Boolean),
     }),
   ),
-}).pipe(T.Http({ method: "POST", path: "/multi_search" }));
-export type MultiSearchInput = typeof MultiSearchInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/multi_search" }),
+) as unknown as Schema.Codec<MultiSearchInput>;
 
 // Output Schema
+export interface MultiSearchOutput {
+  results: {
+    facet_counts?: {
+      counts?: {
+        count?: number;
+        highlighted?: string;
+        value?: string;
+        parent?: unknown;
+      }[];
+      field_name?: string;
+      sampled?: boolean;
+      stats?: {
+        max?: number;
+        min?: number;
+        sum?: number;
+        total_values?: number;
+        avg?: number;
+      };
+    }[];
+    found?: number;
+    found_docs?: number;
+    search_time_ms?: number;
+    out_of?: number;
+    search_cutoff?: boolean;
+    page?: number;
+    grouped_hits?: {
+      found?: number;
+      group_key: unknown[];
+      hits: {
+        highlights?: {
+          field?: string;
+          snippet?: string;
+          snippets?: string[];
+          value?: string;
+          values?: string[];
+          indices?: number[];
+          matched_tokens?: unknown[];
+        }[];
+        highlight?: Record<string, unknown>;
+        document?: Record<string, unknown>;
+        text_match?: number;
+        text_match_info?: {
+          best_field_score?: string;
+          best_field_weight?: number;
+          fields_matched?: number;
+          num_tokens_dropped?: number;
+          score?: string;
+          tokens_matched?: number;
+          typo_prefix_score?: number;
+        };
+        geo_distance_meters?: Record<string, number>;
+        vector_distance?: number;
+        hybrid_search_info?: { rank_fusion_score?: number };
+        search_index?: number;
+      }[];
+    }[];
+    hits?: {
+      highlights?: {
+        field?: string;
+        snippet?: string;
+        snippets?: string[];
+        value?: string;
+        values?: string[];
+        indices?: number[];
+        matched_tokens?: unknown[];
+      }[];
+      highlight?: Record<string, unknown>;
+      document?: Record<string, unknown>;
+      text_match?: number;
+      text_match_info?: {
+        best_field_score?: string;
+        best_field_weight?: number;
+        fields_matched?: number;
+        num_tokens_dropped?: number;
+        score?: string;
+        tokens_matched?: number;
+        typo_prefix_score?: number;
+      };
+      geo_distance_meters?: Record<string, number>;
+      vector_distance?: number;
+      hybrid_search_info?: { rank_fusion_score?: number };
+      search_index?: number;
+    }[];
+    request_params?: {
+      collection_name: string;
+      first_q?: string;
+      q: string;
+      per_page: number;
+      voice_query?: { transcribed_query?: string };
+    };
+    conversation?: {
+      answer: string;
+      conversation_history: unknown[];
+      conversation_id: string;
+      query: string;
+    };
+    union_request_params?: {
+      collection_name: string;
+      first_q?: string;
+      q: string;
+      per_page: number;
+      voice_query?: { transcribed_query?: string };
+    }[];
+    metadata?: Record<string, unknown>;
+    code?: number;
+    error?: string;
+  }[];
+  conversation?: {
+    answer: string;
+    conversation_history: unknown[];
+    conversation_id: string;
+    query: string;
+  };
+}
 export const MultiSearchOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   results: Schema.Array(
     Schema.Struct({
@@ -272,8 +461,7 @@ export const MultiSearchOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       query: Schema.String,
     }),
   ),
-});
-export type MultiSearchOutput = typeof MultiSearchOutput.Type;
+}) as unknown as Schema.Codec<MultiSearchOutput>;
 
 // The operation
 /**

package/src/operations/retrieveAPIStats.ts

@@ -3,12 +3,29 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveAPIStatsInput {}
 export const RetrieveAPIStatsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {},
-).pipe(T.Http({ method: "GET", path: "/stats.json" }));
-export type RetrieveAPIStatsInput = typeof RetrieveAPIStatsInput.Type;
+).pipe(
+  T.Http({ method: "GET", path: "/stats.json" }),
+) as unknown as Schema.Codec<RetrieveAPIStatsInput>;
 
 // Output Schema
+export interface RetrieveAPIStatsOutput {
+  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 const RetrieveAPIStatsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     delete_latency_ms: Schema.optional(Schema.Number),
@@ -25,8 +42,7 @@ export const RetrieveAPIStatsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     write_latency_ms: Schema.optional(Schema.Number),
     write_requests_per_second: Schema.optional(Schema.Number),
   },
-);
-export type RetrieveAPIStatsOutput = typeof RetrieveAPIStatsOutput.Type;
+) as unknown as Schema.Codec<RetrieveAPIStatsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveAllConversationModels.ts

@@ -3,22 +3,20 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveAllConversationModelsInput {}
 export const RetrieveAllConversationModelsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/conversations/models" }),
-  );
-export type RetrieveAllConversationModelsInput =
-  typeof RetrieveAllConversationModelsInput.Type;
+  ) as unknown as Schema.Codec<RetrieveAllConversationModelsInput>;
 
 // Output Schema
+export type RetrieveAllConversationModelsOutput = { id: string }[];
 export const RetrieveAllConversationModelsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
       id: Schema.String,
     }),
-  );
-export type RetrieveAllConversationModelsOutput =
-  typeof RetrieveAllConversationModelsOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveAllConversationModelsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveAllNLSearchModels.ts

@@ -3,22 +3,20 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveAllNLSearchModelsInput {}
 export const RetrieveAllNLSearchModelsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/nl_search_models" }),
-  );
-export type RetrieveAllNLSearchModelsInput =
-  typeof RetrieveAllNLSearchModelsInput.Type;
+  ) as unknown as Schema.Codec<RetrieveAllNLSearchModelsInput>;
 
 // Output Schema
+export type RetrieveAllNLSearchModelsOutput = { id: string }[];
 export const RetrieveAllNLSearchModelsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
       id: Schema.String,
     }),
-  );
-export type RetrieveAllNLSearchModelsOutput =
-  typeof RetrieveAllNLSearchModelsOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveAllNLSearchModelsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveAllPresets.ts

@@ -3,13 +3,169 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveAllPresetsInput {}
 export const RetrieveAllPresetsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/presets" }),
-  );
-export type RetrieveAllPresetsInput = typeof RetrieveAllPresetsInput.Type;
+  ) as unknown as Schema.Codec<RetrieveAllPresetsInput>;
 
 // Output Schema
+export interface RetrieveAllPresetsOutput {
+  presets: {
+    value:
+      | {
+          q?: string;
+          query_by?: string;
+          validate_field_names?: boolean;
+          nl_query?: boolean;
+          nl_model_id?: string;
+          query_by_weights?: string;
+          text_match_type?: string;
+          prefix?: string;
+          infix?: string;
+          max_extra_prefix?: number;
+          max_extra_suffix?: number;
+          filter_by?: string;
+          max_filter_by_candidates?: number;
+          sort_by?: string;
+          facet_by?: string;
+          max_facet_values?: number;
+          facet_query?: string;
+          num_typos?: string;
+          page?: number;
+          per_page?: number;
+          limit?: number;
+          offset?: number;
+          group_by?: string;
+          group_limit?: number;
+          group_missing_values?: boolean;
+          include_fields?: string;
+          exclude_fields?: string;
+          highlight_full_fields?: string;
+          highlight_affix_num_tokens?: number;
+          highlight_start_tag?: string;
+          highlight_end_tag?: string;
+          enable_highlight_v1?: boolean;
+          enable_analytics?: boolean;
+          snippet_threshold?: number;
+          synonym_sets?: string;
+          drop_tokens_threshold?: number;
+          drop_tokens_mode?: "right_to_left" | "left_to_right" | "both_sides:3";
+          typo_tokens_threshold?: number;
+          enable_typos_for_alpha_numerical_tokens?: boolean;
+          filter_curated_hits?: boolean;
+          enable_synonyms?: boolean;
+          synonym_prefix?: boolean;
+          synonym_num_typos?: number;
+          pinned_hits?: string;
+          hidden_hits?: string;
+          curation_tags?: string;
+          highlight_fields?: string;
+          split_join_tokens?: string;
+          pre_segmented_query?: boolean;
+          preset?: string;
+          enable_curations?: boolean;
+          prioritize_exact_match?: boolean;
+          max_candidates?: number;
+          prioritize_token_position?: boolean;
+          prioritize_num_matching_fields?: boolean;
+          enable_typos_for_numerical_tokens?: boolean;
+          exhaustive_search?: boolean;
+          search_cutoff_ms?: number;
+          use_cache?: boolean;
+          cache_ttl?: number;
+          min_len_1typo?: number;
+          min_len_2typo?: number;
+          vector_query?: string;
+          remote_embedding_timeout_ms?: number;
+          remote_embedding_num_tries?: number;
+          facet_strategy?: string;
+          stopwords?: string;
+          facet_return_parent?: string;
+          voice_query?: string;
+          conversation?: boolean;
+          conversation_model_id?: string;
+          conversation_id?: string;
+        }
+      | {
+          union?: boolean;
+          searches: {
+            q?: string;
+            query_by?: string;
+            query_by_weights?: string;
+            text_match_type?: string;
+            prefix?: string;
+            infix?: string;
+            max_extra_prefix?: number;
+            max_extra_suffix?: number;
+            filter_by?: string;
+            sort_by?: string;
+            facet_by?: string;
+            max_facet_values?: number;
+            facet_query?: string;
+            num_typos?: string;
+            page?: number;
+            per_page?: number;
+            limit?: number;
+            offset?: number;
+            group_by?: string;
+            group_limit?: number;
+            group_missing_values?: boolean;
+            include_fields?: string;
+            exclude_fields?: string;
+            highlight_full_fields?: string;
+            highlight_affix_num_tokens?: number;
+            highlight_start_tag?: string;
+            highlight_end_tag?: string;
+            snippet_threshold?: number;
+            drop_tokens_threshold?: number;
+            drop_tokens_mode?:
+              | "right_to_left"
+              | "left_to_right"
+              | "both_sides:3";
+            typo_tokens_threshold?: number;
+            enable_typos_for_alpha_numerical_tokens?: boolean;
+            filter_curated_hits?: boolean;
+            enable_synonyms?: boolean;
+            enable_analytics?: boolean;
+            synonym_prefix?: boolean;
+            synonym_num_typos?: number;
+            pinned_hits?: string;
+            hidden_hits?: string;
+            curation_tags?: string;
+            highlight_fields?: string;
+            pre_segmented_query?: boolean;
+            preset?: string;
+            enable_curations?: boolean;
+            prioritize_exact_match?: boolean;
+            prioritize_token_position?: boolean;
+            prioritize_num_matching_fields?: boolean;
+            enable_typos_for_numerical_tokens?: boolean;
+            exhaustive_search?: boolean;
+            search_cutoff_ms?: number;
+            use_cache?: boolean;
+            cache_ttl?: number;
+            min_len_1typo?: number;
+            min_len_2typo?: number;
+            vector_query?: string;
+            remote_embedding_timeout_ms?: number;
+            remote_embedding_num_tries?: number;
+            facet_strategy?: string;
+            stopwords?: string;
+            facet_return_parent?: string;
+            voice_query?: string;
+            conversation?: boolean;
+            conversation_model_id?: string;
+            conversation_id?: string;
+            validate_field_names?: boolean;
+            collection?: string;
+            "x-typesense-api-key"?: string;
+            rerank_hybrid_matches?: boolean;
+          }[];
+        };
+    name: string;
+  }[];
+}
 export const RetrieveAllPresetsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     presets: Schema.Array(
@@ -18,8 +174,7 @@ export const RetrieveAllPresetsOutput =
         name: Schema.String,
       }),
     ),
-  });
-export type RetrieveAllPresetsOutput = typeof RetrieveAllPresetsOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveAllPresetsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveAnalyticsRule.ts

@@ -4,13 +4,33 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveAnalyticsRuleInput {
+  ruleName: string;
+}
 export const RetrieveAnalyticsRuleInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     ruleName: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/analytics/rules/{ruleName}" }));
-export type RetrieveAnalyticsRuleInput = typeof RetrieveAnalyticsRuleInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/analytics/rules/{ruleName}" }),
+  ) as unknown as Schema.Codec<RetrieveAnalyticsRuleInput>;
 
 // Output Schema
+export interface RetrieveAnalyticsRuleOutput {
+  name: string;
+  type: "popular_queries" | "nohits_queries" | "counter" | "log";
+  collection: string;
+  event_type: string;
+  rule_tag?: string;
+  params?: {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: string[];
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+  };
+}
 export const RetrieveAnalyticsRuleOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String,
@@ -34,9 +54,7 @@ export const RetrieveAnalyticsRuleOutput =
         weight: Schema.optional(Schema.Number),
       }),
     ),
-  });
-export type RetrieveAnalyticsRuleOutput =
-  typeof RetrieveAnalyticsRuleOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveAnalyticsRuleOutput>;
 
 // The operation
 /**

package/src/operations/retrieveAnalyticsRules.ts

@@ -3,14 +3,33 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveAnalyticsRulesInput {
+  rule_tag?: string;
+}
 export const RetrieveAnalyticsRulesInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     rule_tag: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "GET", path: "/analytics/rules" }));
-export type RetrieveAnalyticsRulesInput =
-  typeof RetrieveAnalyticsRulesInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/analytics/rules" }),
+  ) as unknown as Schema.Codec<RetrieveAnalyticsRulesInput>;
 
 // Output Schema
+export type RetrieveAnalyticsRulesOutput = {
+  name: string;
+  type: "popular_queries" | "nohits_queries" | "counter" | "log";
+  collection: string;
+  event_type: string;
+  rule_tag?: string;
+  params?: {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: string[];
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+  };
+}[];
 export const RetrieveAnalyticsRulesOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -36,9 +55,7 @@ export const RetrieveAnalyticsRulesOutput =
         }),
       ),
     }),
-  );
-export type RetrieveAnalyticsRulesOutput =
-  typeof RetrieveAnalyticsRulesOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveAnalyticsRulesOutput>;
 
 // The operation
 /**