@qualithm/arrow-flight-sql-js 1.0.0 → 1.2.0

package/dist/generated/arrow/flight/protocol/sql/FlightSql.d.ts

@@ -0,0 +1,2183 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "arrow.flight.protocol.sql";
+/** Options for CommandGetSqlInfo. */
+export declare const SqlInfo: {
+    /** FLIGHT_SQL_SERVER_NAME - Retrieves a UTF-8 string with the name of the Flight SQL Server. */
+    readonly FLIGHT_SQL_SERVER_NAME: 0;
+    /** FLIGHT_SQL_SERVER_VERSION - Retrieves a UTF-8 string with the native version of the Flight SQL Server. */
+    readonly FLIGHT_SQL_SERVER_VERSION: 1;
+    /** FLIGHT_SQL_SERVER_ARROW_VERSION - Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server. */
+    readonly FLIGHT_SQL_SERVER_ARROW_VERSION: 2;
+    /**
+     * FLIGHT_SQL_SERVER_READ_ONLY - Retrieves a boolean value indicating whether the Flight SQL Server is read only.
+     *
+     * Returns:
+     * - false: if read-write
+     * - true: if read only
+     */
+    readonly FLIGHT_SQL_SERVER_READ_ONLY: 3;
+    /**
+     * FLIGHT_SQL_SERVER_SQL - Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+     * SQL queries.
+     *
+     * Note that the absence of this info (as opposed to a false value) does not necessarily
+     * mean that SQL is not supported, as this property was not originally defined.
+     */
+    readonly FLIGHT_SQL_SERVER_SQL: 4;
+    /**
+     * FLIGHT_SQL_SERVER_SUBSTRAIT - Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+     * Substrait plans.
+     */
+    readonly FLIGHT_SQL_SERVER_SUBSTRAIT: 5;
+    /**
+     * FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION - Retrieves a string value indicating the minimum supported Substrait version, or null
+     * if Substrait is not supported.
+     */
+    readonly FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION: 6;
+    /**
+     * FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION - Retrieves a string value indicating the maximum supported Substrait version, or null
+     * if Substrait is not supported.
+     */
+    readonly FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION: 7;
+    /**
+     * FLIGHT_SQL_SERVER_TRANSACTION - Retrieves an int32 indicating whether the Flight SQL Server supports the
+     * BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
+     *
+     * Even if this is not supported, the database may still support explicit "BEGIN
+     * TRANSACTION"/"COMMIT" SQL statements (see SQL_TRANSACTIONS_SUPPORTED); this property
+     * is only about whether the server implements the Flight SQL API endpoints.
+     *
+     * The possible values are listed in `SqlSupportedTransaction`.
+     */
+    readonly FLIGHT_SQL_SERVER_TRANSACTION: 8;
+    /**
+     * FLIGHT_SQL_SERVER_CANCEL - Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
+     * query cancellation (the CancelQuery action).
+     */
+    readonly FLIGHT_SQL_SERVER_CANCEL: 9;
+    /**
+     * FLIGHT_SQL_SERVER_BULK_INGESTION - Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+     * bulk ingestion.
+     */
+    readonly FLIGHT_SQL_SERVER_BULK_INGESTION: 10;
+    /**
+     * FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED - Retrieves a boolean value indicating whether transactions are supported for bulk ingestion. If not, invoking
+     * the method commit in the context of a bulk ingestion is a noop, and the isolation level is
+     * `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
+     *
+     * Returns:
+     * - false: if bulk ingestion transactions are unsupported;
+     * - true: if bulk ingestion transactions are supported.
+     */
+    readonly FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED: 11;
+    /**
+     * FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT - Retrieves an int32 indicating the timeout (in milliseconds) for prepared statement handles.
+     *
+     * If 0, there is no timeout.  Servers should reset the timeout when the handle is used in a command.
+     */
+    readonly FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT: 100;
+    /**
+     * FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT - Retrieves an int32 indicating the timeout (in milliseconds) for transactions, since transactions are not tied to a connection.
+     *
+     * If 0, there is no timeout.  Servers should reset the timeout when the handle is used in a command.
+     */
+    readonly FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT: 101;
+    /**
+     * SQL_DDL_CATALOG - Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
+     *
+     * Returns:
+     * - false: if it doesn't support CREATE and DROP of catalogs.
+     * - true: if it supports CREATE and DROP of catalogs.
+     */
+    readonly SQL_DDL_CATALOG: 500;
+    /**
+     * SQL_DDL_SCHEMA - Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of schemas.
+     *
+     * Returns:
+     * - false: if it doesn't support CREATE and DROP of schemas.
+     * - true: if it supports CREATE and DROP of schemas.
+     */
+    readonly SQL_DDL_SCHEMA: 501;
+    /**
+     * SQL_DDL_TABLE - Indicates whether the Flight SQL Server supports CREATE and DROP of tables.
+     *
+     * Returns:
+     * - false: if it doesn't support CREATE and DROP of tables.
+     * - true: if it supports CREATE and DROP of tables.
+     */
+    readonly SQL_DDL_TABLE: 502;
+    /**
+     * SQL_IDENTIFIER_CASE - Retrieves an int32 ordinal representing the case sensitivity of catalog, table, schema and table names.
+     *
+     * The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+     */
+    readonly SQL_IDENTIFIER_CASE: 503;
+    /** SQL_IDENTIFIER_QUOTE_CHAR - Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier. */
+    readonly SQL_IDENTIFIER_QUOTE_CHAR: 504;
+    /**
+     * SQL_QUOTED_IDENTIFIER_CASE - Retrieves an int32 describing the case sensitivity of quoted identifiers.
+     *
+     * The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+     */
+    readonly SQL_QUOTED_IDENTIFIER_CASE: 505;
+    /**
+     * SQL_ALL_TABLES_ARE_SELECTABLE - Retrieves a boolean value indicating whether all tables are selectable.
+     *
+     * Returns:
+     * - false: if not all tables are selectable or if none are;
+     * - true: if all tables are selectable.
+     */
+    readonly SQL_ALL_TABLES_ARE_SELECTABLE: 506;
+    /**
+     * SQL_NULL_ORDERING - Retrieves the null ordering.
+     *
+     * Returns an int32 ordinal for the null ordering being used, as described in
+     * `arrow.flight.protocol.sql.SqlNullOrdering`.
+     */
+    readonly SQL_NULL_ORDERING: 507;
+    /** SQL_KEYWORDS - Retrieves a UTF-8 string list with values of the supported keywords. */
+    readonly SQL_KEYWORDS: 508;
+    /** SQL_NUMERIC_FUNCTIONS - Retrieves a UTF-8 string list with values of the supported numeric functions. */
+    readonly SQL_NUMERIC_FUNCTIONS: 509;
+    /** SQL_STRING_FUNCTIONS - Retrieves a UTF-8 string list with values of the supported string functions. */
+    readonly SQL_STRING_FUNCTIONS: 510;
+    /** SQL_SYSTEM_FUNCTIONS - Retrieves a UTF-8 string list with values of the supported system functions. */
+    readonly SQL_SYSTEM_FUNCTIONS: 511;
+    /** SQL_DATETIME_FUNCTIONS - Retrieves a UTF-8 string list with values of the supported datetime functions. */
+    readonly SQL_DATETIME_FUNCTIONS: 512;
+    /**
+     * SQL_SEARCH_STRING_ESCAPE - Retrieves the UTF-8 string that can be used to escape wildcard characters.
+     * This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern
+     * (and therefore use one of the wildcard characters).
+     * The '_' character represents any single character; the '%' character represents any sequence of zero or more
+     * characters.
+     */
+    readonly SQL_SEARCH_STRING_ESCAPE: 513;
+    /**
+     * SQL_EXTRA_NAME_CHARACTERS - Retrieves a UTF-8 string with all the "extra" characters that can be used in unquoted identifier names
+     * (those beyond a-z, A-Z, 0-9 and _).
+     */
+    readonly SQL_EXTRA_NAME_CHARACTERS: 514;
+    /**
+     * SQL_SUPPORTS_COLUMN_ALIASING - Retrieves a boolean value indicating whether column aliasing is supported.
+     * If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns
+     * as required.
+     *
+     * Returns:
+     * - false: if column aliasing is unsupported;
+     * - true: if column aliasing is supported.
+     */
+    readonly SQL_SUPPORTS_COLUMN_ALIASING: 515;
+    /**
+     * SQL_NULL_PLUS_NULL_IS_NULL - Retrieves a boolean value indicating whether concatenations between null and non-null values being
+     * null are supported.
+     *
+     * Returns:
+     * - false: if concatenations between null and non-null values being null are unsupported;
+     * - true: if concatenations between null and non-null values being null are supported.
+     */
+    readonly SQL_NULL_PLUS_NULL_IS_NULL: 516;
+    /**
+     * SQL_SUPPORTS_CONVERT - Retrieves a map where the key is the type to convert from and the value is a list with the types to convert to,
+     * indicating the supported conversions. Each key and each item on the list value is a value to a predefined type on
+     * SqlSupportsConvert enum.
+     * The returned map will be:  map<int32, list<int32>>
+     */
+    readonly SQL_SUPPORTS_CONVERT: 517;
+    /**
+     * SQL_SUPPORTS_TABLE_CORRELATION_NAMES - Retrieves a boolean value indicating whether, when table correlation names are supported,
+     * they are restricted to being different from the names of the tables.
+     *
+     * Returns:
+     * - false: if table correlation names are unsupported;
+     * - true: if table correlation names are supported.
+     */
+    readonly SQL_SUPPORTS_TABLE_CORRELATION_NAMES: 518;
+    /**
+     * SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES - Retrieves a boolean value indicating whether, when table correlation names are supported,
+     * they are restricted to being different from the names of the tables.
+     *
+     * Returns:
+     * - false: if different table correlation names are unsupported;
+     * - true: if different table correlation names are supported
+     */
+    readonly SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES: 519;
+    /**
+     * SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY - Retrieves a boolean value indicating whether expressions in ORDER BY lists are supported.
+     *
+     * Returns:
+     * - false: if expressions in ORDER BY are unsupported;
+     * - true: if expressions in ORDER BY are supported;
+     */
+    readonly SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY: 520;
+    /**
+     * SQL_SUPPORTS_ORDER_BY_UNRELATED - Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
+     * clause is supported.
+     *
+     * Returns:
+     * - false: if using a column that is not in the SELECT statement in a GROUP BY clause is unsupported;
+     * - true: if using a column that is not in the SELECT statement in a GROUP BY clause is supported.
+     */
+    readonly SQL_SUPPORTS_ORDER_BY_UNRELATED: 521;
+    /**
+     * SQL_SUPPORTED_GROUP_BY - Retrieves the supported GROUP BY commands;
+     *
+     * Returns an int32 bitmask value representing the supported commands.
+     * The returned bitmask should be parsed in order to retrieve the supported commands.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (GROUP BY is unsupported);
+     * - return 1 (\b1)   => [SQL_GROUP_BY_UNRELATED];
+     * - return 2 (\b10)  => [SQL_GROUP_BY_BEYOND_SELECT];
+     * - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
+     * Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
+     */
+    readonly SQL_SUPPORTED_GROUP_BY: 522;
+    /**
+     * SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE - Retrieves a boolean value indicating whether specifying a LIKE escape clause is supported.
+     *
+     * Returns:
+     * - false: if specifying a LIKE escape clause is unsupported;
+     * - true: if specifying a LIKE escape clause is supported.
+     */
+    readonly SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE: 523;
+    /**
+     * SQL_SUPPORTS_NON_NULLABLE_COLUMNS - Retrieves a boolean value indicating whether columns may be defined as non-nullable.
+     *
+     * Returns:
+     * - false: if columns cannot be defined as non-nullable;
+     * - true: if columns may be defined as non-nullable.
+     */
+    readonly SQL_SUPPORTS_NON_NULLABLE_COLUMNS: 524;
+    /**
+     * SQL_SUPPORTED_GRAMMAR - Retrieves the supported SQL grammar level as per the ODBC specification.
+     *
+     * Returns an int32 bitmask value representing the supported SQL grammar level.
+     * The returned bitmask should be parsed in order to retrieve the supported grammar levels.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (SQL grammar is unsupported);
+     * - return 1 (\b1)   => [SQL_MINIMUM_GRAMMAR];
+     * - return 2 (\b10)  => [SQL_CORE_GRAMMAR];
+     * - return 3 (\b11)  => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR];
+     * - return 4 (\b100) => [SQL_EXTENDED_GRAMMAR];
+     * - return 5 (\b101) => [SQL_MINIMUM_GRAMMAR, SQL_EXTENDED_GRAMMAR];
+     * - return 6 (\b110) => [SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR];
+     * - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
+     * Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
+     */
+    readonly SQL_SUPPORTED_GRAMMAR: 525;
+    /**
+     * SQL_ANSI92_SUPPORTED_LEVEL - Retrieves the supported ANSI92 SQL grammar level.
+     *
+     * Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
+     * The returned bitmask should be parsed in order to retrieve the supported commands.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (ANSI92 SQL grammar is unsupported);
+     * - return 1 (\b1)   => [ANSI92_ENTRY_SQL];
+     * - return 2 (\b10)  => [ANSI92_INTERMEDIATE_SQL];
+     * - return 3 (\b11)  => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL];
+     * - return 4 (\b100) => [ANSI92_FULL_SQL];
+     * - return 5 (\b101) => [ANSI92_ENTRY_SQL, ANSI92_FULL_SQL];
+     * - return 6 (\b110) => [ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL];
+     * - return 7 (\b111) => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL].
+     * Valid ANSI92 SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevel`.
+     */
+    readonly SQL_ANSI92_SUPPORTED_LEVEL: 526;
+    /**
+     * SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY - Retrieves a boolean value indicating whether the SQL Integrity Enhancement Facility is supported.
+     *
+     * Returns:
+     * - false: if the SQL Integrity Enhancement Facility is unsupported;
+     * - true: if the SQL Integrity Enhancement Facility is supported.
+     */
+    readonly SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY: 527;
+    /**
+     * SQL_OUTER_JOINS_SUPPORT_LEVEL - Retrieves the support level for SQL OUTER JOINs.
+     *
+     * Returns an int32 ordinal for the SQL ordering being used, as described in
+     * `arrow.flight.protocol.sql.SqlOuterJoinsSupportLevel`.
+     */
+    readonly SQL_OUTER_JOINS_SUPPORT_LEVEL: 528;
+    /** SQL_SCHEMA_TERM - Retrieves a UTF-8 string with the preferred term for "schema". */
+    readonly SQL_SCHEMA_TERM: 529;
+    /** SQL_PROCEDURE_TERM - Retrieves a UTF-8 string with the preferred term for "procedure". */
+    readonly SQL_PROCEDURE_TERM: 530;
+    /**
+     * SQL_CATALOG_TERM - Retrieves a UTF-8 string with the preferred term for "catalog".
+     * If an empty string is returned it is assumed that the server does NOT support catalogs.
+     */
+    readonly SQL_CATALOG_TERM: 531;
+    /**
+     * SQL_CATALOG_AT_START - Retrieves a boolean value indicating whether a catalog appears at the start of a fully qualified table name.
+     *
+     * - false: if a catalog does not appear at the start of a fully qualified table name;
+     * - true: if a catalog appears at the start of a fully qualified table name.
+     */
+    readonly SQL_CATALOG_AT_START: 532;
+    /**
+     * SQL_SCHEMAS_SUPPORTED_ACTIONS - Retrieves the supported actions for a SQL schema.
+     *
+     * Returns an int32 bitmask value representing the supported actions for a SQL schema.
+     * The returned bitmask should be parsed in order to retrieve the supported actions for a SQL schema.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported actions for SQL schema);
+     * - return 1 (\b1)   => [SQL_ELEMENT_IN_PROCEDURE_CALLS];
+     * - return 2 (\b10)  => [SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+     * - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+     * - return 4 (\b100) => [SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+     * - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+     * - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+     * - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
+     * Valid actions for a SQL schema are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
+     */
+    readonly SQL_SCHEMAS_SUPPORTED_ACTIONS: 533;
+    /**
+     * SQL_CATALOGS_SUPPORTED_ACTIONS - Retrieves the supported actions for a SQL catalog.
+     *
+     * Returns an int32 bitmask value representing the supported actions for a SQL catalog.
+     * The returned bitmask should be parsed in order to retrieve the supported actions for a SQL catalog.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported actions for SQL catalog);
+     * - return 1 (\b1)   => [SQL_ELEMENT_IN_PROCEDURE_CALLS];
+     * - return 2 (\b10)  => [SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+     * - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+     * - return 4 (\b100) => [SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+     * - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+     * - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+     * - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
+     * Valid actions for a SQL catalog are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
+     */
+    readonly SQL_CATALOGS_SUPPORTED_ACTIONS: 534;
+    /**
+     * SQL_SUPPORTED_POSITIONED_COMMANDS - Retrieves the supported SQL positioned commands.
+     *
+     * Returns an int32 bitmask value representing the supported SQL positioned commands.
+     * The returned bitmask should be parsed in order to retrieve the supported SQL positioned commands.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported SQL positioned commands);
+     * - return 1 (\b1)   => [SQL_POSITIONED_DELETE];
+     * - return 2 (\b10)  => [SQL_POSITIONED_UPDATE];
+     * - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
+     * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
+     */
+    readonly SQL_SUPPORTED_POSITIONED_COMMANDS: 535;
+    /**
+     * SQL_SELECT_FOR_UPDATE_SUPPORTED - Retrieves a boolean value indicating whether SELECT FOR UPDATE statements are supported.
+     *
+     * Returns:
+     * - false: if SELECT FOR UPDATE statements are unsupported;
+     * - true: if SELECT FOR UPDATE statements are supported.
+     */
+    readonly SQL_SELECT_FOR_UPDATE_SUPPORTED: 536;
+    /**
+     * SQL_STORED_PROCEDURES_SUPPORTED - Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
+     * are supported.
+     *
+     * Returns:
+     * - false: if stored procedure calls that use the stored procedure escape syntax are unsupported;
+     * - true: if stored procedure calls that use the stored procedure escape syntax are supported.
+     */
+    readonly SQL_STORED_PROCEDURES_SUPPORTED: 537;
+    /**
+     * SQL_SUPPORTED_SUBQUERIES - Retrieves the supported SQL subqueries.
+     *
+     * Returns an int32 bitmask value representing the supported SQL subqueries.
+     * The returned bitmask should be parsed in order to retrieve the supported SQL subqueries.
+     *
+     * For instance:
+     * - return 0   (\b0)     => [] (no supported SQL subqueries);
+     * - return 1   (\b1)     => [SQL_SUBQUERIES_IN_COMPARISONS];
+     * - return 2   (\b10)    => [SQL_SUBQUERIES_IN_EXISTS];
+     * - return 3   (\b11)    => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS];
+     * - return 4   (\b100)   => [SQL_SUBQUERIES_IN_INS];
+     * - return 5   (\b101)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS];
+     * - return 6   (\b110)   => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_EXISTS];
+     * - return 7   (\b111)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS];
+     * - return 8   (\b1000)  => [SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 9   (\b1001)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 10  (\b1010)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 11  (\b1011)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 12  (\b1100)  => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 13  (\b1101)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 14  (\b1110)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - return 15  (\b1111)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+     * - ...
+     * Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
+     */
+    readonly SQL_SUPPORTED_SUBQUERIES: 538;
+    /**
+     * SQL_CORRELATED_SUBQUERIES_SUPPORTED - Retrieves a boolean value indicating whether correlated subqueries are supported.
+     *
+     * Returns:
+     * - false: if correlated subqueries are unsupported;
+     * - true: if correlated subqueries are supported.
+     */
+    readonly SQL_CORRELATED_SUBQUERIES_SUPPORTED: 539;
+    /**
+     * SQL_SUPPORTED_UNIONS - Retrieves the supported SQL UNIONs.
+     *
+     * Returns an int32 bitmask value representing the supported SQL UNIONs.
+     * The returned bitmask should be parsed in order to retrieve the supported SQL UNIONs.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported SQL UNIONs);
+     * - return 1 (\b1)   => [SQL_UNION];
+     * - return 2 (\b10)  => [SQL_UNION_ALL];
+     * - return 3 (\b11)  => [SQL_UNION, SQL_UNION_ALL].
+     * Valid SQL UNIONs are described under `arrow.flight.protocol.sql.SqlSupportedUnions`.
+     */
+    readonly SQL_SUPPORTED_UNIONS: 540;
+    /** SQL_MAX_BINARY_LITERAL_LENGTH - Retrieves an int64 value representing the maximum number of hex characters allowed in an inline binary literal. */
+    readonly SQL_MAX_BINARY_LITERAL_LENGTH: 541;
+    /** SQL_MAX_CHAR_LITERAL_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed for a character literal. */
+    readonly SQL_MAX_CHAR_LITERAL_LENGTH: 542;
+    /** SQL_MAX_COLUMN_NAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed for a column name. */
+    readonly SQL_MAX_COLUMN_NAME_LENGTH: 543;
+    /** SQL_MAX_COLUMNS_IN_GROUP_BY - Retrieves an int64 value representing the maximum number of columns allowed in a GROUP BY clause. */
+    readonly SQL_MAX_COLUMNS_IN_GROUP_BY: 544;
+    /** SQL_MAX_COLUMNS_IN_INDEX - Retrieves an int64 value representing the maximum number of columns allowed in an index. */
+    readonly SQL_MAX_COLUMNS_IN_INDEX: 545;
+    /** SQL_MAX_COLUMNS_IN_ORDER_BY - Retrieves an int64 value representing the maximum number of columns allowed in an ORDER BY clause. */
+    readonly SQL_MAX_COLUMNS_IN_ORDER_BY: 546;
+    /** SQL_MAX_COLUMNS_IN_SELECT - Retrieves an int64 value representing the maximum number of columns allowed in a SELECT list. */
+    readonly SQL_MAX_COLUMNS_IN_SELECT: 547;
+    /** SQL_MAX_COLUMNS_IN_TABLE - Retrieves an int64 value representing the maximum number of columns allowed in a table. */
+    readonly SQL_MAX_COLUMNS_IN_TABLE: 548;
+    /** SQL_MAX_CONNECTIONS - Retrieves an int64 value representing the maximum number of concurrent connections possible. */
+    readonly SQL_MAX_CONNECTIONS: 549;
+    /** SQL_MAX_CURSOR_NAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed in a cursor name. */
+    readonly SQL_MAX_CURSOR_NAME_LENGTH: 550;
+    /**
+     * SQL_MAX_INDEX_LENGTH - Retrieves an int64 value representing the maximum number of bytes allowed for an index,
+     * including all of the parts of the index.
+     */
+    readonly SQL_MAX_INDEX_LENGTH: 551;
+    /** SQL_DB_SCHEMA_NAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed in a schema name. */
+    readonly SQL_DB_SCHEMA_NAME_LENGTH: 552;
+    /** SQL_MAX_PROCEDURE_NAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed in a procedure name. */
+    readonly SQL_MAX_PROCEDURE_NAME_LENGTH: 553;
+    /** SQL_MAX_CATALOG_NAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed in a catalog name. */
+    readonly SQL_MAX_CATALOG_NAME_LENGTH: 554;
+    /** SQL_MAX_ROW_SIZE - Retrieves an int64 value representing the maximum number of bytes allowed in a single row. */
+    readonly SQL_MAX_ROW_SIZE: 555;
+    /**
+     * SQL_MAX_ROW_SIZE_INCLUDES_BLOBS - Retrieves a boolean indicating whether the return value for the JDBC method getMaxRowSize includes the SQL
+     * data types LONGVARCHAR and LONGVARBINARY.
+     *
+     * Returns:
+     * - false: if return value for the JDBC method getMaxRowSize does
+     *          not include the SQL data types LONGVARCHAR and LONGVARBINARY;
+     * - true: if return value for the JDBC method getMaxRowSize includes
+     *         the SQL data types LONGVARCHAR and LONGVARBINARY.
+     */
+    readonly SQL_MAX_ROW_SIZE_INCLUDES_BLOBS: 556;
+    /**
+     * SQL_MAX_STATEMENT_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed for an SQL statement;
+     * a result of 0 (zero) means that there is no limit or the limit is not known.
+     */
+    readonly SQL_MAX_STATEMENT_LENGTH: 557;
+    /** SQL_MAX_STATEMENTS - Retrieves an int64 value representing the maximum number of active statements that can be open at the same time. */
+    readonly SQL_MAX_STATEMENTS: 558;
+    /** SQL_MAX_TABLE_NAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed in a table name. */
+    readonly SQL_MAX_TABLE_NAME_LENGTH: 559;
+    /** SQL_MAX_TABLES_IN_SELECT - Retrieves an int64 value representing the maximum number of tables allowed in a SELECT statement. */
+    readonly SQL_MAX_TABLES_IN_SELECT: 560;
+    /** SQL_MAX_USERNAME_LENGTH - Retrieves an int64 value representing the maximum number of characters allowed in a user name. */
+    readonly SQL_MAX_USERNAME_LENGTH: 561;
+    /**
+     * SQL_DEFAULT_TRANSACTION_ISOLATION - Retrieves this database's default transaction isolation level as described in
+     * `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
+     *
+     * Returns an int32 ordinal for the SQL transaction isolation level.
+     */
+    readonly SQL_DEFAULT_TRANSACTION_ISOLATION: 562;
+    /**
+     * SQL_TRANSACTIONS_SUPPORTED - Retrieves a boolean value indicating whether transactions are supported. If not, invoking the method commit is a
+     * noop, and the isolation level is `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
+     *
+     * Returns:
+     * - false: if transactions are unsupported;
+     * - true: if transactions are supported.
+     */
+    readonly SQL_TRANSACTIONS_SUPPORTED: 563;
+    /**
+     * SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS - Retrieves the supported transactions isolation levels.
+     *
+     * Returns an int32 bitmask value representing the supported transactions isolation levels.
+     * The returned bitmask should be parsed in order to retrieve the supported transactions isolation levels.
+     *
+     * For instance:
+     * - return 0   (\b0)     => [] (no supported SQL transactions isolation levels);
+     * - return 1   (\b1)     => [SQL_TRANSACTION_NONE];
+     * - return 2   (\b10)    => [SQL_TRANSACTION_READ_UNCOMMITTED];
+     * - return 3   (\b11)    => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED];
+     * - return 4   (\b100)   => [SQL_TRANSACTION_READ_COMMITTED];
+     * - return 5   (\b101)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_COMMITTED];
+     * - return 6   (\b110)   => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED];
+     * - return 7   (\b111)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED];
+     * - return 8   (\b1000)  => [SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 9   (\b1001)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 10  (\b1010)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 11  (\b1011)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 12  (\b1100)  => [SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 13  (\b1101)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 14  (\b1110)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 15  (\b1111)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_READ_COMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+     * - return 16  (\b10000) => [SQL_TRANSACTION_SERIALIZABLE];
+     * - ...
+     * Valid SQL transaction isolation levels are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
+     */
+    readonly SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS: 564;
+    /**
+     * SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT - Retrieves a boolean value indicating whether a data definition statement within a transaction forces
+     * the transaction to commit.
+     *
+     * Returns:
+     * - false: if a data definition statement within a transaction does not force the transaction to commit;
+     * - true: if a data definition statement within a transaction forces the transaction to commit.
+     */
+    readonly SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT: 565;
+    /**
+     * SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED - Retrieves a boolean value indicating whether a data definition statement within a transaction is ignored.
+     *
+     * Returns:
+     * - false: if a data definition statement within a transaction is taken into account;
+     * - true: a data definition statement within a transaction is ignored.
+     */
+    readonly SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED: 566;
+    /**
+     * SQL_SUPPORTED_RESULT_SET_TYPES - Retrieves an int32 bitmask value representing the supported result set types.
+     * The returned bitmask should be parsed in order to retrieve the supported result set types.
+     *
+     * For instance:
+     * - return 0   (\b0)     => [] (no supported result set types);
+     * - return 1   (\b1)     => [SQL_RESULT_SET_TYPE_UNSPECIFIED];
+     * - return 2   (\b10)    => [SQL_RESULT_SET_TYPE_FORWARD_ONLY];
+     * - return 3   (\b11)    => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY];
+     * - return 4   (\b100)   => [SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+     * - return 5   (\b101)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+     * - return 6   (\b110)   => [SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+     * - return 7   (\b111)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+     * - return 8   (\b1000)  => [SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE];
+     * - ...
+     * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
+     */
+    readonly SQL_SUPPORTED_RESULT_SET_TYPES: 567;
+    /**
+     * SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED - Returns an int32 bitmask value representing the concurrency types supported for
+     * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+     * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+     * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+     */
+    readonly SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED: 568;
+    /**
+     * SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY - Returns an int32 bitmask value representing the concurrency types supported for
+     * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+     * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+     * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+     */
+    readonly SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY: 569;
+    /**
+     * SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE - Returns an int32 bitmask value representing the concurrency types supported for
+     * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+     * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+     * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+     */
+    readonly SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE: 570;
+    /**
+     * SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE - Returns an int32 bitmask value representing the concurrency types supported for
+     * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
+     *
+     * For instance:
+     * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+     * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+     * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+     * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+     * Valid result set concurrency types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+     */
+    readonly SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE: 571;
+    /**
+     * SQL_BATCH_UPDATES_SUPPORTED - Retrieves a boolean value indicating whether this database supports batch updates.
+     *
+     * - false: if this database does not support batch updates;
+     * - true: if this database supports batch updates.
+     */
+    readonly SQL_BATCH_UPDATES_SUPPORTED: 572;
+    /**
+     * SQL_SAVEPOINTS_SUPPORTED - Retrieves a boolean value indicating whether this database supports savepoints.
+     *
+     * Returns:
+     * - false: if this database does not support savepoints;
+     * - true: if this database supports savepoints.
+     */
+    readonly SQL_SAVEPOINTS_SUPPORTED: 573;
+    /**
+     * SQL_NAMED_PARAMETERS_SUPPORTED - Retrieves a boolean value indicating whether named parameters are supported in callable statements.
+     *
+     * Returns:
+     * - false: if named parameters in callable statements are unsupported;
+     * - true: if named parameters in callable statements are supported.
+     */
+    readonly SQL_NAMED_PARAMETERS_SUPPORTED: 574;
+    /**
+     * SQL_LOCATORS_UPDATE_COPY - Retrieves a boolean value indicating whether updates made to a LOB are made on a copy or directly to the LOB.
+     *
+     * Returns:
+     * - false: if updates made to a LOB are made directly to the LOB;
+     * - true: if updates made to a LOB are made on a copy.
+     */
+    readonly SQL_LOCATORS_UPDATE_COPY: 575;
+    /**
+     * SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED - Retrieves a boolean value indicating whether invoking user-defined or vendor functions
+     * using the stored procedure escape syntax is supported.
+     *
+     * Returns:
+     * - false: if invoking user-defined or vendor functions using the stored procedure escape syntax is unsupported;
+     * - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
+     */
+    readonly SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED: 576;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlInfo = typeof SqlInfo[keyof typeof SqlInfo];
+export declare namespace SqlInfo {
+    type FLIGHT_SQL_SERVER_NAME = typeof SqlInfo.FLIGHT_SQL_SERVER_NAME;
+    type FLIGHT_SQL_SERVER_VERSION = typeof SqlInfo.FLIGHT_SQL_SERVER_VERSION;
+    type FLIGHT_SQL_SERVER_ARROW_VERSION = typeof SqlInfo.FLIGHT_SQL_SERVER_ARROW_VERSION;
+    type FLIGHT_SQL_SERVER_READ_ONLY = typeof SqlInfo.FLIGHT_SQL_SERVER_READ_ONLY;
+    type FLIGHT_SQL_SERVER_SQL = typeof SqlInfo.FLIGHT_SQL_SERVER_SQL;
+    type FLIGHT_SQL_SERVER_SUBSTRAIT = typeof SqlInfo.FLIGHT_SQL_SERVER_SUBSTRAIT;
+    type FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION = typeof SqlInfo.FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION;
+    type FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION = typeof SqlInfo.FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION;
+    type FLIGHT_SQL_SERVER_TRANSACTION = typeof SqlInfo.FLIGHT_SQL_SERVER_TRANSACTION;
+    type FLIGHT_SQL_SERVER_CANCEL = typeof SqlInfo.FLIGHT_SQL_SERVER_CANCEL;
+    type FLIGHT_SQL_SERVER_BULK_INGESTION = typeof SqlInfo.FLIGHT_SQL_SERVER_BULK_INGESTION;
+    type FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED = typeof SqlInfo.FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED;
+    type FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT = typeof SqlInfo.FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT;
+    type FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT = typeof SqlInfo.FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT;
+    type SQL_DDL_CATALOG = typeof SqlInfo.SQL_DDL_CATALOG;
+    type SQL_DDL_SCHEMA = typeof SqlInfo.SQL_DDL_SCHEMA;
+    type SQL_DDL_TABLE = typeof SqlInfo.SQL_DDL_TABLE;
+    type SQL_IDENTIFIER_CASE = typeof SqlInfo.SQL_IDENTIFIER_CASE;
+    type SQL_IDENTIFIER_QUOTE_CHAR = typeof SqlInfo.SQL_IDENTIFIER_QUOTE_CHAR;
+    type SQL_QUOTED_IDENTIFIER_CASE = typeof SqlInfo.SQL_QUOTED_IDENTIFIER_CASE;
+    type SQL_ALL_TABLES_ARE_SELECTABLE = typeof SqlInfo.SQL_ALL_TABLES_ARE_SELECTABLE;
+    type SQL_NULL_ORDERING = typeof SqlInfo.SQL_NULL_ORDERING;
+    type SQL_KEYWORDS = typeof SqlInfo.SQL_KEYWORDS;
+    type SQL_NUMERIC_FUNCTIONS = typeof SqlInfo.SQL_NUMERIC_FUNCTIONS;
+    type SQL_STRING_FUNCTIONS = typeof SqlInfo.SQL_STRING_FUNCTIONS;
+    type SQL_SYSTEM_FUNCTIONS = typeof SqlInfo.SQL_SYSTEM_FUNCTIONS;
+    type SQL_DATETIME_FUNCTIONS = typeof SqlInfo.SQL_DATETIME_FUNCTIONS;
+    type SQL_SEARCH_STRING_ESCAPE = typeof SqlInfo.SQL_SEARCH_STRING_ESCAPE;
+    type SQL_EXTRA_NAME_CHARACTERS = typeof SqlInfo.SQL_EXTRA_NAME_CHARACTERS;
+    type SQL_SUPPORTS_COLUMN_ALIASING = typeof SqlInfo.SQL_SUPPORTS_COLUMN_ALIASING;
+    type SQL_NULL_PLUS_NULL_IS_NULL = typeof SqlInfo.SQL_NULL_PLUS_NULL_IS_NULL;
+    type SQL_SUPPORTS_CONVERT = typeof SqlInfo.SQL_SUPPORTS_CONVERT;
+    type SQL_SUPPORTS_TABLE_CORRELATION_NAMES = typeof SqlInfo.SQL_SUPPORTS_TABLE_CORRELATION_NAMES;
+    type SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES = typeof SqlInfo.SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES;
+    type SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY = typeof SqlInfo.SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY;
+    type SQL_SUPPORTS_ORDER_BY_UNRELATED = typeof SqlInfo.SQL_SUPPORTS_ORDER_BY_UNRELATED;
+    type SQL_SUPPORTED_GROUP_BY = typeof SqlInfo.SQL_SUPPORTED_GROUP_BY;
+    type SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE = typeof SqlInfo.SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE;
+    type SQL_SUPPORTS_NON_NULLABLE_COLUMNS = typeof SqlInfo.SQL_SUPPORTS_NON_NULLABLE_COLUMNS;
+    type SQL_SUPPORTED_GRAMMAR = typeof SqlInfo.SQL_SUPPORTED_GRAMMAR;
+    type SQL_ANSI92_SUPPORTED_LEVEL = typeof SqlInfo.SQL_ANSI92_SUPPORTED_LEVEL;
+    type SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY = typeof SqlInfo.SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY;
+    type SQL_OUTER_JOINS_SUPPORT_LEVEL = typeof SqlInfo.SQL_OUTER_JOINS_SUPPORT_LEVEL;
+    type SQL_SCHEMA_TERM = typeof SqlInfo.SQL_SCHEMA_TERM;
+    type SQL_PROCEDURE_TERM = typeof SqlInfo.SQL_PROCEDURE_TERM;
+    type SQL_CATALOG_TERM = typeof SqlInfo.SQL_CATALOG_TERM;
+    type SQL_CATALOG_AT_START = typeof SqlInfo.SQL_CATALOG_AT_START;
+    type SQL_SCHEMAS_SUPPORTED_ACTIONS = typeof SqlInfo.SQL_SCHEMAS_SUPPORTED_ACTIONS;
+    type SQL_CATALOGS_SUPPORTED_ACTIONS = typeof SqlInfo.SQL_CATALOGS_SUPPORTED_ACTIONS;
+    type SQL_SUPPORTED_POSITIONED_COMMANDS = typeof SqlInfo.SQL_SUPPORTED_POSITIONED_COMMANDS;
+    type SQL_SELECT_FOR_UPDATE_SUPPORTED = typeof SqlInfo.SQL_SELECT_FOR_UPDATE_SUPPORTED;
+    type SQL_STORED_PROCEDURES_SUPPORTED = typeof SqlInfo.SQL_STORED_PROCEDURES_SUPPORTED;
+    type SQL_SUPPORTED_SUBQUERIES = typeof SqlInfo.SQL_SUPPORTED_SUBQUERIES;
+    type SQL_CORRELATED_SUBQUERIES_SUPPORTED = typeof SqlInfo.SQL_CORRELATED_SUBQUERIES_SUPPORTED;
+    type SQL_SUPPORTED_UNIONS = typeof SqlInfo.SQL_SUPPORTED_UNIONS;
+    type SQL_MAX_BINARY_LITERAL_LENGTH = typeof SqlInfo.SQL_MAX_BINARY_LITERAL_LENGTH;
+    type SQL_MAX_CHAR_LITERAL_LENGTH = typeof SqlInfo.SQL_MAX_CHAR_LITERAL_LENGTH;
+    type SQL_MAX_COLUMN_NAME_LENGTH = typeof SqlInfo.SQL_MAX_COLUMN_NAME_LENGTH;
+    type SQL_MAX_COLUMNS_IN_GROUP_BY = typeof SqlInfo.SQL_MAX_COLUMNS_IN_GROUP_BY;
+    type SQL_MAX_COLUMNS_IN_INDEX = typeof SqlInfo.SQL_MAX_COLUMNS_IN_INDEX;
+    type SQL_MAX_COLUMNS_IN_ORDER_BY = typeof SqlInfo.SQL_MAX_COLUMNS_IN_ORDER_BY;
+    type SQL_MAX_COLUMNS_IN_SELECT = typeof SqlInfo.SQL_MAX_COLUMNS_IN_SELECT;
+    type SQL_MAX_COLUMNS_IN_TABLE = typeof SqlInfo.SQL_MAX_COLUMNS_IN_TABLE;
+    type SQL_MAX_CONNECTIONS = typeof SqlInfo.SQL_MAX_CONNECTIONS;
+    type SQL_MAX_CURSOR_NAME_LENGTH = typeof SqlInfo.SQL_MAX_CURSOR_NAME_LENGTH;
+    type SQL_MAX_INDEX_LENGTH = typeof SqlInfo.SQL_MAX_INDEX_LENGTH;
+    type SQL_DB_SCHEMA_NAME_LENGTH = typeof SqlInfo.SQL_DB_SCHEMA_NAME_LENGTH;
+    type SQL_MAX_PROCEDURE_NAME_LENGTH = typeof SqlInfo.SQL_MAX_PROCEDURE_NAME_LENGTH;
+    type SQL_MAX_CATALOG_NAME_LENGTH = typeof SqlInfo.SQL_MAX_CATALOG_NAME_LENGTH;
+    type SQL_MAX_ROW_SIZE = typeof SqlInfo.SQL_MAX_ROW_SIZE;
+    type SQL_MAX_ROW_SIZE_INCLUDES_BLOBS = typeof SqlInfo.SQL_MAX_ROW_SIZE_INCLUDES_BLOBS;
+    type SQL_MAX_STATEMENT_LENGTH = typeof SqlInfo.SQL_MAX_STATEMENT_LENGTH;
+    type SQL_MAX_STATEMENTS = typeof SqlInfo.SQL_MAX_STATEMENTS;
+    type SQL_MAX_TABLE_NAME_LENGTH = typeof SqlInfo.SQL_MAX_TABLE_NAME_LENGTH;
+    type SQL_MAX_TABLES_IN_SELECT = typeof SqlInfo.SQL_MAX_TABLES_IN_SELECT;
+    type SQL_MAX_USERNAME_LENGTH = typeof SqlInfo.SQL_MAX_USERNAME_LENGTH;
+    type SQL_DEFAULT_TRANSACTION_ISOLATION = typeof SqlInfo.SQL_DEFAULT_TRANSACTION_ISOLATION;
+    type SQL_TRANSACTIONS_SUPPORTED = typeof SqlInfo.SQL_TRANSACTIONS_SUPPORTED;
+    type SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS = typeof SqlInfo.SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS;
+    type SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT = typeof SqlInfo.SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT;
+    type SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED = typeof SqlInfo.SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED;
+    type SQL_SUPPORTED_RESULT_SET_TYPES = typeof SqlInfo.SQL_SUPPORTED_RESULT_SET_TYPES;
+    type SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED = typeof SqlInfo.SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED;
+    type SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY = typeof SqlInfo.SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY;
+    type SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE = typeof SqlInfo.SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE;
+    type SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE = typeof SqlInfo.SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE;
+    type SQL_BATCH_UPDATES_SUPPORTED = typeof SqlInfo.SQL_BATCH_UPDATES_SUPPORTED;
+    type SQL_SAVEPOINTS_SUPPORTED = typeof SqlInfo.SQL_SAVEPOINTS_SUPPORTED;
+    type SQL_NAMED_PARAMETERS_SUPPORTED = typeof SqlInfo.SQL_NAMED_PARAMETERS_SUPPORTED;
+    type SQL_LOCATORS_UPDATE_COPY = typeof SqlInfo.SQL_LOCATORS_UPDATE_COPY;
+    type SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED = typeof SqlInfo.SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED;
+    type UNRECOGNIZED = typeof SqlInfo.UNRECOGNIZED;
+}
+export declare function sqlInfoFromJSON(object: any): SqlInfo;
+export declare function sqlInfoToJSON(object: SqlInfo): string;
+/** The level of support for Flight SQL transaction RPCs. */
+export declare const SqlSupportedTransaction: {
+    /** SQL_SUPPORTED_TRANSACTION_NONE - Unknown/not indicated/no support */
+    readonly SQL_SUPPORTED_TRANSACTION_NONE: 0;
+    /**
+     * SQL_SUPPORTED_TRANSACTION_TRANSACTION - Transactions, but not savepoints.
+     * A savepoint is a mark within a transaction that can be individually
+     * rolled back to. Not all databases support savepoints.
+     */
+    readonly SQL_SUPPORTED_TRANSACTION_TRANSACTION: 1;
+    /** SQL_SUPPORTED_TRANSACTION_SAVEPOINT - Transactions and savepoints */
+    readonly SQL_SUPPORTED_TRANSACTION_SAVEPOINT: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedTransaction = typeof SqlSupportedTransaction[keyof typeof SqlSupportedTransaction];
+export declare namespace SqlSupportedTransaction {
+    type SQL_SUPPORTED_TRANSACTION_NONE = typeof SqlSupportedTransaction.SQL_SUPPORTED_TRANSACTION_NONE;
+    type SQL_SUPPORTED_TRANSACTION_TRANSACTION = typeof SqlSupportedTransaction.SQL_SUPPORTED_TRANSACTION_TRANSACTION;
+    type SQL_SUPPORTED_TRANSACTION_SAVEPOINT = typeof SqlSupportedTransaction.SQL_SUPPORTED_TRANSACTION_SAVEPOINT;
+    type UNRECOGNIZED = typeof SqlSupportedTransaction.UNRECOGNIZED;
+}
+export declare function sqlSupportedTransactionFromJSON(object: any): SqlSupportedTransaction;
+export declare function sqlSupportedTransactionToJSON(object: SqlSupportedTransaction): string;
+export declare const SqlSupportedCaseSensitivity: {
+    readonly SQL_CASE_SENSITIVITY_UNKNOWN: 0;
+    readonly SQL_CASE_SENSITIVITY_CASE_INSENSITIVE: 1;
+    readonly SQL_CASE_SENSITIVITY_UPPERCASE: 2;
+    readonly SQL_CASE_SENSITIVITY_LOWERCASE: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedCaseSensitivity = typeof SqlSupportedCaseSensitivity[keyof typeof SqlSupportedCaseSensitivity];
+export declare namespace SqlSupportedCaseSensitivity {
+    type SQL_CASE_SENSITIVITY_UNKNOWN = typeof SqlSupportedCaseSensitivity.SQL_CASE_SENSITIVITY_UNKNOWN;
+    type SQL_CASE_SENSITIVITY_CASE_INSENSITIVE = typeof SqlSupportedCaseSensitivity.SQL_CASE_SENSITIVITY_CASE_INSENSITIVE;
+    type SQL_CASE_SENSITIVITY_UPPERCASE = typeof SqlSupportedCaseSensitivity.SQL_CASE_SENSITIVITY_UPPERCASE;
+    type SQL_CASE_SENSITIVITY_LOWERCASE = typeof SqlSupportedCaseSensitivity.SQL_CASE_SENSITIVITY_LOWERCASE;
+    type UNRECOGNIZED = typeof SqlSupportedCaseSensitivity.UNRECOGNIZED;
+}
+export declare function sqlSupportedCaseSensitivityFromJSON(object: any): SqlSupportedCaseSensitivity;
+export declare function sqlSupportedCaseSensitivityToJSON(object: SqlSupportedCaseSensitivity): string;
+export declare const SqlNullOrdering: {
+    readonly SQL_NULLS_SORTED_HIGH: 0;
+    readonly SQL_NULLS_SORTED_LOW: 1;
+    readonly SQL_NULLS_SORTED_AT_START: 2;
+    readonly SQL_NULLS_SORTED_AT_END: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlNullOrdering = typeof SqlNullOrdering[keyof typeof SqlNullOrdering];
+export declare namespace SqlNullOrdering {
+    type SQL_NULLS_SORTED_HIGH = typeof SqlNullOrdering.SQL_NULLS_SORTED_HIGH;
+    type SQL_NULLS_SORTED_LOW = typeof SqlNullOrdering.SQL_NULLS_SORTED_LOW;
+    type SQL_NULLS_SORTED_AT_START = typeof SqlNullOrdering.SQL_NULLS_SORTED_AT_START;
+    type SQL_NULLS_SORTED_AT_END = typeof SqlNullOrdering.SQL_NULLS_SORTED_AT_END;
+    type UNRECOGNIZED = typeof SqlNullOrdering.UNRECOGNIZED;
+}
+export declare function sqlNullOrderingFromJSON(object: any): SqlNullOrdering;
+export declare function sqlNullOrderingToJSON(object: SqlNullOrdering): string;
+export declare const SupportedSqlGrammar: {
+    readonly SQL_MINIMUM_GRAMMAR: 0;
+    readonly SQL_CORE_GRAMMAR: 1;
+    readonly SQL_EXTENDED_GRAMMAR: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SupportedSqlGrammar = typeof SupportedSqlGrammar[keyof typeof SupportedSqlGrammar];
+export declare namespace SupportedSqlGrammar {
+    type SQL_MINIMUM_GRAMMAR = typeof SupportedSqlGrammar.SQL_MINIMUM_GRAMMAR;
+    type SQL_CORE_GRAMMAR = typeof SupportedSqlGrammar.SQL_CORE_GRAMMAR;
+    type SQL_EXTENDED_GRAMMAR = typeof SupportedSqlGrammar.SQL_EXTENDED_GRAMMAR;
+    type UNRECOGNIZED = typeof SupportedSqlGrammar.UNRECOGNIZED;
+}
+export declare function supportedSqlGrammarFromJSON(object: any): SupportedSqlGrammar;
+export declare function supportedSqlGrammarToJSON(object: SupportedSqlGrammar): string;
+export declare const SupportedAnsi92SqlGrammarLevel: {
+    readonly ANSI92_ENTRY_SQL: 0;
+    readonly ANSI92_INTERMEDIATE_SQL: 1;
+    readonly ANSI92_FULL_SQL: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SupportedAnsi92SqlGrammarLevel = typeof SupportedAnsi92SqlGrammarLevel[keyof typeof SupportedAnsi92SqlGrammarLevel];
+export declare namespace SupportedAnsi92SqlGrammarLevel {
+    type ANSI92_ENTRY_SQL = typeof SupportedAnsi92SqlGrammarLevel.ANSI92_ENTRY_SQL;
+    type ANSI92_INTERMEDIATE_SQL = typeof SupportedAnsi92SqlGrammarLevel.ANSI92_INTERMEDIATE_SQL;
+    type ANSI92_FULL_SQL = typeof SupportedAnsi92SqlGrammarLevel.ANSI92_FULL_SQL;
+    type UNRECOGNIZED = typeof SupportedAnsi92SqlGrammarLevel.UNRECOGNIZED;
+}
+export declare function supportedAnsi92SqlGrammarLevelFromJSON(object: any): SupportedAnsi92SqlGrammarLevel;
+export declare function supportedAnsi92SqlGrammarLevelToJSON(object: SupportedAnsi92SqlGrammarLevel): string;
+export declare const SqlOuterJoinsSupportLevel: {
+    readonly SQL_JOINS_UNSUPPORTED: 0;
+    readonly SQL_LIMITED_OUTER_JOINS: 1;
+    readonly SQL_FULL_OUTER_JOINS: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlOuterJoinsSupportLevel = typeof SqlOuterJoinsSupportLevel[keyof typeof SqlOuterJoinsSupportLevel];
+export declare namespace SqlOuterJoinsSupportLevel {
+    type SQL_JOINS_UNSUPPORTED = typeof SqlOuterJoinsSupportLevel.SQL_JOINS_UNSUPPORTED;
+    type SQL_LIMITED_OUTER_JOINS = typeof SqlOuterJoinsSupportLevel.SQL_LIMITED_OUTER_JOINS;
+    type SQL_FULL_OUTER_JOINS = typeof SqlOuterJoinsSupportLevel.SQL_FULL_OUTER_JOINS;
+    type UNRECOGNIZED = typeof SqlOuterJoinsSupportLevel.UNRECOGNIZED;
+}
+export declare function sqlOuterJoinsSupportLevelFromJSON(object: any): SqlOuterJoinsSupportLevel;
+export declare function sqlOuterJoinsSupportLevelToJSON(object: SqlOuterJoinsSupportLevel): string;
+export declare const SqlSupportedGroupBy: {
+    readonly SQL_GROUP_BY_UNRELATED: 0;
+    readonly SQL_GROUP_BY_BEYOND_SELECT: 1;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedGroupBy = typeof SqlSupportedGroupBy[keyof typeof SqlSupportedGroupBy];
+export declare namespace SqlSupportedGroupBy {
+    type SQL_GROUP_BY_UNRELATED = typeof SqlSupportedGroupBy.SQL_GROUP_BY_UNRELATED;
+    type SQL_GROUP_BY_BEYOND_SELECT = typeof SqlSupportedGroupBy.SQL_GROUP_BY_BEYOND_SELECT;
+    type UNRECOGNIZED = typeof SqlSupportedGroupBy.UNRECOGNIZED;
+}
+export declare function sqlSupportedGroupByFromJSON(object: any): SqlSupportedGroupBy;
+export declare function sqlSupportedGroupByToJSON(object: SqlSupportedGroupBy): string;
+export declare const SqlSupportedElementActions: {
+    readonly SQL_ELEMENT_IN_PROCEDURE_CALLS: 0;
+    readonly SQL_ELEMENT_IN_INDEX_DEFINITIONS: 1;
+    readonly SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedElementActions = typeof SqlSupportedElementActions[keyof typeof SqlSupportedElementActions];
+export declare namespace SqlSupportedElementActions {
+    type SQL_ELEMENT_IN_PROCEDURE_CALLS = typeof SqlSupportedElementActions.SQL_ELEMENT_IN_PROCEDURE_CALLS;
+    type SQL_ELEMENT_IN_INDEX_DEFINITIONS = typeof SqlSupportedElementActions.SQL_ELEMENT_IN_INDEX_DEFINITIONS;
+    type SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS = typeof SqlSupportedElementActions.SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS;
+    type UNRECOGNIZED = typeof SqlSupportedElementActions.UNRECOGNIZED;
+}
+export declare function sqlSupportedElementActionsFromJSON(object: any): SqlSupportedElementActions;
+export declare function sqlSupportedElementActionsToJSON(object: SqlSupportedElementActions): string;
+export declare const SqlSupportedPositionedCommands: {
+    readonly SQL_POSITIONED_DELETE: 0;
+    readonly SQL_POSITIONED_UPDATE: 1;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedPositionedCommands = typeof SqlSupportedPositionedCommands[keyof typeof SqlSupportedPositionedCommands];
+export declare namespace SqlSupportedPositionedCommands {
+    type SQL_POSITIONED_DELETE = typeof SqlSupportedPositionedCommands.SQL_POSITIONED_DELETE;
+    type SQL_POSITIONED_UPDATE = typeof SqlSupportedPositionedCommands.SQL_POSITIONED_UPDATE;
+    type UNRECOGNIZED = typeof SqlSupportedPositionedCommands.UNRECOGNIZED;
+}
+export declare function sqlSupportedPositionedCommandsFromJSON(object: any): SqlSupportedPositionedCommands;
+export declare function sqlSupportedPositionedCommandsToJSON(object: SqlSupportedPositionedCommands): string;
+export declare const SqlSupportedSubqueries: {
+    readonly SQL_SUBQUERIES_IN_COMPARISONS: 0;
+    readonly SQL_SUBQUERIES_IN_EXISTS: 1;
+    readonly SQL_SUBQUERIES_IN_INS: 2;
+    readonly SQL_SUBQUERIES_IN_QUANTIFIEDS: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedSubqueries = typeof SqlSupportedSubqueries[keyof typeof SqlSupportedSubqueries];
+export declare namespace SqlSupportedSubqueries {
+    type SQL_SUBQUERIES_IN_COMPARISONS = typeof SqlSupportedSubqueries.SQL_SUBQUERIES_IN_COMPARISONS;
+    type SQL_SUBQUERIES_IN_EXISTS = typeof SqlSupportedSubqueries.SQL_SUBQUERIES_IN_EXISTS;
+    type SQL_SUBQUERIES_IN_INS = typeof SqlSupportedSubqueries.SQL_SUBQUERIES_IN_INS;
+    type SQL_SUBQUERIES_IN_QUANTIFIEDS = typeof SqlSupportedSubqueries.SQL_SUBQUERIES_IN_QUANTIFIEDS;
+    type UNRECOGNIZED = typeof SqlSupportedSubqueries.UNRECOGNIZED;
+}
+export declare function sqlSupportedSubqueriesFromJSON(object: any): SqlSupportedSubqueries;
+export declare function sqlSupportedSubqueriesToJSON(object: SqlSupportedSubqueries): string;
+export declare const SqlSupportedUnions: {
+    readonly SQL_UNION: 0;
+    readonly SQL_UNION_ALL: 1;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedUnions = typeof SqlSupportedUnions[keyof typeof SqlSupportedUnions];
+export declare namespace SqlSupportedUnions {
+    type SQL_UNION = typeof SqlSupportedUnions.SQL_UNION;
+    type SQL_UNION_ALL = typeof SqlSupportedUnions.SQL_UNION_ALL;
+    type UNRECOGNIZED = typeof SqlSupportedUnions.UNRECOGNIZED;
+}
+export declare function sqlSupportedUnionsFromJSON(object: any): SqlSupportedUnions;
+export declare function sqlSupportedUnionsToJSON(object: SqlSupportedUnions): string;
+export declare const SqlTransactionIsolationLevel: {
+    readonly SQL_TRANSACTION_NONE: 0;
+    readonly SQL_TRANSACTION_READ_UNCOMMITTED: 1;
+    readonly SQL_TRANSACTION_READ_COMMITTED: 2;
+    readonly SQL_TRANSACTION_REPEATABLE_READ: 3;
+    readonly SQL_TRANSACTION_SERIALIZABLE: 4;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlTransactionIsolationLevel = typeof SqlTransactionIsolationLevel[keyof typeof SqlTransactionIsolationLevel];
+export declare namespace SqlTransactionIsolationLevel {
+    type SQL_TRANSACTION_NONE = typeof SqlTransactionIsolationLevel.SQL_TRANSACTION_NONE;
+    type SQL_TRANSACTION_READ_UNCOMMITTED = typeof SqlTransactionIsolationLevel.SQL_TRANSACTION_READ_UNCOMMITTED;
+    type SQL_TRANSACTION_READ_COMMITTED = typeof SqlTransactionIsolationLevel.SQL_TRANSACTION_READ_COMMITTED;
+    type SQL_TRANSACTION_REPEATABLE_READ = typeof SqlTransactionIsolationLevel.SQL_TRANSACTION_REPEATABLE_READ;
+    type SQL_TRANSACTION_SERIALIZABLE = typeof SqlTransactionIsolationLevel.SQL_TRANSACTION_SERIALIZABLE;
+    type UNRECOGNIZED = typeof SqlTransactionIsolationLevel.UNRECOGNIZED;
+}
+export declare function sqlTransactionIsolationLevelFromJSON(object: any): SqlTransactionIsolationLevel;
+export declare function sqlTransactionIsolationLevelToJSON(object: SqlTransactionIsolationLevel): string;
+export declare const SqlSupportedTransactions: {
+    readonly SQL_TRANSACTION_UNSPECIFIED: 0;
+    readonly SQL_DATA_DEFINITION_TRANSACTIONS: 1;
+    readonly SQL_DATA_MANIPULATION_TRANSACTIONS: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedTransactions = typeof SqlSupportedTransactions[keyof typeof SqlSupportedTransactions];
+export declare namespace SqlSupportedTransactions {
+    type SQL_TRANSACTION_UNSPECIFIED = typeof SqlSupportedTransactions.SQL_TRANSACTION_UNSPECIFIED;
+    type SQL_DATA_DEFINITION_TRANSACTIONS = typeof SqlSupportedTransactions.SQL_DATA_DEFINITION_TRANSACTIONS;
+    type SQL_DATA_MANIPULATION_TRANSACTIONS = typeof SqlSupportedTransactions.SQL_DATA_MANIPULATION_TRANSACTIONS;
+    type UNRECOGNIZED = typeof SqlSupportedTransactions.UNRECOGNIZED;
+}
+export declare function sqlSupportedTransactionsFromJSON(object: any): SqlSupportedTransactions;
+export declare function sqlSupportedTransactionsToJSON(object: SqlSupportedTransactions): string;
+export declare const SqlSupportedResultSetType: {
+    readonly SQL_RESULT_SET_TYPE_UNSPECIFIED: 0;
+    readonly SQL_RESULT_SET_TYPE_FORWARD_ONLY: 1;
+    readonly SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE: 2;
+    readonly SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedResultSetType = typeof SqlSupportedResultSetType[keyof typeof SqlSupportedResultSetType];
+export declare namespace SqlSupportedResultSetType {
+    type SQL_RESULT_SET_TYPE_UNSPECIFIED = typeof SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED;
+    type SQL_RESULT_SET_TYPE_FORWARD_ONLY = typeof SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY;
+    type SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE = typeof SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE;
+    type SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE = typeof SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE;
+    type UNRECOGNIZED = typeof SqlSupportedResultSetType.UNRECOGNIZED;
+}
+export declare function sqlSupportedResultSetTypeFromJSON(object: any): SqlSupportedResultSetType;
+export declare function sqlSupportedResultSetTypeToJSON(object: SqlSupportedResultSetType): string;
+export declare const SqlSupportedResultSetConcurrency: {
+    readonly SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED: 0;
+    readonly SQL_RESULT_SET_CONCURRENCY_READ_ONLY: 1;
+    readonly SQL_RESULT_SET_CONCURRENCY_UPDATABLE: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportedResultSetConcurrency = typeof SqlSupportedResultSetConcurrency[keyof typeof SqlSupportedResultSetConcurrency];
+export declare namespace SqlSupportedResultSetConcurrency {
+    type SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED = typeof SqlSupportedResultSetConcurrency.SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED;
+    type SQL_RESULT_SET_CONCURRENCY_READ_ONLY = typeof SqlSupportedResultSetConcurrency.SQL_RESULT_SET_CONCURRENCY_READ_ONLY;
+    type SQL_RESULT_SET_CONCURRENCY_UPDATABLE = typeof SqlSupportedResultSetConcurrency.SQL_RESULT_SET_CONCURRENCY_UPDATABLE;
+    type UNRECOGNIZED = typeof SqlSupportedResultSetConcurrency.UNRECOGNIZED;
+}
+export declare function sqlSupportedResultSetConcurrencyFromJSON(object: any): SqlSupportedResultSetConcurrency;
+export declare function sqlSupportedResultSetConcurrencyToJSON(object: SqlSupportedResultSetConcurrency): string;
+export declare const SqlSupportsConvert: {
+    readonly SQL_CONVERT_BIGINT: 0;
+    readonly SQL_CONVERT_BINARY: 1;
+    readonly SQL_CONVERT_BIT: 2;
+    readonly SQL_CONVERT_CHAR: 3;
+    readonly SQL_CONVERT_DATE: 4;
+    readonly SQL_CONVERT_DECIMAL: 5;
+    readonly SQL_CONVERT_FLOAT: 6;
+    readonly SQL_CONVERT_INTEGER: 7;
+    readonly SQL_CONVERT_INTERVAL_DAY_TIME: 8;
+    readonly SQL_CONVERT_INTERVAL_YEAR_MONTH: 9;
+    readonly SQL_CONVERT_LONGVARBINARY: 10;
+    readonly SQL_CONVERT_LONGVARCHAR: 11;
+    readonly SQL_CONVERT_NUMERIC: 12;
+    readonly SQL_CONVERT_REAL: 13;
+    readonly SQL_CONVERT_SMALLINT: 14;
+    readonly SQL_CONVERT_TIME: 15;
+    readonly SQL_CONVERT_TIMESTAMP: 16;
+    readonly SQL_CONVERT_TINYINT: 17;
+    readonly SQL_CONVERT_VARBINARY: 18;
+    readonly SQL_CONVERT_VARCHAR: 19;
+    readonly UNRECOGNIZED: -1;
+};
+export type SqlSupportsConvert = typeof SqlSupportsConvert[keyof typeof SqlSupportsConvert];
+export declare namespace SqlSupportsConvert {
+    type SQL_CONVERT_BIGINT = typeof SqlSupportsConvert.SQL_CONVERT_BIGINT;
+    type SQL_CONVERT_BINARY = typeof SqlSupportsConvert.SQL_CONVERT_BINARY;
+    type SQL_CONVERT_BIT = typeof SqlSupportsConvert.SQL_CONVERT_BIT;
+    type SQL_CONVERT_CHAR = typeof SqlSupportsConvert.SQL_CONVERT_CHAR;
+    type SQL_CONVERT_DATE = typeof SqlSupportsConvert.SQL_CONVERT_DATE;
+    type SQL_CONVERT_DECIMAL = typeof SqlSupportsConvert.SQL_CONVERT_DECIMAL;
+    type SQL_CONVERT_FLOAT = typeof SqlSupportsConvert.SQL_CONVERT_FLOAT;
+    type SQL_CONVERT_INTEGER = typeof SqlSupportsConvert.SQL_CONVERT_INTEGER;
+    type SQL_CONVERT_INTERVAL_DAY_TIME = typeof SqlSupportsConvert.SQL_CONVERT_INTERVAL_DAY_TIME;
+    type SQL_CONVERT_INTERVAL_YEAR_MONTH = typeof SqlSupportsConvert.SQL_CONVERT_INTERVAL_YEAR_MONTH;
+    type SQL_CONVERT_LONGVARBINARY = typeof SqlSupportsConvert.SQL_CONVERT_LONGVARBINARY;
+    type SQL_CONVERT_LONGVARCHAR = typeof SqlSupportsConvert.SQL_CONVERT_LONGVARCHAR;
+    type SQL_CONVERT_NUMERIC = typeof SqlSupportsConvert.SQL_CONVERT_NUMERIC;
+    type SQL_CONVERT_REAL = typeof SqlSupportsConvert.SQL_CONVERT_REAL;
+    type SQL_CONVERT_SMALLINT = typeof SqlSupportsConvert.SQL_CONVERT_SMALLINT;
+    type SQL_CONVERT_TIME = typeof SqlSupportsConvert.SQL_CONVERT_TIME;
+    type SQL_CONVERT_TIMESTAMP = typeof SqlSupportsConvert.SQL_CONVERT_TIMESTAMP;
+    type SQL_CONVERT_TINYINT = typeof SqlSupportsConvert.SQL_CONVERT_TINYINT;
+    type SQL_CONVERT_VARBINARY = typeof SqlSupportsConvert.SQL_CONVERT_VARBINARY;
+    type SQL_CONVERT_VARCHAR = typeof SqlSupportsConvert.SQL_CONVERT_VARCHAR;
+    type UNRECOGNIZED = typeof SqlSupportsConvert.UNRECOGNIZED;
+}
+export declare function sqlSupportsConvertFromJSON(object: any): SqlSupportsConvert;
+export declare function sqlSupportsConvertToJSON(object: SqlSupportsConvert): string;
+/**
+ * The JDBC/ODBC-defined type of any object.
+ * All the values here are the same as in the JDBC and ODBC specs.
+ */
+export declare const XdbcDataType: {
+    readonly XDBC_UNKNOWN_TYPE: 0;
+    readonly XDBC_CHAR: 1;
+    readonly XDBC_NUMERIC: 2;
+    readonly XDBC_DECIMAL: 3;
+    readonly XDBC_INTEGER: 4;
+    readonly XDBC_SMALLINT: 5;
+    readonly XDBC_FLOAT: 6;
+    readonly XDBC_REAL: 7;
+    readonly XDBC_DOUBLE: 8;
+    readonly XDBC_DATETIME: 9;
+    readonly XDBC_INTERVAL: 10;
+    readonly XDBC_VARCHAR: 12;
+    readonly XDBC_DATE: 91;
+    readonly XDBC_TIME: 92;
+    readonly XDBC_TIMESTAMP: 93;
+    readonly XDBC_LONGVARCHAR: -1;
+    readonly XDBC_BINARY: -2;
+    readonly XDBC_VARBINARY: -3;
+    readonly XDBC_LONGVARBINARY: -4;
+    readonly XDBC_BIGINT: -5;
+    readonly XDBC_TINYINT: -6;
+    readonly XDBC_BIT: -7;
+    readonly XDBC_WCHAR: -8;
+    readonly XDBC_WVARCHAR: -9;
+};
+export type XdbcDataType = typeof XdbcDataType[keyof typeof XdbcDataType];
+export declare namespace XdbcDataType {
+    type XDBC_UNKNOWN_TYPE = typeof XdbcDataType.XDBC_UNKNOWN_TYPE;
+    type XDBC_CHAR = typeof XdbcDataType.XDBC_CHAR;
+    type XDBC_NUMERIC = typeof XdbcDataType.XDBC_NUMERIC;
+    type XDBC_DECIMAL = typeof XdbcDataType.XDBC_DECIMAL;
+    type XDBC_INTEGER = typeof XdbcDataType.XDBC_INTEGER;
+    type XDBC_SMALLINT = typeof XdbcDataType.XDBC_SMALLINT;
+    type XDBC_FLOAT = typeof XdbcDataType.XDBC_FLOAT;
+    type XDBC_REAL = typeof XdbcDataType.XDBC_REAL;
+    type XDBC_DOUBLE = typeof XdbcDataType.XDBC_DOUBLE;
+    type XDBC_DATETIME = typeof XdbcDataType.XDBC_DATETIME;
+    type XDBC_INTERVAL = typeof XdbcDataType.XDBC_INTERVAL;
+    type XDBC_VARCHAR = typeof XdbcDataType.XDBC_VARCHAR;
+    type XDBC_DATE = typeof XdbcDataType.XDBC_DATE;
+    type XDBC_TIME = typeof XdbcDataType.XDBC_TIME;
+    type XDBC_TIMESTAMP = typeof XdbcDataType.XDBC_TIMESTAMP;
+    type XDBC_LONGVARCHAR = typeof XdbcDataType.XDBC_LONGVARCHAR;
+    type XDBC_BINARY = typeof XdbcDataType.XDBC_BINARY;
+    type XDBC_VARBINARY = typeof XdbcDataType.XDBC_VARBINARY;
+    type XDBC_LONGVARBINARY = typeof XdbcDataType.XDBC_LONGVARBINARY;
+    type XDBC_BIGINT = typeof XdbcDataType.XDBC_BIGINT;
+    type XDBC_TINYINT = typeof XdbcDataType.XDBC_TINYINT;
+    type XDBC_BIT = typeof XdbcDataType.XDBC_BIT;
+    type XDBC_WCHAR = typeof XdbcDataType.XDBC_WCHAR;
+    type XDBC_WVARCHAR = typeof XdbcDataType.XDBC_WVARCHAR;
+}
+export declare function xdbcDataTypeFromJSON(object: any): XdbcDataType;
+export declare function xdbcDataTypeToJSON(object: XdbcDataType): string;
+/** Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL. */
+export declare const XdbcDatetimeSubcode: {
+    readonly XDBC_SUBCODE_UNKNOWN: 0;
+    readonly XDBC_SUBCODE_YEAR: 1;
+    readonly XDBC_SUBCODE_DATE: 1;
+    readonly XDBC_SUBCODE_TIME: 2;
+    readonly XDBC_SUBCODE_MONTH: 2;
+    readonly XDBC_SUBCODE_TIMESTAMP: 3;
+    readonly XDBC_SUBCODE_DAY: 3;
+    readonly XDBC_SUBCODE_TIME_WITH_TIMEZONE: 4;
+    readonly XDBC_SUBCODE_HOUR: 4;
+    readonly XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE: 5;
+    readonly XDBC_SUBCODE_MINUTE: 5;
+    readonly XDBC_SUBCODE_SECOND: 6;
+    readonly XDBC_SUBCODE_YEAR_TO_MONTH: 7;
+    readonly XDBC_SUBCODE_DAY_TO_HOUR: 8;
+    readonly XDBC_SUBCODE_DAY_TO_MINUTE: 9;
+    readonly XDBC_SUBCODE_DAY_TO_SECOND: 10;
+    readonly XDBC_SUBCODE_HOUR_TO_MINUTE: 11;
+    readonly XDBC_SUBCODE_HOUR_TO_SECOND: 12;
+    readonly XDBC_SUBCODE_MINUTE_TO_SECOND: 13;
+    readonly XDBC_SUBCODE_INTERVAL_YEAR: 101;
+    readonly XDBC_SUBCODE_INTERVAL_MONTH: 102;
+    readonly XDBC_SUBCODE_INTERVAL_DAY: 103;
+    readonly XDBC_SUBCODE_INTERVAL_HOUR: 104;
+    readonly XDBC_SUBCODE_INTERVAL_MINUTE: 105;
+    readonly XDBC_SUBCODE_INTERVAL_SECOND: 106;
+    readonly XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH: 107;
+    readonly XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR: 108;
+    readonly XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE: 109;
+    readonly XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND: 110;
+    readonly XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE: 111;
+    readonly XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND: 112;
+    readonly XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND: 113;
+    readonly UNRECOGNIZED: -1;
+};
+export type XdbcDatetimeSubcode = typeof XdbcDatetimeSubcode[keyof typeof XdbcDatetimeSubcode];
+export declare namespace XdbcDatetimeSubcode {
+    type XDBC_SUBCODE_UNKNOWN = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_UNKNOWN;
+    type XDBC_SUBCODE_YEAR = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_YEAR;
+    type XDBC_SUBCODE_DATE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_DATE;
+    type XDBC_SUBCODE_TIME = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_TIME;
+    type XDBC_SUBCODE_MONTH = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_MONTH;
+    type XDBC_SUBCODE_TIMESTAMP = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_TIMESTAMP;
+    type XDBC_SUBCODE_DAY = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_DAY;
+    type XDBC_SUBCODE_TIME_WITH_TIMEZONE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_TIME_WITH_TIMEZONE;
+    type XDBC_SUBCODE_HOUR = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_HOUR;
+    type XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE;
+    type XDBC_SUBCODE_MINUTE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_MINUTE;
+    type XDBC_SUBCODE_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_SECOND;
+    type XDBC_SUBCODE_YEAR_TO_MONTH = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_YEAR_TO_MONTH;
+    type XDBC_SUBCODE_DAY_TO_HOUR = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_DAY_TO_HOUR;
+    type XDBC_SUBCODE_DAY_TO_MINUTE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_DAY_TO_MINUTE;
+    type XDBC_SUBCODE_DAY_TO_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_DAY_TO_SECOND;
+    type XDBC_SUBCODE_HOUR_TO_MINUTE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_HOUR_TO_MINUTE;
+    type XDBC_SUBCODE_HOUR_TO_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_HOUR_TO_SECOND;
+    type XDBC_SUBCODE_MINUTE_TO_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_MINUTE_TO_SECOND;
+    type XDBC_SUBCODE_INTERVAL_YEAR = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_YEAR;
+    type XDBC_SUBCODE_INTERVAL_MONTH = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_MONTH;
+    type XDBC_SUBCODE_INTERVAL_DAY = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_DAY;
+    type XDBC_SUBCODE_INTERVAL_HOUR = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_HOUR;
+    type XDBC_SUBCODE_INTERVAL_MINUTE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_MINUTE;
+    type XDBC_SUBCODE_INTERVAL_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_SECOND;
+    type XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH;
+    type XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR;
+    type XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE;
+    type XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND;
+    type XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE;
+    type XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND;
+    type XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND = typeof XdbcDatetimeSubcode.XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND;
+    type UNRECOGNIZED = typeof XdbcDatetimeSubcode.UNRECOGNIZED;
+}
+export declare function xdbcDatetimeSubcodeFromJSON(object: any): XdbcDatetimeSubcode;
+export declare function xdbcDatetimeSubcodeToJSON(object: XdbcDatetimeSubcode): string;
+export declare const Nullable: {
+    /** NULLABILITY_NO_NULLS - Indicates that the field does not allow the use of null values. */
+    readonly NULLABILITY_NO_NULLS: 0;
+    /** NULLABILITY_NULLABLE - Indicates that the fields allow the use of null values. */
+    readonly NULLABILITY_NULLABLE: 1;
+    /** NULLABILITY_UNKNOWN - Indicates that nullability of the fields cannot be determined. */
+    readonly NULLABILITY_UNKNOWN: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type Nullable = typeof Nullable[keyof typeof Nullable];
+export declare namespace Nullable {
+    type NULLABILITY_NO_NULLS = typeof Nullable.NULLABILITY_NO_NULLS;
+    type NULLABILITY_NULLABLE = typeof Nullable.NULLABILITY_NULLABLE;
+    type NULLABILITY_UNKNOWN = typeof Nullable.NULLABILITY_UNKNOWN;
+    type UNRECOGNIZED = typeof Nullable.UNRECOGNIZED;
+}
+export declare function nullableFromJSON(object: any): Nullable;
+export declare function nullableToJSON(object: Nullable): string;
+export declare const Searchable: {
+    /** SEARCHABLE_NONE - Indicates that column cannot be used in a WHERE clause. */
+    readonly SEARCHABLE_NONE: 0;
+    /**
+     * SEARCHABLE_CHAR - Indicates that the column can be used in a WHERE clause if it is using a
+     * LIKE operator.
+     */
+    readonly SEARCHABLE_CHAR: 1;
+    /**
+     * SEARCHABLE_BASIC - Indicates that the column can be used In a WHERE clause with any
+     * operator other than LIKE.
+     *
+     * - Allowed operators: comparison, quantified comparison, BETWEEN,
+     *                      DISTINCT, IN, MATCH, and UNIQUE.
+     */
+    readonly SEARCHABLE_BASIC: 2;
+    /** SEARCHABLE_FULL - Indicates that the column can be used in a WHERE clause using any operator. */
+    readonly SEARCHABLE_FULL: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type Searchable = typeof Searchable[keyof typeof Searchable];
+export declare namespace Searchable {
+    type SEARCHABLE_NONE = typeof Searchable.SEARCHABLE_NONE;
+    type SEARCHABLE_CHAR = typeof Searchable.SEARCHABLE_CHAR;
+    type SEARCHABLE_BASIC = typeof Searchable.SEARCHABLE_BASIC;
+    type SEARCHABLE_FULL = typeof Searchable.SEARCHABLE_FULL;
+    type UNRECOGNIZED = typeof Searchable.UNRECOGNIZED;
+}
+export declare function searchableFromJSON(object: any): Searchable;
+export declare function searchableToJSON(object: Searchable): string;
+export declare const UpdateDeleteRules: {
+    readonly CASCADE: 0;
+    readonly RESTRICT: 1;
+    readonly SET_NULL: 2;
+    readonly NO_ACTION: 3;
+    readonly SET_DEFAULT: 4;
+    readonly UNRECOGNIZED: -1;
+};
+export type UpdateDeleteRules = typeof UpdateDeleteRules[keyof typeof UpdateDeleteRules];
+export declare namespace UpdateDeleteRules {
+    type CASCADE = typeof UpdateDeleteRules.CASCADE;
+    type RESTRICT = typeof UpdateDeleteRules.RESTRICT;
+    type SET_NULL = typeof UpdateDeleteRules.SET_NULL;
+    type NO_ACTION = typeof UpdateDeleteRules.NO_ACTION;
+    type SET_DEFAULT = typeof UpdateDeleteRules.SET_DEFAULT;
+    type UNRECOGNIZED = typeof UpdateDeleteRules.UNRECOGNIZED;
+}
+export declare function updateDeleteRulesFromJSON(object: any): UpdateDeleteRules;
+export declare function updateDeleteRulesToJSON(object: UpdateDeleteRules): string;
+/**
+ * Represents a metadata request. Used in the command member of FlightDescriptor
+ * for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  info_name: uint32 not null,
+ *  value: dense_union<
+ *              string_value: utf8,
+ *              bool_value: bool,
+ *              bigint_value: int64,
+ *              int32_bitmask: int32,
+ *              string_list: list<string_data: utf8>
+ *              int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>>
+ * >
+ * where there is one row per requested piece of metadata information.
+ */
+export interface CommandGetSqlInfo {
+    /**
+     * Values are modelled after ODBC's SQLGetInfo() function. This information is intended to provide
+     * Flight SQL clients with basic, SQL syntax and SQL functions related information.
+     * More information types can be added in future releases.
+     * E.g. more SQL syntax support types, scalar functions support, type conversion support etc.
+     *
+     * Note that the set of metadata may expand.
+     *
+     * Initially, Flight SQL will support the following information types:
+     * - Server Information - Range [0-500)
+     * - Syntax Information - Range [500-1000)
+     * Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options).
+     * Custom options should start at 10,000.
+     *
+     * If omitted, then all metadata will be retrieved.
+     * Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
+     * at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
+     * If additional metadata is included, the metadata IDs should start from 10,000.
+     */
+    info: number[];
+}
+/**
+ * Represents a request to retrieve information about data type supported on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned schema will be:
+ * <
+ *   type_name: utf8 not null (The name of the data type, for example: VARCHAR, INTEGER, etc),
+ *   data_type: int32 not null (The SQL data type),
+ *   column_size: int32 (The maximum size supported by that column.
+ *                       In case of exact numeric types, this represents the maximum precision.
+ *                       In case of string types, this represents the character length.
+ *                       In case of datetime data types, this represents the length in characters of the string representation.
+ *                       NULL is returned for data types where column size is not applicable.),
+ *   literal_prefix: utf8 (Character or characters used to prefix a literal, NULL is returned for
+ *                         data types where a literal prefix is not applicable.),
+ *   literal_suffix: utf8 (Character or characters used to terminate a literal,
+ *                         NULL is returned for data types where a literal suffix is not applicable.),
+ *   create_params: list<utf8 not null>
+ *                        (A list of keywords corresponding to which parameters can be used when creating
+ *                         a column for that specific type.
+ *                         NULL is returned if there are no parameters for the data type definition.),
+ *   nullable: int32 not null (Shows if the data type accepts a NULL value. The possible values can be seen in the
+ *                             Nullable enum.),
+ *   case_sensitive: bool not null (Shows if a character data type is case-sensitive in collations and comparisons),
+ *   searchable: int32 not null (Shows how the data type is used in a WHERE clause. The possible values can be seen in the
+ *                               Searchable enum.),
+ *   unsigned_attribute: bool (Shows if the data type is unsigned. NULL is returned if the attribute is
+ *                             not applicable to the data type or the data type is not numeric.),
+ *   fixed_prec_scale: bool not null (Shows if the data type has predefined fixed precision and scale.),
+ *   auto_increment: bool (Shows if the data type is auto incremental. NULL is returned if the attribute
+ *                         is not applicable to the data type or the data type is not numeric.),
+ *   local_type_name: utf8 (Localized version of the data source-dependent name of the data type. NULL
+ *                          is returned if a localized name is not supported by the data source),
+ *   minimum_scale: int32 (The minimum scale of the data type on the data source.
+ *                         If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE
+ *                         columns both contain this value. NULL is returned if scale is not applicable.),
+ *   maximum_scale: int32 (The maximum scale of the data type on the data source.
+ *                         NULL is returned if scale is not applicable.),
+ *   sql_data_type: int32 not null (The value of the SQL DATA TYPE which has the same values
+ *                                  as data_type value. Except for interval and datetime, which
+ *                                  uses generic values. More info about those types can be
+ *                                  obtained through datetime_subcode. The possible values can be seen
+ *                                  in the XdbcDataType enum.),
+ *   datetime_subcode: int32 (Only used when the SQL DATA TYPE is interval or datetime. It contains
+ *                            its sub types. For type different from interval and datetime, this value
+ *                            is NULL. The possible values can be seen in the XdbcDatetimeSubcode enum.),
+ *   num_prec_radix: int32 (If the data type is an approximate numeric type, this column contains
+ *                          the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For
+ *                          exact numeric types, this column contains the value 10 to indicate that
+ *                          column size specifies a number of decimal digits. Otherwise, this column is NULL.),
+ *   interval_precision: int32 (If the data type is an interval data type, then this column contains the value
+ *                              of the interval leading precision. Otherwise, this column is NULL. This fields
+ *                              is only relevant to be used by ODBC).
+ * >
+ * The returned data should be ordered by data_type and then by type_name.
+ */
+export interface CommandGetXdbcTypeInfo {
+    /** Specifies the data type to search for the info. */
+    dataType?: number | undefined;
+}
+/**
+ * Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
+ * The definition of a catalog depends on vendor/implementation. It is usually the database itself
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8 not null
+ * >
+ * The returned data should be ordered by catalog_name.
+ */
+export interface CommandGetCatalogs {
+}
+/**
+ * Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
+ * The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8,
+ *  db_schema_name: utf8 not null
+ * >
+ * The returned data should be ordered by catalog_name, then db_schema_name.
+ */
+export interface CommandGetDbSchemas {
+    /**
+     * Specifies the Catalog to search for the tables.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    catalog?: string | undefined;
+    /**
+     * Specifies a filter pattern for schemas to search for.
+     * When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
+     * In the pattern string, two special characters can be used to denote matching rules:
+     *    - "%" means to match any substring with 0 or more characters.
+     *    - "_" means to match any one character.
+     */
+    dbSchemaFilterPattern?: string | undefined;
+}
+/**
+ * Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8,
+ *  db_schema_name: utf8,
+ *  table_name: utf8 not null,
+ *  table_type: utf8 not null,
+ *  [optional] table_schema: bytes not null (schema of the table as described in Schema.fbs::Schema,
+ *                                           it is serialized as an IPC message.)
+ * >
+ * Fields on table_schema may contain the following metadata:
+ *  - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+ *  - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+ *  - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+ *  - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+ *  - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+ *  - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+ *  - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+ *  - ARROW:FLIGHT:SQL:REMARKS           - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
+ * The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
+ */
+export interface CommandGetTables {
+    /**
+     * Specifies the Catalog to search for the tables.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    catalog?: string | undefined;
+    /**
+     * Specifies a filter pattern for schemas to search for.
+     * When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
+     * In the pattern string, two special characters can be used to denote matching rules:
+     *    - "%" means to match any substring with 0 or more characters.
+     *    - "_" means to match any one character.
+     */
+    dbSchemaFilterPattern?: string | undefined;
+    /**
+     * Specifies a filter pattern for tables to search for.
+     * When no table_name_filter_pattern is provided, all tables matching other filters are searched.
+     * In the pattern string, two special characters can be used to denote matching rules:
+     *    - "%" means to match any substring with 0 or more characters.
+     *    - "_" means to match any one character.
+     */
+    tableNameFilterPattern?: string | undefined;
+    /**
+     * Specifies a filter of table types which must match.
+     * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+     * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+     */
+    tableTypes: string[];
+    /** Specifies if the Arrow schema should be returned for found tables. */
+    includeSchema: boolean;
+}
+/**
+ * Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
+ * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+ * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  table_type: utf8 not null
+ * >
+ * The returned data should be ordered by table_type.
+ */
+export interface CommandGetTableTypes {
+}
+/**
+ * Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  catalog_name: utf8,
+ *  db_schema_name: utf8,
+ *  table_name: utf8 not null,
+ *  column_name: utf8 not null,
+ *  key_name: utf8,
+ *  key_sequence: int32 not null
+ * >
+ * The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence.
+ */
+export interface CommandGetPrimaryKeys {
+    /**
+     * Specifies the catalog to search for the table.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    catalog?: string | undefined;
+    /**
+     * Specifies the schema to search for the table.
+     * An empty string retrieves those without a schema.
+     * If omitted the schema name should not be used to narrow the search.
+     */
+    dbSchema?: string | undefined;
+    /** Specifies the table to get the primary keys for. */
+    table: string;
+}
+/**
+ * Represents a request to retrieve a description of the foreign key columns that reference the given table's
+ * primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  pk_catalog_name: utf8,
+ *  pk_db_schema_name: utf8,
+ *  pk_table_name: utf8 not null,
+ *  pk_column_name: utf8 not null,
+ *  fk_catalog_name: utf8,
+ *  fk_db_schema_name: utf8,
+ *  fk_table_name: utf8 not null,
+ *  fk_column_name: utf8 not null,
+ *  key_sequence: int32 not null,
+ *  fk_key_name: utf8,
+ *  pk_key_name: utf8,
+ *  update_rule: uint8 not null,
+ *  delete_rule: uint8 not null
+ * >
+ * The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence.
+ * update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum.
+ */
+export interface CommandGetExportedKeys {
+    /**
+     * Specifies the catalog to search for the foreign key table.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    catalog?: string | undefined;
+    /**
+     * Specifies the schema to search for the foreign key table.
+     * An empty string retrieves those without a schema.
+     * If omitted the schema name should not be used to narrow the search.
+     */
+    dbSchema?: string | undefined;
+    /** Specifies the foreign key table to get the foreign keys for. */
+    table: string;
+}
+/**
+ * Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  pk_catalog_name: utf8,
+ *  pk_db_schema_name: utf8,
+ *  pk_table_name: utf8 not null,
+ *  pk_column_name: utf8 not null,
+ *  fk_catalog_name: utf8,
+ *  fk_db_schema_name: utf8,
+ *  fk_table_name: utf8 not null,
+ *  fk_column_name: utf8 not null,
+ *  key_sequence: int32 not null,
+ *  fk_key_name: utf8,
+ *  pk_key_name: utf8,
+ *  update_rule: uint8 not null,
+ *  delete_rule: uint8 not null
+ * >
+ * The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
+ * update_rule and delete_rule returns a byte that is equivalent to actions:
+ *    - 0 = CASCADE
+ *    - 1 = RESTRICT
+ *    - 2 = SET NULL
+ *    - 3 = NO ACTION
+ *    - 4 = SET DEFAULT
+ */
+export interface CommandGetImportedKeys {
+    /**
+     * Specifies the catalog to search for the primary key table.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    catalog?: string | undefined;
+    /**
+     * Specifies the schema to search for the primary key table.
+     * An empty string retrieves those without a schema.
+     * If omitted the schema name should not be used to narrow the search.
+     */
+    dbSchema?: string | undefined;
+    /** Specifies the primary key table to get the foreign keys for. */
+    table: string;
+}
+/**
+ * Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
+ * reference the primary key or the columns representing a unique constraint of the parent table (could be the same
+ * or a different table) on a Flight SQL enabled backend.
+ * Used in the command member of FlightDescriptor for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *  - GetFlightInfo: execute the catalog metadata request.
+ *
+ * The returned Arrow schema will be:
+ * <
+ *  pk_catalog_name: utf8,
+ *  pk_db_schema_name: utf8,
+ *  pk_table_name: utf8 not null,
+ *  pk_column_name: utf8 not null,
+ *  fk_catalog_name: utf8,
+ *  fk_db_schema_name: utf8,
+ *  fk_table_name: utf8 not null,
+ *  fk_column_name: utf8 not null,
+ *  key_sequence: int32 not null,
+ *  fk_key_name: utf8,
+ *  pk_key_name: utf8,
+ *  update_rule: uint8 not null,
+ *  delete_rule: uint8 not null
+ * >
+ * The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
+ * update_rule and delete_rule returns a byte that is equivalent to actions:
+ *    - 0 = CASCADE
+ *    - 1 = RESTRICT
+ *    - 2 = SET NULL
+ *    - 3 = NO ACTION
+ *    - 4 = SET DEFAULT
+ */
+export interface CommandGetCrossReference {
+    /**
+     * The catalog name where the parent table is.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    pkCatalog?: string | undefined;
+    /**
+     * The Schema name where the parent table is.
+     * An empty string retrieves those without a schema.
+     * If omitted the schema name should not be used to narrow the search.
+     */
+    pkDbSchema?: string | undefined;
+    /** The parent table name. It cannot be null. */
+    pkTable: string;
+    /**
+     * The catalog name where the foreign table is.
+     * An empty string retrieves those without a catalog.
+     * If omitted the catalog name should not be used to narrow the search.
+     */
+    fkCatalog?: string | undefined;
+    /**
+     * The schema name where the foreign table is.
+     * An empty string retrieves those without a schema.
+     * If omitted the schema name should not be used to narrow the search.
+     */
+    fkDbSchema?: string | undefined;
+    /** The foreign table name. It cannot be null. */
+    fkTable: string;
+}
+/** Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend. */
+export interface ActionCreatePreparedStatementRequest {
+    /** The valid SQL string to create a prepared statement for. */
+    query: string;
+    /**
+     * Create/execute the prepared statement as part of this transaction (if
+     * unset, executions of the prepared statement will be auto-committed).
+     */
+    transactionId?: Buffer | undefined;
+}
+/** An embedded message describing a Substrait plan to execute. */
+export interface SubstraitPlan {
+    /**
+     * The serialized substrait.Plan to create a prepared statement for.
+     * XXX(ARROW-16902): this is bytes instead of an embedded message
+     * because Protobuf does not really support one DLL using Protobuf
+     * definitions from another DLL.
+     */
+    plan: Buffer;
+    /**
+     * The Substrait release, e.g. "0.12.0". This information is not
+     * tracked in the plan itself, so this is the only way for consumers
+     * to potentially know if they can handle the plan.
+     */
+    version: string;
+}
+/** Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend. */
+export interface ActionCreatePreparedSubstraitPlanRequest {
+    /** The serialized substrait.Plan to create a prepared statement for. */
+    plan: SubstraitPlan | undefined;
+    /**
+     * Create/execute the prepared statement as part of this transaction (if
+     * unset, executions of the prepared statement will be auto-committed).
+     */
+    transactionId?: Buffer | undefined;
+}
+/**
+ * Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
+ *
+ * The resultant PreparedStatement can be closed either:
+ * - Manually, through the "ClosePreparedStatement" action;
+ * - Automatically, by a server timeout.
+ *
+ * The result should be wrapped in a google.protobuf.Any message.
+ */
+export interface ActionCreatePreparedStatementResult {
+    /** Opaque handle for the prepared statement on the server. */
+    preparedStatementHandle: Buffer;
+    /**
+     * If a result set generating query was provided, dataset_schema contains the
+     * schema of the result set.  It should be an IPC-encapsulated Schema, as described in Schema.fbs.
+     * For some queries, the schema of the results may depend on the schema of the parameters.  The server
+     * should provide its best guess as to the schema at this point.  Clients must not assume that this
+     * schema, if provided, will be accurate.
+     */
+    datasetSchema: Buffer;
+    /**
+     * If the query provided contained parameters, parameter_schema contains the
+     * schema of the expected parameters.  It should be an IPC-encapsulated Schema, as described in Schema.fbs.
+     */
+    parameterSchema: Buffer;
+}
+/**
+ * Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
+ * Closes server resources associated with the prepared statement handle.
+ */
+export interface ActionClosePreparedStatementRequest {
+    /** Opaque handle for the prepared statement on the server. */
+    preparedStatementHandle: Buffer;
+}
+/**
+ * Request message for the "BeginTransaction" action.
+ * Begins a transaction.
+ */
+export interface ActionBeginTransactionRequest {
+}
+/**
+ * Request message for the "BeginSavepoint" action.
+ * Creates a savepoint within a transaction.
+ *
+ * Only supported if FLIGHT_SQL_SERVER_TRANSACTION returns
+ * SQL_SUPPORTED_TRANSACTION_SAVEPOINT.
+ */
+export interface ActionBeginSavepointRequest {
+    /** The transaction to which a savepoint belongs. */
+    transactionId: Buffer;
+    /** Name for the savepoint. */
+    name: string;
+}
+/**
+ * The result of a "BeginTransaction" action.
+ *
+ * The transaction can be manipulated with the "EndTransaction" action, or
+ * automatically via server timeout. If the transaction times out, then it is
+ * automatically rolled back.
+ *
+ * The result should be wrapped in a google.protobuf.Any message.
+ */
+export interface ActionBeginTransactionResult {
+    /** Opaque handle for the transaction on the server. */
+    transactionId: Buffer;
+}
+/**
+ * The result of a "BeginSavepoint" action.
+ *
+ * The transaction can be manipulated with the "EndSavepoint" action.
+ * If the associated transaction is committed, rolled back, or times
+ * out, then the savepoint is also invalidated.
+ *
+ * The result should be wrapped in a google.protobuf.Any message.
+ */
+export interface ActionBeginSavepointResult {
+    /** Opaque handle for the savepoint on the server. */
+    savepointId: Buffer;
+}
+/**
+ * Request message for the "EndTransaction" action.
+ *
+ * Commit (COMMIT) or rollback (ROLLBACK) the transaction.
+ *
+ * If the action completes successfully, the transaction handle is
+ * invalidated, as are all associated savepoints.
+ */
+export interface ActionEndTransactionRequest {
+    /** Opaque handle for the transaction on the server. */
+    transactionId: Buffer;
+    /** Whether to commit/rollback the given transaction. */
+    action: ActionEndTransactionRequest_EndTransaction;
+}
+export declare const ActionEndTransactionRequest_EndTransaction: {
+    readonly END_TRANSACTION_UNSPECIFIED: 0;
+    /** END_TRANSACTION_COMMIT - Commit the transaction. */
+    readonly END_TRANSACTION_COMMIT: 1;
+    /** END_TRANSACTION_ROLLBACK - Roll back the transaction. */
+    readonly END_TRANSACTION_ROLLBACK: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type ActionEndTransactionRequest_EndTransaction = typeof ActionEndTransactionRequest_EndTransaction[keyof typeof ActionEndTransactionRequest_EndTransaction];
+export declare namespace ActionEndTransactionRequest_EndTransaction {
+    type END_TRANSACTION_UNSPECIFIED = typeof ActionEndTransactionRequest_EndTransaction.END_TRANSACTION_UNSPECIFIED;
+    type END_TRANSACTION_COMMIT = typeof ActionEndTransactionRequest_EndTransaction.END_TRANSACTION_COMMIT;
+    type END_TRANSACTION_ROLLBACK = typeof ActionEndTransactionRequest_EndTransaction.END_TRANSACTION_ROLLBACK;
+    type UNRECOGNIZED = typeof ActionEndTransactionRequest_EndTransaction.UNRECOGNIZED;
+}
+export declare function actionEndTransactionRequest_EndTransactionFromJSON(object: any): ActionEndTransactionRequest_EndTransaction;
+export declare function actionEndTransactionRequest_EndTransactionToJSON(object: ActionEndTransactionRequest_EndTransaction): string;
+/**
+ * Request message for the "EndSavepoint" action.
+ *
+ * Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
+ * savepoint.
+ *
+ * Releasing a savepoint invalidates that savepoint.  Rolling back to
+ * a savepoint does not invalidate the savepoint, but invalidates all
+ * savepoints created after the current savepoint.
+ */
+export interface ActionEndSavepointRequest {
+    /** Opaque handle for the savepoint on the server. */
+    savepointId: Buffer;
+    /** Whether to rollback/release the given savepoint. */
+    action: ActionEndSavepointRequest_EndSavepoint;
+}
+export declare const ActionEndSavepointRequest_EndSavepoint: {
+    readonly END_SAVEPOINT_UNSPECIFIED: 0;
+    /** END_SAVEPOINT_RELEASE - Release the savepoint. */
+    readonly END_SAVEPOINT_RELEASE: 1;
+    /** END_SAVEPOINT_ROLLBACK - Roll back to a savepoint. */
+    readonly END_SAVEPOINT_ROLLBACK: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type ActionEndSavepointRequest_EndSavepoint = typeof ActionEndSavepointRequest_EndSavepoint[keyof typeof ActionEndSavepointRequest_EndSavepoint];
+export declare namespace ActionEndSavepointRequest_EndSavepoint {
+    type END_SAVEPOINT_UNSPECIFIED = typeof ActionEndSavepointRequest_EndSavepoint.END_SAVEPOINT_UNSPECIFIED;
+    type END_SAVEPOINT_RELEASE = typeof ActionEndSavepointRequest_EndSavepoint.END_SAVEPOINT_RELEASE;
+    type END_SAVEPOINT_ROLLBACK = typeof ActionEndSavepointRequest_EndSavepoint.END_SAVEPOINT_ROLLBACK;
+    type UNRECOGNIZED = typeof ActionEndSavepointRequest_EndSavepoint.UNRECOGNIZED;
+}
+export declare function actionEndSavepointRequest_EndSavepointFromJSON(object: any): ActionEndSavepointRequest_EndSavepoint;
+export declare function actionEndSavepointRequest_EndSavepointToJSON(object: ActionEndSavepointRequest_EndSavepoint): string;
+/**
+ * Represents a SQL query. Used in the command member of FlightDescriptor
+ * for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *    Fields on this schema may contain the following metadata:
+ *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+ *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+ *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+ *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+ *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+ *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+ *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:REMARKS           - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
+ *  - GetFlightInfo: execute the query.
+ */
+export interface CommandStatementQuery {
+    /** The SQL syntax. */
+    query: string;
+    /** Include the query as part of this transaction (if unset, the query is auto-committed). */
+    transactionId?: Buffer | undefined;
+}
+/**
+ * Represents a Substrait plan. Used in the command member of FlightDescriptor
+ * for the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *    Fields on this schema may contain the following metadata:
+ *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+ *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+ *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+ *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+ *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+ *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+ *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:REMARKS           - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
+ *  - GetFlightInfo: execute the query.
+ *  - DoPut: execute the query.
+ */
+export interface CommandStatementSubstraitPlan {
+    /** A serialized substrait.Plan */
+    plan: SubstraitPlan | undefined;
+    /** Include the query as part of this transaction (if unset, the query is auto-committed). */
+    transactionId?: Buffer | undefined;
+}
+/**
+ * Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
+ * This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this.
+ */
+export interface TicketStatementQuery {
+    /** Unique identifier for the instance of the statement to execute. */
+    statementHandle: Buffer;
+}
+/**
+ * Represents an instance of executing a prepared statement. Used in the command member of FlightDescriptor for
+ * the following RPC calls:
+ *  - GetSchema: return the Arrow schema of the query.
+ *    Fields on this schema may contain the following metadata:
+ *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+ *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+ *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+ *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+ *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+ *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+ *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+ *    - ARROW:FLIGHT:SQL:REMARKS           - A comment describing the column. This field has been added after all others, clients should be prepared to find it missing.
+ *
+ *    If the schema is retrieved after parameter values have been bound with DoPut, then the server should account
+ *    for the parameters when determining the schema.
+ *  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
+ *  - GetFlightInfo: execute the prepared statement instance.
+ */
+export interface CommandPreparedStatementQuery {
+    /** Opaque handle for the prepared statement on the server. */
+    preparedStatementHandle: Buffer;
+}
+/**
+ * Represents a SQL update query. Used in the command member of FlightDescriptor
+ * for the RPC call DoPut to cause the server to execute the included SQL update.
+ */
+export interface CommandStatementUpdate {
+    /** The SQL syntax. */
+    query: string;
+    /** Include the query as part of this transaction (if unset, the query is auto-committed). */
+    transactionId?: Buffer | undefined;
+}
+/**
+ * Represents a SQL update query. Used in the command member of FlightDescriptor
+ * for the RPC call DoPut to cause the server to execute the included
+ * prepared statement handle as an update.
+ */
+export interface CommandPreparedStatementUpdate {
+    /** Opaque handle for the prepared statement on the server. */
+    preparedStatementHandle: Buffer;
+}
+/**
+ * Represents a bulk ingestion request. Used in the command member of FlightDescriptor
+ * for the RPC call DoPut to cause the server load the contents of the stream's
+ * FlightData into the target destination.
+ */
+export interface CommandStatementIngest {
+    /** The behavior for handling the table definition. */
+    tableDefinitionOptions: CommandStatementIngest_TableDefinitionOptions | undefined;
+    /** The table to load data into. */
+    table: string;
+    /** The db_schema of the destination table to load data into. If unset, a backend-specific default may be used. */
+    schema?: string | undefined;
+    /** The catalog of the destination table to load data into. If unset, a backend-specific default may be used. */
+    catalog?: string | undefined;
+    /**
+     * Store ingested data in a temporary table.
+     * The effect of setting temporary is to place the table in a backend-defined namespace, and to drop the table at the end of the session.
+     * The namespacing may make use of a backend-specific schema and/or catalog.
+     * The server should return an error if an explicit choice of schema or catalog is incompatible with the server's namespacing decision.
+     */
+    temporary: boolean;
+    /** Perform the ingestion as part of this transaction. If specified, results should not be committed in the event of an error/cancellation. */
+    transactionId?: Buffer | undefined;
+    /** Backend-specific options. */
+    options: {
+        [key: string]: string;
+    };
+}
+/** Options for table definition behavior */
+export interface CommandStatementIngest_TableDefinitionOptions {
+    ifNotExist: CommandStatementIngest_TableDefinitionOptions_TableNotExistOption;
+    ifExists: CommandStatementIngest_TableDefinitionOptions_TableExistsOption;
+}
+/** The action to take if the target table does not exist */
+export declare const CommandStatementIngest_TableDefinitionOptions_TableNotExistOption: {
+    /** TABLE_NOT_EXIST_OPTION_UNSPECIFIED - Do not use. Servers should error if this is specified by a client. */
+    readonly TABLE_NOT_EXIST_OPTION_UNSPECIFIED: 0;
+    /** TABLE_NOT_EXIST_OPTION_CREATE - Create the table if it does not exist */
+    readonly TABLE_NOT_EXIST_OPTION_CREATE: 1;
+    /** TABLE_NOT_EXIST_OPTION_FAIL - Fail if the table does not exist */
+    readonly TABLE_NOT_EXIST_OPTION_FAIL: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type CommandStatementIngest_TableDefinitionOptions_TableNotExistOption = typeof CommandStatementIngest_TableDefinitionOptions_TableNotExistOption[keyof typeof CommandStatementIngest_TableDefinitionOptions_TableNotExistOption];
+export declare namespace CommandStatementIngest_TableDefinitionOptions_TableNotExistOption {
+    type TABLE_NOT_EXIST_OPTION_UNSPECIFIED = typeof CommandStatementIngest_TableDefinitionOptions_TableNotExistOption.TABLE_NOT_EXIST_OPTION_UNSPECIFIED;
+    type TABLE_NOT_EXIST_OPTION_CREATE = typeof CommandStatementIngest_TableDefinitionOptions_TableNotExistOption.TABLE_NOT_EXIST_OPTION_CREATE;
+    type TABLE_NOT_EXIST_OPTION_FAIL = typeof CommandStatementIngest_TableDefinitionOptions_TableNotExistOption.TABLE_NOT_EXIST_OPTION_FAIL;
+    type UNRECOGNIZED = typeof CommandStatementIngest_TableDefinitionOptions_TableNotExistOption.UNRECOGNIZED;
+}
+export declare function commandStatementIngest_TableDefinitionOptions_TableNotExistOptionFromJSON(object: any): CommandStatementIngest_TableDefinitionOptions_TableNotExistOption;
+export declare function commandStatementIngest_TableDefinitionOptions_TableNotExistOptionToJSON(object: CommandStatementIngest_TableDefinitionOptions_TableNotExistOption): string;
+/** The action to take if the target table already exists */
+export declare const CommandStatementIngest_TableDefinitionOptions_TableExistsOption: {
+    /** TABLE_EXISTS_OPTION_UNSPECIFIED - Do not use. Servers should error if this is specified by a client. */
+    readonly TABLE_EXISTS_OPTION_UNSPECIFIED: 0;
+    /** TABLE_EXISTS_OPTION_FAIL - Fail if the table already exists */
+    readonly TABLE_EXISTS_OPTION_FAIL: 1;
+    /** TABLE_EXISTS_OPTION_APPEND - Append to the table if it already exists */
+    readonly TABLE_EXISTS_OPTION_APPEND: 2;
+    /** TABLE_EXISTS_OPTION_REPLACE - Drop and recreate the table if it already exists */
+    readonly TABLE_EXISTS_OPTION_REPLACE: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type CommandStatementIngest_TableDefinitionOptions_TableExistsOption = typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption[keyof typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption];
+export declare namespace CommandStatementIngest_TableDefinitionOptions_TableExistsOption {
+    type TABLE_EXISTS_OPTION_UNSPECIFIED = typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption.TABLE_EXISTS_OPTION_UNSPECIFIED;
+    type TABLE_EXISTS_OPTION_FAIL = typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption.TABLE_EXISTS_OPTION_FAIL;
+    type TABLE_EXISTS_OPTION_APPEND = typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption.TABLE_EXISTS_OPTION_APPEND;
+    type TABLE_EXISTS_OPTION_REPLACE = typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption.TABLE_EXISTS_OPTION_REPLACE;
+    type UNRECOGNIZED = typeof CommandStatementIngest_TableDefinitionOptions_TableExistsOption.UNRECOGNIZED;
+}
+export declare function commandStatementIngest_TableDefinitionOptions_TableExistsOptionFromJSON(object: any): CommandStatementIngest_TableDefinitionOptions_TableExistsOption;
+export declare function commandStatementIngest_TableDefinitionOptions_TableExistsOptionToJSON(object: CommandStatementIngest_TableDefinitionOptions_TableExistsOption): string;
+export interface CommandStatementIngest_OptionsEntry {
+    key: string;
+    value: string;
+}
+/**
+ * Returned from the RPC call DoPut when a CommandStatementUpdate,
+ * CommandPreparedStatementUpdate, or CommandStatementIngest was
+ * in the request, containing results from the update.
+ */
+export interface DoPutUpdateResult {
+    /**
+     * The number of records updated. A return value of -1 represents
+     * an unknown updated record count.
+     */
+    recordCount: number;
+}
+/**
+ * An *optional* response returned when `DoPut` is called with `CommandPreparedStatementQuery`.
+ *
+ * *Note on legacy behavior*: previous versions of the protocol did not return any result for
+ * this command, and that behavior should still be supported by clients. In that case, the client
+ * can continue as though the fields in this message were not provided or set to sensible default values.
+ */
+export interface DoPutPreparedStatementResult {
+    /**
+     * Represents a (potentially updated) opaque handle for the prepared statement on the server.
+     * Because the handle could potentially be updated, any previous handles for this prepared
+     * statement should be considered invalid, and all subsequent requests for this prepared
+     * statement must use this new handle.
+     * The updated handle allows implementing query parameters with stateless services.
+     *
+     * When an updated handle is not provided by the server, clients should continue
+     * using the previous handle provided by `ActionCreatePreparedStatementResult`.
+     */
+    preparedStatementHandle?: Buffer | undefined;
+}
+/**
+ * Request message for the "CancelQuery" action.
+ *
+ * Explicitly cancel a running query.
+ *
+ * This lets a single client explicitly cancel work, no matter how many clients
+ * are involved/whether the query is distributed or not, given server support.
+ * The transaction/statement is not rolled back; it is the application's job to
+ * commit or rollback as appropriate. This only indicates the client no longer
+ * wishes to read the remainder of the query results or continue submitting
+ * data.
+ *
+ * This command is idempotent.
+ *
+ * This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
+ * action with DoAction instead.
+ *
+ * @deprecated
+ */
+export interface ActionCancelQueryRequest {
+    /**
+     * The result of the GetFlightInfo RPC that initiated the query.
+     * XXX(ARROW-16902): this must be a serialized FlightInfo, but is
+     * rendered as bytes because Protobuf does not really support one
+     * DLL using Protobuf definitions from another DLL.
+     */
+    info: Buffer;
+}
+/**
+ * The result of cancelling a query.
+ *
+ * The result should be wrapped in a google.protobuf.Any message.
+ *
+ * This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
+ * action with DoAction instead.
+ *
+ * @deprecated
+ */
+export interface ActionCancelQueryResult {
+    result: ActionCancelQueryResult_CancelResult;
+}
+export declare const ActionCancelQueryResult_CancelResult: {
+    /**
+     * CANCEL_RESULT_UNSPECIFIED - The cancellation status is unknown. Servers should avoid using
+     * this value (send a NOT_FOUND error if the requested query is
+     * not known). Clients can retry the request.
+     */
+    readonly CANCEL_RESULT_UNSPECIFIED: 0;
+    /**
+     * CANCEL_RESULT_CANCELLED - The cancellation request is complete. Subsequent requests with
+     * the same payload may return CANCELLED or a NOT_FOUND error.
+     */
+    readonly CANCEL_RESULT_CANCELLED: 1;
+    /**
+     * CANCEL_RESULT_CANCELLING - The cancellation request is in progress. The client may retry
+     * the cancellation request.
+     */
+    readonly CANCEL_RESULT_CANCELLING: 2;
+    /**
+     * CANCEL_RESULT_NOT_CANCELLABLE - The query is not cancellable. The client should not retry the
+     * cancellation request.
+     */
+    readonly CANCEL_RESULT_NOT_CANCELLABLE: 3;
+    readonly UNRECOGNIZED: -1;
+};
+export type ActionCancelQueryResult_CancelResult = typeof ActionCancelQueryResult_CancelResult[keyof typeof ActionCancelQueryResult_CancelResult];
+export declare namespace ActionCancelQueryResult_CancelResult {
+    type CANCEL_RESULT_UNSPECIFIED = typeof ActionCancelQueryResult_CancelResult.CANCEL_RESULT_UNSPECIFIED;
+    type CANCEL_RESULT_CANCELLED = typeof ActionCancelQueryResult_CancelResult.CANCEL_RESULT_CANCELLED;
+    type CANCEL_RESULT_CANCELLING = typeof ActionCancelQueryResult_CancelResult.CANCEL_RESULT_CANCELLING;
+    type CANCEL_RESULT_NOT_CANCELLABLE = typeof ActionCancelQueryResult_CancelResult.CANCEL_RESULT_NOT_CANCELLABLE;
+    type UNRECOGNIZED = typeof ActionCancelQueryResult_CancelResult.UNRECOGNIZED;
+}
+export declare function actionCancelQueryResult_CancelResultFromJSON(object: any): ActionCancelQueryResult_CancelResult;
+export declare function actionCancelQueryResult_CancelResultToJSON(object: ActionCancelQueryResult_CancelResult): string;
+export declare const CommandGetSqlInfo: MessageFns<CommandGetSqlInfo>;
+export declare const CommandGetXdbcTypeInfo: MessageFns<CommandGetXdbcTypeInfo>;
+export declare const CommandGetCatalogs: MessageFns<CommandGetCatalogs>;
+export declare const CommandGetDbSchemas: MessageFns<CommandGetDbSchemas>;
+export declare const CommandGetTables: MessageFns<CommandGetTables>;
+export declare const CommandGetTableTypes: MessageFns<CommandGetTableTypes>;
+export declare const CommandGetPrimaryKeys: MessageFns<CommandGetPrimaryKeys>;
+export declare const CommandGetExportedKeys: MessageFns<CommandGetExportedKeys>;
+export declare const CommandGetImportedKeys: MessageFns<CommandGetImportedKeys>;
+export declare const CommandGetCrossReference: MessageFns<CommandGetCrossReference>;
+export declare const ActionCreatePreparedStatementRequest: MessageFns<ActionCreatePreparedStatementRequest>;
+export declare const SubstraitPlan: MessageFns<SubstraitPlan>;
+export declare const ActionCreatePreparedSubstraitPlanRequest: MessageFns<ActionCreatePreparedSubstraitPlanRequest>;
+export declare const ActionCreatePreparedStatementResult: MessageFns<ActionCreatePreparedStatementResult>;
+export declare const ActionClosePreparedStatementRequest: MessageFns<ActionClosePreparedStatementRequest>;
+export declare const ActionBeginTransactionRequest: MessageFns<ActionBeginTransactionRequest>;
+export declare const ActionBeginSavepointRequest: MessageFns<ActionBeginSavepointRequest>;
+export declare const ActionBeginTransactionResult: MessageFns<ActionBeginTransactionResult>;
+export declare const ActionBeginSavepointResult: MessageFns<ActionBeginSavepointResult>;
+export declare const ActionEndTransactionRequest: MessageFns<ActionEndTransactionRequest>;
+export declare const ActionEndSavepointRequest: MessageFns<ActionEndSavepointRequest>;
+export declare const CommandStatementQuery: MessageFns<CommandStatementQuery>;
+export declare const CommandStatementSubstraitPlan: MessageFns<CommandStatementSubstraitPlan>;
+export declare const TicketStatementQuery: MessageFns<TicketStatementQuery>;
+export declare const CommandPreparedStatementQuery: MessageFns<CommandPreparedStatementQuery>;
+export declare const CommandStatementUpdate: MessageFns<CommandStatementUpdate>;
+export declare const CommandPreparedStatementUpdate: MessageFns<CommandPreparedStatementUpdate>;
+export declare const CommandStatementIngest: MessageFns<CommandStatementIngest>;
+export declare const CommandStatementIngest_TableDefinitionOptions: MessageFns<CommandStatementIngest_TableDefinitionOptions>;
+export declare const CommandStatementIngest_OptionsEntry: MessageFns<CommandStatementIngest_OptionsEntry>;
+export declare const DoPutUpdateResult: MessageFns<DoPutUpdateResult>;
+export declare const DoPutPreparedStatementResult: MessageFns<DoPutPreparedStatementResult>;
+export declare const ActionCancelQueryRequest: MessageFns<ActionCancelQueryRequest>;
+export declare const ActionCancelQueryResult: MessageFns<ActionCancelQueryResult>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};
+//# sourceMappingURL=FlightSql.d.ts.map