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

package/src/operations/retrieveCurationSets.ts

@@ -1,89 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface RetrieveCurationSetsInput {}
-export const RetrieveCurationSetsInput =
-  /*@__PURE__*/ Schema.Struct({}).pipe(
-    T.Http({ method: "GET", path: "/curation_sets" }),
-  ) as unknown as Schema.Codec<RetrieveCurationSetsInput>;
-
-// Output Schema
-export type RetrieveCurationSetsOutput = {
-  items: {
-    rule: {
-      tags?: string[];
-      query?: string;
-      match?: "exact" | "contains";
-      filter_by?: string;
-    };
-    includes?: { id: string; position: number }[];
-    excludes?: { id: string }[];
-    filter_by?: string;
-    remove_matched_tokens?: boolean;
-    metadata?: unknown;
-    sort_by?: string;
-    replace_query?: string;
-    filter_curated_hits?: boolean;
-    effective_from_ts?: number;
-    effective_to_ts?: number;
-    stop_processing?: boolean;
-    id?: string;
-  }[];
-  description?: string;
-  name: string;
-}[];
-export const RetrieveCurationSetsOutput =
-  /*@__PURE__*/ Schema.Array(
-    Schema.Struct({
-      items: Schema.Array(
-        Schema.Struct({
-          rule: Schema.Struct({
-            tags: Schema.optional(Schema.Array(Schema.String)),
-            query: Schema.optional(Schema.String),
-            match: Schema.optional(Schema.Literals(["exact", "contains"])),
-            filter_by: Schema.optional(Schema.String),
-          }),
-          includes: Schema.optional(
-            Schema.Array(
-              Schema.Struct({
-                id: Schema.String,
-                position: Schema.Number,
-              }),
-            ),
-          ),
-          excludes: Schema.optional(
-            Schema.Array(
-              Schema.Struct({
-                id: Schema.String,
-              }),
-            ),
-          ),
-          filter_by: Schema.optional(Schema.String),
-          remove_matched_tokens: Schema.optional(Schema.Boolean),
-          metadata: Schema.optional(Schema.Unknown),
-          sort_by: Schema.optional(Schema.String),
-          replace_query: Schema.optional(Schema.String),
-          filter_curated_hits: Schema.optional(Schema.Boolean),
-          effective_from_ts: Schema.optional(Schema.Number),
-          effective_to_ts: Schema.optional(Schema.Number),
-          stop_processing: Schema.optional(Schema.Boolean),
-          id: Schema.optional(Schema.String),
-        }),
-      ),
-      description: Schema.optional(Schema.String),
-      name: Schema.String,
-    }),
-  ) as unknown as Schema.Codec<RetrieveCurationSetsOutput>;
-
-// The operation
-/**
- * List all curation sets
- *
- * Retrieve all curation sets
- */
-export const retrieveCurationSets = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveCurationSetsInput,
-  outputSchema: RetrieveCurationSetsOutput,
-}));

package/src/operations/retrieveMetrics.ts

@@ -1,25 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface RetrieveMetricsInput {}
-export const RetrieveMetricsInput = /*@__PURE__*/ Schema.Struct({}).pipe(
-  T.Http({ method: "GET", path: "/metrics.json" }),
-) as unknown as Schema.Codec<RetrieveMetricsInput>;
-
-// Output Schema
-export type RetrieveMetricsOutput = unknown;
-export const RetrieveMetricsOutput =
-  /*@__PURE__*/ Schema.Unknown as unknown as Schema.Codec<RetrieveMetricsOutput>;
-
-// The operation
-/**
- * Get current RAM, CPU, Disk & Network usage metrics.
- *
- * Retrieve the metrics.
- */
-export const retrieveMetrics = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveMetricsInput,
-  outputSchema: RetrieveMetricsOutput,
-}));

package/src/operations/retrieveNLSearchModel.ts

