sqlparser-rs 0.60.3-rc1 → 0.60.3-rc3

package/README.md

@@ -26,25 +26,22 @@ npm install sqlparser-rs
 ## Quick Start
 
 ```typescript
-import { Parser, GenericDialect, PostgreSqlDialect } from 'sqlparser-rs';
+import { parse, format, validate } from 'sqlparser-rs';
 
-// Simple parsing
-const statements = Parser.parse('SELECT * FROM users', new GenericDialect());
+// Simple parsing (uses generic dialect by default)
+const statements = parse('SELECT * FROM users');
 console.log(statements);
 
-// With specific dialect
-const pgStatements = Parser.parse(
-  'SELECT * FROM users WHERE id = $1',
-  new PostgreSqlDialect()
-);
+// With specific dialect (string name)
+const pgStatements = parse('SELECT * FROM users WHERE id = $1', 'postgresql');
 
 // Format SQL
-const formatted = Parser.format('select   *   from   users', new GenericDialect());
+const formatted = format('select   *   from   users');
 console.log(formatted); // "SELECT * FROM users"
 
 // Validate SQL
 try {
-  Parser.validate('SELEC * FROM users', new GenericDialect());
+  validate('SELEC * FROM users');
 } catch (error) {
   console.log('Invalid SQL:', error.message);
 }
@@ -52,51 +49,93 @@ try {
 
 ## API
 
-### Parser
+### Top-Level Functions
 
-The main class for parsing SQL.
-
-#### Static Methods
+The simplest way to use the parser:
 
 ```typescript
-// Parse SQL into statements
-const statements = Parser.parse(sql: string, dialect: Dialect): Statement[];
-
-// Parse and return JSON string
-const json = Parser.parseToJson(sql: string, dialect: Dialect): string;
+import { parse, format, validate } from 'sqlparser-rs';
 
-// Parse and return formatted SQL string
-const formatted = Parser.parseToString(sql: string, dialect: Dialect): string;
+// Parse SQL - dialect defaults to 'generic'
+parse('SELECT * FROM users');
+parse('SELECT * FROM users', 'postgresql');
+parse('SELECT * FROM users', 'mysql');
 
 // Format SQL (round-trip through parser)
-const formatted = Parser.format(sql: string, dialect: Dialect): string;
+format('select * from users');  // "SELECT * FROM users"
+
+// Validate SQL syntax (throws ParserError if invalid)
+validate('SELECT * FROM users');  // true
+```
+
+### Dialect Options
+
+Dialects can be specified as strings or class instances:
+
+```typescript
+import { parse, PostgreSqlDialect } from 'sqlparser-rs';
 
-// Validate SQL syntax
-const isValid = Parser.validate(sql: string, dialect: Dialect): boolean;
+// String dialect names (recommended)
+parse('SELECT $1', 'postgresql');
+parse('SELECT `col` FROM t', 'mysql');
 
-// Get list of supported dialects
-const dialects = Parser.getSupportedDialects(): string[];
+// Or dialect instances
+parse('SELECT $1', new PostgreSqlDialect());
 ```
 
-#### Instance Methods (Builder Pattern)
+Supported dialect strings: `'generic'`, `'ansi'`, `'mysql'`, `'postgresql'`, `'sqlite'`, `'snowflake'`, `'redshift'`, `'mssql'`, `'clickhouse'`, `'bigquery'`, `'duckdb'`, `'databricks'`, `'hive'`, `'oracle'`
+
+### Parser Class
+
+For advanced use cases with options:
 
 ```typescript
 import { Parser, PostgreSqlDialect } from 'sqlparser-rs';
 
+// Static methods (same as top-level functions)
+Parser.parse('SELECT 1');
+Parser.parse('SELECT 1', 'postgresql');
+Parser.format('select 1');
+Parser.validate('SELECT 1');
+Parser.parseToJson('SELECT 1');      // Returns JSON string
+Parser.parseToString('SELECT 1');    // Returns formatted string
+Parser.getSupportedDialects();       // Returns dialect names
+
+// Builder pattern for custom options
 const parser = new Parser(new PostgreSqlDialect())
