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

package/src/operations/deleteNLSearchModel.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 DeleteNLSearchModelInput {
-  modelId: string;
-}
-export const DeleteNLSearchModelInput =
-  /*@__PURE__*/ Schema.Struct({
-    modelId: Schema.String.pipe(T.PathParam()),
-  }).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__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<DeleteNLSearchModelOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: DeleteNLSearchModelInput,
-  outputSchema: DeleteNLSearchModelOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deletePreset.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 DeletePresetInput {
-  presetId: string;
-}
-export const DeletePresetInput = /*@__PURE__*/ Schema.Struct({
-  presetId: Schema.String.pipe(T.PathParam()),
-}).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__*/ Schema.Struct({
-  name: Schema.String,
-}) as unknown as Schema.Codec<DeletePresetOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: DeletePresetInput,
-  outputSchema: DeletePresetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteStopwordsSet.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 DeleteStopwordsSetInput {
-  setId: string;
-}
-export const DeleteStopwordsSetInput =
-  /*@__PURE__*/ Schema.Struct({
-    setId: Schema.String.pipe(T.PathParam()),
-  }).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__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<DeleteStopwordsSetOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: DeleteStopwordsSetInput,
-  outputSchema: DeleteStopwordsSetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteSynonymSet.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 DeleteSynonymSetInput {
-  synonymSetName: string;
-}
-export const DeleteSynonymSetInput = /*@__PURE__*/ Schema.Struct({
-  synonymSetName: Schema.String.pipe(T.PathParam()),
-}).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__*/ Schema.Struct({
-  name: Schema.String,
-}) as unknown as Schema.Codec<DeleteSynonymSetOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: DeleteSynonymSetInput,
-  outputSchema: DeleteSynonymSetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/deleteSynonymSetItem.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 DeleteSynonymSetItemInput {
-  synonymSetName: string;
-  itemId: string;
-}
-export const DeleteSynonymSetItemInput =
-  /*@__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}",
-    }),
-  ) as unknown as Schema.Codec<DeleteSynonymSetItemInput>;
-
-// Output Schema
-export interface DeleteSynonymSetItemOutput {
-  id: string;
-}
-export const DeleteSynonymSetItemOutput =
-  /*@__PURE__*/ Schema.Struct({
-    id: Schema.String,
-  }) as unknown as Schema.Codec<DeleteSynonymSetItemOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: DeleteSynonymSetItemInput,
-  outputSchema: DeleteSynonymSetItemOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/exportDocuments.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 ExportDocumentsInput {
-  collectionName: string;
-  exportDocumentsParameters?: string;
-}
-export const ExportDocumentsInput = /*@__PURE__*/ Schema.Struct({
-  collectionName: Schema.String.pipe(T.PathParam()),
-  exportDocumentsParameters: Schema.optional(Schema.String),
-}).pipe(
-  T.Http({
-    method: "GET",
-    path: "/collections/{collectionName}/documents/export",
-  }),
-) as unknown as Schema.Codec<ExportDocumentsInput>;
-
-// Output Schema
-export type ExportDocumentsOutput = void;
-export const ExportDocumentsOutput =
-  /*@__PURE__*/ Schema.Void as unknown as Schema.Codec<ExportDocumentsOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: ExportDocumentsInput,
-  outputSchema: ExportDocumentsOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/flushAnalytics.ts

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

package/src/operations/getAlias.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 GetAliasInput {
-  aliasName: string;
-}
-export const GetAliasInput = /*@__PURE__*/ Schema.Struct({
-  aliasName: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/aliases/{aliasName}" }),
-) as unknown as Schema.Codec<GetAliasInput>;
-
-// Output Schema
-export interface GetAliasOutput {
-  name: string;
-  collection_name: string;
-}
-export const GetAliasOutput = /*@__PURE__*/ Schema.Struct({
-  name: Schema.String,
-  collection_name: Schema.String,
-}) as unknown as Schema.Codec<GetAliasOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: GetAliasInput,
-  outputSchema: GetAliasOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/getAliases.ts

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

package/src/operations/getAnalyticsEvents.ts

@@ -1,63 +0,0 @@
-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 interface GetAnalyticsEventsInput {
-  user_id: string;
-  name: string;
-  n: number;
-}
-export const GetAnalyticsEventsInput =
-  /*@__PURE__*/ Schema.Struct({
-    user_id: Schema.String,
-    name: Schema.String,
-    n: Schema.Number,
-  }).pipe(
-    T.Http({ method: "GET", path: "/analytics/events" }),
-  ) as unknown as Schema.Codec<GetAnalyticsEventsInput>;
-
-// Output Schema
-export interface GetAnalyticsEventsOutput {
-  events: {
-    name?: string;
-    event_type?: string;
-    collection?: string;
-    timestamp?: number;
-    user_id?: string;
-    doc_id?: string;
-    doc_ids?: string[];
-    query?: string;
-  }[];
-}
-export const GetAnalyticsEventsOutput =
-  /*@__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),
-      }),
-    ),
-  }) as unknown as Schema.Codec<GetAnalyticsEventsOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: GetAnalyticsEventsInput,
-  outputSchema: GetAnalyticsEventsOutput,
-  errors: [BadRequest] as const,
-}));

package/src/operations/getAnalyticsStatus.ts

@@ -1,42 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../client.ts";
-import * as T from "../traits.ts";
-
-// Input Schema
-export interface GetAnalyticsStatusInput {}
-export const GetAnalyticsStatusInput =
-  /*@__PURE__*/ Schema.Struct({}).pipe(
-    T.Http({ method: "GET", path: "/analytics/status" }),
-  ) as unknown as Schema.Codec<GetAnalyticsStatusInput>;
-
-// Output Schema
-export interface GetAnalyticsStatusOutput {
-  popular_prefix_queries?: number;
-  nohits_prefix_queries?: number;
-  log_prefix_queries?: number;
-  query_log_events?: number;
-  query_counter_events?: number;
-  doc_log_events?: number;
-  doc_counter_events?: number;
-}
-export const GetAnalyticsStatusOutput =
-  /*@__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),
-  }) as unknown as Schema.Codec<GetAnalyticsStatusOutput>;
-
-// The operation
-/**
- * Get analytics subsystem status
- *
- * Returns sizes of internal analytics buffers and queues.
- */
-export const getAnalyticsStatus = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetAnalyticsStatusInput,
-  outputSchema: GetAnalyticsStatusOutput,
-}));

package/src/operations/getCollection.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 GetCollectionInput {
-  collectionName: string;
-}
-export const GetCollectionInput = /*@__PURE__*/ Schema.Struct({
-  collectionName: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/collections/{collectionName}" }),
-) as unknown as Schema.Codec<GetCollectionInput>;
-
-// Output Schema
-export interface GetCollectionOutput {
-  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 GetCollectionOutput = /*@__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<GetCollectionOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: GetCollectionInput,
-  outputSchema: GetCollectionOutput,
-  errors: [NotFound] as const,
-}));