@distilled.cloud/typesense 0.26.1 → 0.28.0

package/src/operations/retrieveConversationModel.ts

@@ -4,20 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveConversationModelInput {
+  modelId: string;
+}
 export const RetrieveConversationModelInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     modelId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/conversations/models/{modelId}" }));
-export type RetrieveConversationModelInput =
-  typeof RetrieveConversationModelInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/conversations/models/{modelId}" }),
+  ) as unknown as Schema.Codec<RetrieveConversationModelInput>;
 
 // Output Schema
+export interface RetrieveConversationModelOutput {
+  id: string;
+}
 export const RetrieveConversationModelOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type RetrieveConversationModelOutput =
-  typeof RetrieveConversationModelOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveConversationModelOutput>;
 
 // The operation
 /**

package/src/operations/retrieveCurationSet.ts

@@ -4,13 +4,41 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveCurationSetInput {
+  curationSetName: string;
+}
 export const RetrieveCurationSetInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     curationSetName: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/curation_sets/{curationSetName}" }));
-export type RetrieveCurationSetInput = typeof RetrieveCurationSetInput.Type;
+  }).pipe(
+    T.Http({ method: "GET", path: "/curation_sets/{curationSetName}" }),
+  ) as unknown as Schema.Codec<RetrieveCurationSetInput>;
 
 // Output Schema
+export interface RetrieveCurationSetOutput {
+  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 RetrieveCurationSetOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     items: Schema.Array(
@@ -50,8 +78,7 @@ export const RetrieveCurationSetOutput =
     ),
     description: Schema.optional(Schema.String),
     name: Schema.String,
-  });
-export type RetrieveCurationSetOutput = typeof RetrieveCurationSetOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveCurationSetOutput>;
 
 // The operation
 /**

package/src/operations/retrieveCurationSetItem.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveCurationSetItemInput {
+  curationSetName: string;
+  itemId: string;
+}
 export const RetrieveCurationSetItemInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     curationSetName: Schema.String.pipe(T.PathParam()),
@@ -13,11 +17,29 @@ export const RetrieveCurationSetItemInput =
       method: "GET",
       path: "/curation_sets/{curationSetName}/items/{itemId}",
     }),
-  );
-export type RetrieveCurationSetItemInput =
-  typeof RetrieveCurationSetItemInput.Type;
+  ) as unknown as Schema.Codec<RetrieveCurationSetItemInput>;
 
 // Output Schema
+export interface RetrieveCurationSetItemOutput {
+  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;
+}
 export const RetrieveCurationSetItemOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     rule: Schema.Struct({
@@ -51,9 +73,7 @@ export const RetrieveCurationSetItemOutput =
     effective_to_ts: Schema.optional(Schema.Number),
     stop_processing: Schema.optional(Schema.Boolean),
     id: Schema.String,
-  });
-export type RetrieveCurationSetItemOutput =
-  typeof RetrieveCurationSetItemOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveCurationSetItemOutput>;
 
 // The operation
 /**

package/src/operations/retrieveCurationSetItems.ts

@@ -4,16 +4,37 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveCurationSetItemsInput {
+  curationSetName: string;
+}
 export const RetrieveCurationSetItemsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     curationSetName: Schema.String.pipe(T.PathParam()),
   }).pipe(
     T.Http({ method: "GET", path: "/curation_sets/{curationSetName}/items" }),
-  );
-export type RetrieveCurationSetItemsInput =
-  typeof RetrieveCurationSetItemsInput.Type;
+  ) as unknown as Schema.Codec<RetrieveCurationSetItemsInput>;
 
 // Output Schema
+export type RetrieveCurationSetItemsOutput = {
+  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;
+}[];
 export const RetrieveCurationSetItemsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -49,9 +70,7 @@ export const RetrieveCurationSetItemsOutput =
       stop_processing: Schema.optional(Schema.Boolean),
       id: Schema.String,
     }),
-  );
-export type RetrieveCurationSetItemsOutput =
-  typeof RetrieveCurationSetItemsOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveCurationSetItemsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveCurationSets.ts

@@ -3,13 +3,37 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveCurationSetsInput {}
 export const RetrieveCurationSetsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/curation_sets" }),
-  );
-export type RetrieveCurationSetsInput = typeof RetrieveCurationSetsInput.Type;
+  ) 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__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -51,8 +75,7 @@ export const RetrieveCurationSetsOutput =
       description: Schema.optional(Schema.String),
       name: Schema.String,
     }),
-  );
-export type RetrieveCurationSetsOutput = typeof RetrieveCurationSetsOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveCurationSetsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveMetrics.ts

@@ -3,14 +3,17 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveMetricsInput {}
 export const RetrieveMetricsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {},
-).pipe(T.Http({ method: "GET", path: "/metrics.json" }));
-export type RetrieveMetricsInput = typeof RetrieveMetricsInput.Type;
+).pipe(
+  T.Http({ method: "GET", path: "/metrics.json" }),
+) as unknown as Schema.Codec<RetrieveMetricsInput>;
 
 // Output Schema
-export const RetrieveMetricsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
-export type RetrieveMetricsOutput = typeof RetrieveMetricsOutput.Type;
+export type RetrieveMetricsOutput = unknown;
+export const RetrieveMetricsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Codec<RetrieveMetricsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveNLSearchModel.ts

@@ -4,19 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveNLSearchModelInput {
+  modelId: string;
+}
 export const RetrieveNLSearchModelInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     modelId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/nl_search_models/{modelId}" }));
-export type RetrieveNLSearchModelInput = typeof RetrieveNLSearchModelInput.Type;
+  }).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__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type RetrieveNLSearchModelOutput =
-  typeof RetrieveNLSearchModelOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveNLSearchModelOutput>;
 
 // The operation
 /**

package/src/operations/retrievePreset.ts

@@ -4,17 +4,171 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrievePresetInput {
+  presetId: string;
+}
 export const RetrievePresetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   presetId: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "GET", path: "/presets/{presetId}" }));
-export type RetrievePresetInput = typeof RetrievePresetInput.Type;
+}).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__*/ /*#__PURE__*/ Schema.Struct({
   value: Schema.Unknown,
   name: Schema.String,
-});
-export type RetrievePresetOutput = typeof RetrievePresetOutput.Type;
+}) as unknown as Schema.Codec<RetrievePresetOutput>;
 
 // The operation
 /**

package/src/operations/retrieveStopwordsSet.ts

@@ -4,13 +4,20 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveStopwordsSetInput {
+  setId: string;
+}
 export const RetrieveStopwordsSetInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     setId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/stopwords/{setId}" }));
-export type RetrieveStopwordsSetInput = typeof RetrieveStopwordsSetInput.Type;
+  }).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__*/ /*#__PURE__*/ Schema.Struct({
     stopwords: Schema.Struct({
@@ -18,8 +25,7 @@ export const RetrieveStopwordsSetOutput =
       stopwords: Schema.Array(Schema.String),
       locale: Schema.optional(Schema.String),
     }),
-  });
-export type RetrieveStopwordsSetOutput = typeof RetrieveStopwordsSetOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveStopwordsSetOutput>;
 
 // The operation
 /**

package/src/operations/retrieveStopwordsSets.ts

@@ -3,13 +3,16 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveStopwordsSetsInput {}
 export const RetrieveStopwordsSetsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/stopwords" }),
-  );
-export type RetrieveStopwordsSetsInput = typeof RetrieveStopwordsSetsInput.Type;
+  ) as unknown as Schema.Codec<RetrieveStopwordsSetsInput>;
 
 // Output Schema
+export interface RetrieveStopwordsSetsOutput {
+  stopwords: { id: string; stopwords: string[]; locale?: string }[];
+}
 export const RetrieveStopwordsSetsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     stopwords: Schema.Array(
@@ -19,9 +22,7 @@ export const RetrieveStopwordsSetsOutput =
         locale: Schema.optional(Schema.String),
       }),
     ),
-  });
-export type RetrieveStopwordsSetsOutput =
-  typeof RetrieveStopwordsSetsOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveStopwordsSetsOutput>;
 
 // The operation
 /**

package/src/operations/retrieveSynonymSet.ts

@@ -4,13 +4,27 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveSynonymSetInput {
+  synonymSetName: string;
+}
 export const RetrieveSynonymSetInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     synonymSetName: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "GET", path: "/synonym_sets/{synonymSetName}" }));
-export type RetrieveSynonymSetInput = typeof RetrieveSynonymSetInput.Type;
+  }).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__*/ /*#__PURE__*/ Schema.Struct({
     items: Schema.Array(
@@ -23,8 +37,7 @@ export const RetrieveSynonymSetOutput =
       }),
     ),
     name: Schema.String,