-  .withRecursionLimit(50)      // Set max recursion depth
-  .withOptions({               // Set parser options
-    trailingCommas: true
-  });
+  .withRecursionLimit(50)
+  .withOptions({ trailingCommas: true });
 
 const statements = parser.parse('SELECT * FROM users');
 ```
 
+### WASM Initialization
+
+The WASM module auto-initializes on import. For most use cases, no action is needed.
+
+If you need to ensure WASM is ready before calling sync APIs (e.g., in tests):
+
+```typescript
+import { ready, parse } from 'sqlparser-rs';
+
+// Wait for WASM to be ready
+await ready();
+
+// Now sync APIs are guaranteed to work
+const ast = parse('SELECT 1');
+```
+
 ### Dialects
 
-All dialects from the upstream Rust crate are supported:
+All dialects from the upstream Rust crate are supported. You can use string names directly with `parse()`, `format()`, and `validate()`:
 
 ```typescript
+// String names (recommended)
+parse('SELECT 1', 'postgresql');
+parse('SELECT 1', 'mysql');
+parse('SELECT 1', 'bigquery');
+
+// Or import dialect classes for type safety
 import {
   GenericDialect,      // Permissive, accepts most SQL syntax
   AnsiDialect,         // ANSI SQL standard
@@ -111,9 +150,10 @@ import {
   DuckDbDialect,       // DuckDB
   DatabricksDialect,   // Databricks
   HiveDialect,         // Apache Hive
+  OracleDialect,       // Oracle
 } from 'sqlparser-rs';
 
-// Create dialect from string
+// Create dialect from string programmatically
 import { dialectFromString } from 'sqlparser-rs';
 const dialect = dialectFromString('postgresql'); // Returns PostgreSqlDialect instance
 ```
@@ -121,10 +161,10 @@ const dialect = dialectFromString('postgresql'); // Returns PostgreSqlDialect in
 ### Error Handling
 
 ```typescript
-import { Parser, GenericDialect, ParserError } from 'sqlparser-rs';
+import { parse, ParserError } from 'sqlparser-rs';
 
 try {
-  Parser.parse('SELEC * FROM users', new GenericDialect());
+  parse('SELEC * FROM users');
 } catch (error) {
   if (error instanceof ParserError) {
     console.log('Parse error:', error.message);
@@ -140,9 +180,10 @@ try {
 Full TypeScript types are provided for the AST:
 
 ```typescript
-import type { Statement, Query, Expr, Ident, ObjectName } from 'sqlparser-rs';
+import { parse } from 'sqlparser-rs';
+import type { Statement, Query } from 'sqlparser-rs';
 
-const statements: Statement[] = Parser.parse('SELECT 1', new GenericDialect());
+const statements: Statement[] = parse('SELECT 1');
 
 // Statement is a discriminated union type
 for (const stmt of statements) {
@@ -155,6 +196,23 @@ for (const stmt of statements) {
 }
 ```
 
+## Bundler Configuration
+
+### Vite
+
+Exclude `sqlparser-rs` from dependency optimization to ensure WASM files load correctly:
+
+```typescript
+// vite.config.ts
+export default defineConfig({
+  optimizeDeps: {
+    exclude: ["sqlparser-rs"],
+  },
+});
+```
+
+This is required because Vite's pre-bundling breaks the WASM file path resolution.
+
 ## Development
 
 ### Prerequisites
@@ -191,7 +249,7 @@ npm test
 This package follows the upstream [sqlparser-rs](https://github.com/apache/datafusion-sqlparser-rs) version:
 
 - **Major.Minor** matches the upstream Rust crate version
-- **Patch** is for TypeScript binding fixes (e.g., `0.60.3-rc1` = upstream `0.60.0` + binding fix)
+- **Patch** is for TypeScript binding fixes (e.g., `0.60.3-rc3` = upstream `0.60.0` + binding fix)
 
 | This package | sqlparser-rs |
 |--------------|--------------|

package/dist/index.cjs

@@ -215,33 +215,45 @@ var WasmInitError = class WasmInitError extends Error {
 
 //#endregion
 //#region src/parser.ts
+function resolveDialect(dialect = "generic") {
+	if (typeof dialect === "string") {
+		const resolved = dialectFromString(dialect);
+		if (!resolved) throw new Error(`Unknown dialect: ${dialect}`);
+		return resolved;
+	}
+	return dialect;
+}
 let wasmModule = null;
-const isBrowser = typeof window !== "undefined" || typeof self !== "undefined";
+let initPromise = null;
+let initStarted = false;
+const isBrowser = typeof window !== "undefined" && typeof process === "undefined";
+function startInit() {
+	if (initStarted) return;
+	initStarted = true;
+	initPromise = initWasm().catch(() => {});
+}
+startInit();
 function getWasmModule() {
 	if (wasmModule) return wasmModule;
-	if (isBrowser) throw new WasmInitError("WASM module not initialized. Call initWasm() first in browser environments.");
-	try {
-		const nodeRequire = (0, eval)("require");
-		const nodeModule = nodeRequire("node:module");
-		const nodeUrl = nodeRequire("node:url");
-		const nodePath = nodeRequire("node:path");
-		const currentDir = nodePath.dirname(nodeUrl.fileURLToPath(require("url").pathToFileURL(__filename).href));
-		const wasmPath = nodePath.join(currentDir, "../wasm/sqlparser_rs_wasm.js");
-		wasmModule = nodeModule.createRequire(require("url").pathToFileURL(__filename).href)(wasmPath);
-		return wasmModule;
-	} catch (error) {
-		throw new WasmInitError(`Failed to load WASM module: ${error instanceof Error ? error.message : String(error)}`);
-	}
+	throw new WasmInitError("WASM module not yet initialized. Use the async import or wait for module to load: import(\"sqlparser-rs\").then(({ parse }) => parse(sql))");
+}
+/**
+* Wait for WASM to be ready (useful for ensuring sync APIs work)
+*/
+async function ready() {
+	startInit();
+	await initPromise;
 }
 /**
-* Initialize the WASM module for browser environments.
-* This must be called before using the Parser in browsers.
+* Initialize the WASM module.
+* This must be called before using the Parser in browsers and Node.js ESM.
+* In Node.js CommonJS, the module is loaded automatically.
 *
 * @example
 * ```typescript
 * import { initWasm, Parser, GenericDialect } from 'sqlparser-rs';
 *
-* // In browser, initialize first
+* // Initialize first
 * await initWasm();
 *
 * // Then use the parser
@@ -250,21 +262,28 @@ function getWasmModule() {
 */
 async function initWasm() {
 	if (wasmModule) return;
-	if (!isBrowser) {
-		getWasmModule();
+	if (isBrowser) {
+		try {
+			const wasmJsUrl = new URL("../wasm/sqlparser_rs_wasm_web.js", require("url").pathToFileURL(__filename).href);
+			const wasmBinaryUrl = new URL("../wasm/sqlparser_rs_wasm_web_bg.wasm", require("url").pathToFileURL(__filename).href);
+			const wasm = await import(
+				/* @vite-ignore */
+				wasmJsUrl.href
+);
+			if (typeof wasm.default === "function") await wasm.default(wasmBinaryUrl);
+			wasmModule = wasm;
+		} catch (error) {
+			throw new WasmInitError(`Failed to load WASM module in browser: ${error instanceof Error ? error.message : String(error)}`);
+		}
 		return;
 	}
 	try {
-		const wasmJsUrl = new URL("../wasm/sqlparser_rs_wasm_web.js", require("url").pathToFileURL(__filename).href);
-		const wasmBinaryUrl = new URL("../wasm/sqlparser_rs_wasm_web_bg.wasm", require("url").pathToFileURL(__filename).href);
-		const wasm = await import(
+		wasmModule = await import(
 			/* @vite-ignore */
-			wasmJsUrl.href
+			new URL("../wasm/sqlparser_rs_wasm.js", require("url").pathToFileURL(__filename).href).href
 );
-		if (typeof wasm.default === "function") await wasm.default(wasmBinaryUrl);
-		wasmModule = wasm;
 	} catch (error) {
-		throw new WasmInitError(`Failed to load WASM module in browser: ${error instanceof Error ? error.message : String(error)}`);
+		throw new WasmInitError(`Failed to load WASM module: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
 /**
@@ -339,28 +358,35 @@ var Parser = class Parser {
 	* Parse SQL statements
 	*
 	* @param sql - SQL string to parse
-	* @param dialect - SQL dialect to use
+	* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
 	* @returns Array of parsed statements
 	*
 	* @example
 	* ```typescript
-	* const statements = Parser.parse('SELECT 1', new GenericDialect());
+	* // Using default dialect
+	* const statements = Parser.parse('SELECT 1');
+	*
+	* // Using string dialect name
+	* const pgStatements = Parser.parse('SELECT $1', 'postgresql');
+	*
+	* // Using dialect instance
+	* const mysqlStatements = Parser.parse('SELECT 1', new MySqlDialect());
 	* ```
 	*/
-	static parse(sql, dialect = new GenericDialect()) {
-		return new Parser(dialect).parse(sql);
+	static parse(sql, dialect = "generic") {
+		return new Parser(resolveDialect(dialect)).parse(sql);
 	}
 	/**
 	* Parse SQL and return the AST as a JSON string
 	*
 	* @param sql - SQL string to parse
-	* @param dialect - SQL dialect to use
+	* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
 	* @returns JSON string representation of the AST
 	*/
-	static parseToJson(sql, dialect = new GenericDialect()) {
+	static parseToJson(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.parse_sql_to_json_string(dialect.name, sql);
+			return wasm.parse_sql_to_json_string(resolveDialect(dialect).name, sql);
 		} catch (error) {
 			throw ParserError.fromWasmError(error);
 		}
@@ -369,13 +395,13 @@ var Parser = class Parser {
 	* Parse SQL and return a formatted string representation
 	*
 	* @param sql - SQL string to parse
-	* @param dialect - SQL dialect to use
+	* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
 	* @returns String representation of the parsed SQL
 	*/
-	static parseToString(sql, dialect = new GenericDialect()) {
+	static parseToString(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.parse_sql_to_string(dialect.name, sql);
+			return wasm.parse_sql_to_string(resolveDialect(dialect).name, sql);
 		} catch (error) {
 			throw ParserError.fromWasmError(error);
 		}
@@ -384,13 +410,13 @@ var Parser = class Parser {
 	* Format SQL by parsing and regenerating it (round-trip)
 	*
 	* @param sql - SQL string to format
-	* @param dialect - SQL dialect to use
+	* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
 	* @returns Formatted SQL string
 	*/
-	static format(sql, dialect = new GenericDialect()) {
+	static format(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.format_sql(dialect.name, sql);
+			return wasm.format_sql(resolveDialect(dialect).name, sql);
 		} catch (error) {
 			throw ParserError.fromWasmError(error);
 		}
@@ -399,13 +425,13 @@ var Parser = class Parser {
 	* Validate SQL syntax without returning the full AST
 	*
 	* @param sql - SQL string to validate
-	* @param dialect - SQL dialect to use
+	* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
 	* @returns true if valid, throws ParserError if invalid
 	*/
-	static validate(sql, dialect = new GenericDialect()) {
+	static validate(sql, dialect = "generic") {
 		const wasm = getWasmModule();
 		try {
-			return wasm.validate_sql(dialect.name, sql);
+			return wasm.validate_sql(resolveDialect(dialect).name, sql);
 		} catch (error) {
 			throw ParserError.fromWasmError(error);
 		}
@@ -417,6 +443,61 @@ var Parser = class Parser {
 		return getWasmModule().get_supported_dialects();
 	}
 };
+/**
+* Parse SQL statements (convenience function)
+*
+* @param sql - SQL string to parse
+* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
+* @returns Array of parsed statements
+*
+* @example
+* ```typescript
+* import { parse } from 'sqlparser-rs';
+*
+* const statements = parse('SELECT * FROM users');
+* const pgStatements = parse('SELECT $1', 'postgresql');
+* ```
+*/
+function parse(sql, dialect = "generic") {
+	return Parser.parse(sql, dialect);
+}
+/**
+* Validate SQL syntax (convenience function)
+*
+* @param sql - SQL string to validate
+* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
+* @returns true if valid, throws ParserError if invalid
+*
+* @example
+* ```typescript
+* import { validate } from 'sqlparser-rs';
+*
+* if (validate('SELECT * FROM users')) {
+*   console.log('Valid SQL!');
+* }
+* ```
+*/
+function validate(sql, dialect = "generic") {
+	return Parser.validate(sql, dialect);
+}
+/**
+* Format SQL by parsing and regenerating it (convenience function)
+*
+* @param sql - SQL string to format
+* @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
+* @returns Formatted SQL string
+*
+* @example
+* ```typescript
+* import { format } from 'sqlparser-rs';
+*
+* const formatted = format('select * from users');
+* // Returns: "SELECT * FROM users"
+* ```
+*/
+function format(sql, dialect = "generic") {
+	return Parser.format(sql, dialect);
+}
 
 //#endregion
 exports.AnsiDialect = AnsiDialect;
@@ -438,4 +519,8 @@ exports.SUPPORTED_DIALECTS = SUPPORTED_DIALECTS;
 exports.SnowflakeDialect = SnowflakeDialect;
 exports.WasmInitError = WasmInitError;
 exports.dialectFromString = dialectFromString;
-exports.initWasm = initWasm;
+exports.format = format;
+exports.initWasm = initWasm;
+exports.parse = parse;
+exports.ready = ready;
+exports.validate = validate;

package/dist/index.d.cts

@@ -1216,6 +1216,8 @@ type MergeClause = {
 type CommentObject = 'Column' | 'Table';
 //#endregion
 //#region src/parser.d.ts
+/** Dialect can be specified as a Dialect instance or a string name */
+type DialectInput = Dialect | DialectName;
 /**
  * Parser options
  */
@@ -1230,14 +1232,19 @@ interface ParserOptions {
   recursionLimit?: number;
 }
 /**
- * Initialize the WASM module for browser environments.
- * This must be called before using the Parser in browsers.
+ * Wait for WASM to be ready (useful for ensuring sync APIs work)
+ */
+declare function ready(): Promise<void>;
+/**
+ * Initialize the WASM module.
+ * This must be called before using the Parser in browsers and Node.js ESM.
+ * In Node.js CommonJS, the module is loaded automatically.
  *
  * @example
  * ```typescript
  * import { initWasm, Parser, GenericDialect } from 'sqlparser-rs';
  *
- * // In browser, initialize first
+ * // Initialize first
  * await initWasm();
  *
  * // Then use the parser
@@ -1299,52 +1306,108 @@ declare class Parser {
    * Parse SQL statements
    *
    * @param sql - SQL string to parse
-   * @param dialect - SQL dialect to use
+   * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
    * @returns Array of parsed statements
    *
    * @example
    * ```typescript
-   * const statements = Parser.parse('SELECT 1', new GenericDialect());
+   * // Using default dialect
+   * const statements = Parser.parse('SELECT 1');
+   *
+   * // Using string dialect name
+   * const pgStatements = Parser.parse('SELECT $1', 'postgresql');
+   *
+   * // Using dialect instance
+   * const mysqlStatements = Parser.parse('SELECT 1', new MySqlDialect());
    * ```
    */
-  static parse(sql: string, dialect?: Dialect): Statement[];
+  static parse(sql: string, dialect?: DialectInput): Statement[];
   /**
    * Parse SQL and return the AST as a JSON string
    *
    * @param sql - SQL string to parse
-   * @param dialect - SQL dialect to use
+   * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
    * @returns JSON string representation of the AST
    */
-  static parseToJson(sql: string, dialect?: Dialect): string;
+  static parseToJson(sql: string, dialect?: DialectInput): string;
   /**
    * Parse SQL and return a formatted string representation
    *
    * @param sql - SQL string to parse
-   * @param dialect - SQL dialect to use
+   * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
    * @returns String representation of the parsed SQL
    */
-  static parseToString(sql: string, dialect?: Dialect): string;
+  static parseToString(sql: string, dialect?: DialectInput): string;
   /**
    * Format SQL by parsing and regenerating it (round-trip)
    *
    * @param sql - SQL string to format
-   * @param dialect - SQL dialect to use
+   * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
    * @returns Formatted SQL string
    */
-  static format(sql: string, dialect?: Dialect): string;
+  static format(sql: string, dialect?: DialectInput): string;
   /**
    * Validate SQL syntax without returning the full AST
    *
    * @param sql - SQL string to validate
-   * @param dialect - SQL dialect to use
+   * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
    * @returns true if valid, throws ParserError if invalid
    */
-  static validate(sql: string, dialect?: Dialect): boolean;
+  static validate(sql: string, dialect?: DialectInput): boolean;
   /**
    * Get the list of supported dialect names
    */
   static getSupportedDialects(): string[];
 }
+/**
+ * Parse SQL statements (convenience function)
+ *
+ * @param sql - SQL string to parse
+ * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
+ * @returns Array of parsed statements
+ *
+ * @example
+ * ```typescript
+ * import { parse } from 'sqlparser-rs';
+ *
+ * const statements = parse('SELECT * FROM users');
+ * const pgStatements = parse('SELECT $1', 'postgresql');
+ * ```
+ */
+declare function parse(sql: string, dialect?: DialectInput): Statement[];
+/**
+ * Validate SQL syntax (convenience function)
+ *
+ * @param sql - SQL string to validate
+ * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
+ * @returns true if valid, throws ParserError if invalid
+ *
+ * @example
+ * ```typescript
+ * import { validate } from 'sqlparser-rs';
+ *
+ * if (validate('SELECT * FROM users')) {
+ *   console.log('Valid SQL!');
+ * }
+ * ```
+ */
+declare function validate(sql: string, dialect?: DialectInput): boolean;
+/**
+ * Format SQL by parsing and regenerating it (convenience function)
+ *
+ * @param sql - SQL string to format
+ * @param dialect - SQL dialect to use (string name or Dialect instance, defaults to 'generic')
+ * @returns Formatted SQL string
+ *
+ * @example
+ * ```typescript
+ * import { format } from 'sqlparser-rs';
+ *
+ * const formatted = format('select * from users');
+ * // Returns: "SELECT * FROM users"
+ * ```
+ */
+declare function format(sql: string, dialect?: DialectInput): string;
 //#endregion
 //#region src/types/errors.d.ts
 /**
@@ -1372,4 +1435,4 @@ declare class WasmInitError extends Error {
   constructor(message: string);
 }
 //#endregion
-export { Action, AlterColumnOperation, AlterTableOperation, AnsiDialect, Assignment, BigQueryDialect, BinaryOperator, ClickHouseDialect, CloseCursor, ColumnDef, ColumnOption, ColumnOptionDef, CommentObject, CopyLegacyOption, CopyOption, CopySource, CopyTarget, Cte, DataType, DatabricksDialect, DateTimeField, DescribeAlias, type Dialect, type DialectName, DiscardObject, Distinct, DoUpdate, DropStatement, DuckDbDialect, ErrorLocation, ExceptSelectItem, ExcludeSelectItem, Expr, Fetch, FetchDirection, FileFormat, ForeignKeyOption, FunctionArg, FunctionArgExpr, FunctionExpr, GeneratedAs, GeneratedExpressionMode, GenericDialect, GrantObjects, GroupByExpr, HiveDialect, HiveDistributionStyle, HiveFormat, HiveIOFormat, HiveRowFormat, Ident, IdentWithAlias, IndexType, IntervalExpr, Join, JoinConstraint, JoinOperator, LateralView, LockClause, LockType, MergeClause, MsSqlDialect, MySqlDialect, NamedWindowDefinition, NonBlock, ObjectName, ObjectType, Offset, OffsetRows, OnCommit, OnInsert, OracleDialect, OrderByExpr, Parser, ParserError, type ParserOptions, PostgreSqlDialect, Privileges, Query, RedshiftDialect, ReferentialAction, RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, SQLiteDialect, SUPPORTED_DIALECTS, SchemaName, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier, ShowCreateObject, ShowStatementFilter, SnowflakeDialect, SqlOption, SqliteOnConflict, Statement, TableAlias, TableConstraint, TableFactor, TableWithJoins, Top, TransactionAccessMode, TransactionIsolationLevel, TransactionMode, TrimWhereField, UnaryOperator, Value, Values, WasmInitError, WildcardAdditionalOptions, WindowFrame, WindowFrameBound, WindowFrameUnits, WindowSpec, With, dialectFromString, initWasm };
+export { Action, AlterColumnOperation, AlterTableOperation, AnsiDialect, Assignment, BigQueryDialect, BinaryOperator, ClickHouseDialect, CloseCursor, ColumnDef, ColumnOption, ColumnOptionDef, CommentObject, CopyLegacyOption, CopyOption, CopySource, CopyTarget, Cte, DataType, DatabricksDialect, DateTimeField, DescribeAlias, type Dialect, type DialectInput, type DialectName, DiscardObject, Distinct, DoUpdate, DropStatement, DuckDbDialect, ErrorLocation, ExceptSelectItem, ExcludeSelectItem, Expr, Fetch, FetchDirection, FileFormat, ForeignKeyOption, FunctionArg, FunctionArgExpr, FunctionExpr, GeneratedAs, GeneratedExpressionMode, GenericDialect, GrantObjects, GroupByExpr, HiveDialect, HiveDistributionStyle, HiveFormat, HiveIOFormat, HiveRowFormat, Ident, IdentWithAlias, IndexType, IntervalExpr, Join, JoinConstraint, JoinOperator, LateralView, LockClause, LockType, MergeClause, MsSqlDialect, MySqlDialect, NamedWindowDefinition, NonBlock, ObjectName, ObjectType, Offset, OffsetRows, OnCommit, OnInsert, OracleDialect, OrderByExpr, Parser, ParserError, type ParserOptions, PostgreSqlDialect, Privileges, Query, RedshiftDialect, ReferentialAction, RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, SQLiteDialect, SUPPORTED_DIALECTS, SchemaName, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier, ShowCreateObject, ShowStatementFilter, SnowflakeDialect, SqlOption, SqliteOnConflict, Statement, TableAlias, TableConstraint, TableFactor, TableWithJoins, Top, TransactionAccessMode, TransactionIsolationLevel, TransactionMode, TrimWhereField, UnaryOperator, Value, Values, WasmInitError, WildcardAdditionalOptions, WindowFrame, WindowFrameBound, WindowFrameUnits, WindowSpec, With, dialectFromString, format, initWasm, parse, ready, validate };