@@ -1,38 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-
-// Input Schema
-export interface RetrieveNLSearchModelInput {
-  modelId: string;
-}
-export const RetrieveNLSearchModelInput =
-  /*@__PURE__*/ Schema.Struct({
-    modelId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/nl_search_models/{modelId}" }),
-  ) as unknown as Schema.Codec<RetrieveNLSearchModelInput>;
-
-// Output Schema
-export interface RetrieveNLSearchModelOutput {
-  id: string;
-}
-export const RetrieveNLSearchModelOutput =
-  /*@__PURE__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<RetrieveNLSearchModelOutput>;
-
-// The operation
-/**
- * Retrieve a NL search model
- *
- * Retrieve a specific NL search model by its ID.
- *
- * @param modelId - The ID of the NL search model to retrieve
- */
-export const retrieveNLSearchModel = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveNLSearchModelInput,
-  outputSchema: RetrieveNLSearchModelOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/retrievePreset.ts

@@ -1,185 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-
-// Input Schema
-export interface RetrievePresetInput {
-  presetId: string;
-}
-export const RetrievePresetInput = /*@__PURE__*/ Schema.Struct({
-  presetId: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/presets/{presetId}" }),
-) as unknown as Schema.Codec<RetrievePresetInput>;
-
-// Output Schema
-export interface RetrievePresetOutput {
-  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 RetrievePresetOutput = /*@__PURE__*/ Schema.Struct({
-  value: Schema.Unknown,
-  name: Schema.String,
-}) as unknown as Schema.Codec<RetrievePresetOutput>;
-
-// The operation
-/**
- * Retrieves a preset.
- *
- * Retrieve the details of a preset, given it's name.
- *
- * @param presetId - The ID of the preset to retrieve.
- */
-export const retrievePreset = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrievePresetInput,
-  outputSchema: RetrievePresetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/retrieveStopwordsSet.ts

@@ -1,42 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-
-// Input Schema
-export interface RetrieveStopwordsSetInput {
-  setId: string;
-}
-export const RetrieveStopwordsSetInput =
-  /*@__PURE__*/ Schema.Struct({
-    setId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/stopwords/{setId}" }),
-  ) as unknown as Schema.Codec<RetrieveStopwordsSetInput>;
-
-// Output Schema
-export interface RetrieveStopwordsSetOutput {
-  stopwords: { id: string; stopwords: string[]; locale?: string };
-}
-export const RetrieveStopwordsSetOutput =
-  /*@__PURE__*/ Schema.Struct({
-    stopwords: Schema.Struct({
-      id: Schema.String,
-      stopwords: Schema.Array(Schema.String),
-      locale: Schema.optional(Schema.String),
-    }),
-  }) as unknown as Schema.Codec<RetrieveStopwordsSetOutput>;
-
-// The operation
-/**
- * Retrieves a stopwords set.
- *
- * Retrieve the details of a stopwords set, given it's name.
- *
- * @param setId - The ID of the stopwords set to retrieve.
- */
-export const retrieveStopwordsSet = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveStopwordsSetInput,
-  outputSchema: RetrieveStopwordsSetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/retrieveStopwordsSets.ts

@@ -1,36 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface RetrieveStopwordsSetsInput {}
-export const RetrieveStopwordsSetsInput =
-  /*@__PURE__*/ Schema.Struct({}).pipe(
-    T.Http({ method: "GET", path: "/stopwords" }),
-  ) as unknown as Schema.Codec<RetrieveStopwordsSetsInput>;
-
-// Output Schema
-export interface RetrieveStopwordsSetsOutput {
-  stopwords: { id: string; stopwords: string[]; locale?: string }[];
-}
-export const RetrieveStopwordsSetsOutput =
-  /*@__PURE__*/ Schema.Struct({
-    stopwords: Schema.Array(
-      Schema.Struct({
-        id: Schema.String,
-        stopwords: Schema.Array(Schema.String),
-        locale: Schema.optional(Schema.String),
-      }),
-    ),
-  }) as unknown as Schema.Codec<RetrieveStopwordsSetsOutput>;
-
-// The operation
-/**
- * Retrieves all stopwords sets.
- *
- * Retrieve the details of all stopwords sets
- */
-export const retrieveStopwordsSets = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveStopwordsSetsInput,
-  outputSchema: RetrieveStopwordsSetsOutput,
-}));

package/src/operations/retrieveSynonymSet.ts

@@ -1,54 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-
-// Input Schema
-export interface RetrieveSynonymSetInput {
-  synonymSetName: string;
-}
-export const RetrieveSynonymSetInput =
-  /*@__PURE__*/ Schema.Struct({
-    synonymSetName: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/synonym_sets/{synonymSetName}" }),
-  ) as unknown as Schema.Codec<RetrieveSynonymSetInput>;
-
-// Output Schema
-export interface RetrieveSynonymSetOutput {
-  items: {
-    id: string;
-    synonyms: string[];
-    root?: string;
-    locale?: string;
-    symbols_to_index?: string[];
-  }[];
-  name: string;
-}
-export const RetrieveSynonymSetOutput =
-  /*@__PURE__*/ Schema.Struct({
-    items: Schema.Array(
-      Schema.Struct({
-        id: Schema.String,
-        synonyms: Schema.Array(Schema.String),
-        root: Schema.optional(Schema.String),
-        locale: Schema.optional(Schema.String),
-        symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-      }),
-    ),
-    name: Schema.String,
-  }) as unknown as Schema.Codec<RetrieveSynonymSetOutput>;
-
-// The operation
-/**
- * Retrieve a synonym set
- *
- * Retrieve a specific synonym set by its name
- *
- * @param synonymSetName - The name of the synonym set to retrieve
- */
-export const retrieveSynonymSet = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveSynonymSetInput,
-  outputSchema: RetrieveSynonymSetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/retrieveSynonymSetItem.ts

@@ -1,52 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-
-// Input Schema
-export interface RetrieveSynonymSetItemInput {
-  synonymSetName: string;
-  itemId: string;
-}
-export const RetrieveSynonymSetItemInput =
-  /*@__PURE__*/ Schema.Struct({
-    synonymSetName: Schema.String.pipe(T.PathParam()),
-    itemId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({
-      method: "GET",
-      path: "/synonym_sets/{synonymSetName}/items/{itemId}",
-    }),
-  ) as unknown as Schema.Codec<RetrieveSynonymSetItemInput>;
-
-// Output Schema
-export interface RetrieveSynonymSetItemOutput {
-  id: string;
-  synonyms: string[];
-  root?: string;
-  locale?: string;
-  symbols_to_index?: string[];
-}
-export const RetrieveSynonymSetItemOutput =
-  /*@__PURE__*/ Schema.Struct({
-    id: Schema.String,
-    synonyms: Schema.Array(Schema.String),
-    root: Schema.optional(Schema.String),
-    locale: Schema.optional(Schema.String),
-    symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-  }) as unknown as Schema.Codec<RetrieveSynonymSetItemOutput>;
-
-// The operation
-/**
- * Retrieve a synonym set item
- *
- * Retrieve a specific synonym item by its id
- *
- * @param synonymSetName - The name of the synonym set
- * @param itemId - The id of the synonym item to retrieve
- */
-export const retrieveSynonymSetItem = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveSynonymSetItemInput,
-  outputSchema: RetrieveSynonymSetItemOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/retrieveSynonymSetItems.ts

@@ -1,48 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-
-// Input Schema
-export interface RetrieveSynonymSetItemsInput {
-  synonymSetName: string;
-}
-export const RetrieveSynonymSetItemsInput =
-  /*@__PURE__*/ Schema.Struct({
-    synonymSetName: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/synonym_sets/{synonymSetName}/items" }),
-  ) as unknown as Schema.Codec<RetrieveSynonymSetItemsInput>;
-
-// Output Schema
-export type RetrieveSynonymSetItemsOutput = {
-  id: string;
-  synonyms: string[];
-  root?: string;
-  locale?: string;
-  symbols_to_index?: string[];
-}[];
-export const RetrieveSynonymSetItemsOutput =
-  /*@__PURE__*/ Schema.Array(
-    Schema.Struct({
-      id: Schema.String,
-      synonyms: Schema.Array(Schema.String),
-      root: Schema.optional(Schema.String),
-      locale: Schema.optional(Schema.String),
-      symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-    }),
-  ) as unknown as Schema.Codec<RetrieveSynonymSetItemsOutput>;
-
-// The operation
-/**
- * List items in a synonym set
- *
- * Retrieve all synonym items in a set
- *
- * @param synonymSetName - The name of the synonym set to retrieve items for
- */
-export const retrieveSynonymSetItems = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveSynonymSetItemsInput,
-  outputSchema: RetrieveSynonymSetItemsOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/retrieveSynonymSets.ts

@@ -1,48 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface RetrieveSynonymSetsInput {}
-export const RetrieveSynonymSetsInput =
-  /*@__PURE__*/ Schema.Struct({}).pipe(
-    T.Http({ method: "GET", path: "/synonym_sets" }),
-  ) as unknown as Schema.Codec<RetrieveSynonymSetsInput>;
-
-// Output Schema
-export type RetrieveSynonymSetsOutput = {
-  items: {
-    id: string;
-    synonyms: string[];
-    root?: string;
-    locale?: string;
-    symbols_to_index?: string[];
-  }[];
-  name: string;
-}[];
-export const RetrieveSynonymSetsOutput =
-  /*@__PURE__*/ Schema.Array(
-    Schema.Struct({
-      items: Schema.Array(
-        Schema.Struct({
-          id: Schema.String,
-          synonyms: Schema.Array(Schema.String),
-          root: Schema.optional(Schema.String),
-          locale: Schema.optional(Schema.String),
-          symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-        }),
-      ),
-      name: Schema.String,
-    }),
-  ) as unknown as Schema.Codec<RetrieveSynonymSetsOutput>;
-
-// The operation
-/**
- * List all synonym sets
- *
- * Retrieve all synonym sets
- */
-export const retrieveSynonymSets = /*@__PURE__*/ API.make(() => ({
-  inputSchema: RetrieveSynonymSetsInput,
-  outputSchema: RetrieveSynonymSetsOutput,
-}));