-  });
-export type RetrieveSynonymSetOutput = typeof RetrieveSynonymSetOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveSynonymSetOutput>;
 
 // The operation
 /**

package/src/operations/retrieveSynonymSetItem.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveSynonymSetItemInput {
+  synonymSetName: string;
+  itemId: string;
+}
 export const RetrieveSynonymSetItemInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     synonymSetName: Schema.String.pipe(T.PathParam()),
@@ -13,11 +17,16 @@ export const RetrieveSynonymSetItemInput =
       method: "GET",
       path: "/synonym_sets/{synonymSetName}/items/{itemId}",
     }),
-  );
-export type RetrieveSynonymSetItemInput =
-  typeof RetrieveSynonymSetItemInput.Type;
+  ) 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__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
@@ -25,9 +34,7 @@ export const RetrieveSynonymSetItemOutput =
     root: Schema.optional(Schema.String),
     locale: Schema.optional(Schema.String),
     symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-  });
-export type RetrieveSynonymSetItemOutput =
-  typeof RetrieveSynonymSetItemOutput.Type;
+  }) as unknown as Schema.Codec<RetrieveSynonymSetItemOutput>;
 
 // The operation
 /**

package/src/operations/retrieveSynonymSetItems.ts

@@ -4,16 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface RetrieveSynonymSetItemsInput {
+  synonymSetName: string;
+}
 export const RetrieveSynonymSetItemsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     synonymSetName: Schema.String.pipe(T.PathParam()),
   }).pipe(
     T.Http({ method: "GET", path: "/synonym_sets/{synonymSetName}/items" }),
-  );
-export type RetrieveSynonymSetItemsInput =
-  typeof RetrieveSynonymSetItemsInput.Type;
+  ) 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__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -23,9 +31,7 @@ export const RetrieveSynonymSetItemsOutput =
       locale: Schema.optional(Schema.String),
       symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
     }),
-  );
-export type RetrieveSynonymSetItemsOutput =
-  typeof RetrieveSynonymSetItemsOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveSynonymSetItemsOutput>;
 
 // The operation
 /**