@cipherstash/stack 0.2.0 → 0.4.0

package/dist/{types-public-Dfg-hkuQ.d.cts → types-public-Wj6tB_ux.d.cts}

@@ -16,10 +16,9 @@ type Brand<T, B extends string> = T & {
 };
 type Client = Awaited<ReturnType<typeof newClient>> | undefined;
 /** A branded type representing encrypted data. Cannot be accidentally used as plaintext. */
-type EncryptedValue = Brand<Encrypted$1, 'encrypted'> | null;
+type EncryptedValue = Brand<Encrypted$1, 'encrypted'>;
 /** Structural type representing encrypted data. See also `EncryptedValue` for branded nominal typing. */
-type Encrypted = Encrypted$1 | null;
-type EncryptPayload = JsPlaintext | null;
+type Encrypted = Encrypted$1;
 type KeysetIdentifier = {
     name: string;
 } | {
@@ -61,34 +60,40 @@ type ClientConfig = {
 };
 type AtLeastOneCsTable<T> = [T, ...T[]];
 type EncryptionClientConfig = {
-    schemas: AtLeastOneCsTable<ProtectTable<ProtectTableColumn>>;
+    schemas: AtLeastOneCsTable<EncryptedTable<EncryptedTableColumn>>;
     config?: ClientConfig;
     logging?: LoggingConfig;
 };
+/**
+ * Options for single-value encrypt operations.
+ * Use a column from your table schema (from {@link encryptedColumn}) or a nested
+ * field (from {@link encryptedField}) as the target for encryption.
+ */
 type EncryptOptions = {
-    column: ProtectColumn | ProtectValue;
-    table: ProtectTable<ProtectTableColumn>;
+    /** The column or nested field to encrypt into. From {@link EncryptedColumn} or {@link EncryptedField}. */
+    column: EncryptedColumn | EncryptedField;
+    table: EncryptedTable<EncryptedTableColumn>;
 };
 /** Format for encrypted query/search term return values */
 type EncryptedReturnType = 'eql' | 'composite-literal' | 'escaped-composite-literal';
 type SearchTerm = {
     value: JsPlaintext;
-    column: ProtectColumn;
-    table: ProtectTable<ProtectTableColumn>;
+    column: EncryptedColumn;
+    table: EncryptedTable<EncryptedTableColumn>;
     returnType?: EncryptedReturnType;
 };
 /** Encrypted search term result: EQL object or composite literal string */
 type EncryptedSearchTerm = Encrypted | string;
-/** Result of encryptQuery (single or batch): EQL, composite literal string, or null */
-type EncryptedQueryResult = Encrypted | string | null;
+/** Result of encryptQuery (single or batch): EQL or composite literal string */
+type EncryptedQueryResult = Encrypted | string;
 type EncryptedFields<T> = {
-    [K in keyof T as T[K] extends Encrypted ? K : never]: T[K];
+    [K in keyof T as NonNullable<T[K]> extends Encrypted ? K : never]: T[K];
 };
 type OtherFields<T> = {
-    [K in keyof T as T[K] extends Encrypted ? never : K]: T[K];
+    [K in keyof T as NonNullable<T[K]> extends Encrypted ? never : K]: T[K];
 };
 type DecryptedFields<T> = {
-    [K in keyof T as T[K] extends Encrypted ? K : never]: string;
+    [K in keyof T as NonNullable<T[K]> extends Encrypted ? K : never]: null extends T[K] ? string | null : string;
 };
 /** Model with encrypted fields replaced by plaintext (decrypted) values */
 type Decrypted<T> = OtherFields<T> & DecryptedFields<T>;
@@ -98,7 +103,7 @@ type Decrypted<T> = OtherFields<T> & DecryptedFields<T>;
  * Fields whose keys match columns defined in `S` become `Encrypted`;
  * all other fields retain their original types from `T`.
  *
- * When `S` is the widened `ProtectTableColumn` (e.g. when a user passes an
+ * When `S` is the widened `EncryptedTableColumn` (e.g. when a user passes an
  * explicit `<User>` type argument without specifying `S`), the type degrades
  * gracefully to `T` — preserving backward compatibility.
  *
@@ -109,16 +114,16 @@ type Decrypted<T> = OtherFields<T> & DecryptedFields<T>;
  * ```typescript
  * type User = { id: string; email: string }
  * // With a schema that defines `email`:
- * type Encrypted = EncryptedFromSchema<User, { email: ProtectColumn }>
+ * type Encrypted = EncryptedFromSchema<User, { email: EncryptedColumn }>
  * // => { id: string; email: Encrypted }
  * ```
  */
-type EncryptedFromSchema<T, S extends ProtectTableColumn> = {
-    [K in keyof T]: [K] extends [keyof S] ? [S[K & keyof S]] extends [ProtectColumn | ProtectValue] ? Encrypted : T[K] : T[K];
+type EncryptedFromSchema<T, S extends EncryptedTableColumn> = {
+    [K in keyof T]: [K] extends [keyof S] ? [S[K & keyof S]] extends [EncryptedColumn | EncryptedField] ? null extends T[K] ? Encrypted | null : Encrypted : T[K] : T[K];
 };
 type BulkEncryptPayload = Array<{
     id?: string;
-    plaintext: JsPlaintext | null;
+    plaintext: JsPlaintext;
 }>;
 type BulkEncryptedData = Array<{
     id?: string;
@@ -128,7 +133,7 @@ type BulkDecryptPayload = Array<{
     id?: string;
     data: Encrypted;
 }>;
-type BulkDecryptedData = Array<DecryptionResult<JsPlaintext | null>>;
+type BulkDecryptedData = Array<DecryptionResult<JsPlaintext>>;
 type DecryptionSuccess<T> = {
     error?: never;
     data: T;
@@ -166,14 +171,14 @@ declare const queryTypes: {
 };
 /** @internal */
 type QueryTermBase = {
-    column: ProtectColumn;
-    table: ProtectTable<ProtectTableColumn>;
+    column: EncryptedColumn;
+    table: EncryptedTable<EncryptedTableColumn>;
     queryType?: QueryTypeName;
     returnType?: EncryptedReturnType;
 };
 type EncryptQueryOptions = QueryTermBase;
 type ScalarQueryTerm = QueryTermBase & {
-    value: JsPlaintext | null;
+    value: JsPlaintext;
 };
 
 /**
@@ -186,6 +191,7 @@ type ScalarQueryTerm = QueryTermBase & {
  * - `"number"`
  * - `"string"`
  * - `"json"`
+ * - `"text"`
  *
  * @remarks
  * This is a Zod enum used at runtime to validate schema definitions.
@@ -193,7 +199,7 @@ type ScalarQueryTerm = QueryTermBase & {
  *
  * @internal
  */
-declare const castAsEnum: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json"]>>;
+declare const castAsEnum: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json", "text"]>>;
 declare const tokenFilterSchema: z.ZodObject<{
     kind: z.ZodLiteral<"downcase">;
 }, "strip", z.ZodTypeAny, {
@@ -281,7 +287,7 @@ declare const steVecIndexOptsSchema: z.ZodObject<{
     prefix: string;
 }>;
 declare const columnSchema: z.ZodDefault<z.ZodObject<{
-    cast_as: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json"]>>;
+    cast_as: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json", "text"]>>;
     indexes: z.ZodDefault<z.ZodObject<{
         ore: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
         unique: z.ZodOptional<z.ZodObject<{
@@ -412,7 +418,7 @@ declare const columnSchema: z.ZodDefault<z.ZodObject<{
         } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
+    cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json" | "text";
     indexes: {
         match?: {
             token_filters?: {
@@ -439,7 +445,7 @@ declare const columnSchema: z.ZodDefault<z.ZodObject<{
         } | undefined;
     };
 }, {
-    cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | undefined;
+    cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | "text" | undefined;
     indexes?: {
         match?: {
             token_filters?: {
@@ -470,7 +476,7 @@ declare const columnSchema: z.ZodDefault<z.ZodObject<{
 declare const encryptConfigSchema: z.ZodObject<{
     v: z.ZodNumber;
     tables: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodObject<{
-        cast_as: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json"]>>;
+        cast_as: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json", "text"]>>;
         indexes: z.ZodDefault<z.ZodObject<{
             ore: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
             unique: z.ZodOptional<z.ZodObject<{
@@ -601,7 +607,7 @@ declare const encryptConfigSchema: z.ZodObject<{
             } | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
-        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
+        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json" | "text";
         indexes: {
             match?: {
                 token_filters?: {
@@ -628,7 +634,7 @@ declare const encryptConfigSchema: z.ZodObject<{
             } | undefined;
         };
     }, {
-        cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | undefined;
+        cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | "text" | undefined;
         indexes?: {
             match?: {
                 token_filters?: {
@@ -658,7 +664,7 @@ declare const encryptConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     v: number;
     tables: Record<string, Record<string, {
-        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
+        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json" | "text";
         indexes: {
             match?: {
                 token_filters?: {
@@ -688,7 +694,7 @@ declare const encryptConfigSchema: z.ZodObject<{
 }, {
     v: number;
     tables?: Record<string, Record<string, {
-        cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | undefined;
+        cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | "text" | undefined;
         indexes?: {
             match?: {
                 token_filters?: {
@@ -729,45 +735,54 @@ type SteVecIndexOpts = z.infer<typeof steVecIndexOptsSchema>;
 type UniqueIndexOpts = z.infer<typeof uniqueIndexOptsSchema>;
 type OreIndexOpts = z.infer<typeof oreIndexOptsSchema>;
 type ColumnSchema = z.infer<typeof columnSchema>;
-type ProtectTableColumn = {
-    [key: string]: ProtectColumn | {
-        [key: string]: ProtectValue | {
-            [key: string]: ProtectValue | {
-                [key: string]: ProtectValue;
+/**
+ * Shape of table columns: either top-level {@link EncryptedColumn} or nested
+ * objects whose leaves are {@link EncryptedField}. Used with {@link encryptedTable}.
+ */
+type EncryptedTableColumn = {
+    [key: string]: EncryptedColumn | {
+        [key: string]: EncryptedField | {
+            [key: string]: EncryptedField | {
+                [key: string]: EncryptedField;
             };
         };
     };
 };
 type EncryptConfig = z.infer<typeof encryptConfigSchema>;
-declare class ProtectValue {
+/**
+ * Builder for a nested encrypted field (encrypted but not searchable).
+ * Create with {@link encryptedField}. Use inside nested objects in {@link encryptedTable};
+ * supports `.dataType()` for plaintext type. No index methods (equality, orderAndRange, etc.).
+ */
+declare class EncryptedField {
     private valueName;
     private castAsValue;
     constructor(valueName: string);
     /**
-     * Set or override the plaintext data type for this value.
+     * Set or override the plaintext data type for this field.
      *
      * By default all values are treated as `'string'`. Use this method to specify
      * a different type so the encryption layer knows how to encode the plaintext
      * before encrypting.
      *
-     * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'bigint'`, or `'json'`.
-     * @returns This `ProtectValue` instance for method chaining.
+     * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'text'`, `'bigint'`, or `'json'`.
+     * @returns This `EncryptedField` instance for method chaining.
      *
      * @example
      * ```typescript
-     * import { encryptedValue } from "@cipherstash/stack/schema"
+     * import { encryptedField } from "@cipherstash/stack/schema"
      *
-     * const age = encryptedValue("age").dataType("number")
+     * const age = encryptedField("age").dataType("number")
      * ```
      */
     dataType(castAs: CastAs): this;
     build(): {
-        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
+        cast_as: "number" | "bigint" | "boolean" | "date" | "json" | "text";
         indexes: {};
     };
     getName(): string;
 }
-declare class ProtectColumn {
+declare class EncryptedColumn {
     private columnName;
     private castAsValue;
     private indexesValue;
@@ -780,7 +795,7 @@ declare class ProtectColumn {
      * before encrypting.
      *
      * @param castAs - The plaintext data type: `'string'`, `'number'`, `'boolean'`, `'date'`, `'bigint'`, or `'json'`.
-     * @returns This `ProtectColumn` instance for method chaining.
+     * @returns This `EncryptedColumn` instance for method chaining.
      *
      * @example
      * ```typescript
@@ -796,7 +811,7 @@ declare class ProtectColumn {
      * ORE allows sorting, comparison, and range queries on encrypted data.
      * Use with `encryptQuery` and `queryType: 'orderAndRange'`.
      *
-     * @returns This `ProtectColumn` instance for method chaining.
+     * @returns This `EncryptedColumn` instance for method chaining.
      *
      * @example
      * ```typescript
@@ -816,7 +831,7 @@ declare class ProtectColumn {
      *
      * @param tokenFilters - Optional array of token filters (e.g. `[{ kind: 'downcase' }]`).
      *   When omitted, no token filters are applied.
-     * @returns This `ProtectColumn` instance for method chaining.
+     * @returns This `EncryptedColumn` instance for method chaining.
      *
      * @example
      * ```typescript
@@ -836,7 +851,7 @@ declare class ProtectColumn {
      *
      * @param opts - Optional match index configuration. Defaults to 3-character ngram
      *   tokenization with a downcase filter, `k=6`, `m=2048`, and `include_original=true`.
-     * @returns This `ProtectColumn` instance for method chaining.
+     * @returns This `EncryptedColumn` instance for method chaining.
      *
      * @example
      * ```typescript
@@ -868,7 +883,7 @@ declare class ProtectColumn {
      * the plaintext type: strings become selector queries, objects/arrays become
      * containment queries.
      *
-     * @returns This `ProtectColumn` instance for method chaining.
+     * @returns This `EncryptedColumn` instance for method chaining.
      *
      * @example
      * ```typescript
@@ -881,7 +896,7 @@ declare class ProtectColumn {
      */
     searchableJson(): this;
     build(): {
-        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
+        cast_as: "number" | "bigint" | "boolean" | "date" | "json" | "text";
         indexes: {
             ore?: OreIndexOpts;
             unique?: UniqueIndexOpts;
@@ -895,9 +910,11 @@ interface TableDefinition {
     tableName: string;
     columns: Record<string, ColumnSchema>;
 }
-declare class ProtectTable<T extends ProtectTableColumn> {
+declare class EncryptedTable<T extends EncryptedTableColumn> {
     readonly tableName: string;
     private readonly columnBuilders;
+    /** @internal Type-level brand so TypeScript can infer `T` from `EncryptedTable<T>`. */
+    readonly _columnType: T;
     constructor(tableName: string, columnBuilders: T);
     /**
      * Compile this table schema into a `TableDefinition` used internally by the encryption client.
@@ -921,7 +938,7 @@ declare class ProtectTable<T extends ProtectTableColumn> {
     build(): TableDefinition;
 }
 /**
- * Infer the plaintext (decrypted) type from a ProtectTable schema.
+ * Infer the plaintext (decrypted) type from a EncryptedTable schema.
  *
  * @example
  * ```typescript
@@ -934,11 +951,11 @@ declare class ProtectTable<T extends ProtectTableColumn> {
  * // => { email: string; name: string }
  * ```
  */
-type InferPlaintext<T extends ProtectTable<any>> = T extends ProtectTable<infer C> ? {
-    [K in keyof C as C[K] extends ProtectColumn | ProtectValue ? K : never]: string;
+type InferPlaintext<T extends EncryptedTable<any>> = T extends EncryptedTable<infer C> ? {
+    [K in keyof C as C[K] extends EncryptedColumn | EncryptedField ? K : never]: string;
 } : never;
 /**
- * Infer the encrypted type from a ProtectTable schema.
+ * Infer the encrypted type from a EncryptedTable schema.
  *
  * @example
  * ```typescript
@@ -950,13 +967,13 @@ type InferPlaintext<T extends ProtectTable<any>> = T extends ProtectTable<infer
  * // => { email: Encrypted }
  * ```
  */
-type InferEncrypted<T extends ProtectTable<any>> = T extends ProtectTable<infer C> ? {
-    [K in keyof C as C[K] extends ProtectColumn | ProtectValue ? K : never]: Encrypted;
+type InferEncrypted<T extends EncryptedTable<any>> = T extends EncryptedTable<infer C> ? {
+    [K in keyof C as C[K] extends EncryptedColumn | EncryptedField ? K : never]: Encrypted;
 } : never;
 /**
  * Define an encrypted table schema.
  *
- * Creates a `ProtectTable` that maps a database table name to a set of encrypted
+ * Creates a `EncryptedTable` that maps a database table name to a set of encrypted
  * column definitions. Pass the resulting object to `Encryption({ schemas: [...] })`
  * when initializing the client.
  *
@@ -966,8 +983,9 @@ type InferEncrypted<T extends ProtectTable<any>> = T extends ProtectTable<infer
  *
  * @param tableName - The name of the database table this schema represents.
  * @param columns - An object whose keys are logical column names and values are
- *   `ProtectColumn` instances created with {@link encryptedColumn}.
- * @returns A `ProtectTable<T> & T` that can be used as both a schema definition
+ *   {@link EncryptedColumn} from {@link encryptedColumn}, or nested objects whose
+ *   leaves are {@link EncryptedField} from {@link encryptedField}.
+ * @returns A `EncryptedTable<T> & T` that can be used as both a schema definition
  *   and a column accessor.
  *
  * @example
@@ -986,17 +1004,17 @@ type InferEncrypted<T extends ProtectTable<any>> = T extends ProtectTable<infer
  * await client.encrypt("hello@example.com", { column: users.email, table: users })
  * ```
  */
-declare function encryptedTable<T extends ProtectTableColumn>(tableName: string, columns: T): ProtectTable<T> & T;
+declare function encryptedTable<T extends EncryptedTableColumn>(tableName: string, columns: T): EncryptedTable<T> & T;
 /**
  * Define an encrypted column within a table schema.
  *
- * Creates a `ProtectColumn` builder for the given column name. Chain index
+ * Creates a `EncryptedColumn` builder for the given column name. Chain index
  * methods (`.equality()`, `.freeTextSearch()`, `.orderAndRange()`,
  * `.searchableJson()`) and/or `.dataType()` to configure searchable encryption
  * and the plaintext data type.
  *
  * @param columnName - The name of the database column to encrypt.
- * @returns A new `ProtectColumn` builder.
+ * @returns A new `EncryptedColumn` builder.
  *
  * @example
  * ```typescript
@@ -1007,31 +1025,52 @@ declare function encryptedTable<T extends ProtectTableColumn>(tableName: string,
  * })
  * ```
  */
-declare function encryptedColumn(columnName: string): ProtectColumn;
+declare function encryptedColumn(columnName: string): EncryptedColumn;
 /**
- * Define an encrypted value for use in nested or structured schemas.
+ * Define an encrypted field for use in nested or structured schemas.
  *
- * `encryptedValue` is similar to {@link encryptedColumn} but creates a `ProtectValue`
- * intended for nested fields within a table schema. It supports `.dataType()`
- * for specifying the plaintext type.
+ * `encryptedField` is similar to {@link encryptedColumn} but creates an {@link EncryptedField}
+ * for nested fields that are encrypted but not searchable (no indexes). Use `.dataType()`
+ * to specify the plaintext type.
  *
  * @param valueName - The name of the value field.
- * @returns A new `ProtectValue` builder.
+ * @returns A new `EncryptedField` builder.
  *
  * @example
  * ```typescript
- * import { encryptedTable, encryptedValue } from "@cipherstash/stack/schema"
+ * import { encryptedTable, encryptedField } from "@cipherstash/stack/schema"
  *
  * const orders = encryptedTable("orders", {
  *   details: {
- *     amount: encryptedValue("amount").dataType("number"),
- *     currency: encryptedValue("currency"),
+ *     amount: encryptedField("amount").dataType("number"),
+ *     currency: encryptedField("currency"),
  *   },
  * })
  * ```
  */
-declare function encryptedValue(valueName: string): ProtectValue;
-/** @internal */
-declare function buildEncryptConfig(...protectTables: Array<ProtectTable<ProtectTableColumn>>): EncryptConfig;
+declare function encryptedField(valueName: string): EncryptedField;
+/**
+ * Build an encrypt config from a list of encrypted tables.
+ *
+ * @param ...tables - The list of encrypted tables to build the config from.
+ * @returns An encrypt config object.
+ *
+ * @example
+ * ```typescript
+ * import { buildEncryptConfig } from "@cipherstash/stack/schema"
+ *
+ * const users = encryptedTable("users", {
+ *   email: encryptedColumn("email").equality(),
+ * })
+ *
+ * const orders = encryptedTable("orders", {
+ *   amount: encryptedColumn("amount").dataType("number"),
+ * })
+ *
+ * const config = buildEncryptConfig(users, orders)
+ * console.log(config)
+ * ```
+ */
+declare function buildEncryptConfig(...protectTables: Array<EncryptedTable<EncryptedTableColumn>>): EncryptConfig;
 
-export { type SearchTerm as A, type BulkDecryptedData as B, type CastAs as C, type Decrypted as D, type EncryptionClientConfig as E, type EncryptedSearchTerm as F, type EncryptedFields as G, type OtherFields as H, type InferPlaintext as I, type DecryptedFields as J, type KeysetIdentifier as K, type DecryptionResult as L, type MatchIndexOpts as M, type LoggingConfig as N, type OreIndexOpts as O, ProtectColumn as P, type QueryTypeName as Q, queryTypes as R, type ScalarQueryTerm as S, type TokenFilter as T, type UniqueIndexOpts as U, encryptedColumn as a, encryptedValue as b, type InferEncrypted as c, ProtectTable as d, encryptedTable as e, type ProtectTableColumn as f, ProtectValue as g, type EncryptedFromSchema as h, type Encrypted as i, type EncryptedValue as j, type EncryptedQueryResult as k, type Client as l, type BulkDecryptPayload as m, type BulkEncryptedData as n, type BulkEncryptPayload as o, type EncryptOptions as p, type EncryptQueryOptions as q, type EncryptedReturnType as r, type EncryptConfig as s, castAsEnum as t, encryptConfigSchema as u, type SteVecIndexOpts as v, type ColumnSchema as w, buildEncryptConfig as x, type EncryptPayload as y, type ClientConfig as z };
+export { type SearchTerm as A, type BulkDecryptedData as B, type CastAs as C, type Decrypted as D, type EncryptionClientConfig as E, type EncryptedSearchTerm as F, type EncryptedFields as G, type OtherFields as H, type InferPlaintext as I, type DecryptedFields as J, type KeysetIdentifier as K, type DecryptionResult as L, type MatchIndexOpts as M, type LoggingConfig as N, type OreIndexOpts as O, queryTypes as P, type QueryTypeName as Q, type ScalarQueryTerm as S, type TokenFilter as T, type UniqueIndexOpts as U, encryptedColumn as a, encryptedField as b, type InferEncrypted as c, EncryptedColumn as d, encryptedTable as e, EncryptedTable as f, type EncryptedTableColumn as g, EncryptedField as h, type EncryptedFromSchema as i, type Encrypted as j, type EncryptedValue as k, type EncryptedQueryResult as l, type Client as m, type BulkDecryptPayload as n, type BulkEncryptedData as o, type BulkEncryptPayload as p, type EncryptOptions as q, type EncryptQueryOptions as r, type EncryptedReturnType as s, type EncryptConfig as t, castAsEnum as u, encryptConfigSchema as v, type SteVecIndexOpts as w, type ColumnSchema as x, buildEncryptConfig as y, type ClientConfig as z };