import { z } from 'zod';

/**
 * Allowed cast types for CipherStash schema fields.
 *
 * **Possible values:**
 * - `"bigint"`
 * - `"boolean"`
 * - `"date"`
 * - `"number"`
 * - `"string"`
 * - `"json"`
 *
 * @remarks
 * This is a Zod enum used at runtime to validate schema definitions.
 * Use {@link CastAs} when typing your own code.
 */
declare const castAsEnum: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json"]>>;
declare const tokenFilterSchema: z.ZodObject<{
    kind: z.ZodLiteral<"downcase">;
}, "strip", z.ZodTypeAny, {
    kind: "downcase";
}, {
    kind: "downcase";
}>;
declare const oreIndexOptsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
declare const uniqueIndexOptsSchema: z.ZodObject<{
    token_filters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
        kind: z.ZodLiteral<"downcase">;
    }, "strip", z.ZodTypeAny, {
        kind: "downcase";
    }, {
        kind: "downcase";
    }>, "many">>>;
}, "strip", z.ZodTypeAny, {
    token_filters?: {
        kind: "downcase";
    }[] | undefined;
}, {
    token_filters?: {
        kind: "downcase";
    }[] | undefined;
}>;
declare const matchIndexOptsSchema: z.ZodObject<{
    tokenizer: z.ZodOptional<z.ZodDefault<z.ZodUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"standard">;
    }, "strip", z.ZodTypeAny, {
        kind: "standard";
    }, {
        kind: "standard";
    }>, z.ZodObject<{
        kind: z.ZodLiteral<"ngram">;
        token_length: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        kind: "ngram";
        token_length: number;
    }, {
        kind: "ngram";
        token_length: number;
    }>]>>>;
    token_filters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
        kind: z.ZodLiteral<"downcase">;
    }, "strip", z.ZodTypeAny, {
        kind: "downcase";
    }, {
        kind: "downcase";
    }>, "many">>>;
    k: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    m: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    include_original: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
}, "strip", z.ZodTypeAny, {
    token_filters?: {
        kind: "downcase";
    }[] | undefined;
    tokenizer?: {
        kind: "standard";
    } | {
        kind: "ngram";
        token_length: number;
    } | undefined;
    k?: number | undefined;
    m?: number | undefined;
    include_original?: boolean | undefined;
}, {
    token_filters?: {
        kind: "downcase";
    }[] | undefined;
    tokenizer?: {
        kind: "standard";
    } | {
        kind: "ngram";
        token_length: number;
    } | undefined;
    k?: number | undefined;
    m?: number | undefined;
    include_original?: boolean | undefined;
}>;
declare const steVecIndexOptsSchema: z.ZodObject<{
    prefix: z.ZodString;
    array_index_mode: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"all">, z.ZodLiteral<"none">, z.ZodObject<{
        item: z.ZodOptional<z.ZodBoolean>;
        wildcard: z.ZodOptional<z.ZodBoolean>;
        position: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        item?: boolean | undefined;
        wildcard?: boolean | undefined;
        position?: boolean | undefined;
    }, {
        item?: boolean | undefined;
        wildcard?: boolean | undefined;
        position?: boolean | undefined;
    }>]>>;
}, "strip", z.ZodTypeAny, {
    prefix: string;
    array_index_mode?: "all" | "none" | {
        item?: boolean | undefined;
        wildcard?: boolean | undefined;
        position?: boolean | undefined;
    } | undefined;
}, {
    prefix: string;
    array_index_mode?: "all" | "none" | {
        item?: boolean | undefined;
        wildcard?: boolean | undefined;
        position?: boolean | undefined;
    } | undefined;
}>;
declare const columnSchema: z.ZodDefault<z.ZodObject<{
    cast_as: z.ZodDefault<z.ZodEnum<["bigint", "boolean", "date", "number", "string", "json"]>>;
    indexes: z.ZodDefault<z.ZodObject<{
        ore: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
        unique: z.ZodOptional<z.ZodObject<{
            token_filters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
                kind: z.ZodLiteral<"downcase">;
            }, "strip", z.ZodTypeAny, {
                kind: "downcase";
            }, {
                kind: "downcase";
            }>, "many">>>;
        }, "strip", z.ZodTypeAny, {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
        }, {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
        }>>;
        match: z.ZodOptional<z.ZodObject<{
            tokenizer: z.ZodOptional<z.ZodDefault<z.ZodUnion<[z.ZodObject<{
                kind: z.ZodLiteral<"standard">;
            }, "strip", z.ZodTypeAny, {
                kind: "standard";
            }, {
                kind: "standard";
            }>, z.ZodObject<{
                kind: z.ZodLiteral<"ngram">;
                token_length: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                kind: "ngram";
                token_length: number;
            }, {
                kind: "ngram";
                token_length: number;
            }>]>>>;
            token_filters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
                kind: z.ZodLiteral<"downcase">;
            }, "strip", z.ZodTypeAny, {
                kind: "downcase";
            }, {
                kind: "downcase";
            }>, "many">>>;
            k: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            m: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            include_original: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        }, "strip", z.ZodTypeAny, {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
            tokenizer?: {
                kind: "standard";
            } | {
                kind: "ngram";
                token_length: number;
            } | undefined;
            k?: number | undefined;
            m?: number | undefined;
            include_original?: boolean | undefined;
        }, {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
            tokenizer?: {
                kind: "standard";
            } | {
                kind: "ngram";
                token_length: number;
            } | undefined;
            k?: number | undefined;
            m?: number | undefined;
            include_original?: boolean | undefined;
        }>>;
        ste_vec: z.ZodOptional<z.ZodObject<{
            prefix: z.ZodString;
            array_index_mode: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"all">, z.ZodLiteral<"none">, z.ZodObject<{
                item: z.ZodOptional<z.ZodBoolean>;
                wildcard: z.ZodOptional<z.ZodBoolean>;
                position: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            }, {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            }>]>>;
        }, "strip", z.ZodTypeAny, {
            prefix: string;
            array_index_mode?: "all" | "none" | {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            } | undefined;
        }, {
            prefix: string;
            array_index_mode?: "all" | "none" | {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            } | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        ore?: {} | undefined;
        unique?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
        } | undefined;
        match?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
            tokenizer?: {
                kind: "standard";
            } | {
                kind: "ngram";
                token_length: number;
            } | undefined;
            k?: number | undefined;
            m?: number | undefined;
            include_original?: boolean | undefined;
        } | undefined;
        ste_vec?: {
            prefix: string;
            array_index_mode?: "all" | "none" | {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            } | undefined;
        } | undefined;
    }, {
        ore?: {} | undefined;
        unique?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
        } | undefined;
        match?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
            tokenizer?: {
                kind: "standard";
            } | {
                kind: "ngram";
                token_length: number;
            } | undefined;
            k?: number | undefined;
            m?: number | undefined;
            include_original?: boolean | undefined;
        } | undefined;
        ste_vec?: {
            prefix: string;
            array_index_mode?: "all" | "none" | {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            } | undefined;
        } | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
    indexes: {
        ore?: {} | undefined;
        unique?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
        } | undefined;
        match?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
            tokenizer?: {
                kind: "standard";
            } | {
                kind: "ngram";
                token_length: number;
            } | undefined;
            k?: number | undefined;
            m?: number | undefined;
            include_original?: boolean | undefined;
        } | undefined;
        ste_vec?: {
            prefix: string;
            array_index_mode?: "all" | "none" | {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            } | undefined;
        } | undefined;
    };
}, {
    cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | undefined;
    indexes?: {
        ore?: {} | undefined;
        unique?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
        } | undefined;
        match?: {
            token_filters?: {
                kind: "downcase";
            }[] | undefined;
            tokenizer?: {
                kind: "standard";
            } | {
                kind: "ngram";
                token_length: number;
            } | undefined;
            k?: number | undefined;
            m?: number | undefined;
            include_original?: boolean | undefined;
        } | undefined;
        ste_vec?: {
            prefix: string;
            array_index_mode?: "all" | "none" | {
                item?: boolean | undefined;
                wildcard?: boolean | undefined;
                position?: boolean | undefined;
            } | undefined;
        } | undefined;
    } | undefined;
}>>;
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"]>>;
        indexes: z.ZodDefault<z.ZodObject<{
            ore: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
            unique: z.ZodOptional<z.ZodObject<{
                token_filters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
                    kind: z.ZodLiteral<"downcase">;
                }, "strip", z.ZodTypeAny, {
                    kind: "downcase";
                }, {
                    kind: "downcase";
                }>, "many">>>;
            }, "strip", z.ZodTypeAny, {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            }, {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            }>>;
            match: z.ZodOptional<z.ZodObject<{
                tokenizer: z.ZodOptional<z.ZodDefault<z.ZodUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"standard">;
                }, "strip", z.ZodTypeAny, {
                    kind: "standard";
                }, {
                    kind: "standard";
                }>, z.ZodObject<{
                    kind: z.ZodLiteral<"ngram">;
                    token_length: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    kind: "ngram";
                    token_length: number;
                }, {
                    kind: "ngram";
                    token_length: number;
                }>]>>>;
                token_filters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
                    kind: z.ZodLiteral<"downcase">;
                }, "strip", z.ZodTypeAny, {
                    kind: "downcase";
                }, {
                    kind: "downcase";
                }>, "many">>>;
                k: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                m: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
                include_original: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
            }, "strip", z.ZodTypeAny, {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            }, {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            }>>;
            ste_vec: z.ZodOptional<z.ZodObject<{
                prefix: z.ZodString;
                array_index_mode: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"all">, z.ZodLiteral<"none">, z.ZodObject<{
                    item: z.ZodOptional<z.ZodBoolean>;
                    wildcard: z.ZodOptional<z.ZodBoolean>;
                    position: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                }, {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                }>]>>;
            }, "strip", z.ZodTypeAny, {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            }, {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            ore?: {} | undefined;
            unique?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            } | undefined;
            match?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            } | undefined;
            ste_vec?: {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            } | undefined;
        }, {
            ore?: {} | undefined;
            unique?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            } | undefined;
            match?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            } | undefined;
            ste_vec?: {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            } | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
        indexes: {
            ore?: {} | undefined;
            unique?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            } | undefined;
            match?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            } | undefined;
            ste_vec?: {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            } | undefined;
        };
    }, {
        cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | undefined;
        indexes?: {
            ore?: {} | undefined;
            unique?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            } | undefined;
            match?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            } | undefined;
            ste_vec?: {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            } | undefined;
        } | undefined;
    }>>>>>>;
}, "strip", z.ZodTypeAny, {
    v: number;
    tables: Record<string, Record<string, {
        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
        indexes: {
            ore?: {} | undefined;
            unique?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            } | undefined;
            match?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            } | undefined;
            ste_vec?: {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            } | undefined;
        };
    }>>;
}, {
    v: number;
    tables?: Record<string, Record<string, {
        cast_as?: "string" | "number" | "bigint" | "boolean" | "date" | "json" | undefined;
        indexes?: {
            ore?: {} | undefined;
            unique?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
            } | undefined;
            match?: {
                token_filters?: {
                    kind: "downcase";
                }[] | undefined;
                tokenizer?: {
                    kind: "standard";
                } | {
                    kind: "ngram";
                    token_length: number;
                } | undefined;
                k?: number | undefined;
                m?: number | undefined;
                include_original?: boolean | undefined;
            } | undefined;
            ste_vec?: {
                prefix: string;
                array_index_mode?: "all" | "none" | {
                    item?: boolean | undefined;
                    wildcard?: boolean | undefined;
                    position?: boolean | undefined;
                } | undefined;
            } | undefined;
        } | undefined;
    } | undefined> | undefined> | undefined;
}>;
/**
 * Type-safe alias for {@link castAsEnum} used to specify the *unencrypted* data type of a column or value.
 * This is important because once encrypted, all data is stored as binary blobs.
 *
 * @see {@link castAsEnum} for possible values.
 */
