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

package/src/operations/createConversationModel.ts

@@ -1,54 +0,0 @@
-import * as Schema from "effect/Schema";
-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__*/ Schema.Struct({
-    id: Schema.optional(Schema.String),
-    model_name: Schema.String,
-    api_key: Schema.optional(SensitiveString),
-    history_collection: Schema.String,
-    account_id: Schema.optional(Schema.String),
-    system_prompt: Schema.optional(Schema.String),
-    ttl: Schema.optional(Schema.Number),
-    max_bytes: Schema.Number,
-    vllm_url: Schema.optional(Schema.String),
-  }).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__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<CreateConversationModelOutput>;
-
-// The operation
-/**
- * Create a conversation model
- *
- * Create a Conversation Model
- */
-export const createConversationModel = /*@__PURE__*/ API.make(() => ({
-  inputSchema: CreateConversationModelInput,
-  outputSchema: CreateConversationModelOutput,
-  errors: [BadRequest] as const,
-}));

package/src/operations/createKey.ts

@@ -1,54 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-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__*/ 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" }),
-) 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__*/ 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),
-  id: Schema.optional(Schema.Number),
-  value_prefix: Schema.optional(Schema.String),
-}) as unknown as Schema.Codec<CreateKeyOutput>;
-
-// The operation
-/**
- * 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 const createKey = /*@__PURE__*/ API.make(() => ({
-  inputSchema: CreateKeyInput,
-  outputSchema: CreateKeyOutput,
-  errors: [BadRequest, Conflict] as const,
-}));

package/src/operations/createNLSearchModel.ts

@@ -1,74 +0,0 @@
-import * as Schema from "effect/Schema";
-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__*/ Schema.Struct({
-    model_name: Schema.optional(Schema.String),
-    api_key: Schema.optional(SensitiveString),
-    api_url: Schema.optional(Schema.String),
-    max_bytes: Schema.optional(Schema.Number),
-    temperature: Schema.optional(Schema.Number),
-    system_prompt: Schema.optional(Schema.String),
-    top_p: Schema.optional(Schema.Number),
-    top_k: Schema.optional(Schema.Number),
-    stop_sequences: Schema.optional(Schema.Array(Schema.String)),
-    api_version: Schema.optional(Schema.String),
-    project_id: Schema.optional(Schema.String),
-    access_token: Schema.optional(SensitiveString),
-    refresh_token: Schema.optional(SensitiveString),
-    client_id: Schema.optional(Schema.String),
-    client_secret: Schema.optional(SensitiveString),
-    region: Schema.optional(Schema.String),
-    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" }),
-  ) as unknown as Schema.Codec<CreateNLSearchModelInput>;
-
-// Output Schema
-export interface CreateNLSearchModelOutput {
-  id: string;
-}
-export const CreateNLSearchModelOutput =
-  /*@__PURE__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<CreateNLSearchModelOutput>;
-
-// The operation
-/**
- * Create a NL search model
- *
- * Create a new NL search model.
- */
-export const createNLSearchModel = /*@__PURE__*/ API.make(() => ({
-  inputSchema: CreateNLSearchModelInput,
-  outputSchema: CreateNLSearchModelOutput,
-  errors: [BadRequest] as const,
-}));

package/src/operations/debug.ts

@@ -1,26 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface DebugInput {}
-export const DebugInput = /*@__PURE__*/ Schema.Struct({}).pipe(
-  T.Http({ method: "GET", path: "/debug" }),
-) as unknown as Schema.Codec<DebugInput>;
-
-// Output Schema
-export interface DebugOutput {
-  version?: string;
-}
-export const DebugOutput = /*@__PURE__*/ Schema.Struct({
-  version: Schema.optional(Schema.String),
-}) as unknown as Schema.Codec<DebugOutput>;
-
-// The operation
-/**
- * Print debugging information
- */
-export const debug = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DebugInput,
-  outputSchema: DebugOutput,
-}));

package/src/operations/deleteAlias.ts

@@ -1,36 +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 DeleteAliasInput {
-  aliasName: string;
-}
-export const DeleteAliasInput = /*@__PURE__*/ Schema.Struct({
-  aliasName: Schema.String.pipe(T.PathParam()),
-}).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__*/ Schema.Struct({
-  name: Schema.String,
-  collection_name: Schema.String,
-}) as unknown as Schema.Codec<DeleteAliasOutput>;
-
-// The operation
-/**
- * Delete an alias
- *
- * @param aliasName - The name of the alias to delete
- */
-export const deleteAlias = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteAliasInput,
-  outputSchema: DeleteAliasOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteAnalyticsRule.ts

