@elaraai/east-node-io 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/sql/index.d.ts

@@ -0,0 +1,777 @@
+/**
+ * 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 "./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<{
+            path: import("./types.js").StringType;
+            readOnly: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            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<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("./types.js").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").VariantType<{
+            select: import("@elaraai/east").StructType<{
+                rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                    Null: import("@elaraai/east").NullType;
+                    Boolean: import("@elaraai/east").BooleanType;
+                    Integer: import("@elaraai/east").IntegerType;
+                    Float: import("@elaraai/east").FloatType;
+                    String: import("./types.js").StringType;
+                    DateTime: import("@elaraai/east").DateTimeType;
+                    Blob: import("@elaraai/east").BlobType;
+                }>>>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+                lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            update: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+            delete: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+        }>>;
+        /**
+         * 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<{
+                path: import("./types.js").StringType;
+                readOnly: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+                memory: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            }>;
+            /**
+             * SQL query parameter value type.
+             */
+            readonly Parameter: import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * Array of SQL query parameters.
+             */
+            readonly Parameters: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query result row type.
+             */
+            readonly Row: import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query execution result type.
+             */
+            readonly Result: import("@elaraai/east").VariantType<{
+                select: import("@elaraai/east").StructType<{
+                    rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                        Null: import("@elaraai/east").NullType;
+                        Boolean: import("@elaraai/east").BooleanType;
+                        Integer: import("@elaraai/east").IntegerType;
+                        Float: import("@elaraai/east").FloatType;
+                        String: import("./types.js").StringType;
+                        DateTime: import("@elaraai/east").DateTimeType;
+                        Blob: import("@elaraai/east").BlobType;
+                    }>>>;
+                }>;
+                insert: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                    lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                update: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+                delete: import("@elaraai/east").StructType<{
+                    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<{
+            host: import("./types.js").StringType;
+            port: import("@elaraai/east").IntegerType;
+            database: import("./types.js").StringType;
+            user: import("./types.js").StringType;
+            password: import("./types.js").StringType;
+            ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            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<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("./types.js").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").VariantType<{
+            select: import("@elaraai/east").StructType<{
+                rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                    Null: import("@elaraai/east").NullType;
+                    Boolean: import("@elaraai/east").BooleanType;
+                    Integer: import("@elaraai/east").IntegerType;
+                    Float: import("@elaraai/east").FloatType;
+                    String: import("./types.js").StringType;
+                    DateTime: import("@elaraai/east").DateTimeType;
+                    Blob: import("@elaraai/east").BlobType;
+                }>>>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+                lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            update: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+            delete: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+        }>>;
+        /**
+         * 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<{
+                host: import("./types.js").StringType;
+                port: import("@elaraai/east").IntegerType;
+                database: import("./types.js").StringType;
+                user: import("./types.js").StringType;
+                password: import("./types.js").StringType;
+                ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+                maxConnections: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * SQL query parameter value type.
+             */
+            readonly Parameter: import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * Array of SQL query parameters.
+             */
+            readonly Parameters: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query result row type.
+             */
+            readonly Row: import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query execution result type.
+             */
+            readonly Result: import("@elaraai/east").VariantType<{
+                select: import("@elaraai/east").StructType<{
+                    rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                        Null: import("@elaraai/east").NullType;
+                        Boolean: import("@elaraai/east").BooleanType;
+                        Integer: import("@elaraai/east").IntegerType;
+                        Float: import("@elaraai/east").FloatType;
+                        String: import("./types.js").StringType;
+                        DateTime: import("@elaraai/east").DateTimeType;
+                        Blob: import("@elaraai/east").BlobType;
+                    }>>>;
+                }>;
+                insert: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                    lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                update: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+                delete: import("@elaraai/east").StructType<{
+                    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<{
+            host: import("./types.js").StringType;
+            port: import("@elaraai/east").IntegerType;
+            database: import("./types.js").StringType;
+            user: import("./types.js").StringType;
+            password: import("./types.js").StringType;
+            ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+            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<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("./types.js").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").VariantType<{
+            select: import("@elaraai/east").StructType<{
+                rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                    Null: import("@elaraai/east").NullType;
+                    Boolean: import("@elaraai/east").BooleanType;
+                    Integer: import("@elaraai/east").IntegerType;
+                    Float: import("@elaraai/east").FloatType;
+                    String: import("./types.js").StringType;
+                    DateTime: import("@elaraai/east").DateTimeType;
+                    Blob: import("@elaraai/east").BlobType;
+                }>>>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+                lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            update: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+            delete: import("@elaraai/east").StructType<{
+                rowsAffected: import("@elaraai/east").IntegerType;
+            }>;
+        }>>;
+        /**
+         * 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<{
+                host: import("./types.js").StringType;
+                port: import("@elaraai/east").IntegerType;
+                database: import("./types.js").StringType;
+                user: import("./types.js").StringType;
+                password: import("./types.js").StringType;
+                ssl: import("@elaraai/east").OptionType<import("@elaraai/east").BooleanType>;
+                maxConnections: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * SQL query parameter value type.
+             */
+            readonly Parameter: import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * Array of SQL query parameters.
+             */
+            readonly Parameters: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query result row type.
+             */
+            readonly Row: import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("./types.js").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * SQL query execution result type.
+             */
+            readonly Result: import("@elaraai/east").VariantType<{
+                select: import("@elaraai/east").StructType<{
+                    rows: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("./types.js").StringType, import("@elaraai/east").VariantType<{
+                        Null: import("@elaraai/east").NullType;
+                        Boolean: import("@elaraai/east").BooleanType;
+                        Integer: import("@elaraai/east").IntegerType;
+                        Float: import("@elaraai/east").FloatType;
+                        String: import("./types.js").StringType;
+                        DateTime: import("@elaraai/east").DateTimeType;
+                        Blob: import("@elaraai/east").BlobType;
+                    }>>>;
+                }>;
+                insert: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                    lastInsertId: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                }>;
+                update: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+                delete: import("@elaraai/east").StructType<{
+                    rowsAffected: import("@elaraai/east").IntegerType;
+                }>;
+            }>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map