@distilled.cloud/typesense 0.26.1 → 0.28.0

package/src/operations/createConversationModel.ts

@@ -3,8 +3,20 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 import { BadRequest } from "../errors.ts";
 import { SensitiveString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface CreateConversationModelInput {
+  id?: string;
+  model_name: string;
+  api_key?: string | Redacted.Redacted<string>;
+  history_collection: string;
+  account_id?: string;
+  system_prompt?: string;
+  ttl?: number;
+  max_bytes: number;
+  vllm_url?: string;
+}
 export const CreateConversationModelInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.optional(Schema.String),
@@ -16,17 +28,18 @@ export const CreateConversationModelInput =
     ttl: Schema.optional(Schema.Number),
     max_bytes: Schema.Number,
     vllm_url: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "POST", path: "/conversations/models" }));
-export type CreateConversationModelInput =
-  typeof CreateConversationModelInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/conversations/models" }),
+  ) as unknown as Schema.Codec<CreateConversationModelInput>;
 
 // Output Schema
+export interface CreateConversationModelOutput {
+  id: string;
+}
 export const CreateConversationModelOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type CreateConversationModelOutput =
-  typeof CreateConversationModelOutput.Type;
+  }) as unknown as Schema.Codec<CreateConversationModelOutput>;
 
 // The operation
 /**

package/src/operations/createKey.ts

@@ -4,16 +4,33 @@ import * as T from "../traits.ts";
 import { BadRequest, Conflict } from "../errors.ts";
 
 // Input Schema
+export interface CreateKeyInput {
+  value?: string;
+  description: string;
+  actions: string[];
+  collections: string[];
+  expires_at?: number;
+}
 export const CreateKeyInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   value: Schema.optional(Schema.String),
   description: Schema.String,
   actions: Schema.Array(Schema.String),
   collections: Schema.Array(Schema.String),
   expires_at: Schema.optional(Schema.Number),
-}).pipe(T.Http({ method: "POST", path: "/keys" }));
-export type CreateKeyInput = typeof CreateKeyInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/keys" }),
+) as unknown as Schema.Codec<CreateKeyInput>;
 
 // Output Schema
+export interface CreateKeyOutput {
+  value?: string;
+  description: string;
+  actions: string[];
+  collections: string[];
+  expires_at?: number;
+  id?: number;
+  value_prefix?: string;
+}
 export const CreateKeyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   value: Schema.optional(Schema.String),
   description: Schema.String,
@@ -22,8 +39,7 @@ export const CreateKeyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   expires_at: Schema.optional(Schema.Number),
   id: Schema.optional(Schema.Number),
   value_prefix: Schema.optional(Schema.String),
-});
-export type CreateKeyOutput = typeof CreateKeyOutput.Type;
+}) as unknown as Schema.Codec<CreateKeyOutput>;
 
 // The operation
 /**

package/src/operations/createNLSearchModel.ts

@@ -3,8 +3,30 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 import { BadRequest } from "../errors.ts";
 import { SensitiveString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface CreateNLSearchModelInput {
+  model_name?: string;
+  api_key?: string | Redacted.Redacted<string>;
+  api_url?: string;
+  max_bytes?: number;
+  temperature?: number;
+  system_prompt?: string;
+  top_p?: number;
+  top_k?: number;
+  stop_sequences?: string[];
+  api_version?: string;
+  project_id?: string;
+  access_token?: string | Redacted.Redacted<string>;
+  refresh_token?: string | Redacted.Redacted<string>;
+  client_id?: string;
+  client_secret?: string | Redacted.Redacted<string>;
+  region?: string;
+  max_output_tokens?: number;
+  account_id?: string;
+  id?: string;
+}
 export const CreateNLSearchModelInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     model_name: Schema.optional(Schema.String),
@@ -26,15 +48,18 @@ export const CreateNLSearchModelInput =
     max_output_tokens: Schema.optional(Schema.Number),
     account_id: Schema.optional(Schema.String),
     id: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "POST", path: "/nl_search_models" }));
-export type CreateNLSearchModelInput = typeof CreateNLSearchModelInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/nl_search_models" }),
+  ) as unknown as Schema.Codec<CreateNLSearchModelInput>;
 
 // Output Schema
+export interface CreateNLSearchModelOutput {
+  id: string;
+}
 export const CreateNLSearchModelOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type CreateNLSearchModelOutput = typeof CreateNLSearchModelOutput.Type;
+  }) as unknown as Schema.Codec<CreateNLSearchModelOutput>;
 
 // The operation
 /**

package/src/operations/debug.ts

@@ -3,16 +3,18 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface DebugInput {}
 export const DebugInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
   T.Http({ method: "GET", path: "/debug" }),
-);
-export type DebugInput = typeof DebugInput.Type;
+) as unknown as Schema.Codec<DebugInput>;
 
 // Output Schema
+export interface DebugOutput {
+  version?: string;
+}
 export const DebugOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   version: Schema.optional(Schema.String),
-});
-export type DebugOutput = typeof DebugOutput.Type;
+}) as unknown as Schema.Codec<DebugOutput>;
 
 // The operation
 /**

package/src/operations/deleteAlias.ts

@@ -4,17 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteAliasInput {
+  aliasName: string;
+}
 export const DeleteAliasInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   aliasName: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "DELETE", path: "/aliases/{aliasName}" }));
-export type DeleteAliasInput = typeof DeleteAliasInput.Type;
+}).pipe(
+  T.Http({ method: "DELETE", path: "/aliases/{aliasName}" }),
+) as unknown as Schema.Codec<DeleteAliasInput>;
 
 // Output Schema
+export interface DeleteAliasOutput {
+  name: string;
+  collection_name: string;
+}
 export const DeleteAliasOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   name: Schema.String,
   collection_name: Schema.String,
-});
-export type DeleteAliasOutput = typeof DeleteAliasOutput.Type;
+}) as unknown as Schema.Codec<DeleteAliasOutput>;
 
 // The operation
 /**

package/src/operations/deleteAnalyticsRule.ts

@@ -4,13 +4,33 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteAnalyticsRuleInput {
+  ruleName: string;
+}
 export const DeleteAnalyticsRuleInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     ruleName: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "DELETE", path: "/analytics/rules/{ruleName}" }));
-export type DeleteAnalyticsRuleInput = typeof DeleteAnalyticsRuleInput.Type;
+  }).pipe(
+    T.Http({ method: "DELETE", path: "/analytics/rules/{ruleName}" }),
+  ) as unknown as Schema.Codec<DeleteAnalyticsRuleInput>;
 
 // Output Schema
+export interface DeleteAnalyticsRuleOutput {
+  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 DeleteAnalyticsRuleOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String,
@@ -34,8 +54,7 @@ export const DeleteAnalyticsRuleOutput =
         weight: Schema.optional(Schema.Number),
       }),
     ),
-  });
-export type DeleteAnalyticsRuleOutput = typeof DeleteAnalyticsRuleOutput.Type;
+  }) as unknown as Schema.Codec<DeleteAnalyticsRuleOutput>;
 
 // The operation
 /**

package/src/operations/deleteCollection.ts

@@ -2,15 +2,68 @@ import * as Schema from "effect/Schema";
 import { API } from "../client.ts";
 import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
-import { SensitiveString } from "../sensitive.ts";
+import { SensitiveOutputString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface DeleteCollectionInput {
+  collectionName: string;
+}
 export const DeleteCollectionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   collectionName: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "DELETE", path: "/collections/{collectionName}" }));
-export type DeleteCollectionInput = typeof DeleteCollectionInput.Type;
+}).pipe(
+  T.Http({ method: "DELETE", path: "/collections/{collectionName}" }),
+) as unknown as Schema.Codec<DeleteCollectionInput>;
 
 // Output Schema
+export interface DeleteCollectionOutput {
+  name: string;
+  fields: {
+    name: string;
+    type: string;
+    optional?: boolean;
+    facet?: boolean;
+    index?: boolean;
+    locale?: string;
+    sort?: boolean;
+    infix?: boolean;
+    reference?: string;
+    async_reference?: boolean;
+    num_dim?: number;
+    drop?: boolean;
+    store?: boolean;
+    vec_dist?: string;
+    range_index?: boolean;
+    stem?: boolean;
+    stem_dictionary?: string;
+    token_separators?: string[];
+    symbols_to_index?: string[];
+    embed?: {
+      from: string[];
+      model_config: {
+        model_name: string;
+        api_key?: Redacted.Redacted<string>;
+        url?: string;
+        access_token?: Redacted.Redacted<string>;
+        refresh_token?: Redacted.Redacted<string>;
+        client_id?: string;
+        client_secret?: Redacted.Redacted<string>;
+        project_id?: string;
+        indexing_prefix?: string;
+        query_prefix?: string;
+      };
+    };
+  }[];
+  default_sorting_field?: string;
+  token_separators?: string[];
+  synonym_sets?: string[];
+  enable_nested_fields?: boolean;
+  symbols_to_index?: string[];
+  voice_query_model?: { model_name?: string };
+  metadata?: unknown;
+  num_documents: number;
+  created_at: number;
+}
 export const DeleteCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     name: Schema.String,
@@ -40,12 +93,12 @@ export const DeleteCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
             from: Schema.Array(Schema.String),
             model_config: Schema.Struct({
               model_name: Schema.String,
-              api_key: Schema.optional(SensitiveString),
+              api_key: Schema.optional(SensitiveOutputString),
               url: Schema.optional(Schema.String),
-              access_token: Schema.optional(SensitiveString),
-              refresh_token: Schema.optional(SensitiveString),
+              access_token: Schema.optional(SensitiveOutputString),
+              refresh_token: Schema.optional(SensitiveOutputString),
               client_id: Schema.optional(Schema.String),
-              client_secret: Schema.optional(SensitiveString),
+              client_secret: Schema.optional(SensitiveOutputString),
               project_id: Schema.optional(Schema.String),
               indexing_prefix: Schema.optional(Schema.String),
               query_prefix: Schema.optional(Schema.String),
@@ -68,8 +121,7 @@ export const DeleteCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     num_documents: Schema.Number,
     created_at: Schema.Number,
   },
-);
-export type DeleteCollectionOutput = typeof DeleteCollectionOutput.Type;
+) as unknown as Schema.Codec<DeleteCollectionOutput>;
 
 // The operation
 /**

package/src/operations/deleteConversationModel.ts

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

package/src/operations/deleteCurationSet.ts

@@ -4,19 +4,25 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteCurationSetInput {
+  curationSetName: string;
+}
 export const DeleteCurationSetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     curationSetName: Schema.String.pipe(T.PathParam()),
   },
-).pipe(T.Http({ method: "DELETE", path: "/curation_sets/{curationSetName}" }));
-export type DeleteCurationSetInput = typeof DeleteCurationSetInput.Type;
+).pipe(
+  T.Http({ method: "DELETE", path: "/curation_sets/{curationSetName}" }),
+) as unknown as Schema.Codec<DeleteCurationSetInput>;
 
 // Output Schema
+export interface DeleteCurationSetOutput {
+  name: string;
+}
 export const DeleteCurationSetOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String,
-  });
-export type DeleteCurationSetOutput = typeof DeleteCurationSetOutput.Type;
+  }) as unknown as Schema.Codec<DeleteCurationSetOutput>;
 
 // The operation
 /**

package/src/operations/deleteCurationSetItem.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteCurationSetItemInput {
+  curationSetName: string;
+  itemId: string;
+}
 export const DeleteCurationSetItemInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     curationSetName: Schema.String.pipe(T.PathParam()),
@@ -13,16 +17,16 @@ export const DeleteCurationSetItemInput =
       method: "DELETE",
       path: "/curation_sets/{curationSetName}/items/{itemId}",
     }),
-  );
-export type DeleteCurationSetItemInput = typeof DeleteCurationSetItemInput.Type;
+  ) as unknown as Schema.Codec<DeleteCurationSetItemInput>;
 
 // Output Schema
+export interface DeleteCurationSetItemOutput {
+  id: string;
+}
 export const DeleteCurationSetItemOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type DeleteCurationSetItemOutput =
-  typeof DeleteCurationSetItemOutput.Type;
+  }) as unknown as Schema.Codec<DeleteCurationSetItemOutput>;
 
 // The operation
 /**

package/src/operations/deleteDocument.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteDocumentInput {
+  collectionName: string;
+  documentId: string;
+}
 export const DeleteDocumentInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   collectionName: Schema.String.pipe(T.PathParam()),
   documentId: Schema.String.pipe(T.PathParam()),
@@ -12,12 +16,12 @@ export const DeleteDocumentInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "DELETE",
     path: "/collections/{collectionName}/documents/{documentId}",
   }),
-);
-export type DeleteDocumentInput = typeof DeleteDocumentInput.Type;
+) as unknown as Schema.Codec<DeleteDocumentInput>;
 
 // Output Schema
-export const DeleteDocumentOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
-export type DeleteDocumentOutput = typeof DeleteDocumentOutput.Type;
+export type DeleteDocumentOutput = unknown;
+export const DeleteDocumentOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Codec<DeleteDocumentOutput>;
 
 // The operation
 /**

package/src/operations/deleteDocuments.ts

@@ -4,19 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteDocumentsInput {
+  collectionName: string;
+  deleteDocumentsParameters?: string;
+}
 export const DeleteDocumentsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   collectionName: Schema.String.pipe(T.PathParam()),
   deleteDocumentsParameters: Schema.optional(Schema.String),
 }).pipe(
   T.Http({ method: "DELETE", path: "/collections/{collectionName}/documents" }),
-);
-export type DeleteDocumentsInput = typeof DeleteDocumentsInput.Type;
+) as unknown as Schema.Codec<DeleteDocumentsInput>;
 
 // Output Schema
+export interface DeleteDocumentsOutput {
+  num_deleted: number;
+}
 export const DeleteDocumentsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   num_deleted: Schema.Number,
-});
-export type DeleteDocumentsOutput = typeof DeleteDocumentsOutput.Type;
+}) as unknown as Schema.Codec<DeleteDocumentsOutput>;
 
 // The operation
 /**

package/src/operations/deleteKey.ts

@@ -4,16 +4,22 @@ import * as T from "../traits.ts";
 import { BadRequest, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteKeyInput {
+  keyId: number;
+}
 export const DeleteKeyInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   keyId: Schema.Number.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "DELETE", path: "/keys/{keyId}" }));
-export type DeleteKeyInput = typeof DeleteKeyInput.Type;
+}).pipe(
+  T.Http({ method: "DELETE", path: "/keys/{keyId}" }),
+) as unknown as Schema.Codec<DeleteKeyInput>;
 
 // Output Schema
+export interface DeleteKeyOutput {
+  id: number;
+}
 export const DeleteKeyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.Number,
-});
-export type DeleteKeyOutput = typeof DeleteKeyOutput.Type;
+}) as unknown as Schema.Codec<DeleteKeyOutput>;
 
 // The operation
 /**

package/src/operations/deleteNLSearchModel.ts

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

package/src/operations/deletePreset.ts

@@ -4,16 +4,22 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeletePresetInput {
+  presetId: string;
+}
 export const DeletePresetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   presetId: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "DELETE", path: "/presets/{presetId}" }));
-export type DeletePresetInput = typeof DeletePresetInput.Type;
+}).pipe(
+  T.Http({ method: "DELETE", path: "/presets/{presetId}" }),
+) as unknown as Schema.Codec<DeletePresetInput>;
 
 // Output Schema
+export interface DeletePresetOutput {
+  name: string;
+}
 export const DeletePresetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   name: Schema.String,
-});
-export type DeletePresetOutput = typeof DeletePresetOutput.Type;
+}) as unknown as Schema.Codec<DeletePresetOutput>;
 
 // The operation
 /**

package/src/operations/deleteStopwordsSet.ts

@@ -4,18 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteStopwordsSetInput {
+  setId: string;
+}
 export const DeleteStopwordsSetInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     setId: Schema.String.pipe(T.PathParam()),
-  }).pipe(T.Http({ method: "DELETE", path: "/stopwords/{setId}" }));
-export type DeleteStopwordsSetInput = typeof DeleteStopwordsSetInput.Type;
+  }).pipe(
+    T.Http({ method: "DELETE", path: "/stopwords/{setId}" }),
+  ) as unknown as Schema.Codec<DeleteStopwordsSetInput>;
 
 // Output Schema
+export interface DeleteStopwordsSetOutput {
+  id: string;
+}
 export const DeleteStopwordsSetOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type DeleteStopwordsSetOutput = typeof DeleteStopwordsSetOutput.Type;
+  }) as unknown as Schema.Codec<DeleteStopwordsSetOutput>;
 
 // The operation
 /**

package/src/operations/deleteSynonymSet.ts

@@ -4,18 +4,24 @@ import * as T from "../traits.ts";
 import { NotFound } from "../errors.ts";
 
 // Input Schema
+export interface DeleteSynonymSetInput {
+  synonymSetName: string;
+}
 export const DeleteSynonymSetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   synonymSetName: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "DELETE", path: "/synonym_sets/{synonymSetName}" }));
-export type DeleteSynonymSetInput = typeof DeleteSynonymSetInput.Type;
+}).pipe(
+  T.Http({ method: "DELETE", path: "/synonym_sets/{synonymSetName}" }),
+) as unknown as Schema.Codec<DeleteSynonymSetInput>;
 
 // Output Schema
+export interface DeleteSynonymSetOutput {
+  name: string;
+}
 export const DeleteSynonymSetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     name: Schema.String,
   },
-);
-export type DeleteSynonymSetOutput = typeof DeleteSynonymSetOutput.Type;
+) as unknown as Schema.Codec<DeleteSynonymSetOutput>;
 
 // The operation
 /**