kern-orm 0.8.0 → 0.9.0

package/dist/{index-B1aH5Ht0.d.mts → index-2z5iTzXf.d.mts}

@@ -244,11 +244,19 @@ interface DriverResult {
  * It rejects with `QueryError` a statement or script that PostgreSQL rejected, whose connection stays usable, and with `ConnectionError` any other failure of a statement, a script, or a connection.
  */
 interface Driver {
-  /** Whether the driver closes a reserved connection that it cannot return to the pool, such as one left in a transaction or lost; a driver over a client that cannot close one, such as postgres.js 3, keeps it reserved instead. */
-  readonly closesReservedConnections: boolean;
-  /** Executes a statement on any pooled connection. */
+  /**
+   * Executes a statement on any pooled connection.
+   *
+   * It rejects a statement that leaves its connection in a transaction, such as `BEGIN`, with `ConnectionError`, and leaves no transaction open on the pool.
+   */
   execute(statement: SqlStatement): Promise<DriverResult>;
-  /** Executes a script of statements without parameters, such as DDL separated by semicolons, on any pooled connection, where PostgreSQL runs them in one implicit transaction. */
+  /**
+   * Executes a script of statements without parameters, such as DDL separated by semicolons, on any pooled connection, where PostgreSQL runs them in one implicit transaction.
+   *
+   * It rejects a script that leaves its connection in a transaction as `execute` rejects such a statement.
+   * A script whose statement PostgreSQL rejected in that transaction may reject with that `QueryError` instead.
+   * Either way, no transaction stays open on the pool.
+   */
   executeScript(text: string): Promise<void>;
   /** Reserves a dedicated connection, such as for a transaction. */
   acquire(): Promise<Connection>;
@@ -270,16 +278,12 @@ interface Connection {
   /** Executes a script of statements without parameters on the connection, in the order of calls with its statements. */
   executeScript(text: string): Promise<void>;
   /**
-   * Returns the connection to the pool.
+   * Returns the connection to the pool once its statements complete, if PostgreSQL reported an idle transaction status after the last statement; otherwise the driver closes it, which rolls back a transaction left on it.
    *
-   * Without `failure`, the connection is idle: no transaction ran on it, or its `COMMIT` or `ROLLBACK` completed.
-   * With `failure`, the last statement on the connection failed, such as `BEGIN`, `COMMIT`, or `ROLLBACK`, so the connection may be in a transaction or lost: the driver returns it to the pool only once it is idle, and never returns a connection it lost.
+   * The driver tells by itself how the statements on the connection ended.
+   * After a `ConnectionError`, a statement may still run or the connection may be lost, so the driver closes the connection, unless its client refused the statement without breaking the exchange of messages and still reads the status, such as postgres.js 4 for a statement of too many parameters.
    */
-  release(failure?: TransactionFailure): void | Promise<void>;
-}
-/** Failure of the last statement on a reserved connection, after which the connection may not be idle. */
-interface TransactionFailure {
-  readonly error: unknown;
+  release(): void | Promise<void>;
 }
 /** Field of a compiled result: the key of a record and how its value is decoded. */
 type ResultField = ScalarField | NestedField;
@@ -2707,6 +2711,21 @@ interface TestTransactionOptions {
    * Queries that the test has already sent complete before the rollback.
    */
   signal?: AbortSignal;
+  /**
+   * Isolation level of the test transaction, such as `serializable`, for code under test that starts a transaction at that level.
+   *
+   * Inside a test fixture, the test transaction runs at the level of the fixture: given another level, it rejects.
+   */
+  isolation?: IsolationLevel;
+}
+/** Options of `useTestFixture`. */
+interface TestFixtureOptions {
+  /**
+   * Isolation level of the transaction of the fixture, such as `serializable`, at which the test transactions and fixtures nested in it run.
+   *
+   * A fixture nested in another one runs at the level of that fixture: given another level, it rejects.
+   */
+  isolation?: IsolationLevel;
 }
 /** Test transactions and test fixtures of a database created with `test: true`. */
 interface TestHelpers {
@@ -2725,7 +2744,7 @@ interface TestHelpers {
    * Test fixtures nest: a new one opens inside the innermost open one, and test transactions run in the innermost one.
    * A fixture whose `seed` rejects rolls back and closes.
    */
-  useTestFixture<T>(seed: () => Promise<T>): TestFixture<T>;
+  useTestFixture<T>(seed: () => Promise<T>, options?: TestFixtureOptions): TestFixture<T>;
 }
 /** Creates the test helpers of a database created with `test: true`, registering fixtures with the hooks of a test runner. */
 declare function createTestHelpers(database: Database, hooks: TestHooks): TestHelpers;
@@ -2739,17 +2758,16 @@ declare class TransactionCoordinator {
   readonly driver: Driver;
   /** Rejects statements and transactions outside a test transaction or the seed of a test fixture instead of running them on the pool. */
   readonly test: boolean;
-  constructor(driver: Driver,
-  /** Rejects statements and transactions outside a test transaction or the seed of a test fixture instead of running them on the pool. */
-  test?: boolean);
+  constructor(driver: Driver, { test, onReleaseError }?: Omit<DatabaseOptions, "driver">);
   execute(statement: SqlStatement): Promise<DriverResult>;
   /** Executes a script of statements without parameters where `execute` executes a statement. */
   executeScript(text: string): Promise<void>;
   /**
    * Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
    *
-   * Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
+   * Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends, and rejects without the savepoint when the isolation level of `options` differs from that of the transaction.
    * A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
+   * A transaction that it starts rolls back instead of `COMMIT` after a `ConnectionError` on its connection, and when it rejects after such an error, also of `COMMIT`, it rejects with `TransactionConnectionError` of the phase of the failure, whose `cause` is the error it would reject with otherwise.
    */
   transaction<T>(callback: () => Promise<T>, options?: TransactionOptions): Promise<T>;
   /**
@@ -2774,21 +2792,21 @@ declare class TransactionCoordinator {
    * A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
    * Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
    */
-  testTransaction<T>(callback: () => Promise<T>, { signal }?: TestTransactionOptions): Promise<T>;
+  testTransaction<T>(callback: () => Promise<T>, options?: TestTransactionOptions): Promise<T>;
   /**
    * Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
    *
    * Test transactions started outside any transaction run in the innermost fixture.
    * A fixture whose `seed` rejects rolls back and closes.
    */
-  createTestFixture<T>(seed: () => Promise<T>): Promise<OpenedTestFixture<T>>;
+  createTestFixture<T>(seed: () => Promise<T>, options?: TestFixtureOptions): Promise<OpenedTestFixture<T>>;
   /**
    * Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
    *
    * Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
    * Closing an open fixture also closes the fixtures opening in it.
    */
-  startTestFixture<T>(seed: () => Promise<T>): PendingTestFixture<T>;
+  startTestFixture<T>(seed: () => Promise<T>, options?: TestFixtureOptions): PendingTestFixture<T>;
   /**
    * Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
    *
@@ -2854,8 +2872,16 @@ interface Database extends AsyncDisposable {
   /** Rolls back the open test fixtures and closes the connections of the driver once the running transactions end. */
   close(): Promise<void>;
 }
+/** Isolation level of a transaction in PostgreSQL. */
+type IsolationLevel = "read committed" | "repeatable read" | "serializable";
 /** Options of `transaction` of a `Database` and `$transaction` of a `Db`. */
 interface TransactionOptions {
+  /**
+   * Isolation level of the transaction, such as `serializable`.
+   *
+   * A nested transaction runs at the level of its transaction: given another level, it rejects.
+   */
+  isolation?: IsolationLevel;
   /**
    * PostgreSQL schemas where the unqualified names of the statements of the transaction resolve, in their order, such as the schema of a tenant followed by the schema of extensions.
    *
@@ -2868,9 +2894,15 @@ interface DatabaseOptions {
   driver: Driver;
   /** Rejects queries and transactions outside the test transactions and the seeds of test fixtures of `kern-orm/testing`, so that every statement of the tests runs in a transaction that rolls back. */
   test?: boolean;
+  /**
+   * Receives a failure to release the connection of a transaction, such as to log it; the failure does not change the result or error of the transaction.
+   *
+   * Without it, the failure goes to `console.error`.
+   */
+  onReleaseError?: (error: unknown) => void;
 }
 /** Creates a database over a driver; its transactions are shared by every schema bound to it. */
-declare function createDatabase({ driver, test }: DatabaseOptions): Database;
+declare function createDatabase({ driver, ...options }: DatabaseOptions): Database;
 /** Physical placement of the tables of a schema bound to a database. */
 interface BindOptions {
   /** PostgreSQL schema of the tables; a function is called on every query, such as to resolve the current tenant. */
@@ -3361,7 +3393,7 @@ declare class QueryError extends Error {
  * The statement may have run or not, and its connection may be lost or in an unknown state of its transaction.
  */
 declare class ConnectionError extends Error {
-  readonly name = "ConnectionError";
+  readonly name: string;
   constructor(message: string, options?: {
     cause?: unknown;
   });
@@ -3390,6 +3422,307 @@ interface DriverErrorFields {
  * With a translated severity, the SQLSTATE tells an error that ends the session, so a few errors of other codes that end it give `QueryError`.
  */
 declare function toDriverError(error: unknown, fields?: DriverErrorFields): QueryError | ConnectionError;
+/** Phase of a transaction in which its connection failed. */
+type TransactionPhase = TransactionConnectionError["phase"];
+/**
+ * Error of a transaction whose connection failed, which tells whether the transaction may have been committed.
+ *
+ * Its `cause` is the error that the transaction would reject with otherwise, such as the error of the callback, or a `SuppressedError` of a failed rollback that keeps it.
+ */
+declare class TransactionConnectionError extends ConnectionError {
+  readonly name: string;
+  /**
+   * Phase of the transaction in which its connection failed:
+   *
+   * - `begin`: before the callback, such as getting the connection or `BEGIN`, so the transaction applied nothing;
+   * - `transaction`: in the callback or its rollback, so the transaction was rolled back;
+   * - `commit`: during `COMMIT`, so whether the transaction was committed is unknown.
+   */
+  readonly phase: "begin" | "transaction" | "commit";
+  constructor(phase: TransactionPhase, options?: {
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `TransactionConnectionError` of another copy of kern-orm. */
+  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
+}
+/**
+ * Condition names of the SQLSTATE codes of PostgreSQL errors, by code: the codes of type `E` with a condition name, which PL/pgSQL takes in `EXCEPTION WHEN`, under the headings of their classes.
+ *
+ * A code that ends in `000` is the condition of its class.
+ * A few names have two codes, such as `null_value_not_allowed`.
+ */
+declare const conditionsByCode: {
+  readonly "03000": "sql_statement_not_yet_complete";
+  readonly "08000": "connection_exception";
+  readonly "08003": "connection_does_not_exist";
+  readonly "08006": "connection_failure";
+  readonly "08001": "sqlclient_unable_to_establish_sqlconnection";
+  readonly "08004": "sqlserver_rejected_establishment_of_sqlconnection";
+  readonly "08007": "transaction_resolution_unknown";
+  readonly "08P01": "protocol_violation";
+  readonly "09000": "triggered_action_exception";
+  readonly "0A000": "feature_not_supported";
+  readonly "0B000": "invalid_transaction_initiation";
+  readonly "0F000": "locator_exception";
+  readonly "0F001": "invalid_locator_specification";
+  readonly "0L000": "invalid_grantor";
+  readonly "0LP01": "invalid_grant_operation";
+  readonly "0P000": "invalid_role_specification";
+  readonly "0Z000": "diagnostics_exception";
+  readonly "0Z002": "stacked_diagnostics_accessed_without_active_handler";
+  readonly "10608": "invalid_argument_for_xquery";
+  readonly "20000": "case_not_found";
+  readonly "21000": "cardinality_violation";
+  readonly "22000": "data_exception";
+  readonly "2202E": "array_subscript_error";
+  readonly "22021": "character_not_in_repertoire";
+  readonly "22008": "datetime_field_overflow";
+  readonly "22012": "division_by_zero";
+  readonly "22005": "error_in_assignment";
+  readonly "2200B": "escape_character_conflict";
+  readonly "22022": "indicator_overflow";
+  readonly "22015": "interval_field_overflow";
+  readonly "2201E": "invalid_argument_for_logarithm";
+  readonly "22014": "invalid_argument_for_ntile_function";
+  readonly "22016": "invalid_argument_for_nth_value_function";
+  readonly "2201F": "invalid_argument_for_power_function";
+  readonly "2201G": "invalid_argument_for_width_bucket_function";
+  readonly "22018": "invalid_character_value_for_cast";
+  readonly "22007": "invalid_datetime_format";
+  readonly "22019": "invalid_escape_character";
+  readonly "2200D": "invalid_escape_octet";
+  readonly "22025": "invalid_escape_sequence";
+  readonly "22P06": "nonstandard_use_of_escape_character";
+  readonly "22010": "invalid_indicator_parameter_value";
+  readonly "22023": "invalid_parameter_value";
+  readonly "22013": "invalid_preceding_or_following_size";
+  readonly "2201B": "invalid_regular_expression";
+  readonly "2201W": "invalid_row_count_in_limit_clause";
+  readonly "2201X": "invalid_row_count_in_result_offset_clause";
+  readonly "2202H": "invalid_tablesample_argument";
+  readonly "2202G": "invalid_tablesample_repeat";
+  readonly "22009": "invalid_time_zone_displacement_value";
+  readonly "2200C": "invalid_use_of_escape_character";
+  readonly "2200G": "most_specific_type_mismatch";
+  readonly "22004": "null_value_not_allowed";
+  readonly "22002": "null_value_no_indicator_parameter";
+  readonly "22003": "numeric_value_out_of_range";
+  readonly "2200H": "sequence_generator_limit_exceeded";
+  readonly "22026": "string_data_length_mismatch";
+  readonly "22001": "string_data_right_truncation";
+  readonly "22011": "substring_error";
+  readonly "22027": "trim_error";
+  readonly "22024": "unterminated_c_string";
+  readonly "2200F": "zero_length_character_string";
+  readonly "22P01": "floating_point_exception";
+  readonly "22P02": "invalid_text_representation";
+  readonly "22P03": "invalid_binary_representation";
+  readonly "22P04": "bad_copy_file_format";
+  readonly "22P05": "untranslatable_character";
+  readonly "2200L": "not_an_xml_document";
+  readonly "2200M": "invalid_xml_document";
+  readonly "2200N": "invalid_xml_content";
+  readonly "2200S": "invalid_xml_comment";
+  readonly "2200T": "invalid_xml_processing_instruction";
+  readonly "22030": "duplicate_json_object_key_value";
+  readonly "22031": "invalid_argument_for_sql_json_datetime_function";
+  readonly "22032": "invalid_json_text";
+  readonly "22033": "invalid_sql_json_subscript";
+  readonly "22034": "more_than_one_sql_json_item";
+  readonly "22035": "no_sql_json_item";
+  readonly "22036": "non_numeric_sql_json_item";
+  readonly "22037": "non_unique_keys_in_a_json_object";
+  readonly "22038": "singleton_sql_json_item_required";
+  readonly "22039": "sql_json_array_not_found";
+  readonly "2203A": "sql_json_member_not_found";
+  readonly "2203B": "sql_json_number_not_found";
+  readonly "2203C": "sql_json_object_not_found";
+  readonly "2203D": "too_many_json_array_elements";
+  readonly "2203E": "too_many_json_object_members";
+  readonly "2203F": "sql_json_scalar_required";
+  readonly "2203G": "sql_json_item_cannot_be_cast_to_target_type";
+  readonly "23000": "integrity_constraint_violation";
+  readonly "23001": "restrict_violation";
+  readonly "23502": "not_null_violation";
+  readonly "23503": "foreign_key_violation";
+  readonly "23505": "unique_violation";
+  readonly "23514": "check_violation";
+  readonly "23P01": "exclusion_violation";
+  readonly "24000": "invalid_cursor_state";
+  readonly "25000": "invalid_transaction_state";
+  readonly "25001": "active_sql_transaction";
+  readonly "25002": "branch_transaction_already_active";
+  readonly "25008": "held_cursor_requires_same_isolation_level";
+  readonly "25003": "inappropriate_access_mode_for_branch_transaction";
+  readonly "25004": "inappropriate_isolation_level_for_branch_transaction";
+  readonly "25005": "no_active_sql_transaction_for_branch_transaction";
+  readonly "25006": "read_only_sql_transaction";
+  readonly "25007": "schema_and_data_statement_mixing_not_supported";
+  readonly "25P01": "no_active_sql_transaction";
+  readonly "25P02": "in_failed_sql_transaction";
+  readonly "25P03": "idle_in_transaction_session_timeout";
+  readonly "25P04": "transaction_timeout";
+  readonly "26000": "invalid_sql_statement_name";
+  readonly "27000": "triggered_data_change_violation";
+  readonly "28000": "invalid_authorization_specification";
+  readonly "28P01": "invalid_password";
+  readonly "2B000": "dependent_privilege_descriptors_still_exist";
+  readonly "2BP01": "dependent_objects_still_exist";
+  readonly "2D000": "invalid_transaction_termination";
+  readonly "2F000": "sql_routine_exception";
+  readonly "2F005": "function_executed_no_return_statement";
+  readonly "2F002": "modifying_sql_data_not_permitted";
+  readonly "2F003": "prohibited_sql_statement_attempted";
+  readonly "2F004": "reading_sql_data_not_permitted";
+  readonly "34000": "invalid_cursor_name";
+  readonly "38000": "external_routine_exception";
+  readonly "38001": "containing_sql_not_permitted";
+  readonly "38002": "modifying_sql_data_not_permitted";
+  readonly "38003": "prohibited_sql_statement_attempted";
+  readonly "38004": "reading_sql_data_not_permitted";
+  readonly "39000": "external_routine_invocation_exception";
+  readonly "39001": "invalid_sqlstate_returned";
+  readonly "39004": "null_value_not_allowed";
+  readonly "39P01": "trigger_protocol_violated";
+  readonly "39P02": "srf_protocol_violated";
+  readonly "39P03": "event_trigger_protocol_violated";
+  readonly "3B000": "savepoint_exception";
+  readonly "3B001": "invalid_savepoint_specification";
+  readonly "3D000": "invalid_catalog_name";
+  readonly "3F000": "invalid_schema_name";
+  readonly "40000": "transaction_rollback";
+  readonly "40002": "transaction_integrity_constraint_violation";
+  readonly "40001": "serialization_failure";
+  readonly "40003": "statement_completion_unknown";
+  readonly "40P01": "deadlock_detected";
+  readonly "42000": "syntax_error_or_access_rule_violation";
+  readonly "42601": "syntax_error";
+  readonly "42501": "insufficient_privilege";
+  readonly "42846": "cannot_coerce";
+  readonly "42803": "grouping_error";
+  readonly "42P20": "windowing_error";
+  readonly "42P19": "invalid_recursion";
+  readonly "42830": "invalid_foreign_key";
+  readonly "42602": "invalid_name";
+  readonly "42622": "name_too_long";
+  readonly "42939": "reserved_name";
+  readonly "42804": "datatype_mismatch";
+  readonly "42P18": "indeterminate_datatype";
+  readonly "42P21": "collation_mismatch";
+  readonly "42P22": "indeterminate_collation";
+  readonly "42809": "wrong_object_type";
+  readonly "428C9": "generated_always";
+  readonly "42703": "undefined_column";
+  readonly "42883": "undefined_function";
+  readonly "42P01": "undefined_table";
+  readonly "42P02": "undefined_parameter";
+  readonly "42704": "undefined_object";
+  readonly "42701": "duplicate_column";
+  readonly "42P03": "duplicate_cursor";
+  readonly "42P04": "duplicate_database";
+  readonly "42723": "duplicate_function";
+  readonly "42P05": "duplicate_prepared_statement";
+  readonly "42P06": "duplicate_schema";
+  readonly "42P07": "duplicate_table";
+  readonly "42712": "duplicate_alias";
+  readonly "42710": "duplicate_object";
+  readonly "42702": "ambiguous_column";
+  readonly "42725": "ambiguous_function";
+  readonly "42P08": "ambiguous_parameter";
+  readonly "42P09": "ambiguous_alias";
+  readonly "42P10": "invalid_column_reference";
+  readonly "42611": "invalid_column_definition";
+  readonly "42P11": "invalid_cursor_definition";
+  readonly "42P12": "invalid_database_definition";
+  readonly "42P13": "invalid_function_definition";
+  readonly "42P14": "invalid_prepared_statement_definition";
+  readonly "42P15": "invalid_schema_definition";
+  readonly "42P16": "invalid_table_definition";
+  readonly "42P17": "invalid_object_definition";
+  readonly "44000": "with_check_option_violation";
+  readonly "53000": "insufficient_resources";
+  readonly "53100": "disk_full";
+  readonly "53200": "out_of_memory";
+  readonly "53300": "too_many_connections";
+  readonly "53400": "configuration_limit_exceeded";
+  readonly "54000": "program_limit_exceeded";
+  readonly "54001": "statement_too_complex";
+  readonly "54011": "too_many_columns";
+  readonly "54023": "too_many_arguments";
+  readonly "55000": "object_not_in_prerequisite_state";
+  readonly "55006": "object_in_use";
+  readonly "55P02": "cant_change_runtime_param";
+  readonly "55P03": "lock_not_available";
+  readonly "55P04": "unsafe_new_enum_value_usage";
+  readonly "57000": "operator_intervention";
+  readonly "57014": "query_canceled";
+  readonly "57P01": "admin_shutdown";
+  readonly "57P02": "crash_shutdown";
+  readonly "57P03": "cannot_connect_now";
+  readonly "57P04": "database_dropped";
+  readonly "57P05": "idle_session_timeout";
+  readonly "58000": "system_error";
+  readonly "58030": "io_error";
+  readonly "58P01": "undefined_file";
+  readonly "58P02": "duplicate_file";
+  readonly "58P03": "file_name_too_long";
+  readonly F0000: "config_file_error";
+  readonly F0001: "lock_file_exists";
+  readonly HV000: "fdw_error";
+  readonly HV005: "fdw_column_name_not_found";
+  readonly HV002: "fdw_dynamic_parameter_value_needed";
+  readonly HV010: "fdw_function_sequence_error";
+  readonly HV021: "fdw_inconsistent_descriptor_information";
+  readonly HV024: "fdw_invalid_attribute_value";
+  readonly HV007: "fdw_invalid_column_name";
+  readonly HV008: "fdw_invalid_column_number";
+  readonly HV004: "fdw_invalid_data_type";
+  readonly HV006: "fdw_invalid_data_type_descriptors";
+  readonly HV091: "fdw_invalid_descriptor_field_identifier";
+  readonly HV00B: "fdw_invalid_handle";
+  readonly HV00C: "fdw_invalid_option_index";
+  readonly HV00D: "fdw_invalid_option_name";
+  readonly HV090: "fdw_invalid_string_length_or_buffer_length";
+  readonly HV00A: "fdw_invalid_string_format";
+  readonly HV009: "fdw_invalid_use_of_null_pointer";
+  readonly HV014: "fdw_too_many_handles";
+  readonly HV001: "fdw_out_of_memory";
+  readonly HV00P: "fdw_no_schemas";
+  readonly HV00J: "fdw_option_name_not_found";
+  readonly HV00K: "fdw_reply_handle";
+  readonly HV00Q: "fdw_schema_not_found";
+  readonly HV00R: "fdw_table_not_found";
+  readonly HV00L: "fdw_unable_to_create_execution";
+  readonly HV00M: "fdw_unable_to_create_reply";
+  readonly HV00N: "fdw_unable_to_establish_connection";
+  readonly P0000: "plpgsql_error";
+  readonly P0001: "raise_exception";
+  readonly P0002: "no_data_found";
+  readonly P0003: "too_many_rows";
+  readonly P0004: "assert_failure";
+  readonly XX000: "internal_error";
+  readonly XX001: "data_corrupted";
+  readonly XX002: "index_corrupted";
+};
+type ConditionsByCode = typeof conditionsByCode;
+/** Name of a condition of PostgreSQL errors, such as `unique_violation`, or of a class of them, such as `integrity_constraint_violation`. */
+type QueryErrorCondition = ConditionsByCode[keyof ConditionsByCode];
+/**
+ * SQLSTATE codes of each condition, with every code of its class for the condition of a class.
+ *
+ * TypeScript computes the map once, whereas a mapped type of the table for each condition would cost a check of another condition about 70 times as many instantiations.
+ */
+type CodesByCondition = { [K in keyof ConditionsByCode as ConditionsByCode[K]]: K extends `${infer Class}000` ? `${Class}${string}` : K; };
+/** SQLSTATE codes of the condition `C`, with every code of its class for the condition of a class. */
+type QueryErrorCode<C extends QueryErrorCondition> = CodesByCondition[C];
+/**
+ * Tells whether `error` is a `QueryError` of `condition`, including a `QueryError` of another copy of kern-orm.
+ *
+ * The condition of a class, such as `integrity_constraint_violation`, matches every error of its class, as in PL/pgSQL.
+ */
+declare function isQueryError<C extends QueryErrorCondition>(error: unknown, condition: C): error is QueryError & {
+  readonly code: QueryErrorCode<C>;
+};
 /**
  * Defines a reusable expression of a table, which the callbacks of queries over the table call with their columns and any further arguments, such as to filter by it and select it in one query.
  *
@@ -3473,4 +3806,4 @@ declare function param<E extends AnyExpression, V extends (E extends AnyExpressi
  * A run of capital letters is one word, such as `user_id` for `userID`, and digits stay in their word, such as `line2`.
  */
 declare function toSnakeCase(key: string): string;
-export { TransformedQuery as $, Column as $i, QueryContext as $n, Operand as $r, CaseValue as $t, TypedExpression as A, defineTable as Ai, StringAggOptions as An, CombinedCondition as Ar, SelectionState as At, TransactionOptions as B, TransactionFailure as Bi, stringAgg as Bn, OneValueRows as Br, ConflictActionRequired as Bt, textOperators as C, Selectable as Ci, Literal as Cn, PrimaryKeyColumn as Cr, SchemaPartRelations as Ct, BaseOperators as D, TableOptions as Di, CountExpression as Dn, WhereCondition as Dr, AnyRecordQuery as Dt, AnyExpression as E, TableKeys as Ei, AggregateOptions as En, WhereCallback as Er, defineSchema as Et, DbMutationState as F, ResultRows as Fi, countDistinct as Fn, not as Fr, FieldTypes as Ft, TestFixture as G, Type as Gi, OrderTerm as Gn, CompileOptions as Gr, InsertMutationState as Gt, TransactionCoordinator as H, AnyType as Hi, OrderColumns as Hn, ResultByRows as Hr, ConflictTarget as Ht, DbOf as I, Connection as Ii, every as In, or as Ir, InitialSqlQueryState as It, TestTransactionOptions as J, TypeOptions as Ji, SelectedRefs as Jn, HasEquality as Jr, Helper as Jt, TestHelpers as K, TypeInput as Ki, OrderTerms as Kn, EqualityOperator as Kr, MutationQuery as Kt, DbQueryState as L, Driver as Li, max as Ln, ExistsValueType as Lr, SqlQuery as Lt, AnyDb as M, RequiredRelationError as Mi, UnfilteredStringAggOptions as Mn, ConditionOperand as Mr, SelectQueryKind as Mt, BindOptions as N, ResultDecodeError as Ni, avg as Nn, Predicate as Nr, AnySqlQuery as Nt, Expression as O, ToColumns as Oi, GroupAggregateExpression as On, WhereFilter as Or, RecordQuery as Ot, Db as P, ResultMode as Pi, count as Pn, and as Pr, DecodedFields as Pt, SynchronousResult as Q, AnyColumn as Qi, ColumnRefs as Qn, ComparisonSignature as Qr, CaseCondition as Qt, Database as R, DriverResult as Ri, min as Rn, FilteredRows as Rr, SqlQueryState as Rt, TextTypeOperators as S, KeyColumns as Si, SelectionUses as Sn, NotAKey as Sr, SchemaPart as St, orderingOperators as T, TableFactoryOptions as Ti, AggregateExpression as Tn, EqValue as Tr, Tables as Tt, OpenedTestFixture as U, BaseType as Ui, OrderDirection as Un, ValueRows as Ur, InitialInsertState as Ut, createDatabase as V, createStatement as Vi, sum as Vn, QueryResult as Vr, ConflictKeyRequired as Vt, PendingTestFixture as W, TextValue as Wi, OrderKey as Wn, CountValueType as Wr, InitialMutationState as Wt, AnyTransformedQuery as X, TypeTransform as Xi, desc as Xn, equalityOperators as Xr, defineHelper as Xt, createTestHelpers as Y, TypeOutput as Yi, asc as Yn, InSignature as Yr, HelperEffect as Yt, NotSynchronous as Z, defineType as Zi, orderBy as Zn, BooleanResult as Zr, CaseBranch as Zt, TRUE as _, AnyTableKeys as _i, NestedQuery as _n, SelectedOperandType as _r, UsedRelation as _t, sql as a, NoOperators as aa, ValuesQuery as ai, caseWhen as an, SingletonInsertMany as ar, Relation as at, TextLengthSignature as b, ColumnShape as bi, SelectionFieldTypes as bn, GroupTerms as br, AnySchema as bt, MatchResult as c, GenericOperatorImplementation as ca, Grouped as ci, least as cn, ConflictUpdateSet as cr, RelationKey as ct, defineExpression as d, QueryStateOf as di, ExpressionValue as dn, UpdateValues as dr, RequiredMember as dt, ColumnAttributes as ea, OperandValue as ei, FollowingOperand as en, RelationRefs as er, TransformedQueryState as et, ConnectionError as f, QueryValueType as fi, GroupOperandValue as fn, UpsertValues as fr, SchemaContext as ft, FALSE as g, AnyTable as gi, MergeSelection as gn, GroupedState as gr, UsableRelation as gt, toDriverError as h, TableQueryState as hi, GroupedRecord as hn, FoundState as hr, TableRelations as ht, param as i, MergeOperators as ia, TypedScalarQuery as ii, TypedOperandOperators as in, SelectQuery as ir, OneRelationKeys as it, UntypedExpression as j, NotFoundError as ji, UnfilteredAggregateOptions as jn, Condition as jr, AnyQuery as jt, ExpressionOperators as k, createTableFactory as ki, GroupValue as kn, WhereValues as kr, RecordQueryState as kt, NotAColumn as l, OperatorSignature as la, InitialQueryState as li, ColumnFieldTypes as ln, InsertValues as lr, RelationKeys as lt, QueryError as m, SingletonQueryState as mi, GroupedField as mn, FoundQueryState as mr, TableContext as mt, SqlTemplate as n, ToColumn as na, OperandUses as ni, TypedOperand as nn, BoundSelectQuery as nr, MergeRelations as nt, ColumnRefKey as o, OperatorDefinitions as oa, EmptyRecord as oi, coalesce as on, from as or, RelationDeclaration as ot, DriverErrorFields as p, SelectQueryState as pi, GroupSelectionResult as pn, FilteredStateRows as pr, SchemaRelations as pt, TestHooks as q, TypeOperators as qi, Ordering as qn, EqualityOperators as qr, MutationQueryState as qt, identifier as r, BoundOperators as ra, ScalarQuery as ri, TypedOperandInput as rn, ResultOf as rr, NoRelations as rt, MatchCheck as s, GenericOperator as sa, FoundKey as si, greatest as sn, ColumnValue as sr, RelationDeclarations as st, toSnakeCase as t, KeyKind as ta, compare as ti, NullSkippingResult as tn, AnySelectQuery as tr, DeclaredRelations as tt, matches as u, defineGenericOperator as ua, QueryState as ui, ExpressionInput as un, UpdateSet as ur, RelationKind as ut, PatternSignature as v, ColumnDefinitions as vi, SelectedFieldTypes as vn, RowLockOptions as vr, many as vt, NumberTypeOperators as w, Table as wi, literal as wn, PrimaryKeyValues as wr, SchemaTables as wt, TextOperators as x, ColumnValues as xi, SelectionResult as xn, KeyCheck as xr, Schema as xt, TextConversionSignature as y, ColumnOperators as yi, Selection as yn, GroupTerm as yr, one as yt, DatabaseOptions as z, SqlStatement as zi, some as zn, OneRow as zr, AnyMutationQuery as zt };
+export { TestHooks as $, TypeOptions as $i, Ordering as $n, EqualityOperators as $r, MutationQueryState as $t, AnyExpression as A, Table as Ai, literal as An, PrimaryKeyValues as Ar, SchemaTables as At, DbOf as B, ResultMode as Bi, count as Bn, and as Br, DecodedFields as Bt, TextConversionSignature as C, AnyTableKeys as Ci, NestedQuery as Cn, SelectedOperandType as Cr, UsedRelation as Ct, textOperators as D, ColumnValues as Di, SelectionResult as Dn, KeyCheck as Dr, Schema as Dt, TextTypeOperators as E, ColumnShape as Ei, SelectionFieldTypes as En, GroupTerms as Er, AnySchema as Et, UntypedExpression as F, createTableFactory as Fi, GroupValue as Fn, WhereValues as Fr, RecordQueryState as Ft, TransactionOptions as G, SqlStatement as Gi, some as Gn, OneRow as Gr, AnyMutationQuery as Gt, Database as H, Connection as Hi, every as Hn, or as Hr, InitialSqlQueryState as Ht, AnyDb as I, defineTable as Ii, StringAggOptions as In, CombinedCondition as Ir, SelectionState as It, OpenedTestFixture as J, BaseType as Ji, OrderColumns as Jn, ResultByRows as Jr, ConflictTarget as Jt, createDatabase as K, createStatement as Ki, stringAgg as Kn, OneValueRows as Kr, ConflictActionRequired as Kt, BindOptions as L, NotFoundError as Li, UnfilteredAggregateOptions as Ln, Condition as Lr, AnyQuery as Lt, Expression as M, TableKeys as Mi, AggregateOptions as Mn, WhereCallback as Mr, defineSchema as Mt, ExpressionOperators as N, TableOptions as Ni, CountExpression as Nn, WhereCondition as Nr, AnyRecordQuery as Nt, NumberTypeOperators as O, KeyColumns as Oi, SelectionUses as On, NotAKey as Or, SchemaPart as Ot, TypedExpression as P, ToColumns as Pi, GroupAggregateExpression as Pn, WhereFilter as Pr, RecordQuery as Pt, TestHelpers as Q, TypeOperators as Qi, OrderTerms as Qn, EqualityOperator as Qr, MutationQuery as Qt, Db as R, RequiredRelationError as Ri, UnfilteredStringAggOptions as Rn, ConditionOperand as Rr, SelectQueryKind as Rt, PatternSignature as S, AnyTable as Si, MergeSelection as Sn, GroupedState as Sr, UsableRelation as St, TextOperators as T, ColumnOperators as Ti, Selection as Tn, GroupTerm as Tr, one as Tt, DatabaseOptions as U, Driver as Ui, max as Un, ExistsValueType as Ur, SqlQuery as Ut, DbQueryState as V, ResultRows as Vi, countDistinct as Vn, not as Vr, FieldTypes as Vt, IsolationLevel as W, DriverResult as Wi, min as Wn, FilteredRows as Wr, SqlQueryState as Wt, TestFixture as X, Type as Xi, OrderKey as Xn, CountValueType as Xr, InitialMutationState as Xt, PendingTestFixture as Y, TextValue as Yi, OrderDirection as Yn, ValueRows as Yr, InitialInsertState as Yt, TestFixtureOptions as Z, TypeInput as Zi, OrderTerm as Zn, CompileOptions as Zr, InsertMutationState as Zt, DriverErrorFields as _, QueryStateOf as _i, ExpressionValue as _n, UpdateValues as _r, RequiredMember as _t, sql as a, ColumnAttributes as aa, Operand as ai, CaseValue as an, QueryContext as ar, TransformedQuery as at, FALSE as b, SingletonQueryState as bi, GroupedField as bn, FoundQueryState as br, TableContext as bt, MatchResult as c, BoundOperators as ca, OperandUses as ci, TypedOperand as cn, BoundSelectQuery as cr, MergeRelations as ct, defineExpression as d, OperatorDefinitions as da, ValuesQuery as di, caseWhen as dn, SingletonInsertMany as dr, Relation as dt, TypeOutput as ea, HasEquality as ei, Helper as en, SelectedRefs as er, TestTransactionOptions as et, QueryErrorCode as f, GenericOperator as fa, EmptyRecord as fi, coalesce as fn, from as fr, RelationDeclaration as ft, ConnectionError as g, QueryState as gi, ExpressionInput as gn, UpdateSet as gr, RelationKind as gt, TransactionConnectionError as h, defineGenericOperator as ha, InitialQueryState as hi, ColumnFieldTypes as hn, InsertValues as hr, RelationKeys as ht, param as i, Column as ia, ComparisonSignature as ii, CaseCondition as in, ColumnRefs as ir, SynchronousResult as it, BaseOperators as j, TableFactoryOptions as ji, AggregateExpression as jn, EqValue as jr, Tables as jt, orderingOperators as k, Selectable as ki, Literal as kn, PrimaryKeyColumn as kr, SchemaPartRelations as kt, NotAColumn as l, MergeOperators as la, ScalarQuery as li, TypedOperandInput as ln, ResultOf as lr, NoRelations as lt, isQueryError as m, OperatorSignature as ma, Grouped as mi, least as mn, ConflictUpdateSet as mr, RelationKey as mt, SqlTemplate as n, defineType as na, equalityOperators as ni, defineHelper as nn, desc as nr, AnyTransformedQuery as nt, ColumnRefKey as o, KeyKind as oa, OperandValue as oi, FollowingOperand as on, RelationRefs as or, TransformedQueryState as ot, QueryErrorCondition as p, GenericOperatorImplementation as pa, FoundKey as pi, greatest as pn, ColumnValue as pr, RelationDeclarations as pt, TransactionCoordinator as q, AnyType as qi, sum as qn, QueryResult as qr, ConflictKeyRequired as qt, identifier as r, AnyColumn as ra, BooleanResult as ri, CaseBranch as rn, orderBy as rr, NotSynchronous as rt, MatchCheck as s, ToColumn as sa, compare as si, NullSkippingResult as sn, AnySelectQuery as sr, DeclaredRelations as st, toSnakeCase as t, TypeTransform as ta, InSignature as ti, HelperEffect as tn, asc as tr, createTestHelpers as tt, matches as u, NoOperators as ua, TypedScalarQuery as ui, TypedOperandOperators as un, SelectQuery as ur, OneRelationKeys as ut, QueryError as v, QueryValueType as vi, GroupOperandValue as vn, UpsertValues as vr, SchemaContext as vt, TextLengthSignature as w, ColumnDefinitions as wi, SelectedFieldTypes as wn, RowLockOptions as wr, many as wt, TRUE as x, TableQueryState as xi, GroupedRecord as xn, FoundState as xr, TableRelations as xt, toDriverError as y, SelectQueryState as yi, GroupSelectionResult as yn, FilteredStateRows as yr, SchemaRelations as yt, DbMutationState as z, ResultDecodeError as zi, avg as zn, Predicate as zr, AnySqlQuery as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as TransformedQuery, $i as Column, $n as QueryContext, $r as Operand, $t as CaseValue, A as TypedExpression, Ai as defineTable, An as StringAggOptions, Ar as CombinedCondition, At as SelectionState, B as TransactionOptions, Bi as TransactionFailure, Bn as stringAgg, Br as OneValueRows, Bt as ConflictActionRequired, C as textOperators, Ci as Selectable, Cn as Literal, Cr as PrimaryKeyColumn, Ct as SchemaPartRelations, D as BaseOperators, Di as TableOptions, Dn as CountExpression, Dr as WhereCondition, Dt as AnyRecordQuery, E as AnyExpression, Ei as TableKeys, En as AggregateOptions, Er as WhereCallback, Et as defineSchema, F as DbMutationState, Fi as ResultRows, Fn as countDistinct, Fr as not, Ft as FieldTypes, Gi as Type, Gn as OrderTerm, Gr as CompileOptions, Gt as InsertMutationState, H as TransactionCoordinator, Hi as AnyType, Hn as OrderColumns, Hr as ResultByRows, Ht as ConflictTarget, I as DbOf, Ii as Connection, In as every, Ir as or, It as InitialSqlQueryState, Ji as TypeOptions, Jn as SelectedRefs, Jr as HasEquality, Jt as Helper, Ki as TypeInput, Kn as OrderTerms, Kr as EqualityOperator, Kt as MutationQuery, L as DbQueryState, Li as Driver, Ln as max, Lr as ExistsValueType, Lt as SqlQuery, M as AnyDb, Mi as RequiredRelationError, Mn as UnfilteredStringAggOptions, Mr as ConditionOperand, Mt as SelectQueryKind, N as BindOptions, Ni as ResultDecodeError, Nn as avg, Nr as Predicate, Nt as AnySqlQuery, O as Expression, Oi as ToColumns, On as GroupAggregateExpression, Or as WhereFilter, Ot as RecordQuery, P as Db, Pi as ResultMode, Pn as count, Pr as and, Pt as DecodedFields, Q as SynchronousResult, Qi as AnyColumn, Qn as ColumnRefs, Qr as ComparisonSignature, Qt as CaseCondition, R as Database, Ri as DriverResult, Rn as min, Rr as FilteredRows, Rt as SqlQueryState, S as TextTypeOperators, Si as KeyColumns, Sn as SelectionUses, Sr as NotAKey, St as SchemaPart, T as orderingOperators, Ti as TableFactoryOptions, Tn as AggregateExpression, Tr as EqValue, Tt as Tables, Ui as BaseType, Un as OrderDirection, Ur as ValueRows, Ut as InitialInsertState, V as createDatabase, Vi as createStatement, Vn as sum, Vr as QueryResult, Vt as ConflictKeyRequired, Wi as TextValue, Wn as OrderKey, Wr as CountValueType, Wt as InitialMutationState, X as AnyTransformedQuery, Xi as TypeTransform, Xn as desc, Xr as equalityOperators, Xt as defineHelper, Yi as TypeOutput, Yn as asc, Yr as InSignature, Yt as HelperEffect, Z as NotSynchronous, Zi as defineType, Zn as orderBy, Zr as BooleanResult, Zt as CaseBranch, _ as TRUE, _i as AnyTableKeys, _n as NestedQuery, _r as SelectedOperandType, _t as UsedRelation, a as sql, aa as NoOperators, ai as ValuesQuery, an as caseWhen, ar as SingletonInsertMany, at as Relation, b as TextLengthSignature, bi as ColumnShape, bn as SelectionFieldTypes, br as GroupTerms, bt as AnySchema, c as MatchResult, ca as GenericOperatorImplementation, ci as Grouped, cn as least, cr as ConflictUpdateSet, ct as RelationKey, d as defineExpression, di as QueryStateOf, dn as ExpressionValue, dr as UpdateValues, dt as RequiredMember, ea as ColumnAttributes, ei as OperandValue, en as FollowingOperand, er as RelationRefs, et as TransformedQueryState, f as ConnectionError, fi as QueryValueType, fn as GroupOperandValue, fr as UpsertValues, ft as SchemaContext, g as FALSE, gi as AnyTable, gn as MergeSelection, gr as GroupedState, gt as UsableRelation, h as toDriverError, hi as TableQueryState, hn as GroupedRecord, hr as FoundState, ht as TableRelations, i as param, ia as MergeOperators, ii as TypedScalarQuery, in as TypedOperandOperators, ir as SelectQuery, it as OneRelationKeys, j as UntypedExpression, ji as NotFoundError, jn as UnfilteredAggregateOptions, jr as Condition, jt as AnyQuery, k as ExpressionOperators, ki as createTableFactory, kn as GroupValue, kr as WhereValues, kt as RecordQueryState, l as NotAColumn, la as OperatorSignature, li as InitialQueryState, ln as ColumnFieldTypes, lr as InsertValues, lt as RelationKeys, m as QueryError, mi as SingletonQueryState, mn as GroupedField, mr as FoundQueryState, mt as TableContext, n as SqlTemplate, na as ToColumn, ni as OperandUses, nn as TypedOperand, nr as BoundSelectQuery, nt as MergeRelations, o as ColumnRefKey, oa as OperatorDefinitions, oi as EmptyRecord, on as coalesce, or as from, ot as RelationDeclaration, p as DriverErrorFields, pi as SelectQueryState, pn as GroupSelectionResult, pr as FilteredStateRows, pt as SchemaRelations, qi as TypeOperators, qn as Ordering, qr as EqualityOperators, qt as MutationQueryState, r as identifier, ra as BoundOperators, ri as ScalarQuery, rn as TypedOperandInput, rr as ResultOf, rt as NoRelations, s as MatchCheck, sa as GenericOperator, si as FoundKey, sn as greatest, sr as ColumnValue, st as RelationDeclarations, t as toSnakeCase, ta as KeyKind, ti as compare, tn as NullSkippingResult, tr as AnySelectQuery, tt as DeclaredRelations, u as matches, ua as defineGenericOperator, ui as QueryState, un as ExpressionInput, ur as UpdateSet, ut as RelationKind, v as PatternSignature, vi as ColumnDefinitions, vn as SelectedFieldTypes, vr as RowLockOptions, vt as many, w as NumberTypeOperators, wi as Table, wn as literal, wr as PrimaryKeyValues, wt as SchemaTables, x as TextOperators, xi as ColumnValues, xn as SelectionResult, xr as KeyCheck, xt as Schema, y as TextConversionSignature, yi as ColumnOperators, yn as Selection, yr as GroupTerm, yt as one, z as DatabaseOptions, zi as SqlStatement, zn as some, zr as OneRow, zt as AnyMutationQuery } from "./index-B1aH5Ht0.mjs";
-export { type AggregateExpression, type AggregateOptions, type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyTransformedQuery, type AnyType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnFieldTypes, type ColumnOperators, type ColumnRefKey, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type ConflictActionRequired, type ConflictKeyRequired, type ConflictTarget, type ConflictUpdateSet, type Connection, ConnectionError, type CountExpression, type CountValueType, type Database, type DatabaseOptions, type Db, type DbMutationState, type DbOf, type DbQueryState, type DeclaredRelations, type DecodedFields, type Driver, type DriverErrorFields, type DriverResult, type EmptyRecord, type EqValue, type EqualityOperator, type EqualityOperators, type ExistsValueType, type Expression, type ExpressionInput, type ExpressionOperators, type ExpressionValue, FALSE, type FieldTypes, type FilteredRows, type FilteredStateRows, type FollowingOperand, type FoundKey, type FoundQueryState, type FoundState, type GenericOperator, type GenericOperatorImplementation, type GroupAggregateExpression, type GroupOperandValue, type GroupSelectionResult, type GroupTerm, type GroupTerms, type GroupValue, type Grouped, type GroupedField, type GroupedRecord, type GroupedState, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialInsertState, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertMutationState, type InsertValues, type KeyCheck, type KeyColumns, type KeyKind, type Literal, type MatchCheck, type MatchResult, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAColumn, type NotAKey, NotFoundError, type NotSynchronous, type NullSkippingResult, type NumberTypeOperators, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, type OperandUses, type OperandValue, type OperatorDefinitions, type OperatorSignature, type OrderColumns, type OrderDirection, type OrderKey, type OrderTerm, type OrderTerms, type Ordering, type PatternSignature, type Predicate, type PrimaryKeyColumn, type PrimaryKeyValues, type QueryContext, QueryError, type QueryResult, type QueryState, type QueryStateOf, type QueryValueType, type RecordQuery, type RecordQueryState, type Relation, type RelationDeclaration, type RelationDeclarations, type RelationKey, type RelationKeys, type RelationKind, type RelationRefs, type RequiredMember, RequiredRelationError, type ResultByRows, ResultDecodeError, type ResultMode, type ResultOf, type ResultRows, type RowLockOptions, type ScalarQuery, type Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedFieldTypes, type SelectedOperandType, type SelectedRefs, type Selection, type SelectionFieldTypes, type SelectionResult, type SelectionState, type SelectionUses, type SingletonInsertMany, type SingletonQueryState, type SqlQuery, type SqlQueryState, type SqlStatement, type SqlTemplate, type StringAggOptions, type SynchronousResult, TRUE, type Table, type TableContext, type TableFactoryOptions, type TableKeys, type TableOptions, type TableQueryState, type TableRelations, type Tables, type TextConversionSignature, type TextLengthSignature, type TextOperators, type TextTypeOperators, type TextValue, type ToColumn, type ToColumns, type TransactionCoordinator, type TransactionFailure, type TransactionOptions, type TransformedQuery, type TransformedQueryState, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UnfilteredAggregateOptions, type UnfilteredStringAggOptions, type UntypedExpression, type UpdateSet, type UpdateValues, type UpsertValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, and, asc, avg, caseWhen, coalesce, compare, count, countDistinct, createDatabase, createStatement, createTableFactory, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, every, from, greatest, identifier, least, literal, many, matches, max, min, not, one, or, orderBy, orderingOperators, param, some, sql, stringAgg, sum, textOperators, toDriverError, toSnakeCase };
+import { $i as TypeOptions, $n as Ordering, $r as EqualityOperators, $t as MutationQueryState, A as AnyExpression, Ai as Table, An as literal, Ar as PrimaryKeyValues, At as SchemaTables, B as DbOf, Bi as ResultMode, Bn as count, Br as and, Bt as DecodedFields, C as TextConversionSignature, Ci as AnyTableKeys, Cn as NestedQuery, Cr as SelectedOperandType, Ct as UsedRelation, D as textOperators, Di as ColumnValues, Dn as SelectionResult, Dr as KeyCheck, Dt as Schema, E as TextTypeOperators, Ei as ColumnShape, En as SelectionFieldTypes, Er as GroupTerms, Et as AnySchema, F as UntypedExpression, Fi as createTableFactory, Fn as GroupValue, Fr as WhereValues, Ft as RecordQueryState, G as TransactionOptions, Gi as SqlStatement, Gn as some, Gr as OneRow, Gt as AnyMutationQuery, H as Database, Hi as Connection, Hn as every, Hr as or, Ht as InitialSqlQueryState, I as AnyDb, Ii as defineTable, In as StringAggOptions, Ir as CombinedCondition, It as SelectionState, Ji as BaseType, Jn as OrderColumns, Jr as ResultByRows, Jt as ConflictTarget, K as createDatabase, Ki as createStatement, Kn as stringAgg, Kr as OneValueRows, Kt as ConflictActionRequired, L as BindOptions, Li as NotFoundError, Ln as UnfilteredAggregateOptions, Lr as Condition, Lt as AnyQuery, M as Expression, Mi as TableKeys, Mn as AggregateOptions, Mr as WhereCallback, Mt as defineSchema, N as ExpressionOperators, Ni as TableOptions, Nn as CountExpression, Nr as WhereCondition, Nt as AnyRecordQuery, O as NumberTypeOperators, Oi as KeyColumns, On as SelectionUses, Or as NotAKey, Ot as SchemaPart, P as TypedExpression, Pi as ToColumns, Pn as GroupAggregateExpression, Pr as WhereFilter, Pt as RecordQuery, Qi as TypeOperators, Qn as OrderTerms, Qr as EqualityOperator, Qt as MutationQuery, R as Db, Ri as RequiredRelationError, Rn as UnfilteredStringAggOptions, Rr as ConditionOperand, Rt as SelectQueryKind, S as PatternSignature, Si as AnyTable, Sn as MergeSelection, Sr as GroupedState, St as UsableRelation, T as TextOperators, Ti as ColumnOperators, Tn as Selection, Tr as GroupTerm, Tt as one, U as DatabaseOptions, Ui as Driver, Un as max, Ur as ExistsValueType, Ut as SqlQuery, V as DbQueryState, Vi as ResultRows, Vn as countDistinct, Vr as not, Vt as FieldTypes, W as IsolationLevel, Wi as DriverResult, Wn as min, Wr as FilteredRows, Wt as SqlQueryState, Xi as Type, Xn as OrderKey, Xr as CountValueType, Xt as InitialMutationState, Yi as TextValue, Yn as OrderDirection, Yr as ValueRows, Yt as InitialInsertState, Zi as TypeInput, Zn as OrderTerm, Zr as CompileOptions, Zt as InsertMutationState, _ as DriverErrorFields, _i as QueryStateOf, _n as ExpressionValue, _r as UpdateValues, _t as RequiredMember, a as sql, aa as ColumnAttributes, ai as Operand, an as CaseValue, ar as QueryContext, at as TransformedQuery, b as FALSE, bi as SingletonQueryState, bn as GroupedField, br as FoundQueryState, bt as TableContext, c as MatchResult, ca as BoundOperators, ci as OperandUses, cn as TypedOperand, cr as BoundSelectQuery, ct as MergeRelations, d as defineExpression, da as OperatorDefinitions, di as ValuesQuery, dn as caseWhen, dr as SingletonInsertMany, dt as Relation, ea as TypeOutput, ei as HasEquality, en as Helper, er as SelectedRefs, f as QueryErrorCode, fa as GenericOperator, fi as EmptyRecord, fn as coalesce, fr as from, ft as RelationDeclaration, g as ConnectionError, gi as QueryState, gn as ExpressionInput, gr as UpdateSet, gt as RelationKind, h as TransactionConnectionError, ha as defineGenericOperator, hi as InitialQueryState, hn as ColumnFieldTypes, hr as InsertValues, ht as RelationKeys, i as param, ia as Column, ii as ComparisonSignature, in as CaseCondition, ir as ColumnRefs, it as SynchronousResult, j as BaseOperators, ji as TableFactoryOptions, jn as AggregateExpression, jr as EqValue, jt as Tables, k as orderingOperators, ki as Selectable, kn as Literal, kr as PrimaryKeyColumn, kt as SchemaPartRelations, l as NotAColumn, la as MergeOperators, li as ScalarQuery, ln as TypedOperandInput, lr as ResultOf, lt as NoRelations, m as isQueryError, ma as OperatorSignature, mi as Grouped, mn as least, mr as ConflictUpdateSet, mt as RelationKey, n as SqlTemplate, na as defineType, ni as equalityOperators, nn as defineHelper, nr as desc, nt as AnyTransformedQuery, o as ColumnRefKey, oa as KeyKind, oi as OperandValue, on as FollowingOperand, or as RelationRefs, ot as TransformedQueryState, p as QueryErrorCondition, pa as GenericOperatorImplementation, pi as FoundKey, pn as greatest, pr as ColumnValue, pt as RelationDeclarations, q as TransactionCoordinator, qi as AnyType, qn as sum, qr as QueryResult, qt as ConflictKeyRequired, r as identifier, ra as AnyColumn, ri as BooleanResult, rn as CaseBranch, rr as orderBy, rt as NotSynchronous, s as MatchCheck, sa as ToColumn, si as compare, sn as NullSkippingResult, sr as AnySelectQuery, st as DeclaredRelations, t as toSnakeCase, ta as TypeTransform, ti as InSignature, tn as HelperEffect, tr as asc, u as matches, ua as NoOperators, ui as TypedScalarQuery, un as TypedOperandOperators, ur as SelectQuery, ut as OneRelationKeys, v as QueryError, vi as QueryValueType, vn as GroupOperandValue, vr as UpsertValues, vt as SchemaContext, w as TextLengthSignature, wi as ColumnDefinitions, wn as SelectedFieldTypes, wr as RowLockOptions, wt as many, x as TRUE, xi as TableQueryState, xn as GroupedRecord, xr as FoundState, xt as TableRelations, y as toDriverError, yi as SelectQueryState, yn as GroupSelectionResult, yr as FilteredStateRows, yt as SchemaRelations, z as DbMutationState, zi as ResultDecodeError, zn as avg, zr as Predicate, zt as AnySqlQuery } from "./index-2z5iTzXf.mjs";
+export { type AggregateExpression, type AggregateOptions, type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyTransformedQuery, type AnyType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnFieldTypes, type ColumnOperators, type ColumnRefKey, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type ConflictActionRequired, type ConflictKeyRequired, type ConflictTarget, type ConflictUpdateSet, type Connection, ConnectionError, type CountExpression, type CountValueType, type Database, type DatabaseOptions, type Db, type DbMutationState, type DbOf, type DbQueryState, type DeclaredRelations, type DecodedFields, type Driver, type DriverErrorFields, type DriverResult, type EmptyRecord, type EqValue, type EqualityOperator, type EqualityOperators, type ExistsValueType, type Expression, type ExpressionInput, type ExpressionOperators, type ExpressionValue, FALSE, type FieldTypes, type FilteredRows, type FilteredStateRows, type FollowingOperand, type FoundKey, type FoundQueryState, type FoundState, type GenericOperator, type GenericOperatorImplementation, type GroupAggregateExpression, type GroupOperandValue, type GroupSelectionResult, type GroupTerm, type GroupTerms, type GroupValue, type Grouped, type GroupedField, type GroupedRecord, type GroupedState, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialInsertState, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertMutationState, type InsertValues, type IsolationLevel, type KeyCheck, type KeyColumns, type KeyKind, type Literal, type MatchCheck, type MatchResult, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAColumn, type NotAKey, NotFoundError, type NotSynchronous, type NullSkippingResult, type NumberTypeOperators, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, type OperandUses, type OperandValue, type OperatorDefinitions, type OperatorSignature, type OrderColumns, type OrderDirection, type OrderKey, type OrderTerm, type OrderTerms, type Ordering, type PatternSignature, type Predicate, type PrimaryKeyColumn, type PrimaryKeyValues, type QueryContext, QueryError, type QueryErrorCode, type QueryErrorCondition, type QueryResult, type QueryState, type QueryStateOf, type QueryValueType, type RecordQuery, type RecordQueryState, type Relation, type RelationDeclaration, type RelationDeclarations, type RelationKey, type RelationKeys, type RelationKind, type RelationRefs, type RequiredMember, RequiredRelationError, type ResultByRows, ResultDecodeError, type ResultMode, type ResultOf, type ResultRows, type RowLockOptions, type ScalarQuery, type Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedFieldTypes, type SelectedOperandType, type SelectedRefs, type Selection, type SelectionFieldTypes, type SelectionResult, type SelectionState, type SelectionUses, type SingletonInsertMany, type SingletonQueryState, type SqlQuery, type SqlQueryState, type SqlStatement, type SqlTemplate, type StringAggOptions, type SynchronousResult, TRUE, type Table, type TableContext, type TableFactoryOptions, type TableKeys, type TableOptions, type TableQueryState, type TableRelations, type Tables, type TextConversionSignature, type TextLengthSignature, type TextOperators, type TextTypeOperators, type TextValue, type ToColumn, type ToColumns, TransactionConnectionError, type TransactionCoordinator, type TransactionOptions, type TransformedQuery, type TransformedQueryState, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UnfilteredAggregateOptions, type UnfilteredStringAggOptions, type UntypedExpression, type UpdateSet, type UpdateValues, type UpsertValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, and, asc, avg, caseWhen, coalesce, compare, count, countDistinct, createDatabase, createStatement, createTableFactory, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, every, from, greatest, identifier, isQueryError, least, literal, many, matches, max, min, not, one, or, orderBy, orderingOperators, param, some, sql, stringAgg, sum, textOperators, toDriverError, toSnakeCase };