type CastAs = z.infer<typeof castAsEnum>;
type TokenFilter = z.infer<typeof tokenFilterSchema>;
type MatchIndexOpts = z.infer<typeof matchIndexOptsSchema>;
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;
            };
        };
    };
};
type EncryptConfig = z.infer<typeof encryptConfigSchema>;
declare class ProtectValue {
    private valueName;
    private castAsValue;
    constructor(valueName: string);
    /**
     * Set or override the cast_as value.
     */
    dataType(castAs: CastAs): this;
    build(): {
        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
        indexes: {};
    };
    getName(): string;
}
declare class ProtectColumn {
    private columnName;
    private castAsValue;
    private indexesValue;
    constructor(columnName: string);
    /**
     * Set or override the cast_as value.
     */
    dataType(castAs: CastAs): this;
    /**
     * Enable ORE indexing (Order-Revealing Encryption).
     */
    orderAndRange(): this;
    /**
     * Enable an Exact index. Optionally pass tokenFilters.
     */
    equality(tokenFilters?: TokenFilter[]): this;
    /**
     * Enable a Match index. Allows passing of custom match options.
     */
    freeTextSearch(opts?: MatchIndexOpts): this;
    /**
     * Configure this column for searchable encrypted JSON.
     * Enables path queries ($.user.email) and containment queries ({ role: 'admin' }).
     * Automatically sets cast_as to 'json'.
     */
    searchableJson(): this;
    build(): {
        cast_as: "string" | "number" | "bigint" | "boolean" | "date" | "json";
        indexes: {
            ore?: OreIndexOpts;
            unique?: UniqueIndexOpts;
            match?: Required<MatchIndexOpts>;
            ste_vec?: SteVecIndexOpts;
        };
    };
    getName(): string;
}
interface TableDefinition {
    tableName: string;
    columns: Record<string, ColumnSchema>;
}
declare class ProtectTable<T extends ProtectTableColumn> {
    readonly tableName: string;
    private readonly columnBuilders;
    constructor(tableName: string, columnBuilders: T);
    /**
     * Build a TableDefinition object: tableName + built column configs.
     */
    build(): TableDefinition;
}
declare function csTable<T extends ProtectTableColumn>(tableName: string, columns: T): ProtectTable<T> & T;
declare function csColumn(columnName: string): ProtectColumn;
declare function csValue(valueName: string): ProtectValue;
declare function buildEncryptConfig(...protectTables: Array<ProtectTable<ProtectTableColumn>>): EncryptConfig;

export { type CastAs, type ColumnSchema, type EncryptConfig, type MatchIndexOpts, type OreIndexOpts, ProtectColumn, ProtectTable, type ProtectTableColumn, ProtectValue, type SteVecIndexOpts, type TokenFilter, type UniqueIndexOpts, buildEncryptConfig, castAsEnum, csColumn, csTable, csValue, encryptConfigSchema };