@distilled.cloud/typesense 0.0.0 → 0.14.0

package/src/operations/deleteCurationSet.ts

@@ -0,0 +1,33 @@
+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 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;
+
+// Output Schema
+export const DeleteCurationSetOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    name: Schema.String,
+  });
+export type DeleteCurationSetOutput = typeof DeleteCurationSetOutput.Type;
+
+// 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteCurationSetInput,
+  outputSchema: DeleteCurationSetOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deleteCurationSetItem.ts

@@ -0,0 +1,42 @@
+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 const DeleteCurationSetItemInput =
+  /*@__PURE__*/ /*#__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}",
+    }),
+  );
+export type DeleteCurationSetItemInput = typeof DeleteCurationSetItemInput.Type;
+
+// Output Schema
+export const DeleteCurationSetItemOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+  });
+export type DeleteCurationSetItemOutput =
+  typeof DeleteCurationSetItemOutput.Type;
+
+// 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__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: DeleteCurationSetItemInput,
+    outputSchema: DeleteCurationSetItemOutput,
+    errors: [NotFound] as const,
+  }),
+);

package/src/operations/deleteDocument.ts

@@ -0,0 +1,35 @@
+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 const DeleteDocumentInput = /*@__PURE__*/ /*#__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}",
+  }),
+);
+export type DeleteDocumentInput = typeof DeleteDocumentInput.Type;
+
+// Output Schema
+export const DeleteDocumentOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export type DeleteDocumentOutput = typeof DeleteDocumentOutput.Type;
+
+// 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteDocumentInput,
+  outputSchema: DeleteDocumentOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deleteDocuments.ts

@@ -0,0 +1,33 @@
+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 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;
+
+// Output Schema
+export const DeleteDocumentsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  num_deleted: Schema.Number,
+});
+export type DeleteDocumentsOutput = typeof DeleteDocumentsOutput.Type;
+
+// 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__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteDocumentsInput,
+  outputSchema: DeleteDocumentsOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deleteKey.ts

@@ -0,0 +1,28 @@
+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 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;
+
+// Output Schema
+export const DeleteKeyOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.Number,
+});
+export type DeleteKeyOutput = typeof DeleteKeyOutput.Type;
+
+// The operation
+/**
+ * Delete an API key given its ID.
+ *
+ * @param keyId - The ID of the key to delete
+ */
+export const deleteKey = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteKeyInput,
+  outputSchema: DeleteKeyOutput,
+  errors: [BadRequest, NotFound] as const,
+}));

package/src/operations/deleteNLSearchModel.ts

@@ -0,0 +1,32 @@
+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 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;
+
+// Output Schema
+export const DeleteNLSearchModelOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+  });
+export type DeleteNLSearchModelOutput = typeof DeleteNLSearchModelOutput.Type;
+
+// The operation
+/**
+ * Delete a NL search model
+ *
+ * Delete a specific NL search model by its ID.
+ *
+ * @param modelId - The ID of the NL search model to delete
+ */
+export const deleteNLSearchModel = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteNLSearchModelInput,
+  outputSchema: DeleteNLSearchModelOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deletePreset.ts

@@ -0,0 +1,30 @@
+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 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;
+
+// Output Schema
+export const DeletePresetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  name: Schema.String,
+});
+export type DeletePresetOutput = typeof DeletePresetOutput.Type;
+
+// The operation
+/**
+ * Delete a preset.
+ *
+ * Permanently deletes a preset, given it's name.
+ *
+ * @param presetId - The ID of the preset to delete.
+ */
+export const deletePreset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeletePresetInput,
+  outputSchema: DeletePresetOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deleteStopwordsSet.ts

@@ -0,0 +1,32 @@
+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 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;
+
+// Output Schema
+export const DeleteStopwordsSetOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+  });
+export type DeleteStopwordsSetOutput = typeof DeleteStopwordsSetOutput.Type;
+
+// The operation
+/**
+ * Delete a stopwords set.
+ *
+ * Permanently deletes a stopwords set, given it's name.
+ *
+ * @param setId - The ID of the stopwords set to delete.
+ */
+export const deleteStopwordsSet = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteStopwordsSetInput,
+  outputSchema: DeleteStopwordsSetOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deleteSynonymSet.ts

