@adonisjs/core 7.0.0-next.9 → 7.0.1

package/build/modules/ace/main.js

@@ -1,41 +1,2 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Ace command line interface module for AdonisJS applications.
- * Provides the kernel, base commands, and utilities for building CLI applications.
- *
- * @example
- * // Create and use the Ace kernel
- * import { Kernel, BaseCommand } from '@adonisjs/core/ace'
- *
- * const kernel = new Kernel(app)
- * await kernel.handle(['make:controller', 'UserController'])
- *
- * @example
- * // Create a custom command
- * import { BaseCommand, args, flags } from '@adonisjs/core/ace'
- *
- * export default class MakeUser extends BaseCommand {
- *   static commandName = 'make:user'
- *   static description = 'Create a new user'
- *
- *   @args.string({ description: 'Name of the user' })
- *   declare name: string
- *
- *   @flags.boolean({ description: 'Create admin user' })
- *   declare admin: boolean
- *
- *   async run() {
- *     this.logger.info(`Creating user: ${this.name}`)
- *   }
- * }
- */
-export { Kernel } from "./kernel.js";
-export { BaseCommand, ListCommand } from "./commands.js";
-export { args, flags, errors, Parser, FsLoader, ListLoader, cliHelpers, HelpCommand, IndexGenerator, tracingChannels, } from '@adonisjs/ace';
+import { a as Parser, c as errors, d as Kernel, f as BaseCommand, i as ListLoader, l as flags, n as HelpCommand, o as args, p as ListCommand, r as IndexGenerator, s as cliHelpers, t as FsLoader, u as tracingChannels } from "../../main-MBAMnmJb.js";
+export { BaseCommand, FsLoader, HelpCommand, IndexGenerator, Kernel, ListCommand, ListLoader, Parser, args, cliHelpers, errors, flags, tracingChannels };

package/build/modules/app.js

@@ -1,26 +1,6 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Application module re-exports all functionality from @adonisjs/application.
- * This includes the main Application class and related types for managing
- * the AdonisJS application lifecycle, container bindings, and service providers.
- *
- * @example
- * // Import the Application class
- * import { Application } from '@adonisjs/core/app'
- *
- * const app = new Application(new URL('../', import.meta.url))
- * await app.init()
- * await app.boot()
- *
- * @example
- * // Import application types
- * import type { ApplicationService, ContainerBindings } from '@adonisjs/core/app'
- */
-export * from '@adonisjs/application';
+import { n as __reExport, t as __exportAll } from "../chunk-iKc69rpz.js";
+export * from "@adonisjs/application";
+var app_exports = /* @__PURE__ */ __exportAll({});
+import * as import__adonisjs_application from "@adonisjs/application";
+__reExport(app_exports, import__adonisjs_application);
+export { app_exports as t };

package/build/modules/bodyparser/bodyparser_middleware.js

@@ -1,14 +1,3 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { BodyParserMiddleware } from '@adonisjs/bodyparser/bodyparser_middleware';
-/**
- * Default export allows lazy importing middleware with
- * destructuring the named exports
- */
-export default BodyParserMiddleware;
+import { BodyParserMiddleware } from "@adonisjs/bodyparser/bodyparser_middleware";
+var bodyparser_middleware_default = BodyParserMiddleware;
+export { bodyparser_middleware_default as default };

package/build/modules/bodyparser/main.js

@@ -1,9 +1,6 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export * from '@adonisjs/bodyparser';
+import { n as __reExport, t as __exportAll } from "../../chunk-iKc69rpz.js";
+export * from "@adonisjs/bodyparser";
+var main_exports = /* @__PURE__ */ __exportAll({});
+import * as import__adonisjs_bodyparser from "@adonisjs/bodyparser";
+__reExport(main_exports, import__adonisjs_bodyparser);
+export { main_exports as t };

package/build/modules/config.js

@@ -1,26 +1,6 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Configuration module re-exports all functionality from @adonisjs/config.
- * This includes the Config class and related types for managing application
- * configuration files and environment-specific settings.
- *
- * @example
- * // Import the Config class
- * import { Config } from '@adonisjs/core/config'
- *
- * const config = new Config()
- * config.set('database.connection', 'mysql')
- * const dbConnection = config.get('database.connection')
- *
- * @example
- * // Import configuration types
- * import type { ConfigProvider } from '@adonisjs/core/config'
- */
-export * from '@adonisjs/config';
+import { n as __reExport, t as __exportAll } from "../chunk-iKc69rpz.js";
+export * from "@adonisjs/config";
+var config_exports = /* @__PURE__ */ __exportAll({});
+import * as import__adonisjs_config from "@adonisjs/config";
+__reExport(config_exports, import__adonisjs_config);
+export { config_exports as t };

