@elaraai/east-node-io 0.0.1-beta.8 → 1.0.0

package/dist/src/sql/index.d.ts

@@ -0,0 +1,1112 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SQL database platform functions.
+ *
+ * Provides type-safe SQL database operations for East programs, supporting
+ * SQLite, PostgreSQL, and MySQL with connection pooling and parameterized queries.
+ *
+ * @packageDocumentation
+ */
+export * from "./sqlite.js";
+export * from "./postgres.js";
+export * from "./mysql.js";
+export * from "./access.js";
+export * from "./types.js";
+/**
+ * SQL database platform functions.
+ *
+ * Provides type-safe SQL database operations for East programs, supporting
+ * SQLite, PostgreSQL, and MySQL with connection pooling and parameterized queries.
+ *
+ * @example
+ * ```ts
+ * import { East, StringType, IntegerType, NullType, variant } from "@elaraai/east";
+ * import { SQL } from "@elaraai/east-node-io";
+ *
+ * const getUserName = East.function([IntegerType], NullType, ($, userId) => {
+ *     const config = $.let({
+ *         host: "localhost",
+ *         port: 5432n,
+ *         database: "myapp",
+ *         user: "postgres",
+ *         password: "secret",
+ *         ssl: variant('none', null),
+ *         maxConnections: variant('none', null),
+ *     });
+ *
+ *     const conn = $.let(SQL.Postgres.connect(config));
+ *     $(SQL.Postgres.query(
+ *         conn,
+ *         "SELECT name FROM users WHERE id = $1",
+ *         [variant('Integer', userId)]
+ *     ));
+ *     $(SQL.Postgres.close(conn));
+ *     $.return(null);
+ * });
+ *
+ * // All SQL operations are async
+ * const compiled = East.compileAsync(getUserName.toIR(), SQL.Postgres.Implementation);
+ * await compiled(42n);
+ * ```
+ */
+export declare const SQL: {
+    /**
+     * SQLite database operations.
+     *
+     * Provides platform functions for SQLite, a serverless embedded SQL database.
+     */
+    readonly SQLite: {
+        /**
+         * Opens a SQLite database connection.
+         *
+         * Creates a connection to a SQLite database file or in-memory database
+         * and returns an opaque handle for use in queries.
+         *
+         * @example
+         * ```ts
+         * const getUser = East.function([IntegerType], NullType, ($, userId) => {
+         *     const config = $.let({
+         *         path: "./mydb.sqlite",
+         *         readOnly: variant('none', null),
+         *         memory: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.SQLite.connect(config));
+         *     $(SQL.SQLite.query(
+         *         conn,
+         *         "SELECT name FROM users WHERE id = ?",
+         *         [variant('Integer', userId)]
+         *     ));
+         *     $(SQL.SQLite.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUser.toIR(), SQL.SQLite.Implementation);
+         * await compiled(42n);
+         * ```
+         */
+        readonly connect: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
+            readonly path: import("./types.js").StringType;
+            readonly readOnly: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            readonly memory: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+        }>], import("./types.js").StringType>;
+        /**
+         * Executes a SQL query with parameters.
+         *
+         * Runs a SQL query with parameter binding using ? placeholders.
+         *
+         * @example
+         * ```ts
+         * const getUser = East.function([IntegerType], NullType, ($, userId) => {
+         *     const config = $.let({
+         *         path: "./mydb.sqlite",
+         *         readOnly: variant('none', null),
+         *         memory: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.SQLite.connect(config));
+         *     $(SQL.SQLite.query(
+         *         conn,
+         *         "SELECT name FROM users WHERE id = ?",
+         *         [variant('Integer', userId)]
+         *     ));
+         *     $(SQL.SQLite.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUser.toIR(), SQL.SQLite.Implementation);
+         * await compiled(42n);
+         * ```
+         */
+        readonly query: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType, import("./types.js").StringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: import("./types.js").StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").VariantType<{
+            readonly select: import("@elaraai/east").StructType<{
+                readonly rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").BooleanType;
+                    readonly Integer: import("@elaraai/east").IntegerType;
+                    readonly Float: import("@elaraai/east").FloatType;
+                    readonly String: import("./types.js").StringType;
+                    readonly DateTime: import("@elaraai/east").DateTimeType;
+                    readonly Blob: import("@elaraai/east").BlobType;
+                }>>>;
+            }>;
+            readonly insert: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+                readonly lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            readonly update: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+            readonly delete: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+        }>>;
+        /**
+         * Executes a SELECT query with user-defined return type.
+         *
+         * Runs a SELECT query and returns typed rows. The return type is generic,
+         * allowing users to specify the expected row structure for type-safe access.
+         *
+         * @example
+         * ```ts
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         * });
+         *
+         * const getUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: ":memory:",
+         *         readOnly: variant('none', null),
+         *         memory: variant('some', true),
+         *     });
+         *     const conn = $.let(SQL.SQLite.connect(config));
+         *
+         *     // Create table and insert data
+         *     $(SQL.SQLite.query(conn, "CREATE TABLE users (id INTEGER, name TEXT)", []));
+         *     $(SQL.SQLite.query(conn, "INSERT INTO users VALUES (1, 'Alice')", []));
+         *
+         *     // Query with typed results
+         *     const users = $.let(SQL.SQLite.select([UserRowType], conn,
+         *         "SELECT id, name FROM users",
+         *         []
+         *     ));
+         *     // users is typed as Array<{ id: bigint, name: string }>
+         *
+         *     $(SQL.SQLite.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUsers.toIR(), SQL.SQLite.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly select: import("@elaraai/east").AsyncGenericPlatformDefinition<readonly ["T"], readonly [import("./types.js").StringType, import("./types.js").StringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: import("./types.js").StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").ArrayType<"T">>;
+        /**
+         * Closes the SQLite database connection.
+         *
+         * Releases all resources associated with the connection.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         path: "./mydb.sqlite",
+         *         readOnly: variant('none', null),
+         *         memory: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.SQLite.connect(config));
+         *     // ... do work ...
+         *     $(SQL.SQLite.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), SQL.SQLite.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly close: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Closes all SQLite connections.
+         *
+         * Closes all active SQLite connections and releases all resources.
+         * Useful for test cleanup to ensure all connections are closed.
+         *
+         * @returns Null on success
+         *
+         * @example
+         * ```ts
+         * const cleanupAll = East.function([], NullType, $ => {
+         *     // ... test code that may have left connections open ...
+         *     $(SQL.SQLite.closeAll());
+         *     return $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanupAll.toIR(), SQL.SQLite.Implementation);
+         * await compiled();
+         * ```
+         *
+         * @internal
+         */
+        readonly closeAll: import("@elaraai/east").AsyncPlatformDefinition<[], import("@elaraai/east").NullType>;
+        /**
+         * Node.js implementation of SQLite platform functions.
+         *
+         * Pass this to East.compileAsync() to enable SQLite operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for SQLite operations.
+         */
+        readonly Types: {
+            /**
+             * SQLite connection configuration type.
+             */
+            readonly Config: import("@elaraai/east").StructType<{
+                readonly path: import("./types.js").StringType;
+                readonly readOnly: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+                readonly memory: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            }>;
+            /**
+             * SQL query parameter value type.
+             */
+            readonly Parameter: import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * Array of SQL query parameters.
+             */
+            readonly Parameters: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query result row type.
+             */
+            readonly Row: import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query execution result type.
+             */
+            readonly Result: import("@elaraai/east").VariantType<{
+                readonly select: import("@elaraai/east").StructType<{
+                    readonly rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                        readonly Null: import("@elaraai/east").NullType;
+                        readonly Boolean: import("@elaraai/east").BooleanType;
+                        readonly Integer: import("@elaraai/east").IntegerType;
+                        readonly Float: import("@elaraai/east").FloatType;
+                        readonly String: import("./types.js").StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Blob: import("@elaraai/east").BlobType;
+                    }>>>;
+                }>;
+                readonly insert: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                    readonly lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                readonly update: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+                readonly delete: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+            }>;
+        };
+    };
+    /**
+     * PostgreSQL database operations.
+     *
+     * Provides platform functions for PostgreSQL with connection pooling.
+     */
+    readonly Postgres: {
+        /**
+         * Connects to a PostgreSQL database.
+         *
+         * Creates a connection pool to a PostgreSQL database and returns an
+         * opaque handle for use in queries.
+         *
+         * @example
+         * ```ts
+         * const getUser = East.function([IntegerType], NullType, ($, userId) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 5432n,
+         *         database: "myapp",
+         *         user: "postgres",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Postgres.connect(config));
+         *     $(SQL.Postgres.query(
+         *         conn,
+         *         "SELECT name FROM users WHERE id = $1",
+         *         [variant('Integer', userId)]
+         *     ));
+         *     $(SQL.Postgres.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUser.toIR(), SQL.Postgres.Implementation);
+         * await compiled(42n);
+         * ```
+         */
+        readonly connect: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
+            readonly host: import("./types.js").StringType;
+            readonly port: import("@elaraai/east").IntegerType;
+            readonly database: import("./types.js").StringType;
+            readonly user: import("./types.js").StringType;
+            readonly password: import("./types.js").StringType;
+            readonly ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            readonly maxConnections: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("./types.js").StringType>;
+        /**
+         * Executes a SQL query with parameters.
+         *
+         * Runs a SQL query with parameter binding using $1, $2, etc. placeholders.
+         *
+         * @example
+         * ```ts
+         * const getUser = East.function([IntegerType], NullType, ($, userId) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 5432n,
+         *         database: "myapp",
+         *         user: "postgres",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.Postgres.connect(config));
+         *     $(SQL.Postgres.query(
+         *         conn,
+         *         "SELECT name FROM users WHERE id = $1",
+         *         [variant('Integer', userId)]
+         *     ));
+         *     $(SQL.Postgres.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUser.toIR(), SQL.Postgres.Implementation);
+         * await compiled(42n);
+         * ```
+         */
+        readonly query: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType, import("./types.js").StringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: import("./types.js").StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").VariantType<{
+            readonly select: import("@elaraai/east").StructType<{
+                readonly rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").BooleanType;
+                    readonly Integer: import("@elaraai/east").IntegerType;
+                    readonly Float: import("@elaraai/east").FloatType;
+                    readonly String: import("./types.js").StringType;
+                    readonly DateTime: import("@elaraai/east").DateTimeType;
+                    readonly Blob: import("@elaraai/east").BlobType;
+                }>>>;
+            }>;
+            readonly insert: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+                readonly lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            readonly update: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+            readonly delete: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+        }>>;
+        /**
+         * Executes a SELECT query with user-defined return type.
+         *
+         * Runs a SELECT query and returns typed rows. The return type is generic,
+         * allowing users to specify the expected row structure for type-safe access.
+         *
+         * @example
+         * ```ts
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         * });
+         *
+         * const getUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 5432n,
+         *         database: "myapp",
+         *         user: "postgres",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.Postgres.connect(config));
+         *
+         *     // Query with typed results
+         *     const users = $.let(SQL.Postgres.select([UserRowType], conn,
+         *         "SELECT id, name FROM users",
+         *         []
+         *     ));
+         *     // users is typed as Array<{ id: bigint, name: string }>
+         *
+         *     $(SQL.Postgres.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUsers.toIR(), SQL.Postgres.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly select: import("@elaraai/east").AsyncGenericPlatformDefinition<readonly ["T"], readonly [import("./types.js").StringType, import("./types.js").StringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: import("./types.js").StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").ArrayType<"T">>;
+        /**
+         * Closes the PostgreSQL connection pool.
+         *
+         * Terminates all connections and releases all resources.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 5432n,
+         *         database: "myapp",
+         *         user: "postgres",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.Postgres.connect(config));
+         *     // ... do work ...
+         *     $(SQL.Postgres.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), SQL.Postgres.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly close: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Closes all PostgreSQL connections.
+         *
+         * Closes all active PostgreSQL connection pools and releases all resources.
+         * Useful for test cleanup to ensure all connections are closed.
+         *
+         * @returns Null on success
+         *
+         * @example
+         * ```ts
+         * const cleanupAll = East.function([], NullType, $ => {
+         *     // ... test code that may have left connections open ...
+         *     $(SQL.Postgres.closeAll());
+         *     return $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanupAll.toIR(), SQL.Postgres.Implementation);
+         * await compiled();
+         * ```
+         *
+         * @internal
+         */
+        readonly closeAll: import("@elaraai/east").AsyncPlatformDefinition<[], import("@elaraai/east").NullType>;
+        /**
+         * Node.js implementation of PostgreSQL platform functions.
+         *
+         * Pass this to East.compileAsync() to enable PostgreSQL operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for PostgreSQL operations.
+         */
+        readonly Types: {
+            /**
+             * PostgreSQL connection configuration type.
+             */
+            readonly Config: import("@elaraai/east").StructType<{
+                readonly host: import("./types.js").StringType;
+                readonly port: import("@elaraai/east").IntegerType;
+                readonly database: import("./types.js").StringType;
+                readonly user: import("./types.js").StringType;
+                readonly password: import("./types.js").StringType;
+                readonly ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+                readonly maxConnections: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * SQL query parameter value type.
+             */
+            readonly Parameter: import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * Array of SQL query parameters.
+             */
+            readonly Parameters: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query result row type.
+             */
+            readonly Row: import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query execution result type.
+             */
+            readonly Result: import("@elaraai/east").VariantType<{
+                readonly select: import("@elaraai/east").StructType<{
+                    readonly rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                        readonly Null: import("@elaraai/east").NullType;
+                        readonly Boolean: import("@elaraai/east").BooleanType;
+                        readonly Integer: import("@elaraai/east").IntegerType;
+                        readonly Float: import("@elaraai/east").FloatType;
+                        readonly String: import("./types.js").StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Blob: import("@elaraai/east").BlobType;
+                    }>>>;
+                }>;
+                readonly insert: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                    readonly lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                readonly update: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+                readonly delete: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+            }>;
+        };
+    };
+    /**
+     * MySQL database operations.
+     *
+     * Provides platform functions for MySQL with connection pooling.
+     */
+    readonly MySQL: {
+        /**
+         * Connects to a MySQL database.
+         *
+         * Creates a connection pool to a MySQL database and returns an
+         * opaque handle for use in queries.
+         *
+         * @example
+         * ```ts
+         * const getUser = East.function([IntegerType], NullType, ($, userId) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 3306n,
+         *         database: "myapp",
+         *         user: "root",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.MySQL.connect(config));
+         *     $(SQL.MySQL.query(
+         *         conn,
+         *         "SELECT name FROM users WHERE id = ?",
+         *         [variant('Integer', userId)]
+         *     ));
+         *     $(SQL.MySQL.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUser.toIR(), SQL.MySQL.Implementation);
+         * await compiled(42n);
+         * ```
+         */
+        readonly connect: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
+            readonly host: import("./types.js").StringType;
+            readonly port: import("@elaraai/east").IntegerType;
+            readonly database: import("./types.js").StringType;
+            readonly user: import("./types.js").StringType;
+            readonly password: import("./types.js").StringType;
+            readonly ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            readonly maxConnections: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("./types.js").StringType>;
+        /**
+         * Executes a SQL query with parameters.
+         *
+         * Runs a SQL query with parameter binding using ? placeholders.
+         *
+         * @example
+         * ```ts
+         * const getUser = East.function([IntegerType], NullType, ($, userId) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 3306n,
+         *         database: "myapp",
+         *         user: "root",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.MySQL.connect(config));
+         *     $(SQL.MySQL.query(
+         *         conn,
+         *         "SELECT name FROM users WHERE id = ?",
+         *         [variant('Integer', userId)]
+         *     ));
+         *     $(SQL.MySQL.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUser.toIR(), SQL.MySQL.Implementation);
+         * await compiled(42n);
+         * ```
+         */
+        readonly query: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType, import("./types.js").StringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: import("./types.js").StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").VariantType<{
+            readonly select: import("@elaraai/east").StructType<{
+                readonly rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                    readonly Null: import("@elaraai/east").NullType;
+                    readonly Boolean: import("@elaraai/east").BooleanType;
+                    readonly Integer: import("@elaraai/east").IntegerType;
+                    readonly Float: import("@elaraai/east").FloatType;
+                    readonly String: import("./types.js").StringType;
+                    readonly DateTime: import("@elaraai/east").DateTimeType;
+                    readonly Blob: import("@elaraai/east").BlobType;
+                }>>>;
+            }>;
+            readonly insert: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+                readonly lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            readonly update: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+            readonly delete: import("@elaraai/east").StructType<{
+                readonly rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+        }>>;
+        /**
+         * Executes a SELECT query with user-defined return type.
+         *
+         * Runs a SELECT query and returns typed rows. The return type is generic,
+         * allowing users to specify the expected row structure for type-safe access.
+         *
+         * @example
+         * ```ts
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         * });
+         *
+         * const getUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 3306n,
+         *         database: "myapp",
+         *         user: "root",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.MySQL.connect(config));
+         *
+         *     // Query with typed results
+         *     const users = $.let(SQL.MySQL.select([UserRowType], conn,
+         *         "SELECT id, name FROM users",
+         *         []
+         *     ));
+         *     // users is typed as Array<{ id: bigint, name: string }>
+         *
+         *     $(SQL.MySQL.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(getUsers.toIR(), SQL.MySQL.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly select: import("@elaraai/east").AsyncGenericPlatformDefinition<readonly ["T"], readonly [import("./types.js").StringType, import("./types.js").StringType, import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            readonly Null: import("@elaraai/east").NullType;
+            readonly Boolean: import("@elaraai/east").BooleanType;
+            readonly Integer: import("@elaraai/east").IntegerType;
+            readonly Float: import("@elaraai/east").FloatType;
+            readonly String: import("./types.js").StringType;
+            readonly DateTime: import("@elaraai/east").DateTimeType;
+            readonly Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").ArrayType<"T">>;
+        /**
+         * Closes the MySQL connection pool.
+         *
+         * Terminates all connections and releases all resources.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 3306n,
+         *         database: "myapp",
+         *         user: "root",
+         *         password: "secret",
+         *         ssl: variant('none', null),
+         *         maxConnections: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.MySQL.connect(config));
+         *     // ... do work ...
+         *     $(SQL.MySQL.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), SQL.MySQL.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly close: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Closes all MySQL connections.
+         *
+         * Closes all active MySQL connection pools and releases all resources.
+         * Useful for test cleanup to ensure all connections are closed.
+         *
+         * @returns Null on success
+         *
+         * @example
+         * ```ts
+         * const cleanupAll = East.function([], NullType, $ => {
+         *     // ... test code that may have left connections open ...
+         *     $(SQL.MySQL.closeAll());
+         *     return $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanupAll.toIR(), SQL.MySQL.Implementation);
+         * await compiled();
+         * ```
+         *
+         * @internal
+         */
+        readonly closeAll: import("@elaraai/east").AsyncPlatformDefinition<[], import("@elaraai/east").NullType>;
+        /**
+         * Node.js implementation of MySQL platform functions.
+         *
+         * Pass this to East.compileAsync() to enable MySQL operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for MySQL operations.
+         */
+        readonly Types: {
+            /**
+             * MySQL connection configuration type.
+             */
+            readonly Config: import("@elaraai/east").StructType<{
+                readonly host: import("./types.js").StringType;
+                readonly port: import("@elaraai/east").IntegerType;
+                readonly database: import("./types.js").StringType;
+                readonly user: import("./types.js").StringType;
+                readonly password: import("./types.js").StringType;
+                readonly ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+                readonly maxConnections: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * SQL query parameter value type.
+             */
+            readonly Parameter: import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * Array of SQL query parameters.
+             */
+            readonly Parameters: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query result row type.
+             */
+            readonly Row: import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                readonly Null: import("@elaraai/east").NullType;
+                readonly Boolean: import("@elaraai/east").BooleanType;
+                readonly Integer: import("@elaraai/east").IntegerType;
+                readonly Float: import("@elaraai/east").FloatType;
+                readonly String: import("./types.js").StringType;
+                readonly DateTime: import("@elaraai/east").DateTimeType;
+                readonly Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query execution result type.
+             */
+            readonly Result: import("@elaraai/east").VariantType<{
+                readonly select: import("@elaraai/east").StructType<{
+                    readonly rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                        readonly Null: import("@elaraai/east").NullType;
+                        readonly Boolean: import("@elaraai/east").BooleanType;
+                        readonly Integer: import("@elaraai/east").IntegerType;
+                        readonly Float: import("@elaraai/east").FloatType;
+                        readonly String: import("./types.js").StringType;
+                        readonly DateTime: import("@elaraai/east").DateTimeType;
+                        readonly Blob: import("@elaraai/east").BlobType;
+                    }>>>;
+                }>;
+                readonly insert: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                    readonly lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                readonly update: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+                readonly delete: import("@elaraai/east").StructType<{
+                    readonly rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+            }>;
+        };
+    };
+    /**
+     * Microsoft Access database operations.
+     *
+     * Provides read-only platform functions for Access databases (.mdb, .accdb).
+     * Supports Access 97 through Access 2019, including encrypted databases.
+     */
+    readonly Access: {
+        /**
+         * Opens a Microsoft Access database file.
+         *
+         * Opens an Access database file and returns an opaque handle for use in queries.
+         *
+         * @example
+         * ```ts
+         * const listTables = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Access.open(config));
+         *     const tables = $.let(SQL.Access.tables(conn));
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(listTables.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly open: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
+            readonly path: import("./types.js").StringType;
+            readonly password: import("@elaraai/east").OptionType<import("./types.js").StringType>;
+        }>], import("./types.js").StringType>;
+        /**
+         * Lists all table names in an Access database.
+         *
+         * Returns an array of normal table names (not system or linked tables).
+         *
+         * @example
+         * ```ts
+         * const showTables = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Access.open(config));
+         *     const result = $.let(SQL.Access.tables(conn));
+         *     // result.tables contains ['Table1', 'Table2', ...]
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(showTables.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly tables: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType], import("@elaraai/east").StructType<{
+            readonly tables: import("@elaraai/east").ArrayType<import("./types.js").StringType>;
+        }>>;
+        /**
+         * Queries data from an Access database table with a user-defined return type.
+         *
+         * Reads rows from a specified table with optional column selection and pagination.
+         * The return type is generic, allowing users to specify the expected row structure.
+         *
+         * @typeParam T - The expected row type for query results
+         *
+         * @example
+         * ```ts
+         * // Define the expected row type
+         * const UserRowType = StructType({
+         *     id: IntegerType,
+         *     name: StringType,
+         *     email: StringType,
+         * });
+         *
+         * const queryUsers = East.function([], NullType, ($) => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(SQL.Access.open(config));
+         *     // Query with typed results - returns Array<UserRowType>
+         *     const users = $.let(SQL.Access.query([UserRowType], conn, {
+         *         table: "Users",
+         *         columns: variant('some', ["id", "name", "email"]),
+         *         rowOffset: variant('none', null),
+         *         rowLimit: variant('some', 100n),
+         *     }));
+         *     // users is typed as Array<{ id: bigint, name: string, email: string }>
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(queryUsers.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly query: import("@elaraai/east").AsyncGenericPlatformDefinition<readonly ["T"], readonly [import("./types.js").StringType, import("@elaraai/east").StructType<{
+            readonly table: import("./types.js").StringType;
+            readonly columns: import("@elaraai/east").OptionType<import("@elaraai/east").ArrayType<import("./types.js").StringType>>;
+            readonly rowOffset: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            readonly rowLimit: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("@elaraai/east").ArrayType<"T">>;
+        /**
+         * Closes an Access database connection.
+         *
+         * Releases all resources associated with the connection.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         path: "./database.mdb",
+         *         password: variant('none', null),
+         *     });
+         *     const conn = $.let(SQL.Access.open(config));
+         *     // ... do work ...
+         *     $(SQL.Access.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly close: import("@elaraai/east").AsyncPlatformDefinition<[import("./types.js").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Closes all Access database connections.
+         *
+         * Closes all active Access connections and releases all resources.
+         * Useful for test cleanup to ensure all connections are closed.
+         *
+         * @returns Null on success
+         *
+         * @example
+         * ```ts
+         * const cleanupAll = East.function([], NullType, $ => {
+         *     // ... test code that may have left connections open ...
+         *     $(SQL.Access.closeAll());
+         *     return $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanupAll.toIR(), SQL.Access.Implementation);
+         * await compiled();
+         * ```
+         *
+         * @internal
+         */
+        readonly closeAll: import("@elaraai/east").AsyncPlatformDefinition<[], import("@elaraai/east").NullType>;
+        /**
+         * Node.js implementation of Access platform functions.
+         *
+         * Pass this to East.compileAsync() to enable Access operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for Access operations.
+         */
+        readonly Types: {
+            /**
+             * Access connection configuration type.
+             */
+            readonly Config: import("@elaraai/east").StructType<{
+                readonly path: import("./types.js").StringType;
+                readonly password: import("@elaraai/east").OptionType<import("./types.js").StringType>;
+            }>;
+            /**
+             * Access query options type.
+             */
+            readonly QueryOptions: import("@elaraai/east").StructType<{
+                readonly table: import("./types.js").StringType;
+                readonly columns: import("@elaraai/east").OptionType<import("@elaraai/east").ArrayType<import("./types.js").StringType>>;
+                readonly rowOffset: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                readonly rowLimit: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * Access tables list result type.
+             */
+            readonly TablesResult: import("@elaraai/east").StructType<{
+                readonly tables: import("@elaraai/east").ArrayType<import("./types.js").StringType>;
+            }>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map