@@ -0,0 +1,32 @@
+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 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;
+
+// Output Schema
+export const DeleteSynonymSetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    name: Schema.String,
+  },
+);
+export type DeleteSynonymSetOutput = typeof DeleteSynonymSetOutput.Type;
+
+// The operation
+/**
+ * Delete a synonym set
+ *
+ * Delete a specific synonym set by its name
+ *
+ * @param synonymSetName - The name of the synonym set to delete
+ */
+export const deleteSynonymSet = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteSynonymSetInput,
+  outputSchema: DeleteSynonymSetOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/deleteSynonymSetItem.ts

@@ -0,0 +1,41 @@
+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 const DeleteSynonymSetItemInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    synonymSetName: Schema.String.pipe(T.PathParam()),
+    itemId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/synonym_sets/{synonymSetName}/items/{itemId}",
+    }),
+  );
+export type DeleteSynonymSetItemInput = typeof DeleteSynonymSetItemInput.Type;
+
+// Output Schema
+export const DeleteSynonymSetItemOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+  });
+export type DeleteSynonymSetItemOutput = typeof DeleteSynonymSetItemOutput.Type;
+
+// The operation
+/**
+ * Delete a synonym set item
+ *
+ * Delete a specific synonym item by its id
+ *
+ * @param synonymSetName - The name of the synonym set
+ * @param itemId - The id of the synonym item to delete
+ */
+export const deleteSynonymSetItem = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: DeleteSynonymSetItemInput,
+    outputSchema: DeleteSynonymSetItemOutput,
+    errors: [NotFound] as const,
+  }),
+);

package/src/operations/exportDocuments.ts

@@ -0,0 +1,34 @@
+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 const ExportDocumentsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  collectionName: Schema.String.pipe(T.PathParam()),
+  exportDocumentsParameters: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/collections/{collectionName}/documents/export",
+  }),
+);
+export type ExportDocumentsInput = typeof ExportDocumentsInput.Type;
+
+// Output Schema
+export const ExportDocumentsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type ExportDocumentsOutput = typeof ExportDocumentsOutput.Type;
+
+// The operation
+/**
+ * Export all documents in a collection
+ *
+ * Export all documents in a collection in JSON lines format.
+ *
+ * @param collectionName - The name of the collection
+ */
+export const exportDocuments = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ExportDocumentsInput,
+  outputSchema: ExportDocumentsOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/flushAnalytics.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export const FlushAnalyticsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "POST", path: "/analytics/flush" }));
+export type FlushAnalyticsInput = typeof FlushAnalyticsInput.Type;
+
+// Output Schema
+export const FlushAnalyticsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  ok: Schema.Boolean,
+});
+export type FlushAnalyticsOutput = typeof FlushAnalyticsOutput.Type;
+
+// The operation
+/**
+ * Flush in-memory analytics to disk
+ *
+ * Triggers a flush of analytics data to persistent storage.
+ */
+export const flushAnalytics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: FlushAnalyticsInput,
+  outputSchema: FlushAnalyticsOutput,
+}));

package/src/operations/getAlias.ts

@@ -0,0 +1,31 @@
+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 const GetAliasInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  aliasName: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/aliases/{aliasName}" }));
+export type GetAliasInput = typeof GetAliasInput.Type;
+
+// Output Schema
+export const GetAliasOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  name: Schema.String,
+  collection_name: Schema.String,
+});
+export type GetAliasOutput = typeof GetAliasOutput.Type;
+
+// The operation
+/**
+ * Retrieve an alias
+ *
+ * Find out which collection an alias points to by fetching it
+ *
+ * @param aliasName - The name of the alias to retrieve
+ */
+export const getAlias = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAliasInput,
+  outputSchema: GetAliasOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/getAliases.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export const GetAliasesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/aliases" }));
+export type GetAliasesInput = typeof GetAliasesInput.Type;
+
+// Output Schema
+export const GetAliasesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  aliases: Schema.Array(
+    Schema.Struct({
+      name: Schema.String,
+      collection_name: Schema.String,
+    }),
+  ),
+});
+export type GetAliasesOutput = typeof GetAliasesOutput.Type;
+
+// The operation
+/**
+ * List all aliases
+ *
+ * List all aliases and the corresponding collections that they map to.
+ */
+export const getAliases = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAliasesInput,
+  outputSchema: GetAliasesOutput,
+}));