@@ -1,71 +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 DeleteAnalyticsRuleInput {
-  ruleName: string;
-}
-export const DeleteAnalyticsRuleInput =
-  /*@__PURE__*/ Schema.Struct({
-    ruleName: Schema.String.pipe(T.PathParam()),
-  }).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__*/ Schema.Struct({
-    name: Schema.String,
-    type: Schema.Literals([
-      "popular_queries",
-      "nohits_queries",
-      "counter",
-      "log",
-    ]),
-    collection: Schema.String,
-    event_type: Schema.String,
-    rule_tag: Schema.optional(Schema.String),
-    params: Schema.optional(
-      Schema.Struct({
-        destination_collection: Schema.optional(Schema.String),
-        limit: Schema.optional(Schema.Number),
-        capture_search_requests: Schema.optional(Schema.Boolean),
-        meta_fields: Schema.optional(Schema.Array(Schema.String)),
-        expand_query: Schema.optional(Schema.Boolean),
-        counter_field: Schema.optional(Schema.String),
-        weight: Schema.optional(Schema.Number),
-      }),
-    ),
-  }) as unknown as Schema.Codec<DeleteAnalyticsRuleOutput>;
-
-// The operation
-/**
- * Delete an analytics rule
- *
- * Permanently deletes an analytics rule, given it's name
- *
- * @param ruleName - The name of the analytics rule to delete
- */
-export const deleteAnalyticsRule = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteAnalyticsRuleInput,
-  outputSchema: DeleteAnalyticsRuleOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteCollection.ts

