@distilled.cloud/typesense 0.27.0 → 0.28.1

package/src/operations/retrieveSynonymSets.ts

@@ -3,13 +3,23 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface RetrieveSynonymSetsInput {}
 export const RetrieveSynonymSetsInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
     T.Http({ method: "GET", path: "/synonym_sets" }),
-  );
-export type RetrieveSynonymSetsInput = typeof RetrieveSynonymSetsInput.Type;
+  ) as unknown as Schema.Codec<RetrieveSynonymSetsInput>;
 
 // Output Schema
+export type RetrieveSynonymSetsOutput = {
+  items: {
+    id: string;
+    synonyms: string[];
+    root?: string;
+    locale?: string;
+    symbols_to_index?: string[];
+  }[];
+  name: string;
+}[];
 export const RetrieveSynonymSetsOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -24,8 +34,7 @@ export const RetrieveSynonymSetsOutput =
       ),
       name: Schema.String,
     }),
-  );
-export type RetrieveSynonymSetsOutput = typeof RetrieveSynonymSetsOutput.Type;
+  ) as unknown as Schema.Codec<RetrieveSynonymSetsOutput>;
 
 // The operation
 /**

package/src/operations/searchCollection.ts

@@ -4,6 +4,10 @@ import * as T from "../traits.ts";
 import { BadRequest, NotFound } from "../errors.ts";
 
 // Input Schema
+export interface SearchCollectionInput {
+  collectionName: string;
+  searchParameters: string;
+}
 export const SearchCollectionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   collectionName: Schema.String.pipe(T.PathParam()),
   searchParameters: Schema.String,
@@ -12,10 +16,113 @@ export const SearchCollectionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     method: "GET",
     path: "/collections/{collectionName}/documents/search",
   }),
-);
-export type SearchCollectionInput = typeof SearchCollectionInput.Type;
+) as unknown as Schema.Codec<SearchCollectionInput>;
 
 // Output Schema
+export interface SearchCollectionOutput {
+  facet_counts?: {
+    counts?: {
+      count?: number;
+      highlighted?: string;
+      value?: string;
+      parent?: unknown;
+    }[];
+    field_name?: string;
+    sampled?: boolean;
+    stats?: {
+      max?: number;
+      min?: number;
+      sum?: number;
+      total_values?: number;
+      avg?: number;
+    };
+  }[];
+  found?: number;
+  found_docs?: number;
+  search_time_ms?: number;
+  out_of?: number;
+  search_cutoff?: boolean;
+  page?: number;
+  grouped_hits?: {
+    found?: number;
+    group_key: unknown[];
+    hits: {
+      highlights?: {
+        field?: string;
+        snippet?: string;
+        snippets?: string[];
+        value?: string;
+        values?: string[];
+        indices?: number[];
+        matched_tokens?: unknown[];
+      }[];
+      highlight?: Record<string, unknown>;
+      document?: Record<string, unknown>;
+      text_match?: number;
+      text_match_info?: {
+        best_field_score?: string;
+        best_field_weight?: number;
+        fields_matched?: number;
+        num_tokens_dropped?: number;
+        score?: string;
+        tokens_matched?: number;
+        typo_prefix_score?: number;
+      };
+      geo_distance_meters?: Record<string, number>;
+      vector_distance?: number;
+      hybrid_search_info?: { rank_fusion_score?: number };
+      search_index?: number;
+    }[];
+  }[];
+  hits?: {
+    highlights?: {
+      field?: string;
+      snippet?: string;
+      snippets?: string[];
+      value?: string;
+      values?: string[];
+      indices?: number[];
+      matched_tokens?: unknown[];
+    }[];
+    highlight?: Record<string, unknown>;
+    document?: Record<string, unknown>;
+    text_match?: number;
+    text_match_info?: {
+      best_field_score?: string;
+      best_field_weight?: number;
+      fields_matched?: number;
+      num_tokens_dropped?: number;
+      score?: string;
+      tokens_matched?: number;
+      typo_prefix_score?: number;
+    };
+    geo_distance_meters?: Record<string, number>;
+    vector_distance?: number;
+    hybrid_search_info?: { rank_fusion_score?: number };
+    search_index?: number;
+  }[];
+  request_params?: {
+    collection_name: string;
+    first_q?: string;
+    q: string;
+    per_page: number;
+    voice_query?: { transcribed_query?: string };
+  };
+  conversation?: {
+    answer: string;
+    conversation_history: unknown[];
+    conversation_id: string;
+    query: string;
+  };
+  union_request_params?: {
+    collection_name: string;
+    first_q?: string;
+    q: string;
+    per_page: number;
+    voice_query?: { transcribed_query?: string };
+  }[];
+  metadata?: Record<string, unknown>;
+}
 export const SearchCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     facet_counts: Schema.optional(
@@ -191,8 +298,7 @@ export const SearchCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     ),
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   },
-);
-export type SearchCollectionOutput = typeof SearchCollectionOutput.Type;
+) as unknown as Schema.Codec<SearchCollectionOutput>;
 
 // The operation
 /**

package/src/operations/takeSnapshot.ts

@@ -3,16 +3,22 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface TakeSnapshotInput {
+  snapshot_path: string;
+}
 export const TakeSnapshotInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   snapshot_path: Schema.String,
-}).pipe(T.Http({ method: "POST", path: "/operations/snapshot" }));
-export type TakeSnapshotInput = typeof TakeSnapshotInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/operations/snapshot" }),
+) as unknown as Schema.Codec<TakeSnapshotInput>;
 
 // Output Schema
+export interface TakeSnapshotOutput {
+  success: boolean;
+}
 export const TakeSnapshotOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   success: Schema.Boolean,
-});
-export type TakeSnapshotOutput = typeof TakeSnapshotOutput.Type;
+}) as unknown as Schema.Codec<TakeSnapshotOutput>;
 
 // The operation
 /**

package/src/operations/toggleSlowRequestLog.ts

@@ -3,18 +3,24 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 
 // Input Schema
+export interface ToggleSlowRequestLogInput {
+  "log-slow-requests-time-ms": number;
+}
 export const ToggleSlowRequestLogInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     "log-slow-requests-time-ms": Schema.Number,
-  }).pipe(T.Http({ method: "POST", path: "/config" }));
-export type ToggleSlowRequestLogInput = typeof ToggleSlowRequestLogInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/config" }),
+  ) as unknown as Schema.Codec<ToggleSlowRequestLogInput>;
 
 // Output Schema
+export interface ToggleSlowRequestLogOutput {
+  success: boolean;
+}
 export const ToggleSlowRequestLogOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     success: Schema.Boolean,
-  });
-export type ToggleSlowRequestLogOutput = typeof ToggleSlowRequestLogOutput.Type;
+  }) as unknown as Schema.Codec<ToggleSlowRequestLogOutput>;
 
 // The operation
 /**

package/src/operations/updateCollection.ts

@@ -2,60 +2,55 @@ import * as Schema from "effect/Schema";
 import { API } from "../client.ts";
 import * as T from "../traits.ts";
 import { BadRequest, NotFound } from "../errors.ts";
-import { SensitiveString } from "../sensitive.ts";
+import { SensitiveString, SensitiveOutputString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface UpdateCollectionInput {
+  collectionName: 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?: string | Redacted.Redacted<string>;
+        url?: string;
+        access_token?: string | Redacted.Redacted<string>;
+        refresh_token?: string | Redacted.Redacted<string>;
+        client_id?: string;
+        client_secret?: string | Redacted.Redacted<string>;
+        project_id?: string;
+        indexing_prefix?: string;
+        query_prefix?: string;
+      };
+    };
+  }[];
+  synonym_sets?: string[];
+  metadata?: unknown;
+}
 export const UpdateCollectionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   collectionName: Schema.String.pipe(T.PathParam()),
-  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),
-          }),
-        }),
-      ),
-    }),
-  ),
-  synonym_sets: Schema.optional(Schema.Array(Schema.String)),
-  metadata: Schema.optional(Schema.Unknown),
-}).pipe(T.Http({ method: "PATCH", path: "/collections/{collectionName}" }));
-export type UpdateCollectionInput = typeof UpdateCollectionInput.Type;
-
-// Output Schema
-export const UpdateCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
-  {
-    fields: Schema.Array(
+  fields: Schema.optional(
+    Schema.Array(
       Schema.Struct({
         name: Schema.String,
         type: Schema.String,
@@ -95,11 +90,102 @@ export const UpdateCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
         ),
       }),
     ),
+  ),
+  synonym_sets: Schema.optional(Schema.Array(Schema.String)),
+  metadata: Schema.optional(Schema.Unknown),
+}).pipe(
+  T.Http({ method: "PATCH", path: "/collections/{collectionName}" }),
+) as unknown as Schema.Codec<UpdateCollectionInput>;
+
+// Output Schema
+export interface UpdateCollectionOutput {
+  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;
+      };
+    };
+  }[];
+  synonym_sets?: string[];
+  metadata?: unknown;
+}
+export const UpdateCollectionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    fields: Schema.optional(
+      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),
+              }),
+            }),
+          ),
+        }),
+      ),
+    ),
     synonym_sets: Schema.optional(Schema.Array(Schema.String)),
     metadata: Schema.optional(Schema.Unknown),
   },
-);
-export type UpdateCollectionOutput = typeof UpdateCollectionOutput.Type;
+) as unknown as Schema.Codec<UpdateCollectionOutput>;
 
 // The operation
 /**

package/src/operations/updateConversationModel.ts

@@ -3,8 +3,21 @@ import { API } from "../client.ts";
 import * as T from "../traits.ts";
 import { BadRequest, NotFound } from "../errors.ts";
 import { SensitiveString } from "../sensitive.ts";
+import * as Redacted from "effect/Redacted";
 
 // Input Schema
+export interface UpdateConversationModelInput {
+  modelId: string;
+  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 UpdateConversationModelInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     modelId: Schema.String.pipe(T.PathParam()),
@@ -17,17 +30,18 @@ export const UpdateConversationModelInput =
     ttl: Schema.optional(Schema.Number),
     max_bytes: Schema.optional(Schema.Number),
     vllm_url: Schema.optional(Schema.String),
-  }).pipe(T.Http({ method: "PUT", path: "/conversations/models/{modelId}" }));
-export type UpdateConversationModelInput =
-  typeof UpdateConversationModelInput.Type;
+  }).pipe(
+    T.Http({ method: "PUT", path: "/conversations/models/{modelId}" }),
+  ) as unknown as Schema.Codec<UpdateConversationModelInput>;
 
 // Output Schema
+export interface UpdateConversationModelOutput {
+  id: string;
+}
 export const UpdateConversationModelOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String,
-  });
-export type UpdateConversationModelOutput =
-  typeof UpdateConversationModelOutput.Type;
+  }) as unknown as Schema.Codec<UpdateConversationModelOutput>;
 
 // The operation
 /**

package/src/operations/updateDocument.ts

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

package/src/operations/updateDocuments.ts

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

package/src/operations/updateNLSearchModel.ts

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

package/src/operations/upsertAlias.ts

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

package/src/operations/upsertAnalyticsRule.ts

@@ -4,6 +4,20 @@ import * as T from "../traits.ts";
 import { BadRequest } from "../errors.ts";
 
 // Input Schema
+export interface UpsertAnalyticsRuleInput {
+  ruleName: string;
+  name?: 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 UpsertAnalyticsRuleInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     ruleName: Schema.String.pipe(T.PathParam()),
@@ -20,10 +34,27 @@ export const UpsertAnalyticsRuleInput =
         weight: Schema.optional(Schema.Number),
       }),
     ),
-  }).pipe(T.Http({ method: "PUT", path: "/analytics/rules/{ruleName}" }));
-export type UpsertAnalyticsRuleInput = typeof UpsertAnalyticsRuleInput.Type;
+  }).pipe(
+    T.Http({ method: "PUT", path: "/analytics/rules/{ruleName}" }),
+  ) as unknown as Schema.Codec<UpsertAnalyticsRuleInput>;
 
 // Output Schema
+export interface UpsertAnalyticsRuleOutput {
+  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 UpsertAnalyticsRuleOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     name: Schema.String,
@@ -47,8 +78,7 @@ export const UpsertAnalyticsRuleOutput =
         weight: Schema.optional(Schema.Number),
       }),
     ),
-  });
-export type UpsertAnalyticsRuleOutput = typeof UpsertAnalyticsRuleOutput.Type;
+  }) as unknown as Schema.Codec<UpsertAnalyticsRuleOutput>;
 
 // The operation
 /**