package/src/operations/getAnalyticsEvents.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { BadRequest } from "../errors.ts";
+
+// Input Schema
+export const GetAnalyticsEventsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    user_id: Schema.String,
+    name: Schema.String,
+    n: Schema.Number,
+  }).pipe(T.Http({ method: "GET", path: "/analytics/events" }));
+export type GetAnalyticsEventsInput = typeof GetAnalyticsEventsInput.Type;
+
+// Output Schema
+export const GetAnalyticsEventsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    events: Schema.Array(
+      Schema.Struct({
+        name: Schema.optional(Schema.String),
+        event_type: Schema.optional(Schema.String),
+        collection: Schema.optional(Schema.String),
+        timestamp: Schema.optional(Schema.Number),
+        user_id: Schema.optional(Schema.String),
+        doc_id: Schema.optional(Schema.String),
+        doc_ids: Schema.optional(Schema.Array(Schema.String)),
+        query: Schema.optional(Schema.String),
+      }),
+    ),
+  });
+export type GetAnalyticsEventsOutput = typeof GetAnalyticsEventsOutput.Type;
+
+// The operation
+/**
+ * Retrieve analytics events
+ *
+ * Retrieve the most recent events for a user and rule.
+ *
+ * @param name - Analytics rule name
+ * @param n - Number of events to return (max 1000)
+ */
+export const getAnalyticsEvents = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAnalyticsEventsInput,
+  outputSchema: GetAnalyticsEventsOutput,
+  errors: [BadRequest] as const,
+}));

package/src/operations/getAnalyticsStatus.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+
+// Input Schema
+export const GetAnalyticsStatusInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({ method: "GET", path: "/analytics/status" }),
+  );
+export type GetAnalyticsStatusInput = typeof GetAnalyticsStatusInput.Type;
+
+// Output Schema
+export const GetAnalyticsStatusOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    popular_prefix_queries: Schema.optional(Schema.Number),
+    nohits_prefix_queries: Schema.optional(Schema.Number),
+    log_prefix_queries: Schema.optional(Schema.Number),
+    query_log_events: Schema.optional(Schema.Number),
+    query_counter_events: Schema.optional(Schema.Number),
+    doc_log_events: Schema.optional(Schema.Number),
+    doc_counter_events: Schema.optional(Schema.Number),
+  });
+export type GetAnalyticsStatusOutput = typeof GetAnalyticsStatusOutput.Type;
+
+// The operation
+/**
+ * Get analytics subsystem status
+ *
+ * Returns sizes of internal analytics buffers and queues.
+ */
+export const getAnalyticsStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAnalyticsStatusInput,
+  outputSchema: GetAnalyticsStatusOutput,
+}));

package/src/operations/getCollection.ts

@@ -0,0 +1,84 @@
+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";
+
+// Input Schema
+export const GetCollectionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  collectionName: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/collections/{collectionName}" }));
+export type GetCollectionInput = typeof GetCollectionInput.Type;
+
+// Output Schema
+export const GetCollectionOutput = /*@__PURE__*/ /*#__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(SensitiveString),
+            url: 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),
+            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,
+});
+export type GetCollectionOutput = typeof GetCollectionOutput.Type;
+
+// The operation
+/**
+ * Retrieve a single collection
+ *
+ * Retrieve the details of a collection, given its name.
+ *
+ * @param collectionName - The name of the collection to retrieve
+ */
+export const getCollection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetCollectionInput,
+  outputSchema: GetCollectionOutput,
+  errors: [NotFound] as const,
+}));