package/build/modules/container.js

@@ -1,9 +1,6 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export * from '@adonisjs/fold';
+import { n as __reExport, t as __exportAll } from "../chunk-iKc69rpz.js";
+export * from "@adonisjs/fold";
+var container_exports = /* @__PURE__ */ __exportAll({});
+import * as import__adonisjs_fold from "@adonisjs/fold";
+__reExport(container_exports, import__adonisjs_fold);
+export { container_exports as t };

package/build/modules/dumper/main.js

@@ -1,32 +1,6 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-/**
- * Dumper module provides debugging and inspection utilities for AdonisJS applications.
- * Includes the Dumper class for formatting output, error classes, and configuration helpers.
- *
- * @example
- * // Use the dumper service
- * import { Dumper } from '@adonisjs/core/dumper'
- *
- * const dumper = new Dumper(app)
- * const htmlOutput = dumper.dumpToHtml(user, { title: 'User Data' })
- * const ansiOutput = dumper.dumpToAnsi(user, { title: 'Debug User' })
- *
- * @example
- * // Configure dumper output
- * import { defineConfig } from '@adonisjs/core/dumper'
- *
- * export default defineConfig({
- *   html: { showHidden: true, depth: 5 },
- *   console: { collapse: ['Date', 'DateTime'] }
- * })
- */
-export * as errors from "./errors.js";
-export { Dumper } from "./dumper.js";
-export { defineConfig } from "./define_config.js";
+import "../../chunk-iKc69rpz.js";
+import { n as errors_exports, t as Dumper } from "../../dumper-BBgqFX5a.js";
+function defineConfig(dumperConfig) {
+	return dumperConfig;
+}
+export { Dumper, defineConfig, errors_exports as errors };

package/build/modules/dumper/plugins/edge.js