@@ -1,136 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { NotFound } from "../errors.ts";
-import { SensitiveOutputString } from "../sensitive.ts";
-import * as Redacted from "effect/Redacted";
-
-// Input Schema
-export interface DeleteCollectionInput {
-  collectionName: string;
-}
-export const DeleteCollectionInput = /*@__PURE__*/ Schema.Struct({
-  collectionName: Schema.String.pipe(T.PathParam()),
-}).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__*/ Schema.Struct({
-  name: Schema.String,
-  fields: Schema.Array(
-    Schema.Struct({
-      name: Schema.String,
-      type: Schema.String,
-      optional: Schema.optional(Schema.Boolean),
-      facet: Schema.optional(Schema.Boolean),
-      index: Schema.optional(Schema.Boolean),
-      locale: Schema.optional(Schema.String),
-      sort: Schema.optional(Schema.Boolean),
-      infix: Schema.optional(Schema.Boolean),
-      reference: Schema.optional(Schema.String),
-      async_reference: Schema.optional(Schema.Boolean),
-      num_dim: Schema.optional(Schema.Number),
-      drop: Schema.optional(Schema.Boolean),
-      store: Schema.optional(Schema.Boolean),
-      vec_dist: Schema.optional(Schema.String),
-      range_index: Schema.optional(Schema.Boolean),
-      stem: Schema.optional(Schema.Boolean),
-      stem_dictionary: Schema.optional(Schema.String),
-      token_separators: Schema.optional(Schema.Array(Schema.String)),
-      symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-      embed: Schema.optional(
-        Schema.Struct({
-          from: Schema.Array(Schema.String),
-          model_config: Schema.Struct({
-            model_name: Schema.String,
-            api_key: Schema.optional(SensitiveOutputString),
-            url: Schema.optional(Schema.String),
-            access_token: Schema.optional(SensitiveOutputString),
-            refresh_token: Schema.optional(SensitiveOutputString),
-            client_id: Schema.optional(Schema.String),
-            client_secret: Schema.optional(SensitiveOutputString),
-            project_id: Schema.optional(Schema.String),
-            indexing_prefix: Schema.optional(Schema.String),
-            query_prefix: Schema.optional(Schema.String),
-          }),
-        }),
-      ),
-    }),
-  ),
-  default_sorting_field: Schema.optional(Schema.String),
-  token_separators: Schema.optional(Schema.Array(Schema.String)),
-  synonym_sets: Schema.optional(Schema.Array(Schema.String)),
-  enable_nested_fields: Schema.optional(Schema.Boolean),
-  symbols_to_index: Schema.optional(Schema.Array(Schema.String)),
-  voice_query_model: Schema.optional(
-    Schema.Struct({
-      model_name: Schema.optional(Schema.String),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Unknown),
-  num_documents: Schema.Number,
-  created_at: Schema.Number,
-}) as unknown as Schema.Codec<DeleteCollectionOutput>;
-
-// The operation
-/**
- * Delete a collection
- *
- * Permanently drops a collection. This action cannot be undone. For large collections, this might have an impact on read latencies.
- *
- * @param collectionName - The name of the collection to delete
- */
-export const deleteCollection = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteCollectionInput,
-  outputSchema: DeleteCollectionOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteConversationModel.ts

@@ -1,36 +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 DeleteConversationModelInput {
-  modelId: string;
-}
-export const DeleteConversationModelInput =
-  /*@__PURE__*/ Schema.Struct({
-    modelId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "DELETE", path: "/conversations/models/{modelId}" }),
-  ) as unknown as Schema.Codec<DeleteConversationModelInput>;
-
-// Output Schema
-export interface DeleteConversationModelOutput {
-  id: string;
-}
-export const DeleteConversationModelOutput =
-  /*@__PURE__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<DeleteConversationModelOutput>;
-
-// The operation
-/**
- * Delete a conversation model
- *
- * @param modelId - The id of the conversation model to delete
- */
-export const deleteConversationModel = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteConversationModelInput,
-  outputSchema: DeleteConversationModelOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteCurationSet.ts

@@ -1,37 +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 DeleteCurationSetInput {
-  curationSetName: string;
-}
-export const DeleteCurationSetInput = /*@__PURE__*/ Schema.Struct({
-  curationSetName: Schema.String.pipe(T.PathParam()),
-}).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__*/ Schema.Struct({
-    name: Schema.String,
-  }) as unknown as Schema.Codec<DeleteCurationSetOutput>;
-
-// The operation
-/**
- * Delete a curation set
- *
- * Delete a specific curation set by its name
- *
- * @param curationSetName - The name of the curation set to delete
- */
-export const deleteCurationSet = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteCurationSetInput,
-  outputSchema: DeleteCurationSetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteCurationSetItem.ts

@@ -1,44 +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 DeleteCurationSetItemInput {
-  curationSetName: string;
-  itemId: string;
-}
-export const DeleteCurationSetItemInput =
-  /*@__PURE__*/ Schema.Struct({
-    curationSetName: Schema.String.pipe(T.PathParam()),
-    itemId: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({
-      method: "DELETE",
-      path: "/curation_sets/{curationSetName}/items/{itemId}",
-    }),
-  ) as unknown as Schema.Codec<DeleteCurationSetItemInput>;
-
-// Output Schema
-export interface DeleteCurationSetItemOutput {
-  id: string;
-}
-export const DeleteCurationSetItemOutput =
-  /*@__PURE__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<DeleteCurationSetItemOutput>;
-
-// The operation
-/**
- * Delete a curation set item
- *
- * Delete a specific curation item by its id
- *
- * @param curationSetName - The name of the curation set
- * @param itemId - The id of the curation item to delete
- */
-export const deleteCurationSetItem = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteCurationSetItemInput,
-  outputSchema: DeleteCurationSetItemOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteDocument.ts

@@ -1,39 +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 DeleteDocumentInput {
-  collectionName: string;
-  documentId: string;
-}
-export const DeleteDocumentInput = /*@__PURE__*/ Schema.Struct({
-  collectionName: Schema.String.pipe(T.PathParam()),
-  documentId: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({
-    method: "DELETE",
-    path: "/collections/{collectionName}/documents/{documentId}",
-  }),
-) as unknown as Schema.Codec<DeleteDocumentInput>;
-
-// Output Schema
-export type DeleteDocumentOutput = unknown;
-export const DeleteDocumentOutput =
-  /*@__PURE__*/ Schema.Unknown as unknown as Schema.Codec<DeleteDocumentOutput>;
-
-// The operation
-/**
- * Delete a document
- *
- * Delete an individual document from a collection by using its ID.
- *
- * @param collectionName - The name of the collection to search for the document under
- * @param documentId - The Document ID
- */
-export const deleteDocument = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteDocumentInput,
-  outputSchema: DeleteDocumentOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteDocuments.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 DeleteDocumentsInput {
-  collectionName: string;
-  deleteDocumentsParameters?: string;
-}
-export const DeleteDocumentsInput = /*@__PURE__*/ Schema.Struct({
-  collectionName: Schema.String.pipe(T.PathParam()),
-  deleteDocumentsParameters: Schema.optional(Schema.String),
-}).pipe(
-  T.Http({ method: "DELETE", path: "/collections/{collectionName}/documents" }),
-) as unknown as Schema.Codec<DeleteDocumentsInput>;
-
-// Output Schema
-export interface DeleteDocumentsOutput {
-  num_deleted: number;
-}
-export const DeleteDocumentsOutput = /*@__PURE__*/ Schema.Struct({
-  num_deleted: Schema.Number,
-}) as unknown as Schema.Codec<DeleteDocumentsOutput>;
-
-// The operation
-/**
- * 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.
- *
- * @param collectionName - The name of the collection to delete documents from
- */
-export const deleteDocuments = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteDocumentsInput,
-  outputSchema: DeleteDocumentsOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteKey.ts

@@ -1,34 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-import { BadRequest, NotFound } from "../errors.ts";
-
-// Input Schema
-export interface DeleteKeyInput {
-  keyId: number;
-}
-export const DeleteKeyInput = /*@__PURE__*/ Schema.Struct({
-  keyId: Schema.Number.pipe(T.PathParam()),
-}).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__*/ Schema.Struct({
-  id: Schema.Number,
-}) as unknown as Schema.Codec<DeleteKeyOutput>;
-
-// The operation
-/**
- * Delete an API key given its ID.
- *
- * @param keyId - The ID of the key to delete
- */
-export const deleteKey = /*@__PURE__*/ API.make(() => ({
-  inputSchema: DeleteKeyInput,
-  outputSchema: DeleteKeyOutput,
-  errors: [BadRequest, NotFound] as const,
-}));