@@ -1,62 +1,47 @@
-/*
- * @adonisjs/core
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { Template } from 'edge.js';
-/**
- * Returns an edge plugin that integrates with a given
- * dumper instance
- */
-export function pluginEdgeDumper(dumper) {
-    Template.macro('dumper', dumper);
-    return (edge) => {
-        edge.registerTag({
-            tagName: 'dump',
-            block: false,
-            seekable: true,
-            noNewLine: true,
-            compile(parser, buffer, token) {
-                const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
-                buffer.writeExpression(`template.stacks.pushOnceTo('dumper', 'dumper_globals', template.dumper.getHeadElements(state.cspNonce))`, token.filename, token.loc.start.line);
-                buffer.outputExpression(`template.dumper.dumpToHtml(${parser.utils.stringify(parsed)}, { cspNonce: state.cspNonce, source: { location: $filename, line: $lineNumber } })`, token.filename, token.loc.start.line, true);
-            },
-        });
-        edge.registerTag({
-            tagName: 'dd',
-            block: false,
-            seekable: true,
-            noNewLine: true,
-            compile(parser, buffer, token) {
-                const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
-                /**
-                 * Dump/Die statement to catch error and convert it into
-                 * an Edge error
-                 */
-                const ddStatement = [
-                    'try {',
-                    `  template.dumper.dd(${parser.utils.stringify(parsed)})`,
-                    '} catch (error) {',
-                    `  if (error.code === 'E_DUMP_DIE_EXCEPTION') {`,
-                    '    const edgeError = template.createError(error.message, $filename, $lineNumber)',
-                    '    error.fileName = $filename',
-                    '    error.lineNumber = $lineNumber',
-                    '    edgeError.handle = function (_, ctx) {',
-                    '      return error.handle(error, ctx)',
-                    '    }',
-                    '    edgeError.report = function () {',
-                    '      return error.report(error)',
-                    '    }',
-                    '    throw edgeError',
-                    '  }',
-                    '  throw error',
-                    '}',
-                ].join('\n');
-                buffer.writeStatement(ddStatement, token.filename, token.loc.start.line);
-            },
-        });
-    };
+import { Template } from "edge.js";
+function pluginEdgeDumper(dumper) {
+	Template.macro("dumper", dumper);
+	return (edge) => {
+		edge.registerTag({
+			tagName: "dump",
+			block: false,
+			seekable: true,
+			noNewLine: true,
+			compile(parser, buffer, token) {
+				const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+				buffer.writeExpression(`template.stacks.pushOnceTo('dumper', 'dumper_globals', template.dumper.getHeadElements(state.cspNonce))`, token.filename, token.loc.start.line);
+				buffer.outputExpression(`template.dumper.dumpToHtml(${parser.utils.stringify(parsed)}, { cspNonce: state.cspNonce, source: { location: $filename, line: $lineNumber } })`, token.filename, token.loc.start.line, true);
+			}
+		});
+		edge.registerTag({
+			tagName: "dd",
+			block: false,
+			seekable: true,
+			noNewLine: true,
+			compile(parser, buffer, token) {
+				const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+				const ddStatement = [
+					"try {",
+					`  template.dumper.dd(${parser.utils.stringify(parsed)})`,
+					"} catch (error) {",
+					`  if (error.code === 'E_DUMP_DIE_EXCEPTION') {`,
+					"    const edgeError = template.createError(error.message, $filename, $lineNumber)",
+					"    error.fileName = $filename",
+					"    error.lineNumber = $lineNumber",
+					"    edgeError.handle = function (_, ctx) {",
+					"      return error.handle(error, ctx)",
+					"    }",
+					"    edgeError.report = function () {",
+					"      return error.report(error)",
+					"    }",
+					"    throw edgeError",
+					"  }",
+					"  throw error",
+					"}"
+				].join("\n");
+				buffer.writeStatement(ddStatement, token.filename, token.loc.start.line);
+			}
+		});
+	};
 }
+export { pluginEdgeDumper };

package/build/modules/encryption/define_config.d.ts

@@ -0,0 +1,161 @@
+import { type ConfigProvider } from '../../src/types.ts';
+import { type AESSIVDriverConfig, type AES256CBCDriverConfig, type AES256GCMDriverConfig, type ChaCha20Poly1305DriverConfig, type LegacyDriverConfig } from '../../types/encryption.ts';
+import { type EncryptionConfig } from '../../types/encryption.ts';
+/**
+ * Resolved configuration from the config provider that will be
+ * accepted by the encryption manager.
+ *
+ * This type unwraps ConfigProvider types to their resolved values,
+ * ensuring all encryptors in the list are concrete EncryptionConfig
+ * objects rather than providers.
+ *
+ * @template KnownEncryptors - Record of encryptor names to their configurations
+ */
+type ResolvedConfig<KnownEncryptors extends Record<string, EncryptionConfig | ConfigProvider<EncryptionConfig>>> = {
+    /**
+     * The default encryptor name to use when no specific
+     * encryptor is requested
+     */
+    default?: keyof KnownEncryptors;
+    /**
+     * Map of encryptor names to their resolved configurations.
+     * ConfigProvider types are unwrapped to their underlying
+     * EncryptionConfig values.
+     */
+    list: {
+        [K in keyof KnownEncryptors]: KnownEncryptors[K] extends ConfigProvider<infer A> ? A : KnownEncryptors[K];
+    };
+};
+/**
+ * Defines the encryption configuration for the application.
+ *
+ * This function creates a configuration provider that lazily resolves
+ * encryption drivers. It validates that the default encryptor (if specified)
+ * exists in the list and resolves any ConfigProvider instances to their
+ * concrete values.
+ *
+ * @template KnownEncryptors - Record of encryptor names to their configurations
+ *
+ * @param config - The encryption configuration object
+ * @param config.default - Optional default encryptor name
+ * @param config.list - Map of encryptor names to their configurations or providers
+ *
+ * @example
+ * ```ts
+ * const encryptionConfig = defineConfig({
+ *   default: 'app',
+ *   list: {
+ *     app: drivers.aes256gcm({
+ *       id: 'app',
+ *       keys: [env.get('APP_KEY')]
+ *     }),
+ *     backup: drivers.chacha20({
+ *       id: 'backup',
+ *       keys: [env.get('BACKUP_KEY')]
+ *     })
+ *   }
+ * })
+ * ```
+ */
+export declare function defineConfig<KnownEncryptors extends Record<string, EncryptionConfig | ConfigProvider<EncryptionConfig>>>(config: {
+    default?: keyof KnownEncryptors;
+    list: KnownEncryptors;
+}): ConfigProvider<ResolvedConfig<KnownEncryptors>>;
+/**
+ * Collection of encryption driver factory functions.
+ *
+ * Each driver factory creates a ConfigProvider that lazily imports
+ * and configures the corresponding encryption driver. This allows
+ * for efficient code splitting and on-demand loading of encryption
+ * algorithms.
+ */
+export declare const drivers: {
+    /**
+     * Creates a ChaCha20-Poly1305 encryption driver configuration.
+     *
+     * ChaCha20-Poly1305 is a modern authenticated encryption algorithm
+     * that provides excellent performance on systems without AES hardware
+     * acceleration.
+     *
+     * @param config - The ChaCha20-Poly1305 driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.chacha20({
+     *   id: 'app',
+     *   keys: [env.get('APP_KEY')]
+     * })
+     * ```
+     */
+    chacha20: (config: ChaCha20Poly1305DriverConfig) => ConfigProvider<EncryptionConfig>;
+    /**
+     * Creates an AES-256-CBC encryption driver configuration.
+     *
+     * AES-256-CBC is a widely-supported block cipher mode. However,
+     * consider using AES-256-GCM for new applications as it provides
+     * authenticated encryption.
+     *
+     * @param config - The AES-256-CBC driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.aes256cbc({
+     *   id: 'legacy',
+     *   keys: [env.get('LEGACY_KEY')]
+     * })
+     * ```
+     */
+    aes256cbc: (config: AES256CBCDriverConfig) => ConfigProvider<EncryptionConfig>;
+    /**
+     * Creates an AES-256-GCM encryption driver configuration.
+     *
+     * AES-256-GCM is an authenticated encryption algorithm that provides
+     * both confidentiality and integrity. It offers excellent performance
+     * on systems with AES hardware acceleration.
+     *
+     * @param config - The AES-256-GCM driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.aes256gcm({
+     *   id: 'app',
+     *   keys: [env.get('APP_KEY')]
+     * })
+     * ```
+     */
+    aes256gcm: (config: AES256GCMDriverConfig) => ConfigProvider<EncryptionConfig>;
+    /**
+     * Creates an AES-SIV encryption driver configuration.
+     *
+     * @param config - The AES-SIV driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.aessiv({
+     *   id: 'app',
+     *   key: env.get('APP_KEY')
+     * })
+     * ```
+     */
+    aessiv: (config: AESSIVDriverConfig) => ConfigProvider<EncryptionConfig>;
+    /**
+     * Creates a Legacy encryption driver configuration.
+     *
+     * The Legacy driver maintains compatibility with the old AdonisJS v6
+     * encryption format. It uses AES-256-CBC with HMAC SHA-256.
+     *
+     * Use this driver to decrypt values encrypted with older versions
+     * of AdonisJS or when migrating to newer encryption drivers.
+     *
+     * @param config - The Legacy driver configuration
+     *
+     * @example
+     * ```ts
+     * drivers.legacy({
+     *   keys: [env.get('APP_KEY')]
+     * })
+     * ```
+     */
+    legacy: (config: LegacyDriverConfig) => ConfigProvider<EncryptionConfig>;
+};
+export {};

package/build/modules/encryption/drivers/aes_256_cbc.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AES-256-CBC encryption driver implementation.
+ *
+ * This driver provides encryption and decryption using the AES-256-CBC
+ * (Advanced Encryption Standard with 256-bit key in Cipher Block Chaining mode)
+ * algorithm. While widely supported, AES-256-CBC does not provide authenticated
+ * encryption. Consider using AES-256-GCM for new applications.
+ *
+ * @example
+ * ```ts
+ * const driver = new AES256CBC({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { AES256CBC } from '@boringnode/encryption/drivers/aes_256_cbc';

package/build/modules/encryption/drivers/aes_256_cbc.js

@@ -0,0 +1,2 @@
+import { AES256CBC } from "@boringnode/encryption/drivers/aes_256_cbc";
+export { AES256CBC };

package/build/modules/encryption/drivers/aes_256_gcm.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AES-256-GCM encryption driver implementation.
+ *
+ * This driver provides authenticated encryption and decryption using the
+ * AES-256-GCM (Advanced Encryption Standard with 256-bit key in Galois/Counter Mode)
+ * algorithm. GCM mode provides both confidentiality and authenticity, making it
+ * the recommended choice for modern applications. It offers excellent performance
+ * on systems with AES hardware acceleration.
+ *
+ * @example
+ * ```ts
+ * const driver = new AES256GCM({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { AES256GCM } from '@boringnode/encryption/drivers/aes_256_gcm';

package/build/modules/encryption/drivers/aes_256_gcm.js

@@ -0,0 +1,2 @@
+import { AES256GCM } from "@boringnode/encryption/drivers/aes_256_gcm";
+export { AES256GCM };

package/build/modules/encryption/drivers/aes_siv.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AES-SIV encryption driver implementation.
+ *
+ * This driver provides deterministic authenticated encryption using AES-SIV
+ * (Synthetic Initialization Vector). It is useful when you need equality
+ * queries over encrypted values while preserving authenticity guarantees.
+ *
+ * @example
+ * ```ts
+ * const driver = new AESSIV({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { AESSIV } from '@boringnode/encryption/drivers/aes_siv';

package/build/modules/encryption/drivers/aes_siv.js

@@ -0,0 +1,2 @@
+import { AESSIV } from "@boringnode/encryption/drivers/aes_siv";
+export { AESSIV };

package/build/modules/encryption/drivers/chacha20_poly1305.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ChaCha20-Poly1305 encryption driver implementation.
+ *
+ * This driver provides authenticated encryption and decryption using the
+ * ChaCha20-Poly1305 algorithm. ChaCha20 is a modern stream cipher that
+ * provides excellent performance on systems without AES hardware acceleration.
+ * Combined with Poly1305 for authentication, it offers both confidentiality
+ * and authenticity.
+ *
+ * @example
+ * ```ts
+ * const driver = new ChaCha20Poly1305({
+ *   id: 'app',
+ *   key: 'your-256-bit-key-here'
+ * })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export { ChaCha20Poly1305 } from '@boringnode/encryption/drivers/chacha20_poly1305';

package/build/modules/encryption/drivers/chacha20_poly1305.js

@@ -0,0 +1,2 @@
+import { ChaCha20Poly1305 } from "@boringnode/encryption/drivers/chacha20_poly1305";
+export { ChaCha20Poly1305 };

package/build/modules/encryption/drivers/legacy.d.ts

@@ -0,0 +1,84 @@
+import { type Secret } from '@poppinss/utils';
+import { BaseDriver } from '@boringnode/encryption';
+import type { CypherText, EncryptOptions, EncryptionDriverContract } from '@boringnode/encryption/types';
+/**
+ * Configuration for the Legacy encryption driver.
+ *
+ * The Legacy driver maintains compatibility with the old AdonisJS v6
+ * encryption format using AES-256-CBC with HMAC SHA-256.
+ */
+export interface LegacyConfig {
+    key: string | Secret<string>;
+}
+/**
+ * Configuration for the Legacy encryption driver factory.
+ *
+ * Used when configuring the driver through the defineConfig function.
+ */
+export interface LegacyDriverConfig {
+    keys: (string | Secret<string>)[];
+}
+/**
+ * Factory function to create a Legacy encryption configuration.
+ *
+ * @example
+ * ```ts
+ * drivers.legacy({
+ *   keys: [env.get('APP_KEY')]
+ * })
+ * ```
+ */
+export declare function legacy(config: LegacyDriverConfig): {
+    driver: (key: string | Secret<string>) => Legacy;
+    keys: (string | Secret<string>)[];
+};
+/**
+ * Legacy encryption driver for AdonisJS.
+ *
+ * This driver maintains compatibility with the old AdonisJS v6 encryption
+ * format. It uses:
+ * - AES-256-CBC for encryption
+ * - HMAC SHA-256 for integrity verification
+ * - MessageBuilder from @poppinss/utils for encoding values
+ *
+ * Encrypted format: `[encrypted_base64url].[iv_base64url].[hmac]`
+ *
+ * @example
+ * ```ts
+ * const driver = new Legacy({ key: 'your-32-character-secret-key!!' })
+ *
+ * const encrypted = driver.encrypt('sensitive data')
+ * const decrypted = driver.decrypt(encrypted)
+ * ```
+ */
+export declare class Legacy extends BaseDriver implements EncryptionDriverContract {
+    constructor(config: LegacyConfig);
+    /**
+     * Encrypt a given piece of value using the app secret. A wide range of
+     * data types are supported.
+     *
+     * - String
+     * - Arrays
+     * - Objects
+     * - Booleans
+     * - Numbers
+     * - Dates
+     *
+     * You can optionally define a purpose for which the value was encrypted and
+     * mentioning a different purpose/no purpose during decrypt will fail.
+     */
+    encrypt(payload: any, options?: EncryptOptions): CypherText;
+    encrypt(payload: any, expiresIn?: string | number, purpose?: string): CypherText;
+    /**
+     * Decrypt value and verify it against a purpose
+     */
+    decrypt<T extends any>(value: string, purpose?: string): T | null;
+    /**
+     * Legacy driver does not support blind indexes.
+     */
+    blindIndex(_payload: any, _purpose: string): string;
+    /**
+     * Legacy driver does not support blind indexes.
+     */
+    blindIndexes(_payload: any, _purpose: string): string[];
+}