SYMBOL INDEX (3234 symbols across 393 files)

FILE: deno.check.d.ts
  type Database (line 12) | interface Database {
  type AuditTable (line 22) | interface AuditTable {
  type PersonTable (line 27) | interface PersonTable {
  type PetTable (line 50) | interface PetTable {
  type ToyTable (line 59) | interface ToyTable {
  type WineTable (line 66) | interface WineTable {
  type WineStockChangeTable (line 72) | interface WineStockChangeTable {
  type Person (line 78) | type Person = Selectable<PersonTable>
  type NewPerson (line 79) | type NewPerson = Insertable<PersonTable>
  type PersonUpdate (line 80) | type PersonUpdate = Updateable<PersonTable>
  type Pet (line 81) | type Pet = Selectable<PetTable>
  type NewPet (line 82) | type NewPet = Insertable<PetTable>
  type PetUpdate (line 83) | type PetUpdate = Updateable<PetTable>
  type Species (line 84) | type Species = 'dog' | 'cat' | 'hamster'
  class Buffer (line 88) | class Buffer {

FILE: example/src/app.ts
  class App (line 17) | class App {
    method constructor (line 24) | constructor(config: Config) {
    method db (line 47) | get db(): Kysely<Database> {
    method start (line 51) | async start(): Promise<void> {
    method stop (line 57) | async stop(): Promise<void> {
  function respondError (line 95) | function respondError(ctx: Context, error: ControllerError): void {
  function createUnknownError (line 100) | function createUnknownError(error: unknown): ControllerError {

FILE: example/src/authentication/auth-token.service.ts
  class AuthTokenError (line 9) | class AuthTokenError extends Error {}
  class InvalidAuthTokenError (line 10) | class InvalidAuthTokenError extends AuthTokenError {}
  class AuthTokenExpiredError (line 11) | class AuthTokenExpiredError extends AuthTokenError {}
  class RefreshTokenUserIdMismatchError (line 12) | class RefreshTokenUserIdMismatchError extends Error {}
  type AuthTokenPayload (line 14) | interface AuthTokenPayload {
  type RefreshTokenPayload (line 19) | interface RefreshTokenPayload {
  function createRefreshToken (line 25) | async function createRefreshToken(
  function signRefreshToken (line 41) | function signRefreshToken(tokenPayload: RefreshTokenPayload): RefreshTok...
  function createAuthToken (line 46) | async function createAuthToken(
  function verifyRefreshToken (line 59) | function verifyRefreshToken(token: RefreshToken): RefreshTokenPayload {
  function signAuthToken (line 79) | function signAuthToken(tokenPayload: AuthTokenPayload): AuthToken {
  function verifyAuthToken (line 87) | function verifyAuthToken(token: AuthToken): AuthTokenPayload {
  function verifyToken (line 105) | function verifyToken(token: string): string | jwt.JwtPayload {
  function deleteRefreshToken (line 117) | async function deleteRefreshToken(

FILE: example/src/authentication/auth-token.ts
  type AuthToken (line 1) | interface AuthToken {

FILE: example/src/authentication/authentication.service.ts
  function authenticateUser (line 9) | async function authenticateUser(

FILE: example/src/authentication/refresh-token.repository.ts
  function insertRefreshToken (line 8) | async function insertRefreshToken(
  function findRefreshToken (line 24) | async function findRefreshToken(
  function updateRefreshToken (line 40) | async function updateRefreshToken(

FILE: example/src/authentication/refresh-token.table.ts
  type RefreshTokenTable (line 3) | interface RefreshTokenTable {
  type RefreshTokenRow (line 10) | type RefreshTokenRow = Selectable<RefreshTokenTable>
  type InsertableRefreshTokenRow (line 11) | type InsertableRefreshTokenRow = Insertable<RefreshTokenTable>
  type UpdateableRefreshTokenRow (line 12) | type UpdateableRefreshTokenRow = Updateable<RefreshTokenTable>

FILE: example/src/authentication/refresh-token.ts
  type RefreshToken (line 3) | interface RefreshToken {

FILE: example/src/config.ts
  type Config (line 6) | interface Config {
  function getEnvVariable (line 24) | function getEnvVariable(name: string): string {

FILE: example/src/context.ts
  type ContextExtension (line 7) | interface ContextExtension {
  type Context (line 11) | type Context = Koa.ParameterizedContext<

FILE: example/src/database.ts
  type Database (line 6) | interface Database {

FILE: example/src/migrate-to-latest.ts
  function migrateToLatest (line 13) | async function migrateToLatest() {

FILE: example/src/migrations/2021_09_18_06_54_59_create_user.ts
  function up (line 3) | async function up(db: Kysely<any>): Promise<void> {
  function down (line 16) | async function down(db: Kysely<any>): Promise<void> {

FILE: example/src/migrations/2021_09_18_14_05_20_create_refresh_token.ts
  function up (line 3) | async function up(db: Kysely<any>): Promise<void> {
  function down (line 25) | async function down(db: Kysely<any>): Promise<void> {

FILE: example/src/migrations/2021_09_18_18_22_45_create_sign_in_method.ts
  function up (line 3) | async function up(db: Kysely<any>): Promise<void> {
  function down (line 34) | async function down(db: Kysely<any>): Promise<void> {

FILE: example/src/router.ts
  class Router (line 5) | class Router extends KoaRouter<any, ContextExtension> {}

FILE: example/src/user/sign-in-method/password-sign-in-method.table.ts
  type PasswordSignInMethodTable (line 3) | interface PasswordSignInMethodTable {
  type PasswordSignInMethodRow (line 8) | type PasswordSignInMethodRow = Selectable<PasswordSignInMethodTable>
  type InsertablePasswordSignInMethodRow (line 10) | type InsertablePasswordSignInMethodRow =
  type UpdateablePasswordSignInMethodRow (line 13) | type UpdateablePasswordSignInMethodRow =

FILE: example/src/user/sign-in-method/sign-in-method.controller.ts
  function signInMethodController (line 18) | function signInMethodController(router: Router): void {

FILE: example/src/user/sign-in-method/sign-in-method.repository.ts
  function findPasswordSignInMethod (line 8) | async function findPasswordSignInMethod(
  function insertPasswordSignInMethod (line 23) | async function insertPasswordSignInMethod(

FILE: example/src/user/sign-in-method/sign-in-method.service.ts
  constant MIN_PASSWORD_LENGTH (line 12) | const MIN_PASSWORD_LENGTH = 8
  constant MAX_PASSWORD_LENGTH (line 13) | const MAX_PASSWORD_LENGTH = 255
  class UserAlreadyHasSignInMethodError (line 15) | class UserAlreadyHasSignInMethodError extends Error {}
  class SignInMethodNotFoundError (line 16) | class SignInMethodNotFoundError extends Error {}
  class WrongPasswordError (line 17) | class WrongPasswordError extends Error {}
  class PasswordTooWeakError (line 18) | class PasswordTooWeakError extends Error {}
  class PasswordTooLongError (line 19) | class PasswordTooLongError extends Error {}
  function addPasswordSignInMethod (line 21) | async function addPasswordSignInMethod(
  function encryptPassword (line 44) | async function encryptPassword(password: string): Promise<string> {
  function encryptSecret (line 56) | async function encryptSecret(secret: string): Promise<string> {
  function verifySecret (line 61) | async function verifySecret(secret: string, hash: string): Promise<boole...
  function scrypt (line 66) | async function scrypt(secret: string, salt: string): Promise<string> {
  function singInUsingPassword (line 84) | async function singInUsingPassword(
  function verifyPassword (line 117) | async function verifyPassword(

FILE: example/src/user/sign-in-method/sign-in-method.table.ts
  type SignInMethodTable (line 3) | interface SignInMethodTable {
  type SignInMethodRow (line 8) | type SignInMethodRow = Selectable<SignInMethodTable>
  type InsertableSignInMethodRow (line 9) | type InsertableSignInMethodRow = Insertable<SignInMethodTable>
  type UpdateableSignInMethodRow (line 10) | type UpdateableSignInMethodRow = Updateable<SignInMethodTable>

FILE: example/src/user/sign-in-method/sign-in-method.ts
  type SignInMethod (line 3) | type SignInMethod = PasswordSignInMethod
  type PasswordSignInMethod (line 5) | interface PasswordSignInMethod {

FILE: example/src/user/signed-in-user.ts
  type SignedInUser (line 5) | interface SignedInUser {

FILE: example/src/user/user.controller.ts
  function userController (line 9) | function userController(router: Router): void {

FILE: example/src/user/user.repository.ts
  function insertUser (line 5) | async function insertUser(
  function findUserById (line 18) | async function findUserById(
  function lockUserById (line 31) | async function lockUserById(
  function lockUserByEmail (line 38) | async function lockUserByEmail(
  function lockUser (line 45) | async function lockUser(
  function setUserEmail (line 60) | async function setUserEmail(

FILE: example/src/user/user.service.ts
  function createAnonymousUser (line 10) | async function createAnonymousUser(
  function findUserById (line 33) | async function findUserById(
  function lockUserById (line 44) | async function lockUserById(
  function lockUserByEmail (line 55) | async function lockUserByEmail(
  function setUserEmail (line 66) | async function setUserEmail(
  function userRowToUser (line 74) | function userRowToUser(user: UserRow): User {

FILE: example/src/user/user.table.ts
  type UserTable (line 3) | interface UserTable {
  type UserRow (line 11) | type UserRow = Selectable<UserTable>
  type InsertableUserRow (line 12) | type InsertableUserRow = Insertable<UserTable>
  type UpdateableUserRow (line 13) | type UpdateableUserRow = Updateable<UserTable>

FILE: example/src/user/user.ts
  type User (line 3) | interface User {
  type CreateAnonymousUserRequest (line 10) | interface CreateAnonymousUserRequest {

FILE: example/src/util/errors.ts
  type AuthenticationErrors (line 1) | type AuthenticationErrors =
  type UserApiErrors (line 9) | type UserApiErrors = 'InvalidUser' | 'UserNotFound'
  type SignInMethodApiErrors (line 11) | type SignInMethodApiErrors =
  type ErrorCode (line 20) | type ErrorCode =
  type ErrorStatus (line 26) | type ErrorStatus = 400 | 401 | 403 | 404 | 409 | 500
  class ControllerError (line 28) | class ControllerError extends Error {
    method constructor (line 33) | constructor(
    method toJSON (line 45) | toJSON() {
  class UserNotFoundError (line 52) | class UserNotFoundError extends Error {}

FILE: example/src/util/object.ts
  function isObject (line 1) | function isObject(value: unknown): value is Record<string, any> {

FILE: example/test/test-config.ts
  type TestConfig (line 4) | interface TestConfig extends Config {

FILE: example/test/test-context.ts
  class TestContext (line 18) | class TestContext {
    method db (line 26) | get db(): Kysely<Database> {

FILE: example/test/user/user.test.ts
  constant EMAIL (line 7) | const EMAIL = 'foo@bar.fake'
  constant PASSWORD (line 8) | const PASSWORD = '12345678'
  function createAuthHeaders (line 127) | function createAuthHeaders(authToken: string) {
  function createPasswordSignInMethod (line 135) | async function createPasswordSignInMethod(

FILE: scripts/add-deno-type-references.js
  constant ESM_DIST_PATH (line 11) | const ESM_DIST_PATH = path.join(__dirname, '..', 'dist', 'esm')

FILE: scripts/check-esm-imports.js
  function checkDir (line 13) | function checkDir(dir) {
  function readLines (line 37) | function readLines(filePath) {
  function isLocalImport (line 42) | function isLocalImport(row) {
  function isDotJsImport (line 46) | function isDotJsImport(row) {

FILE: scripts/check-exports.js
  function checkExports (line 13) | function checkExports(dir) {

FILE: scripts/copy-interface-documentation.js
  constant DIST_PATH (line 18) | const DIST_PATH = path.join(__dirname, '..', 'dist')
  constant PROPERTY_REGEX (line 20) | const PROPERTY_REGEX = /^\s+(?:get )?(?:readonly )?(?:abstract )?(\w+)[\...
  constant OBJECT_REGEXES (line 21) | const OBJECT_REGEXES = [
  constant GENERIC_ARGUMENTS_REGEX (line 25) | const GENERIC_ARGUMENTS_REGEX = /<[\w"'`,{}=|\[\] ]+>/g
  constant JSDOC_START_REGEX (line 26) | const JSDOC_START_REGEX = /^\s+\/\*\*/
  constant JSDOC_END_REGEX (line 27) | const JSDOC_END_REGEX = /^\s+\*\//
  function main (line 29) | function main() {
  function readLines (line 57) | function readLines(filePath) {
  function parseObjects (line 66) | function parseObjects(file) {
  function parseImplements (line 123) | function parseImplements(line) {
  function parseDocumentation (line 161) | function parseDocumentation(lines, propertyLineIdx) {
  function copyDocumentation (line 181) | function copyDocumentation(files) {
  function findDocProperty (line 219) | function findDocProperty(files, object, propertyName) {
  function findObject (line 247) | function findObject(files, objectName) {

FILE: scripts/generate-site-examples.js
  constant ESM_PATH (line 13) | const ESM_PATH = path.join(__dirname, '..', 'dist', 'esm')
  constant SITE_EXAMPLE_PATH (line 14) | const SITE_EXAMPLE_PATH = path.join(__dirname, '..', 'site', 'docs', 'ex...
  constant SITE_EXAMPLE_START_REGEX (line 16) | const SITE_EXAMPLE_START_REGEX = /<!--\s*siteExample\(/
  constant SITE_EXAMPLE_ANNOTATION_REGEX (line 17) | const SITE_EXAMPLE_ANNOTATION_REGEX =
  constant CODE_BLOCK_START_REGEX (line 20) | const CODE_BLOCK_START_REGEX = /\*\s*```/
  constant CODE_BLOCK_END_REGEX (line 21) | const CODE_BLOCK_END_REGEX = /\*\s*```/
  constant COMMENT_LINE_REGEX (line 22) | const COMMENT_LINE_REGEX = /\*\s*(.*)/
  constant CODE_LINE_REGEX (line 23) | const CODE_LINE_REGEX = /\*(.*)/
  function main (line 98) | function main() {
  function deleteAllExamples (line 145) | function deleteAllExamples() {
  function readLines (line 161) | function readLines(filePath) {
  function isCodeBlockEnd (line 166) | function isCodeBlockEnd(state) {
  function writeSiteExample (line 170) | function writeSiteExample(state) {
  function buildMoreExamplesMarkdown (line 238) | function buildMoreExamplesMarkdown(category) {
  function exitExample (line 262) | function exitExample(state) {
  function addCodeLine (line 270) | function addCodeLine(state) {
  function isCodeBlockStart (line 284) | function isCodeBlockStart(state) {
  function enterCodeBlock (line 288) | function enterCodeBlock(state) {
  function addCommentLine (line 292) | function addCommentLine(state) {
  function isExampleStart (line 306) | function isExampleStart(state) {
  function enterExample (line 310) | function enterExample(state) {
  function deindent (line 324) | function deindent(str) {
  function trimEmptyLines (line 346) | function trimEmptyLines(lines) {
  function overwritePlaygroundTypes (line 358) | function overwritePlaygroundTypes() {

FILE: scripts/module-fixup.js
  constant ROOT_PATH (line 14) | const ROOT_PATH = path.join(__dirname, '..')
  constant DIST_PATH (line 15) | const DIST_PATH = path.join(ROOT_PATH, 'dist')

FILE: scripts/util/for-each-file.js
  function forEachFile (line 4) | function forEachFile(dir, callback) {
  function isDir (line 18) | function isDir(file) {

FILE: site/docs/getting-started/Dialects.tsx
  type DialectsProps (line 24) | type DialectsProps = PropsWithPackageManager
  type BuiltInDialect (line 26) | interface BuiltInDialect {
  function Dialects (line 54) | function Dialects(props: DialectsProps) {
  type UnsupportedDriverProps (line 156) | interface UnsupportedDriverProps {
  function UnsupportedDriver (line 162) | function UnsupportedDriver(props: UnsupportedDriverProps) {

FILE: site/docs/getting-started/IUseADifferentDialect.tsx
  function IUseADifferentDialect (line 8) | function IUseADifferentDialect(

FILE: site/docs/getting-started/IUseADifferentPackageManager.tsx
  function IUseADifferentPackageManager (line 8) | function IUseADifferentPackageManager(

FILE: site/docs/getting-started/Installation.tsx
  type PackageManagerDetails (line 14) | interface PackageManagerDetails {
  function Installation (line 99) | function Installation() {

FILE: site/docs/getting-started/Instantiation.tsx
  type InstantiationProps (line 23) | type InstantiationProps = PropsWithDialect<PropsWithPackageManager>
  function Instantiation (line 25) | function Instantiation(props: InstantiationProps) {
  function getNotSupportedCode (line 109) | function getNotSupportedCode(
  function getDialectSpecificCodeSnippet (line 121) | function getDialectSpecificCodeSnippet(

FILE: site/docs/getting-started/Querying.tsx
  function Querying (line 75) | function Querying(props: PropsWithDialect) {

FILE: site/docs/getting-started/Summary.tsx
  function Summary (line 60) | function Summary(props: PropsWithDialect) {

FILE: site/docs/getting-started/shared.tsx
  constant DIALECTS (line 5) | const DIALECTS = ['postgresql', 'mysql', 'sqlite', 'mssql'] as const
  type Dialect (line 7) | type Dialect = (typeof DIALECTS)[number]
  constant DEFAULT_DIALECT (line 9) | const DEFAULT_DIALECT = 'postgresql' satisfies Dialect
  type PropsWithDialect (line 11) | type PropsWithDialect<P = {}> = P & {
  type PropsWithPackageManager (line 17) | type PropsWithPackageManager<P = {}> = P & {
  constant PACKAGE_MANAGERS (line 23) | const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'deno', 'bun'] as const
  type PackageManager (line 25) | type PackageManager = (typeof PACKAGE_MANAGERS)[number]
  constant DEFAULT_PACKAGE_MANAGER (line 27) | const DEFAULT_PACKAGE_MANAGER = 'npm' satisfies PackageManager
  constant PACKAGE_MANAGER_UNSUPPORTED_DIALECTS (line 29) | const PACKAGE_MANAGER_UNSUPPORTED_DIALECTS: Record<PackageManager, Diale...
  function isDialectSupported (line 38) | function isDialectSupported(
  constant DIALECT_CLASS_NAMES (line 45) | const DIALECT_CLASS_NAMES = {
  constant POOL_NPM_PACKAGE_NAMES (line 62) | const POOL_NPM_PACKAGE_NAMES = {
  constant PRETTY_DIALECT_NAMES (line 66) | const PRETTY_DIALECT_NAMES = {
  constant PRETTY_PACKAGE_MANAGER_NAMES (line 73) | const PRETTY_PACKAGE_MANAGER_NAMES = {
  constant PACKAGE_MANAGER_INSTALL_COMMANDS (line 81) | const PACKAGE_MANAGER_INSTALL_COMMANDS = {
  type Command (line 88) | interface Command {
  function getBashCommand (line 95) | function getBashCommand(
  function getDenoCommand (line 116) | function getDenoCommand(
  type UseSearchStateProps (line 144) | interface UseSearchStateProps<Value extends string> {
  function useSearchState (line 151) | function useSearchState<Value extends string>(

FILE: site/src/components/DemoVideo.tsx
  function DemoVideo (line 4) | function DemoVideo() {

FILE: site/src/components/Playground.tsx
  function Playground (line 8) | function Playground(props: PlaygroundProps) {
  function useSrc (line 65) | function useSrc(props: PlaygroundProps) {
  function getPlaygroundStateHash (line 87) | function getPlaygroundStateHash(props: PlaygroundProps) {
  type PlaygroundProps (line 103) | interface PlaygroundProps {
  type PlaygroundState (line 111) | interface PlaygroundState {

FILE: site/src/components/SectionFeatures/index.tsx
  type FeatureItem (line 5) | type FeatureItem = {
  function TickIcon (line 101) | function TickIcon(props: SVGProps<SVGSVGElement>) {
  function Feature (line 119) | function Feature({ title, description }: FeatureItem) {
  function SectionFeatures (line 135) | function SectionFeatures(): JSX.Element {

FILE: site/src/components/SectionQuotes/Quote.tsx
  type QuoteProps (line 7) | interface QuoteProps {
  function Quote (line 22) | function Quote(props: QuoteProps) {
  function XIcon (line 54) | function XIcon() {
  function DiscordIcon (line 68) | function DiscordIcon() {
  function GithubIcon (line 89) | function GithubIcon() {
  function RedditIcon (line 108) | function RedditIcon() {

FILE: site/src/components/SectionQuotes/index.tsx
  function SectionQuotes (line 7) | function SectionQuotes() {

FILE: site/src/components/playground-example-types.ts
  constant GENERATED_PLAYGROUND_EXAMPLE_TYPES (line 3) | const GENERATED_PLAYGROUND_EXAMPLE_TYPES = `import type {

FILE: site/src/pages/index.tsx
  function HomepageHeader (line 13) | function HomepageHeader() {
  function Home (line 66) | function Home(): JSX.Element {
  constant STACKBLITZ_URL (line 87) | const STACKBLITZ_URL = 'https://stackblitz.com/edit/react-ts-pppzf5'
  constant STACKBLITZ_PARAMS (line 88) | const STACKBLITZ_PARAMS = new URLSearchParams({
  function SectionPlayground (line 98) | function SectionPlayground() {
  function SectionExamplesCTA (line 130) | function SectionExamplesCTA() {

FILE: src/dialect/database-introspector.ts
  type DatabaseIntrospector (line 4) | interface DatabaseIntrospector {
  type DatabaseMetadataOptions (line 23) | interface DatabaseMetadataOptions {
  type SchemaMetadata (line 31) | interface SchemaMetadata {
  type DatabaseMetadata (line 35) | interface DatabaseMetadata {
  type TableMetadata (line 43) | interface TableMetadata {
  type ColumnMetadata (line 50) | interface ColumnMetadata {

FILE: src/dialect/dialect-adapter-base.ts
  method supportsCreateIfNotExists (line 11) | get supportsCreateIfNotExists(): boolean {
  method supportsTransactionalDdl (line 15) | get supportsTransactionalDdl(): boolean {
  method supportsReturning (line 19) | get supportsReturning(): boolean {
  method supportsOutput (line 23) | get supportsOutput(): boolean {

FILE: src/dialect/dialect-adapter.ts
  type DialectAdapter (line 11) | interface DialectAdapter {
  type MigrationLockOptions (line 113) | interface MigrationLockOptions {

FILE: src/dialect/dialect.ts
  type Dialect (line 14) | interface Dialect {

FILE: src/dialect/mssql/mssql-adapter.ts
  class MssqlAdapter (line 6) | class MssqlAdapter extends DialectAdapterBase {
    method supportsCreateIfNotExists (line 7) | override get supportsCreateIfNotExists(): boolean {
    method supportsTransactionalDdl (line 11) | override get supportsTransactionalDdl(): boolean {
    method supportsOutput (line 15) | override get supportsOutput(): boolean {
    method acquireMigrationLock (line 19) | override async acquireMigrationLock(db: Kysely<any>): Promise<void> {
    method releaseMigrationLock (line 29) | override async releaseMigrationLock(): Promise<void> {

FILE: src/dialect/mssql/mssql-dialect-config.ts
  type MssqlDialectConfig (line 3) | interface MssqlDialectConfig {
  type Tedious (line 78) | interface Tedious {
  type TediousConnection (line 90) | interface TediousConnection {
  type TediousIsolationLevel (line 124) | type TediousIsolationLevel = Record<string, number>
  type TediousRequestClass (line 126) | interface TediousRequestClass {
  class TediousRequest (line 136) | class TediousRequest {
  type TediousTypes (line 158) | interface TediousTypes {
  type TediousDataType (line 169) | interface TediousDataType {}
  type TediousColumnValue (line 171) | interface TediousColumnValue {
  type Tarn (line 178) | interface Tarn {
  class TarnPool (line 197) | class TarnPool<R> {
  type TarnPoolOptions (line 204) | interface TarnPoolOptions<R> {
  type TarnPendingRequest (line 220) | interface TarnPendingRequest<R> {

FILE: src/dialect/mssql/mssql-dialect.ts
  class MssqlDialect (line 52) | class MssqlDialect implements Dialect {
    method constructor (line 55) | constructor(config: MssqlDialectConfig) {
    method createDriver (line 59) | createDriver(): Driver {
    method createQueryCompiler (line 63) | createQueryCompiler(): QueryCompiler {
    method createAdapter (line 67) | createAdapter(): DialectAdapter {
    method createIntrospector (line 71) | createIntrospector(db: Kysely<any>): DatabaseIntrospector {

FILE: src/dialect/mssql/mssql-driver.ts
  constant PRIVATE_RESET_METHOD (line 34) | const PRIVATE_RESET_METHOD: unique symbol = Symbol()
  constant PRIVATE_DESTROY_METHOD (line 35) | const PRIVATE_DESTROY_METHOD: unique symbol = Symbol()
  constant PRIVATE_VALIDATE_METHOD (line 36) | const PRIVATE_VALIDATE_METHOD: unique symbol = Symbol()
  class MssqlDriver (line 38) | class MssqlDriver implements Driver {
    method constructor (line 42) | constructor(config: MssqlDialectConfig) {
    method init (line 71) | async init(): Promise<void> {
    method acquireConnection (line 75) | async acquireConnection(): Promise<DatabaseConnection> {
    method beginTransaction (line 79) | async beginTransaction(
    method commitTransaction (line 86) | async commitTransaction(connection: MssqlConnection): Promise<void> {
    method rollbackTransaction (line 90) | async rollbackTransaction(connection: MssqlConnection): Promise<void> {
    method savepoint (line 94) | async savepoint(
    method rollbackToSavepoint (line 101) | async rollbackToSavepoint(
    method releaseConnection (line 108) | async releaseConnection(connection: MssqlConnection): Promise<void> {
    method destroy (line 119) | async destroy(): Promise<void> {
  class MssqlConnection (line 124) | class MssqlConnection implements DatabaseConnection {
    method constructor (line 129) | constructor(connection: TediousConnection, tedious: Tedious) {
    method beginTransaction (line 135) | async beginTransaction(settings: TransactionSettings): Promise<void> {
    method commitTransaction (line 152) | async commitTransaction(): Promise<void> {
    method connect (line 161) | async connect(): Promise<this> {
    method executeQuery (line 202) | async executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResu...
    method rollbackTransaction (line 225) | async rollbackTransaction(savepointName?: string): Promise<void> {
    method savepoint (line 234) | async savepoint(savepointName: string): Promise<void> {
    method streamQuery (line 243) | async *streamQuery<O>(
    method #getTediousIsolationLevel (line 278) | #getTediousIsolationLevel(isolationLevel: IsolationLevel) {
    method #cancelRequest (line 301) | #cancelRequest<O>(request: MssqlRequest<O>): Promise<void> {
    method [PRIVATE_DESTROY_METHOD] (line 314) | [PRIVATE_DESTROY_METHOD](): Promise<void> {
    method [PRIVATE_RESET_METHOD] (line 326) | async [PRIVATE_RESET_METHOD](): Promise<void> {
    method [PRIVATE_VALIDATE_METHOD] (line 338) | async [PRIVATE_VALIDATE_METHOD](): Promise<boolean> {
    method #isConnectionClosed (line 362) | #isConnectionClosed(): boolean {
  type OnDone (line 367) | interface OnDone<O> {
  type PlainDeferred (line 372) | interface PlainDeferred<O> {
  class MssqlRequest (line 377) | class MssqlRequest<O> {
    method constructor (line 388) | constructor(props: MssqlRequestProps<O>) {
    method request (line 437) | get request(): TediousRequest {
    method readChunk (line 441) | readChunk(): Promise<O[]> {
    method #addParametersToRequest (line 459) | #addParametersToRequest(parameters: readonly unknown[]): void {
    method #attachListeners (line 471) | #attachListeners(): void {
    method #getTediousDataType (line 506) | #getTediousDataType(value: unknown): any {
  type MssqlRequestProps (line 539) | interface MssqlRequestProps<O> {

FILE: src/dialect/mssql/mssql-introspector.ts
  class MssqlIntrospector (line 15) | class MssqlIntrospector implements DatabaseIntrospector {
    method constructor (line 18) | constructor(db: Kysely<any>) {
    method getSchemas (line 22) | async getSchemas(): Promise<SchemaMetadata[]> {
    method getTables (line 26) | async getTables(
    method getMetadata (line 172) | async getMetadata(
  type MssqlSysTables (line 181) | interface MssqlSysTables {

FILE: src/dialect/mssql/mssql-query-compiler.ts
  constant COLLATION_CHAR_REGEX (line 9) | const COLLATION_CHAR_REGEX = /^[a-z0-9_]$/i
  class MssqlQueryCompiler (line 11) | class MssqlQueryCompiler extends DefaultQueryCompiler {
    method getCurrentParameterPlaceholder (line 12) | protected override getCurrentParameterPlaceholder(): string {
    method visitOffset (line 16) | protected override visitOffset(node: OffsetNode): void {
    method compileColumnAlterations (line 26) | protected override compileColumnAlterations(
    method visitAddColumn (line 78) | protected override visitAddColumn(node: AddColumnNode): void {
    method visitDropColumn (line 82) | protected override visitDropColumn(node: DropColumnNode): void {
    method visitMergeQuery (line 86) | protected override visitMergeQuery(node: MergeQueryNode): void {
    method visitCollate (line 91) | protected override visitCollate(node: CollateNode): void {
    method announcesNewColumnDataType (line 105) | protected override announcesNewColumnDataType(): boolean {

FILE: src/dialect/mysql/mysql-adapter.ts
  constant LOCK_ID (line 6) | const LOCK_ID = 'ea586330-2c93-47c8-908d-981d9d270f9d'
  constant LOCK_TIMEOUT_SECONDS (line 7) | const LOCK_TIMEOUT_SECONDS = 60 * 60
  class MysqlAdapter (line 9) | class MysqlAdapter extends DialectAdapterBase {
    method supportsTransactionalDdl (line 10) | override get supportsTransactionalDdl(): boolean {
    method supportsReturning (line 14) | override get supportsReturning(): boolean {
    method acquireMigrationLock (line 18) | override async acquireMigrationLock(
    method releaseMigrationLock (line 33) | override async releaseMigrationLock(

FILE: src/dialect/mysql/mysql-dialect-config.ts
  type MysqlDialectConfig (line 8) | interface MysqlDialectConfig {
  type MysqlPool (line 37) | interface MysqlPool {
  type MysqlPoolConnection (line 44) | interface MysqlPoolConnection {
  type MysqlStreamOptions (line 57) | interface MysqlStreamOptions {
  type MysqlStream (line 62) | interface MysqlStream<T> {
  type MysqlOkPacket (line 66) | interface MysqlOkPacket {
  type MysqlQueryResult (line 72) | type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[]

FILE: src/dialect/mysql/mysql-dialect.ts
  class MysqlDialect (line 43) | class MysqlDialect implements Dialect {
    method constructor (line 46) | constructor(config: MysqlDialectConfig) {
    method createDriver (line 50) | createDriver(): Driver {
    method createQueryCompiler (line 54) | createQueryCompiler(): QueryCompiler {
    method createAdapter (line 58) | createAdapter(): DialectAdapter {
    method createIntrospector (line 62) | createIntrospector(db: Kysely<any>): DatabaseIntrospector {

FILE: src/dialect/mysql/mysql-driver.ts
  constant PRIVATE_RELEASE_METHOD (line 20) | const PRIVATE_RELEASE_METHOD: unique symbol = Symbol()
  class MysqlDriver (line 22) | class MysqlDriver implements Driver {
    method constructor (line 27) | constructor(configOrPool: MysqlDialectConfig) {
    method init (line 31) | async init(): Promise<void> {
    method acquireConnection (line 37) | async acquireConnection(): Promise<DatabaseConnection> {
    method #acquireConnection (line 60) | async #acquireConnection(): Promise<MysqlPoolConnection> {
    method beginTransaction (line 72) | async beginTransaction(
    method commitTransaction (line 96) | async commitTransaction(connection: DatabaseConnection): Promise<void> {
    method rollbackTransaction (line 100) | async rollbackTransaction(connection: DatabaseConnection): Promise<voi...
    method savepoint (line 104) | async savepoint(
    method rollbackToSavepoint (line 117) | async rollbackToSavepoint(
    method releaseSavepoint (line 130) | async releaseSavepoint(
    method releaseConnection (line 143) | async releaseConnection(connection: MysqlConnection): Promise<void> {
    method destroy (line 147) | async destroy(): Promise<void> {
  function isOkPacket (line 160) | function isOkPacket(obj: unknown): obj is MysqlOkPacket {
  class MysqlConnection (line 164) | class MysqlConnection implements DatabaseConnection {
    method constructor (line 167) | constructor(rawConnection: MysqlPoolConnection) {
    method executeQuery (line 171) | async executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResu...
    method #executeQuery (line 209) | #executeQuery(compiledQuery: CompiledQuery): Promise<MysqlQueryResult> {
    method streamQuery (line 225) | async *streamQuery<O>(
    method [PRIVATE_RELEASE_METHOD] (line 257) | [PRIVATE_RELEASE_METHOD](): void {

FILE: src/dialect/mysql/mysql-introspector.ts
  class MysqlIntrospector (line 16) | class MysqlIntrospector implements DatabaseIntrospector {
    method constructor (line 19) | constructor(db: Kysely<any>) {
    method getSchemas (line 23) | async getSchemas(): Promise<SchemaMetadata[]> {
    method getTables (line 33) | async getTables(
    method getMetadata (line 70) | async getMetadata(
    method #parseTableMetadata (line 78) | #parseTableMetadata(columns: RawColumnMetadata[]): TableMetadata[] {
  type RawSchemaMetadata (line 109) | interface RawSchemaMetadata {
  type RawColumnMetadata (line 113) | interface RawColumnMetadata {

FILE: src/dialect/mysql/mysql-query-compiler.ts
  constant LITERAL_ESCAPE_REGEX (line 4) | const LITERAL_ESCAPE_REGEX = /\\|'/g
  constant ID_WRAP_REGEX (line 5) | const ID_WRAP_REGEX = /`/g
  class MysqlQueryCompiler (line 7) | class MysqlQueryCompiler extends DefaultQueryCompiler {
    method getCurrentParameterPlaceholder (line 8) | protected override getCurrentParameterPlaceholder(): string {
    method getLeftExplainOptionsWrapper (line 12) | protected override getLeftExplainOptionsWrapper(): string {
    method getExplainOptionAssignment (line 16) | protected override getExplainOptionAssignment(): string {
    method getExplainOptionsDelimiter (line 20) | protected override getExplainOptionsDelimiter(): string {
    method getRightExplainOptionsWrapper (line 24) | protected override getRightExplainOptionsWrapper(): string {
    method getLeftIdentifierWrapper (line 28) | protected override getLeftIdentifierWrapper(): string {
    method getRightIdentifierWrapper (line 32) | protected override getRightIdentifierWrapper(): string {
    method sanitizeIdentifier (line 36) | protected override sanitizeIdentifier(identifier: string): string {
    method sanitizeStringLiteral (line 47) | protected override sanitizeStringLiteral(value: string): string {
    method visitCreateIndex (line 53) | protected override visitCreateIndex(node: CreateIndexNode): void {

FILE: src/dialect/postgres/postgres-adapter.ts
  constant LOCK_ID (line 7) | const LOCK_ID = BigInt('3853314791062309107')
  class PostgresAdapter (line 9) | class PostgresAdapter extends DialectAdapterBase {
    method supportsTransactionalDdl (line 10) | override get supportsTransactionalDdl(): boolean {
    method supportsReturning (line 14) | override get supportsReturning(): boolean {
    method acquireMigrationLock (line 18) | override async acquireMigrationLock(
    method releaseMigrationLock (line 26) | override async releaseMigrationLock(

FILE: src/dialect/postgres/postgres-dialect-config.ts
  type PostgresDialectConfig (line 6) | interface PostgresDialectConfig {
  type PostgresPool (line 52) | interface PostgresPool {
  type PostgresPoolClient (line 57) | interface PostgresPoolClient {
  type PostgresCursor (line 66) | interface PostgresCursor<T> {
  type PostgresCursorConstructor (line 71) | type PostgresCursorConstructor = new <T>(
  type PostgresQueryResult (line 76) | interface PostgresQueryResult<R> {
  type PostgresStream (line 82) | interface PostgresStream<T> {

FILE: src/dialect/postgres/postgres-dialect.ts
  class PostgresDialect (line 43) | class PostgresDialect implements Dialect {
    method constructor (line 46) | constructor(config: PostgresDialectConfig) {
    method createDriver (line 50) | createDriver(): Driver {
    method createQueryCompiler (line 54) | createQueryCompiler(): QueryCompiler {
    method createAdapter (line 58) | createAdapter(): DialectAdapter {
    method createIntrospector (line 62) | createIntrospector(db: Kysely<any>): DatabaseIntrospector {

FILE: src/dialect/postgres/postgres-driver.ts
  constant PRIVATE_RELEASE_METHOD (line 19) | const PRIVATE_RELEASE_METHOD: unique symbol = Symbol()
  class PostgresDriver (line 21) | class PostgresDriver implements Driver {
    method constructor (line 26) | constructor(config: PostgresDialectConfig) {
    method init (line 30) | async init(): Promise<void> {
    method acquireConnection (line 36) | async acquireConnection(): Promise<DatabaseConnection> {
    method beginTransaction (line 61) | async beginTransaction(
    method commitTransaction (line 82) | async commitTransaction(connection: DatabaseConnection): Promise<void> {
    method rollbackTransaction (line 86) | async rollbackTransaction(connection: DatabaseConnection): Promise<voi...
    method savepoint (line 90) | async savepoint(
    method rollbackToSavepoint (line 103) | async rollbackToSavepoint(
    method releaseSavepoint (line 116) | async releaseSavepoint(
    method releaseConnection (line 129) | async releaseConnection(connection: PostgresConnection): Promise<void> {
    method destroy (line 133) | async destroy(): Promise<void> {
  type PostgresConnectionOptions (line 142) | interface PostgresConnectionOptions {
  class PostgresConnection (line 146) | class PostgresConnection implements DatabaseConnection {
    method constructor (line 150) | constructor(client: PostgresPoolClient, options: PostgresConnectionOpt...
    method executeQuery (line 155) | async executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResu...
    method streamQuery (line 177) | async *streamQuery<O>(
    method [PRIVATE_RELEASE_METHOD] (line 215) | [PRIVATE_RELEASE_METHOD](): void {

FILE: src/dialect/postgres/postgres-introspector.ts
  class PostgresIntrospector (line 16) | class PostgresIntrospector implements DatabaseIntrospector {
    method constructor (line 19) | constructor(db: Kysely<any>) {
    method getSchemas (line 23) | async getSchemas(): Promise<SchemaMetadata[]> {
    method getTables (line 33) | async getTables(
    method getMetadata (line 99) | async getMetadata(
    method #parseTableMetadata (line 107) | #parseTableMetadata(columns: RawColumnMetadata[]): TableMetadata[] {
  type RawSchemaMetadata (line 141) | interface RawSchemaMetadata {
  type RawColumnMetadata (line 145) | interface RawColumnMetadata {

FILE: src/dialect/postgres/postgres-query-compiler.ts
  constant ID_WRAP_REGEX (line 3) | const ID_WRAP_REGEX = /"/g
  class PostgresQueryCompiler (line 5) | class PostgresQueryCompiler extends DefaultQueryCompiler {
    method sanitizeIdentifier (line 6) | protected override sanitizeIdentifier(identifier: string): string {

FILE: src/dialect/sqlite/sqlite-adapter.ts
  class SqliteAdapter (line 5) | class SqliteAdapter extends DialectAdapterBase {
    method supportsTransactionalDdl (line 6) | override get supportsTransactionalDdl(): boolean {
    method supportsReturning (line 10) | override get supportsReturning(): boolean {
    method acquireMigrationLock (line 14) | override async acquireMigrationLock(
    method releaseMigrationLock (line 23) | override async releaseMigrationLock(

FILE: src/dialect/sqlite/sqlite-dialect-config.ts
  type SqliteDialectConfig (line 6) | interface SqliteDialectConfig {
  type SqliteDatabase (line 32) | interface SqliteDatabase {
  type SqliteStatement (line 37) | interface SqliteStatement {

FILE: src/dialect/sqlite/sqlite-dialect.ts
  class SqliteDialect (line 38) | class SqliteDialect implements Dialect {
    method constructor (line 41) | constructor(config: SqliteDialectConfig) {
    method createDriver (line 45) | createDriver(): Driver {
    method createQueryCompiler (line 49) | createQueryCompiler(): QueryCompiler {
    method createAdapter (line 53) | createAdapter(): DialectAdapter {
    method createIntrospector (line 57) | createIntrospector(db: Kysely<any>): DatabaseIntrospector {

FILE: src/dialect/sqlite/sqlite-driver.ts
  class SqliteDriver (line 17) | class SqliteDriver implements Driver {
    method constructor (line 24) | constructor(config: SqliteDialectConfig) {
    method init (line 28) | async init(): Promise<void> {
    method acquireConnection (line 40) | async acquireConnection(): Promise<DatabaseConnection> {
    method beginTransaction (line 47) | async beginTransaction(connection: DatabaseConnection): Promise<void> {
    method commitTransaction (line 51) | async commitTransaction(connection: DatabaseConnection): Promise<void> {
    method rollbackTransaction (line 55) | async rollbackTransaction(connection: DatabaseConnection): Promise<voi...
    method savepoint (line 59) | async savepoint(
    method rollbackToSavepoint (line 72) | async rollbackToSavepoint(
    method releaseSavepoint (line 85) | async releaseSavepoint(
    method releaseConnection (line 98) | async releaseConnection(): Promise<void> {
    method destroy (line 102) | async destroy(): Promise<void> {
  class SqliteConnection (line 107) | class SqliteConnection implements DatabaseConnection {
    method constructor (line 110) | constructor(db: SqliteDatabase) {
    method executeQuery (line 114) | executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>> {
    method streamQuery (line 137) | async *streamQuery<R>(
  class ConnectionMutex (line 156) | class ConnectionMutex {
    method lock (line 160) | async lock(): Promise<void> {
    method unlock (line 170) | unlock(): void {

FILE: src/dialect/sqlite/sqlite-introspector.ts
  type SqliteSystemDatabase (line 16) | interface SqliteSystemDatabase {
  type SQliteMasterTable (line 22) | interface SQliteMasterTable {
  type PragmaTableInfo (line 31) | interface PragmaTableInfo {
  class SqliteIntrospector (line 40) | class SqliteIntrospector implements DatabaseIntrospector {
    method constructor (line 43) | constructor(db: Kysely<any>) {
    method getSchemas (line 47) | async getSchemas(): Promise<SchemaMetadata[]> {
    method getTables (line 52) | async getTables(
    method getMetadata (line 58) | async getMetadata(
    method #tablesQuery (line 66) | #tablesQuery(
    method #getTableMetadata (line 85) | async #getTableMetadata(

FILE: src/dialect/sqlite/sqlite-query-compiler.ts
  constant ID_WRAP_REGEX (line 5) | const ID_WRAP_REGEX = /"/g
  class SqliteQueryCompiler (line 7) | class SqliteQueryCompiler extends DefaultQueryCompiler {
    method visitOrAction (line 8) | protected override visitOrAction(node: OrActionNode): void {
    method getCurrentParameterPlaceholder (line 13) | protected override getCurrentParameterPlaceholder(): string {
    method getLeftExplainOptionsWrapper (line 17) | protected override getLeftExplainOptionsWrapper(): string {
    method getRightExplainOptionsWrapper (line 21) | protected override getRightExplainOptionsWrapper(): string {
    method getLeftIdentifierWrapper (line 25) | protected override getLeftIdentifierWrapper(): string {
    method getRightIdentifierWrapper (line 29) | protected override getRightIdentifierWrapper(): string {
    method getAutoIncrement (line 33) | protected override getAutoIncrement(): string {
    method sanitizeIdentifier (line 37) | protected override sanitizeIdentifier(identifier: string): string {
    method visitDefaultInsertValue (line 41) | protected override visitDefaultInsertValue(_: DefaultInsertValueNode):...

FILE: src/driver/connection-provider.ts
  type ConnectionProvider (line 3) | interface ConnectionProvider {

FILE: src/driver/database-connection.ts
  type DatabaseConnection (line 8) | interface DatabaseConnection {
  type QueryResult (line 16) | interface QueryResult<O> {

FILE: src/driver/default-connection-provider.ts
  class DefaultConnectionProvider (line 5) | class DefaultConnectionProvider implements ConnectionProvider {
    method constructor (line 8) | constructor(driver: Driver) {
    method provideConnection (line 12) | async provideConnection<T>(

FILE: src/driver/driver.ts
  type Driver (line 9) | interface Driver {
  type TransactionSettings (line 79) | interface TransactionSettings {
  constant TRANSACTION_ACCESS_MODES (line 84) | const TRANSACTION_ACCESS_MODES = ['read only', 'read write'] as const
  type AccessMode (line 86) | type AccessMode = ArrayItemType<typeof TRANSACTION_ACCESS_MODES>
  constant TRANSACTION_ISOLATION_LEVELS (line 88) | const TRANSACTION_ISOLATION_LEVELS = [
  type IsolationLevel (line 96) | type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>
  function validateTransactionSettings (line 98) | function validateTransactionSettings(

FILE: src/driver/dummy-driver.ts
  class DummyDriver (line 41) | class DummyDriver implements Driver {
    method init (line 42) | async init(): Promise<void> {
    method acquireConnection (line 46) | async acquireConnection(): Promise<DatabaseConnection> {
    method beginTransaction (line 50) | async beginTransaction(): Promise<void> {
    method commitTransaction (line 54) | async commitTransaction(): Promise<void> {
    method rollbackTransaction (line 58) | async rollbackTransaction(): Promise<void> {
    method releaseConnection (line 62) | async releaseConnection(): Promise<void> {
    method destroy (line 66) | async destroy(): Promise<void> {
    method releaseSavepoint (line 70) | async releaseSavepoint(): Promise<void> {
    method rollbackToSavepoint (line 74) | async rollbackToSavepoint(): Promise<void> {
    method savepoint (line 78) | async savepoint(): Promise<void> {
  class DummyConnection (line 83) | class DummyConnection implements DatabaseConnection {
    method executeQuery (line 84) | async executeQuery<R>(): Promise<QueryResult<R>> {
    method streamQuery (line 90) | async *streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {

FILE: src/driver/runtime-driver.ts
  class RuntimeDriver (line 13) | class RuntimeDriver implements Driver {
    method constructor (line 22) | constructor(driver: Driver, log: Log) {
    method init (line 28) | async init(): Promise<void> {
    method acquireConnection (line 48) | async acquireConnection(): Promise<DatabaseConnection> {
    method releaseConnection (line 70) | async releaseConnection(connection: DatabaseConnection): Promise<void> {
    method beginTransaction (line 74) | beginTransaction(
    method commitTransaction (line 81) | commitTransaction(connection: DatabaseConnection): Promise<void> {
    method rollbackTransaction (line 85) | rollbackTransaction(connection: DatabaseConnection): Promise<void> {
    method savepoint (line 89) | savepoint(
    method rollbackToSavepoint (line 101) | rollbackToSavepoint(
    method releaseSavepoint (line 119) | releaseSavepoint(
    method destroy (line 137) | async destroy(): Promise<void> {
    method #needsLogging (line 154) | #needsLogging(): boolean {
    method #addLogging (line 163) | #addLogging(connection: DatabaseConnection): void {
    method #logError (line 214) | async #logError(
    method #logQuery (line 227) | async #logQuery(
    method #calculateDurationMillis (line 240) | #calculateDurationMillis(startTime: number): number {

FILE: src/driver/single-connection-provider.ts
  class SingleConnectionProvider (line 6) | class SingleConnectionProvider implements ConnectionProvider {
    method constructor (line 10) | constructor(connection: DatabaseConnection) {
    method provideConnection (line 14) | async provideConnection<T>(
    method #run (line 33) | async #run<T>(

FILE: src/dynamic/dynamic-reference-builder.ts
  class DynamicReferenceBuilder (line 9) | class DynamicReferenceBuilder<
    method dynamicReference (line 14) | get dynamicReference(): string {
    method refType (line 26) | protected get refType(): R {
    method constructor (line 30) | constructor(reference: string) {
    method toOperationNode (line 34) | toOperationNode(): SimpleReferenceExpressionNode {
  function isDynamicReferenceBuilder (line 39) | function isDynamicReferenceBuilder(

FILE: src/dynamic/dynamic-table-builder.ts
  class DynamicTableBuilder (line 10) | class DynamicTableBuilder<T extends string> {
    method table (line 13) | get table(): T {
    method constructor (line 17) | constructor(table: T) {
    method as (line 21) | as<A extends string>(alias: A): AliasedDynamicTableBuilder<T, A> {
  class AliasedDynamicTableBuilder (line 26) | class AliasedDynamicTableBuilder<
    method table (line 33) | get table(): T {
    method alias (line 37) | get alias(): A {
    method constructor (line 41) | constructor(table: T, alias: A) {
    method toOperationNode (line 46) | toOperationNode(): AliasNode {
  function isAliasedDynamicTableBuilder (line 54) | function isAliasedDynamicTableBuilder(

FILE: src/dynamic/dynamic.ts
  class DynamicModule (line 4) | class DynamicModule<DB> {
    method ref (line 90) | ref<R extends string = never>(reference: string): DynamicReferenceBuil...
    method table (line 127) | table<T extends keyof DB & string>(table: T): DynamicTableBuilder<T> {

FILE: src/expression/expression-builder.ts
  type ExpressionBuilder (line 82) | interface ExpressionBuilder<DB, TB extends keyof DB> {
  function createExpressionBuilder (line 1156) | function createExpressionBuilder<DB, TB extends keyof DB>(
  function expressionBuilder (line 1395) | function expressionBuilder<DB, TB extends keyof DB>(

FILE: src/expression/expression-wrapper.ts
  class ExpressionWrapper (line 23) | class ExpressionWrapper<
    method constructor (line 30) | constructor(node: OperationNode) {
    method expressionType (line 35) | get expressionType(): T | undefined {
    method as (line 70) | as(alias: string | Expression<any>): AliasedExpression<T, string> {
    method or (line 153) | or(...args: any[]): any {
    method and (line 238) | and(...args: any[]): any {
    method $castTo (line 250) | $castTo<C>(): ExpressionWrapper<DB, TB, C> {
    method $notNull (line 263) | $notNull(): ExpressionWrapper<DB, TB, Exclude<T, null>> {
    method toOperationNode (line 267) | toOperationNode(): OperationNode {
  class AliasedExpressionWrapper (line 272) | class AliasedExpressionWrapper<
    method constructor (line 279) | constructor(expr: Expression<T>, alias: A | Expression<unknown>) {
    method expression (line 285) | get expression(): Expression<T> {
    method alias (line 290) | get alias(): A | Expression<unknown> {
    method toOperationNode (line 294) | toOperationNode(): AliasNode {
  class OrWrapper (line 304) | class OrWrapper<
    method constructor (line 311) | constructor(node: OrNode) {
    method expressionType (line 316) | get expressionType(): T | undefined {
    method as (line 351) | as(alias: string | Expression<any>): AliasedExpression<T, string> {
    method or (line 367) | or(...args: any[]): any {
    method $castTo (line 379) | $castTo<C extends SqlBool>(): OrWrapper<DB, TB, C> {
    method toOperationNode (line 383) | toOperationNode(): ParensNode {
  class AndWrapper (line 388) | class AndWrapper<
    method constructor (line 395) | constructor(node: AndNode) {
    method expressionType (line 400) | get expressionType(): T | undefined {
    method as (line 435) | as(alias: string | Expression<any>): AliasedExpression<T, string> {
    method and (line 453) | and(...args: any[]): any {
    method $castTo (line 465) | $castTo<C extends SqlBool>(): AndWrapper<DB, TB, C> {
    method toOperationNode (line 469) | toOperationNode(): ParensNode {

FILE: src/expression/expression.ts
  type Expression (line 26) | interface Expression<T> extends OperationNodeSource {
  type AliasableExpression (line 81) | interface AliasableExpression<T> extends Expression<T> {
  type AliasedExpression (line 191) | interface AliasedExpression<
  function isExpression (line 211) | function isExpression(obj: unknown): obj is Expression<any> {
  function isAliasedExpression (line 215) | function isAliasedExpression(

FILE: src/helpers/mssql.ts
  function jsonArrayFrom (line 82) | function jsonArrayFrom<O>(
  function jsonObjectFrom (line 160) | function jsonObjectFrom<O>(
  function jsonBuildObject (line 226) | function jsonBuildObject<O extends Record<string, Expression<unknown>>>(

FILE: src/helpers/mysql.ts
  function jsonArrayFrom (line 61) | function jsonArrayFrom<O>(
  function jsonObjectFrom (line 119) | function jsonObjectFrom<O>(
  function jsonBuildObject (line 167) | function jsonBuildObject<O extends Record<string, Expression<unknown>>>(
  function getMysqlJsonObjectArgs (line 181) | function getMysqlJsonObjectArgs(

FILE: src/helpers/postgres.ts
  function jsonArrayFrom (line 59) | function jsonArrayFrom<O>(
  function jsonObjectFrom (line 116) | function jsonObjectFrom<O>(
  function jsonBuildObject (line 165) | function jsonBuildObject<O extends Record<string, Expression<unknown>>>(
  type MergeAction (line 179) | type MergeAction = 'INSERT' | 'UPDATE' | 'DELETE'
  function mergeAction (line 227) | function mergeAction(): RawBuilder<MergeAction> {

FILE: src/helpers/sqlite.ts
  function jsonArrayFrom (line 74) | function jsonArrayFrom<O>(
  function jsonObjectFrom (line 145) | function jsonObjectFrom<O>(
  function jsonBuildObject (line 209) | function jsonBuildObject<O extends Record<string, Expression<unknown>>>(
  function getSqliteJsonObjectArgs (line 223) | function getSqliteJsonObjectArgs(

FILE: src/kysely.ts
  type AsyncDisposable (line 54) | interface AsyncDisposable {}
  type SymbolConstructor (line 55) | interface SymbolConstructor {
  class Kysely (line 96) | class Kysely<DB>
    method constructor (line 104) | constructor(args: KyselyConfig | KyselyProps) {
    method schema (line 145) | get schema(): SchemaModule {
    method dynamic (line 155) | get dynamic(): DynamicModule<DB> {
    method introspection (line 162) | get introspection(): DatabaseIntrospector {
    method case (line 175) | case<V>(value?: Expression<V>): any {
    method fn (line 231) | get fn(): FunctionModule<DB, keyof DB> {
    method transaction (line 306) | transaction(): TransactionBuilder<DB> {
    method startTransaction (line 421) | startTransaction(): ControlledTransactionBuilder<DB> {
    method connection (line 445) | connection(): ConnectionBuilder<DB> {
    method withPlugin (line 452) | override withPlugin(plugin: KyselyPlugin): Kysely<DB> {
    method withoutPlugins (line 462) | override withoutPlugins(): Kysely<DB> {
    method withSchema (line 472) | override withSchema(schema: string): Kysely<DB> {
    method withTables (line 511) | withTables<T extends Record<string, Record<string, any>>>(): Kysely<
    method destroy (line 522) | async destroy(): Promise<void> {
    method isTransaction (line 531) | get isTransaction(): boolean {
    method getExecutor (line 539) | getExecutor(): QueryExecutor {
    method executeQuery (line 548) | executeQuery<R>(
  method [Symbol.asyncDispose] (line 564) | async [Symbol.asyncDispose]() {
  class Transaction (line 569) | class Transaction<DB> extends Kysely<DB> {
    method constructor (line 572) | constructor(props: KyselyProps) {
    method isTransaction (line 580) | override get isTransaction(): true {
    method transaction (line 584) | override transaction(): TransactionBuilder<DB> {
    method connection (line 590) | override connection(): ConnectionBuilder<DB> {
    method destroy (line 596) | override async destroy(): Promise<void> {
    method withPlugin (line 602) | override withPlugin(plugin: KyselyPlugin): Transaction<DB> {
    method withoutPlugins (line 609) | override withoutPlugins(): Transaction<DB> {
    method withSchema (line 616) | override withSchema(schema: string): Transaction<DB> {
    method withTables (line 625) | override withTables<
  type KyselyProps (line 632) | interface KyselyProps {
  function isKyselyProps (line 639) | function isKyselyProps(obj: unknown): obj is KyselyProps {
  type KyselyConfig (line 649) | interface KyselyConfig {
  class ConnectionBuilder (line 699) | class ConnectionBuilder<DB> {
    method constructor (line 702) | constructor(props: ConnectionBuilderProps) {
    method execute (line 706) | async execute<T>(callback: (db: Kysely<DB>) => Promise<T>): Promise<T> {
  type ConnectionBuilderProps (line 722) | interface ConnectionBuilderProps extends KyselyProps {}
  class TransactionBuilder (line 724) | class TransactionBuilder<DB> {
    method constructor (line 727) | constructor(props: TransactionBuilderProps) {
    method setAccessMode (line 731) | setAccessMode(accessMode: AccessMode): TransactionBuilder<DB> {
    method setIsolationLevel (line 738) | setIsolationLevel(isolationLevel: IsolationLevel): TransactionBuilder<...
    method execute (line 745) | async execute<T>(callback: (trx: Transaction<DB>) => Promise<T>): Prom...
  type TransactionBuilderProps (line 789) | interface TransactionBuilderProps extends KyselyProps {
  class ControlledTransactionBuilder (line 794) | class ControlledTransactionBuilder<DB> {
    method constructor (line 797) | constructor(props: TransactionBuilderProps) {
    method setAccessMode (line 801) | setAccessMode(accessMode: AccessMode): ControlledTransactionBuilder<DB> {
    method setIsolationLevel (line 808) | setIsolationLevel(
    method execute (line 817) | async execute(): Promise<ControlledTransaction<DB>> {
  class ControlledTransaction (line 837) | class ControlledTransaction<
    method constructor (line 845) | constructor(props: ControlledTransactionProps) {
    method isCommitted (line 864) | get isCommitted(): boolean {
    method isRolledBack (line 868) | get isRolledBack(): boolean {
    method commit (line 896) | commit(): Command<void> {
    method rollback (line 932) | rollback(): Command<void> {
    method savepoint (line 973) | savepoint<SN extends string>(
    method rollbackToSavepoint (line 1019) | rollbackToSavepoint<SN extends S[number]>(
    method releaseSavepoint (line 1072) | releaseSavepoint<SN extends S[number]>(
    method withPlugin (line 1090) | override withPlugin(plugin: KyselyPlugin): ControlledTransaction<DB, S> {
    method withoutPlugins (line 1097) | override withoutPlugins(): ControlledTransaction<DB, S> {
    method withSchema (line 1104) | override withSchema(schema: string): ControlledTransaction<DB, S> {
    method withTables (line 1113) | override withTables<
  type ControlledTransctionState (line 1120) | interface ControlledTransctionState {
  type ControlledTransactionProps (line 1125) | interface ControlledTransactionProps extends KyselyProps {
  class Command (line 1129) | class Command<T> {
    method constructor (line 1132) | constructor(cb: () => Promise<T>) {
    method execute (line 1139) | async execute(): Promise<T> {
  function assertNotCommittedOrRolledBack (line 1144) | function assertNotCommittedOrRolledBack(
  class NotCommittedOrRolledBackAssertingExecutor (line 1162) | class NotCommittedOrRolledBackAssertingExecutor implements QueryExecutor {
    method constructor (line 1166) | constructor(executor: QueryExecutor, state: ControlledTransctionState) {
    method adapter (line 1176) | get adapter() {
    method plugins (line 1180) | get plugins() {
    method transformQuery (line 1184) | transformQuery<T extends RootOperationNode>(node: T, queryId: QueryId)...
    method compileQuery (line 1188) | compileQuery<R = unknown>(
    method provideConnection (line 1195) | provideConnection<T>(
    method executeQuery (line 1201) | executeQuery<R>(compiledQuery: CompiledQuery<R>): Promise<QueryResult<...
    method stream (line 1206) | stream<R>(
    method withConnectionProvider (line 1214) | withConnectionProvider(
    method withPlugin (line 1223) | withPlugin(plugin: KyselyPlugin): QueryExecutor {
    method withPlugins (line 1230) | withPlugins(plugins: ReadonlyArray<KyselyPlugin>): QueryExecutor {
    method withPluginAtFront (line 1237) | withPluginAtFront(plugin: KyselyPlugin): QueryExecutor {
    method withoutPlugins (line 1244) | withoutPlugins(): QueryExecutor {

FILE: src/migration/file-migration-provider.ts
  class FileMigrationProvider (line 20) | class FileMigrationProvider implements MigrationProvider {
    method constructor (line 23) | constructor(props: FileMigrationProviderProps) {
    method getMigrations (line 27) | async getMigrations(): Promise<Record<string, Migration>> {
  function isMigration (line 59) | function isMigration(obj: unknown): obj is Migration {
  type FileMigrationProviderFS (line 63) | interface FileMigrationProviderFS {
  type FileMigrationProviderPath (line 67) | interface FileMigrationProviderPath {
  type FileMigrationProviderProps (line 71) | interface FileMigrationProviderProps {

FILE: src/migration/migrator.ts
  constant DEFAULT_MIGRATION_TABLE (line 10) | const DEFAULT_MIGRATION_TABLE = 'kysely_migration'
  constant DEFAULT_MIGRATION_LOCK_TABLE (line 11) | const DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock'
  constant DEFAULT_ALLOW_UNORDERED_MIGRATIONS (line 12) | const DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false
  constant MIGRATION_LOCK_ID (line 13) | const MIGRATION_LOCK_ID = 'migration_lock'
  constant NO_MIGRATIONS (line 14) | const NO_MIGRATIONS: NoMigrations = freeze({ __noMigrations__: true })
  type Migration (line 16) | interface Migration {
  class Migrator (line 66) | class Migrator {
    method constructor (line 69) | constructor(props: MigratorProps) {
    method getMigrations (line 78) | async getMigrations(): Promise<ReadonlyArray<MigrationInfo>> {
    method migrateToLatest (line 149) | async migrateToLatest(): Promise<MigrationResultSet> {
    method migrateTo (line 204) | async migrateTo(
    method migrateUp (line 277) | async migrateUp(): Promise<MigrationResultSet> {
    method migrateDown (line 309) | async migrateDown(): Promise<MigrationResultSet> {
    method #migrate (line 313) | async #migrate(
    method #migrationTableSchema (line 335) | get #migrationTableSchema(): string | undefined {
    method #migrationTable (line 339) | get #migrationTable(): string {
    method #migrationLockTable (line 343) | get #migrationLockTable(): string {
    method #allowUnorderedMigrations (line 347) | get #allowUnorderedMigrations(): boolean {
    method #schemaPlugin (line 353) | get #schemaPlugin(): KyselyPlugin {
    method #ensureMigrationTableSchemaExists (line 361) | async #ensureMigrationTableSchemaExists(): Promise<void> {
    method #ensureMigrationTableExists (line 389) | async #ensureMigrationTableExists(): Promise<void> {
    method #ensureMigrationLockTableExists (line 420) | async #ensureMigrationLockTableExists(): Promise<void> {
    method #ensureLockRowExists (line 449) | async #ensureLockRowExists(): Promise<void> {
    method #doesSchemaExist (line 471) | async #doesSchemaExist(): Promise<boolean> {
    method #doesTableExist (line 477) | async #doesTableExist(tableName: string): Promise<boolean> {
    method #doesLockRowExists (line 489) | async #doesLockRowExists(): Promise<boolean> {
    method #runMigrations (line 500) | async #runMigrations(
    method #getState (line 549) | async #getState(db: Kysely<any>): Promise<MigrationState> {
    method #getPendingMigrations (line 571) | #getPendingMigrations(
    method #resolveMigrations (line 580) | async #resolveMigrations(): Promise<ReadonlyArray<NamedMigration>> {
    method #getExecutedMigrations (line 591) | async #getExecutedMigrations(
    method #ensureNoMissingMigrations (line 620) | #ensureNoMissingMigrations(
    method #ensureMigrationsInOrder (line 634) | #ensureMigrationsInOrder(
    method #migrateDown (line 648) | async #migrateDown(
    method #migrateUp (line 705) | async #migrateUp(
    method #createIfNotExists (line 757) | async #createIfNotExists(
  type MigratorProps (line 768) | interface MigratorProps {
  type MigrationResultSet (line 857) | interface MigrationResultSet {
  type MigrationDirection (line 887) | type MigrationDirection = 'Up' | 'Down'
  type MigrationResult (line 889) | interface MigrationResult {
  type MigrationProvider (line 914) | interface MigrationProvider {
  type NoMigrations (line 936) | interface NoMigrations {
  type MigrationInfo (line 940) | interface MigrationInfo {
  type NamedMigration (line 959) | interface NamedMigration extends Migration {
  type MigrationState (line 963) | interface MigrationState {
  class MigrationResultSetError (line 977) | class MigrationResultSetError extends Error {
    method constructor (line 980) | constructor(result: MigrationResultSet) {
    method resultSet (line 985) | get resultSet(): MigrationResultSet {

FILE: src/operation-node/add-column-node.ts
  type AddColumnNode (line 5) | interface AddColumnNode extends OperationNode {
  type AddColumnNodeFactory (line 10) | type AddColumnNodeFactory = Readonly<{
  method is (line 20) | is(node): node is AddColumnNode {
  method create (line 24) | create(column) {

FILE: src/operation-node/add-constraint-node.ts
  type AddConstraintNode (line 5) | interface AddConstraintNode extends OperationNode {
  type AddConstraintNodeFactory (line 10) | type AddConstraintNodeFactory = Readonly<{
  method is (line 20) | is(node): node is AddConstraintNode {
  method create (line 24) | create(constraint) {

FILE: src/operation-node/add-index-node.ts
  type AddIndexNodeProps (line 6) | type AddIndexNodeProps = Omit<AddIndexNode, 'kind' | 'name'>
  type AddIndexNode (line 8) | interface AddIndexNode extends OperationNode {
  type AddIndexNodeFactory (line 17) | type AddIndexNodeFactory = Readonly<{
  method is (line 34) | is(node): node is AddIndexNode {
  method create (line 38) | create(name) {
  method cloneWith (line 45) | cloneWith(node, props) {
  method cloneWithColumns (line 52) | cloneWithColumns(node, columns) {

FILE: src/operation-node/aggregate-function-node.ts
  type AggregateFunctionNode (line 8) | interface AggregateFunctionNode extends OperationNode {
  type AggregateFunctionNodeFactory (line 19) | type AggregateFunctionNodeFactory = Readonly<{
  method is (line 52) | is(node): node is AggregateFunctionNode {
  method create (line 56) | create(aggregateFunction, aggregated = []) {
  method cloneWithDistinct (line 64) | cloneWithDistinct(aggregateFunctionNode) {
  method cloneWithOrderBy (line 71) | cloneWithOrderBy(aggregateFunctionNode, orderItems, withinGroup = false) {
  method cloneWithFilter (line 82) | cloneWithFilter(aggregateFunctionNode, filter) {
  method cloneWithOrFilter (line 95) | cloneWithOrFilter(aggregateFunctionNode, filter) {
  method cloneWithOver (line 108) | cloneWithOver(aggregateFunctionNode, over?) {

FILE: src/operation-node/alias-node.ts
  type AliasNode (line 4) | interface AliasNode extends OperationNode {
  type AliasNodeFactory (line 10) | type AliasNodeFactory = Readonly<{
  method is (line 19) | is(node): node is AliasNode {
  method create (line 23) | create(node, alias) {

FILE: src/operation-node/alter-column-node.ts
  type AlterColumnNodeProps (line 6) | type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>
  type AlterColumnNode (line 8) | interface AlterColumnNode extends OperationNode {
  type AlterColumnNodeFactory (line 19) | type AlterColumnNodeFactory = Readonly<{
  method is (line 33) | is(node): node is AlterColumnNode {
  method create (line 37) | create(column, prop, value) {

FILE: src/operation-node/alter-table-node.ts
  type AlterTableNodeTableProps (line 16) | type AlterTableNodeTableProps = Pick<
  type AlterTableColumnAlterationNode (line 27) | type AlterTableColumnAlterationNode =
  type AlterTableNode (line 34) | interface AlterTableNode extends OperationNode {
  type AlterTableNodeFactory (line 47) | type AlterTableNodeFactory = Readonly<{
  method is (line 65) | is(node): node is AlterTableNode {
  method create (line 69) | create(table) {
  method cloneWithTableProps (line 76) | cloneWithTableProps(node, props) {
  method cloneWithColumnAlteration (line 83) | cloneWithColumnAlteration(node, columnAlteration) {

FILE: src/operation-node/and-node.ts
  type AndNode (line 4) | interface AndNode extends OperationNode {
  type AndNodeFactory (line 10) | type AndNodeFactory = Readonly<{
  method is (line 19) | is(node): node is AndNode {
  method create (line 23) | create(left, right) {

FILE: src/operation-node/binary-operation-node.ts
  type BinaryOperationNode (line 4) | interface BinaryOperationNode extends OperationNode {
  type BinaryOperationNodeFactory (line 11) | type BinaryOperationNodeFactory = Readonly<{
  method is (line 25) | is(node): node is BinaryOperationNode {
  method create (line 29) | create(leftOperand, operator, rightOperand) {

FILE: src/operation-node/case-node.ts
  type CaseNode (line 5) | interface CaseNode extends OperationNode {
  type CaseNodeFactory (line 13) | type CaseNodeFactory = Readonly<{
  method is (line 28) | is(node): node is CaseNode {
  method create (line 32) | create(value?) {
  method cloneWithWhen (line 39) | cloneWithWhen(caseNode, when) {
  method cloneWithThen (line 46) | cloneWithThen(caseNode, then) {
  method cloneWith (line 61) | cloneWith(caseNode, props) {

FILE: src/operation-node/cast-node.ts
  type CastNode (line 4) | interface CastNode extends OperationNode {
  type CastNodeFactory (line 10) | type CastNodeFactory = Readonly<{
  method is (line 19) | is(node): node is CastNode {
  method create (line 23) | create(expression, dataType) {

FILE: src/operation-node/check-constraint-node.ts
  type CheckConstraintNode (line 5) | interface CheckConstraintNode extends OperationNode {
  type CheckConstraintNodeFactory (line 11) | type CheckConstraintNodeFactory = Readonly<{
  method is (line 24) | is(node): node is CheckConstraintNode {
  method create (line 28) | create(expression, constraintName?) {

FILE: src/operation-node/collate-node.ts
  type CollateNode (line 5) | interface CollateNode extends OperationNode {
  type CollateNodeFactory (line 10) | type CollateNodeFactory = Readonly<{
  method is (line 19) | is(node): node is CollateNode {
  method create (line 23) | create(collation) {

FILE: src/operation-node/column-definition-node.ts
  type ColumnDefinitionNodeProps (line 9) | type ColumnDefinitionNodeProps = Omit<
  type ColumnDefinitionNode (line 14) | interface ColumnDefinitionNode extends OperationNode {
  type ColumnDefinitionNodeFactory (line 34) | type ColumnDefinitionNodeFactory = Readonly<{
  method is (line 59) | is(node): node is ColumnDefinitionNode {
  method create (line 63) | create(column, dataType) {
  method cloneWithFrontModifier (line 71) | cloneWithFrontModifier(node, modifier) {
  method cloneWithEndModifier (line 80) | cloneWithEndModifier(node, modifier) {
  method cloneWith (line 89) | cloneWith(node, props) {

FILE: src/operation-node/column-node.ts
  type ColumnNode (line 5) | interface ColumnNode extends OperationNode {
  type ColumnNodeFactory (line 10) | type ColumnNodeFactory = Readonly<{
  method is (line 19) | is(node): node is ColumnNode {
  method create (line 23) | create(column) {

FILE: src/operation-node/column-update-node.ts
  type ColumnUpdateNode (line 4) | interface ColumnUpdateNode extends OperationNode {
  type ColumnUpdateNodeFactory (line 10) | type ColumnUpdateNodeFactory = Readonly<{
  method is (line 23) | is(node): node is ColumnUpdateNode {
  method create (line 27) | create(column, value) {

FILE: src/operation-node/common-table-expression-name-node.ts
  type CommonTableExpressionNameNode (line 6) | interface CommonTableExpressionNameNode extends OperationNode {
  type CommonTableExpressionNameNodeFactory (line 12) | type CommonTableExpressionNameNodeFactory = Readonly<{
  method is (line 25) | is(node): node is CommonTableExpressionNameNode {
  method create (line 29) | create(tableName, columnNames?) {

FILE: src/operation-node/common-table-expression-node.ts
  type CommonTableExpressionNodeProps (line 5) | type CommonTableExpressionNodeProps = Pick<
  type CommonTableExpressionNode (line 10) | interface CommonTableExpressionNode extends OperationNode {
  type CommonTableExpressionNodeFactory (line 17) | type CommonTableExpressionNodeFactory = Readonly<{
  method is (line 34) | is(node): node is CommonTableExpressionNode {
  method create (line 38) | create(name, expression) {
  method cloneWith (line 46) | cloneWith(node, props) {

FILE: src/operation-node/constraint-node.ts
  type ConstraintNode (line 6) | type ConstraintNode =

FILE: src/operation-node/create-index-node.ts
  type CreateIndexNodeProps (line 8) | type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>
  type IndexType (line 9) | type IndexType = 'btree' | 'hash' | 'gist' | 'gin'
  type CreateIndexNode (line 11) | interface CreateIndexNode extends OperationNode {
  type CreateIndexNodeFactory (line 28) | type CreateIndexNodeFactory = Readonly<{
  method is (line 46) | is(node): node is CreateIndexNode {
  method create (line 50) | create(name) {
  method cloneWith (line 57) | cloneWith(node, props) {
  method cloneWithColumns (line 64) | cloneWithColumns(node, columns) {

FILE: src/operation-node/create-schema-node.ts
  type CreateSchemaNodeParams (line 5) | type CreateSchemaNodeParams = Omit<
  type CreateSchemaNode (line 10) | interface CreateSchemaNode extends OperationNode {
  type CreateSchemaNodeFactory (line 16) | type CreateSchemaNodeFactory = Readonly<{
  method is (line 33) | is(node): node is CreateSchemaNode {
  method create (line 37) | create(schema, params?) {
  method cloneWith (line 45) | cloneWith(createSchema, params) {

FILE: src/operation-node/create-table-node.ts
  constant ON_COMMIT_ACTIONS (line 8) | const ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop']
  type OnCommitAction (line 9) | type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>
  type CreateTableNodeParams (line 11) | type CreateTableNodeParams = Omit<
  type CreateTableNode (line 21) | interface CreateTableNode extends OperationNode {
  type CreateTableNodeFactory (line 34) | type CreateTableNodeFactory = Readonly<{
  method is (line 64) | is(node): node is CreateTableNode {
  method create (line 68) | create(table) {
  method cloneWithColumn (line 76) | cloneWithColumn(createTable, column) {
  method cloneWithConstraint (line 83) | cloneWithConstraint(createTable, constraint) {
  method cloneWithFrontModifier (line 92) | cloneWithFrontModifier(createTable, modifier) {
  method cloneWithEndModifier (line 101) | cloneWithEndModifier(createTable, modifier) {
  method cloneWith (line 110) | cloneWith(createTable, params) {

FILE: src/operation-node/create-type-node.ts
  type CreateTypeNodeParams (line 7) | type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>
  type CreateTypeNode (line 9) | interface CreateTypeNode extends OperationNode {
  type CreateTypeNodeFactory (line 15) | type CreateTypeNodeFactory = Readonly<{
  method is (line 29) | is(node): node is CreateTypeNode {
  method create (line 33) | create(name) {
  method cloneWithEnum (line 40) | cloneWithEnum(createType, values) {

FILE: src/operation-node/create-view-node.ts
  type CreateViewNodeParams (line 8) | type CreateViewNodeParams = Omit<
  type CreateViewNode (line 13) | interface CreateViewNode extends OperationNode {
  type CreateViewNodeFactory (line 24) | type CreateViewNodeFactory = Readonly<{
  method is (line 38) | is(node): node is CreateViewNode {
  method create (line 42) | create(name) {
  method cloneWith (line 49) | cloneWith(createView, params) {

FILE: src/operation-node/data-type-node.ts
  constant SIMPLE_COLUMN_DATA_TYPES (line 4) | const SIMPLE_COLUMN_DATA_TYPES = [
  constant COLUMN_DATA_TYPE_REGEX (line 50) | const COLUMN_DATA_TYPE_REGEX = [
  type SimpleColumnDataType (line 64) | type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number]
  type ColumnDataType (line 66) | type ColumnDataType =
  type DataTypeParams (line 80) | type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>
  type DataTypeNode (line 82) | interface DataTypeNode extends OperationNode {
  type DataTypeNodeFactory (line 87) | type DataTypeNodeFactory = Readonly<{
  method is (line 96) | is(node): node is DataTypeNode {
  method create (line 100) | create(dataType) {
  function isColumnDataType (line 108) | function isColumnDataType(dataType: string): dataType is ColumnDataType {

FILE: src/operation-node/default-insert-value-node.ts
  type DefaultInsertValueNode (line 4) | interface DefaultInsertValueNode extends OperationNode {
  type DefaultInsertValueNodeFactory (line 8) | type DefaultInsertValueNodeFactory = Readonly<{
  method is (line 18) | is(node): node is DefaultInsertValueNode {
  method create (line 22) | create() {

FILE: src/operation-node/default-value-node.ts
  type DefaultValueNode (line 4) | interface DefaultValueNode extends OperationNode {
  type DefaultValueNodeFactory (line 9) | type DefaultValueNodeFactory = Readonly<{
  method is (line 19) | is(node): node is DefaultValueNode {
  method create (line 23) | create(defaultValue) {

FILE: src/operation-node/delete-query-node.ts
  type DeleteQueryNode (line 17) | interface DeleteQueryNode extends OperationNode {
  type DeleteQueryNodeFactory (line 33) | type DeleteQueryNodeFactory = Readonly<{
  method is (line 60) | is(node): node is DeleteQueryNode {
  method create (line 64) | create(fromItems, withNode?) {
  method cloneWithLimit (line 85) | cloneWithLimit(deleteNode, limit) {
  method cloneWithoutLimit (line 92) | cloneWithoutLimit(deleteNode) {
  method cloneWithUsing (line 99) | cloneWithUsing(deleteNode, tables) {

FILE: src/operation-node/drop-column-node.ts
  type DropColumnNode (line 5) | interface DropColumnNode extends OperationNode {
  type DropColumnNodeFactory (line 10) | type DropColumnNodeFactory = Readonly<{
  method is (line 20) | is(node): node is DropColumnNode {
  method create (line 24) | create(column) {

FILE: src/operation-node/drop-constraint-node.ts
  type DropConstraintNodeProps (line 5) | type DropConstraintNodeProps = Omit<
  type DropConstraintNode (line 10) | interface DropConstraintNode extends OperationNode {
  type DropConstraintNodeFactory (line 17) | type DropConstraintNodeFactory = Readonly<{
  method is (line 34) | is(node): node is DropConstraintNode {
  method create (line 38) | create(constraintName) {
  method cloneWith (line 45) | cloneWith(dropConstraint, props) {

FILE: src/operation-node/drop-index-node.ts
  type DropIndexNodeProps (line 6) | type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>
  type DropIndexNode (line 8) | interface DropIndexNode extends OperationNode {
  type DropIndexNodeFactory (line 16) | type DropIndexNodeFactory = Readonly<{
  method is (line 30) | is(node): node is DropIndexNode {
  method create (line 34) | create(name, params?) {
  method cloneWith (line 42) | cloneWith(dropIndex, props) {

FILE: src/operation-node/drop-schema-node.ts
  type DropSchemaNodeParams (line 5) | type DropSchemaNodeParams = Omit<
  type DropSchemaNode (line 10) | interface DropSchemaNode extends OperationNode {
  type DropSchemaNodeFactory (line 17) | type DropSchemaNodeFactory = Readonly<{
  method is (line 34) | is(node): node is DropSchemaNode {
  method create (line 38) | create(schema, params?) {
  method cloneWith (line 46) | cloneWith(dropSchema, params) {

FILE: src/operation-node/drop-table-node.ts
  type DropTablexNodeParams (line 5) | type DropTablexNodeParams = Omit<
  type DropTableNode (line 9) | interface DropTableNode extends OperationNode {
  type DropTableNodeFactory (line 16) | type DropTableNodeFactory = Readonly<{
  method is (line 33) | is(node): node is DropTableNode {
  method create (line 37) | create(table, params?) {
  method cloneWith (line 45) | cloneWith(dropIndex, params) {

FILE: src/operation-node/drop-type-node.ts
  type DropTypeNodeParams (line 5) | type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>
  type DropTypeNode (line 7) | interface DropTypeNode extends OperationNode {
  type DropTypeNodeFactory (line 13) | type DropTypeNodeFactory = Readonly<{
  method is (line 26) | is(node): node is DropTypeNode {
  method create (line 30) | create(name) {
  method cloneWith (line 37) | cloneWith(dropType, params) {

FILE: src/operation-node/drop-view-node.ts
  type DropViewNodeParams (line 5) | type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>
  type DropViewNode (line 7) | interface DropViewNode extends OperationNode {
  type DropViewNodeFactory (line 15) | type DropViewNodeFactory = Readonly<{
  method is (line 28) | is(node): node is DropViewNode {
  method create (line 32) | create(name) {
  method cloneWith (line 39) | cloneWith(dropView, params) {

FILE: src/operation-node/explain-node.ts
  type ExplainNode (line 5) | interface ExplainNode extends OperationNode {
  type ExplainNodeFactory (line 11) | type ExplainNodeFactory = Readonly<{
  method is (line 20) | is(node): node is ExplainNode {
  method create (line 24) | create(format?, options?) {

FILE: src/operation-node/fetch-node.ts
  type FetchModifier (line 5) | type FetchModifier = 'only' | 'with ties'
  type FetchNode (line 7) | interface FetchNode extends OperationNode {
  type FetchNodeFactory (line 13) | type FetchNodeFactory = Readonly<{
  method is (line 25) | is(node): node is FetchNode {
  method create (line 29) | create(rowCount, modifier) {

FILE: src/operation-node/foreign-key-constraint-node.ts
  type ForeignKeyConstraintNodeProps (line 11) | type ForeignKeyConstraintNodeProps = Omit<
  type ForeignKeyConstraintNode (line 16) | interface ForeignKeyConstraintNode extends OperationNode {
  type ForeignKeyConstraintNodeFactory (line 27) | type ForeignKeyConstraintNodeFactory = Readonly<{
  method is (line 46) | is(node): node is ForeignKeyConstraintNode {
  method create (line 50) | create(sourceColumns, targetTable, targetColumns, constraintName?) {
  method cloneWith (line 61) | cloneWith(node, props) {

FILE: src/operation-node/from-node.ts
  type FromNode (line 4) | interface FromNode extends OperationNode {
  type FromNodeFactory (line 9) | type FromNodeFactory = Readonly<{
  method is (line 22) | is(node): node is FromNode {
  method create (line 26) | create(froms) {
  method cloneWithFroms (line 33) | cloneWithFroms(from, froms) {

FILE: src/operation-node/function-node.ts
  type FunctionNode (line 4) | interface FunctionNode extends OperationNode {
  type FunctionNodeFactory (line 10) | type FunctionNodeFactory = Readonly<{
  method is (line 22) | is(node): node is FunctionNode {
  method create (line 26) | create(func, args) {

FILE: src/operation-node/generated-node.ts
  type GeneratedNodeParams (line 4) | type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>
  type GeneratedNode (line 6) | interface GeneratedNode extends OperationNode {
  type GeneratedNodeFactory (line 15) | type GeneratedNodeFactory = Readonly<{
  method is (line 30) | is(node): node is GeneratedNode {
  method create (line 34) | create(params) {
  method createWithExpression (line 41) | createWithExpression(expression) {
  method cloneWith (line 49) | cloneWith(node, params) {

FILE: src/operation-node/group-by-item-node.ts
  type GroupByItemNode (line 4) | interface GroupByItemNode extends OperationNode {
  type GroupByItemNodeFactory (line 9) | type GroupByItemNodeFactory = Readonly<{
  method is (line 19) | is(node): node is GroupByItemNode {
  method create (line 23) | create(groupBy) {

FILE: src/operation-node/group-by-node.ts
  type GroupByNode (line 5) | interface GroupByNode extends OperationNode {
  type GroupByNodeFactory (line 10) | type GroupByNodeFactory = Readonly<{
  method is (line 23) | is(node): node is GroupByNode {
  method create (line 27) | create(items) {
  method cloneWithItems (line 34) | cloneWithItems(groupBy, items) {

FILE: src/operation-node/having-node.ts
  type HavingNode (line 6) | interface HavingNode extends OperationNode {
  type HavingNodeFactory (line 11) | type HavingNodeFactory = Readonly<{
  method is (line 25) | is(node): node is HavingNode {
  method create (line 29) | create(filter) {
  method cloneWithOperation (line 36) | cloneWithOperation(havingNode, operator, operation) {

FILE: src/operation-node/identifier-node.ts
  type IdentifierNode (line 4) | interface IdentifierNode extends OperationNode {
  type IdentifierNodeFactory (line 9) | type IdentifierNodeFactory = Readonly<{
  method is (line 19) | is(node): node is IdentifierNode {
  method create (line 23) | create(name) {

FILE: src/operation-node/insert-query-node.ts
  type InsertQueryNodeProps (line 14) | type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>
  type InsertQueryNode (line 16) | interface InsertQueryNode extends OperationNode {
  type InsertQueryNodeFactory (line 37) | type InsertQueryNodeFactory = Readonly<{
  method is (line 56) | is(node): node is InsertQueryNode {
  method create (line 60) | create(into, withNode?, replace?) {
  method createWithoutInto (line 69) | createWithoutInto() {
  method cloneWith (line 75) | cloneWith(insertQuery, props) {

FILE: src/operation-node/join-node.ts
  type JoinType (line 5) | type JoinType =
  type JoinNode (line 18) | interface JoinNode extends OperationNode {
  type JoinNodeFactory (line 25) | type JoinNodeFactory = Readonly<{
  method is (line 40) | is(node): node is JoinNode {
  method create (line 44) | create(joinType, table) {
  method createWithOn (line 53) | createWithOn(joinType, table, on) {
  method cloneWithOn (line 62) | cloneWithOn(joinNode, operation) {

FILE: src/operation-node/json-operator-chain-node.ts
  type JSONOperatorChainNode (line 6) | interface JSONOperatorChainNode extends OperationNode {
  type JSONOperatorChainNodeFactory (line 12) | type JSONOperatorChainNodeFactory = Readonly<{
  method is (line 26) | is(node): node is JSONOperatorChainNode {
  method create (line 30) | create(operator) {
  method cloneWithValue (line 38) | cloneWithValue(node, value) {

FILE: src/operation-node/json-path-leg-node.ts
  type JSONPathLegType (line 4) | type JSONPathLegType = 'Member' | 'ArrayLocation'
  type JSONPathLegNode (line 6) | interface JSONPathLegNode extends OperationNode {
  type JSONPathLegNodeFactory (line 12) | type JSONPathLegNodeFactory = Readonly<{
  method is (line 25) | is(node): node is JSONPathLegNode {
  method create (line 29) | create(type, value) {

FILE: src/operation-node/json-path-node.ts
  type JSONPathNode (line 6) | interface JSONPathNode extends OperationNode {
  type JSONPathNodeFactory (line 12) | type JSONPathNodeFactory = Readonly<{
  method is (line 25) | is(node): node is JSONPathNode {
  method create (line 29) | create(inOperator?) {
  method cloneWithLeg (line 37) | cloneWithLeg(jsonPathNode, pathLeg) {

FILE: src/operation-node/json-reference-node.ts
  type JSONReferenceNode (line 7) | interface JSONReferenceNode extends OperationNode {
  type JSONReferenceNodeFactory (line 13) | type JSONReferenceNodeFactory = Readonly<{
  method is (line 30) | is(node): node is JSONReferenceNode {
  method create (line 34) | create(reference, traversal) {
  method cloneWithTraversal (line 42) | cloneWithTraversal(node, traversal) {

FILE: src/operation-node/limit-node.ts
  type LimitNode (line 4) | interface LimitNode extends OperationNode {
  type LimitNodeFactory (line 9) | type LimitNodeFactory = Readonly<{
  method is (line 18) | is(node): node is LimitNode {
  method create (line 22) | create(limit) {

FILE: src/operation-node/list-node.ts
  type ListNode (line 4) | interface ListNode extends OperationNode {
  type ListNodeFactory (line 9) | type ListNodeFactory = Readonly<{
  method is (line 18) | is(node): node is ListNode {
  method create (line 22) | create(items) {

FILE: src/operation-node/matched-node.ts
  type MatchedNode (line 4) | interface MatchedNode extends OperationNode {
  type MatchedNodeFactory (line 10) | type MatchedNodeFactory = Readonly<{
  method is (line 19) | is(node): node is MatchedNode {
  method create (line 23) | create(not, bySource = false) {

FILE: src/operation-node/merge-query-node.ts
  type MergeQueryNode (line 12) | interface MergeQueryNode extends OperationNode {
  type MergeQueryNodeFactory (line 24) | type MergeQueryNodeFactory = Readonly<{
  method is (line 49) | is(node): node is MergeQueryNode {
  method create (line 53) | create(into, withNode?) {
  method cloneWithUsing (line 61) | cloneWithUsing(mergeNode, using) {
  method cloneWithWhen (line 68) | cloneWithWhen(mergeNode, when) {
  method cloneWithThen (line 77) | cloneWithThen(mergeNode, then) {

FILE: src/operation-node/modify-column-node.ts
  type ModifyColumnNode (line 5) | interface ModifyColumnNode extends OperationNode {
  type ModifyColumnNodeFactory (line 10) | type ModifyColumnNodeFactory = Readonly<{
  method is (line 20) | is(node): node is ModifyColumnNode {
  method create (line 24) | create(column) {

FILE: src/operation-node/offset-node.ts
  type OffsetNode (line 4) | interface OffsetNode extends OperationNode {
  type OffsetNodeFactory (line 9) | type OffsetNodeFactory = Readonly<{
  method is (line 18) | is(node): node is OffsetNode {
  method create (line 22) | create(offset) {

FILE: src/operation-node/on-conflict-node.ts
  type OnConflictNodeProps (line 8) | type OnConflictNodeProps = Omit<
  type OnConflictNode (line 13) | interface OnConflictNode extends OperationNode {
  type OnConflictNodeFactory (line 24) | type OnConflictNodeFactory = Readonly<{
  method is (line 55) | is(node): node is OnConflictNode {
  method create (line 59) | create() {
  method cloneWith (line 65) | cloneWith(node, props) {
  method cloneWithIndexWhere (line 72) | cloneWithIndexWhere(node, operation) {
  method cloneWithIndexOrWhere (line 81) | cloneWithIndexOrWhere(node, operation) {
  method cloneWithUpdateWhere (line 90) | cloneWithUpdateWhere(node, operation) {
  method cloneWithUpdateOrWhere (line 99) | cloneWithUpdateOrWhere(node, operation) {
  method cloneWithoutIndexWhere (line 108) | cloneWithoutIndexWhere(node) {
  method cloneWithoutUpdateWhere (line 115) | cloneWithoutUpdateWhere(node) {

FILE: src/operation-node/on-duplicate-key-node.ts
  type OnDuplicateKeyNodeProps (line 5) | type OnDuplicateKeyNodeProps = Omit<OnDuplicateKeyNode, 'kind'>
  type OnDuplicateKeyNode (line 7) | interface OnDuplicateKeyNode extends OperationNode {
  type OnDuplicateKeyNodeFactory (line 12) | type OnDuplicateKeyNodeFactory = Readonly<{
  method is (line 22) | is(node): node is OnDuplicateKeyNode {
  method create (line 26) | create(updates) {

FILE: src/operation-node/on-node.ts
  type OnNode (line 6) | interface OnNode extends OperationNode {
  type OnNodeFactory (line 11) | type OnNodeFactory = Readonly<{
  method is (line 25) | is(node): node is OnNode {
  method create (line 29) | create(filter) {
  method cloneWithOperation (line 36) | cloneWithOperation(onNode, operator, operation) {

FILE: src/operation-node/operation-node-source.ts
  type OperationNodeSource (line 4) | interface OperationNodeSource {
  function isOperationNodeSource (line 8) | function isOperationNodeSource(

FILE: src/operation-node/operation-node-transformer.ts
  class OperationNodeTransformer (line 138) | class OperationNodeTransformer {
    method transformNode (line 247) | transformNode<T extends OperationNode | undefined>(
    method transformNodeImpl (line 262) | protected transformNodeImpl<T extends OperationNode>(
    method transformNodeList (line 269) | protected transformNodeList<
    method transformSelectQuery (line 279) | protected transformSelectQuery(
    method transformSelection (line 305) | protected transformSelection(
    method transformColumn (line 315) | protected transformColumn(node: ColumnNode, queryId?: QueryId): Column...
    method transformAlias (line 322) | protected transformAlias(node: AliasNode, queryId?: QueryId): AliasNode {
    method transformTable (line 330) | protected transformTable(node: TableNode, queryId?: QueryId): TableNode {
    method transformFrom (line 337) | protected transformFrom(node: FromNode, queryId?: QueryId): FromNode {
    method transformReference (line 344) | protected transformReference(
    method transformAnd (line 355) | protected transformAnd(node: AndNode, queryId?: QueryId): AndNode {
    method transformOr (line 363) | protected transformOr(node: OrNode, queryId?: QueryId): OrNode {
    method transformValueList (line 371) | protected transformValueList(
    method transformParens (line 381) | protected transformParens(node: ParensNode, queryId?: QueryId): Parens...
    method transformJoin (line 388) | protected transformJoin(node: JoinNode, queryId?: QueryId): JoinNode {
    method transformRaw (line 397) | protected transformRaw(node: RawNode, queryId?: QueryId): RawNode {
    method transformWhere (line 405) | protected transformWhere(node: WhereNode, queryId?: QueryId): WhereNode {
    method transformInsertQuery (line 412) | protected transformInsertQuery(
    method transformValues (line 436) | protected transformValues(node: ValuesNode, queryId?: QueryId): Values...
    method transformDeleteQuery (line 443) | protected transformDeleteQuery(
    method transformReturning (line 464) | protected transformReturning(
    method transformCreateTable (line 474) | protected transformCreateTable(
    method transformColumnDefinition (line 492) | protected transformColumnDefinition(
    method transformAddColumn (line 517) | protected transformAddColumn(
    method transformDropTable (line 527) | protected transformDropTable(
    method transformOrderBy (line 539) | protected transformOrderBy(
    method transformOrderByItem (line 549) | protected transformOrderByItem(
    method transformGroupBy (line 562) | protected transformGroupBy(
    method transformGroupByItem (line 572) | protected transformGroupByItem(
    method transformUpdateQuery (line 582) | protected transformUpdateQuery(
    method transformColumnUpdate (line 604) | protected transformColumnUpdate(
    method transformLimit (line 615) | protected transformLimit(node: LimitNode, queryId?: QueryId): LimitNode {
    method transformOffset (line 622) | protected transformOffset(node: OffsetNode, queryId?: QueryId): Offset...
    method transformOnConflict (line 629) | protected transformOnConflict(
    method transformOnDuplicateKey (line 645) | protected transformOnDuplicateKey(
    method transformCreateIndex (line 655) | protected transformCreateIndex(
    method transformList (line 672) | protected transformList(node: ListNode, queryId?: QueryId): ListNode {
    method transformDropIndex (line 679) | protected transformDropIndex(
    method transformPrimaryKeyConstraint (line 692) | protected transformPrimaryKeyConstraint(
    method transformUniqueConstraint (line 705) | protected transformUniqueConstraint(
    method transformForeignKeyConstraint (line 719) | protected transformForeignKeyConstraint(
    method transformSetOperation (line 735) | protected transformSetOperation(
    method transformReferences (line 747) | protected transformReferences(
    method transformCheckConstraint (line 760) | protected transformCheckConstraint(
    method transformWith (line 771) | protected transformWith(node: WithNode, queryId?: QueryId): WithNode {
    method transformCommonTableExpression (line 779) | protected transformCommonTableExpression(
    method transformCommonTableExpressionName (line 791) | protected transformCommonTableExpressionName(
    method transformHaving (line 802) | protected transformHaving(node: HavingNode, queryId?: QueryId): Having...
    method transformCreateSchema (line 809) | protected transformCreateSchema(
    method transformDropSchema (line 820) | protected transformDropSchema(
    method transformAlterTable (line 832) | protected transformAlterTable(
    method transformDropColumn (line 853) | protected transformDropColumn(
    method transformRenameColumn (line 863) | protected transformRenameColumn(
    method transformAlterColumn (line 874) | protected transformAlterColumn(
    method transformModifyColumn (line 890) | protected transformModifyColumn(
    method transformAddConstraint (line 900) | protected transformAddConstraint(
    method transformDropConstraint (line 910) | protected transformDropConstraint(
    method transformRenameConstraint (line 922) | protected transformRenameConstraint(
    method transformCreateView (line 933) | protected transformCreateView(
    method transformRefreshMaterializedView (line 949) | protected transformRefreshMaterializedView(
    method transformDropView (line 961) | protected transformDropView(
    method transformGenerated (line 974) | protected transformGenerated(
    method transformDefaultValue (line 988) | protected transformDefaultValue(
    method transformOn (line 998) | protected transformOn(node: OnNode, queryId?: QueryId): OnNode {
    method transformSelectModifier (line 1005) | protected transformSelectModifier(
    method transformCreateType (line 1017) | protected transformCreateType(
    method transformDropType (line 1028) | protected transformDropType(
    method transformExplain (line 1039) | protected transformExplain(
    method transformSchemableIdentifier (line 1050) | protected transformSchemableIdentifier(
    method transformAggregateFunction (line 1061) | protected transformAggregateFunction(
    method transformOver (line 1077) | protected transformOver(node: OverNode, queryId?: QueryId): OverNode {
    method transformPartitionBy (line 1085) | protected transformPartitionBy(
    method transformPartitionByItem (line 1095) | protected transformPartitionByItem(
    method transformBinaryOperation (line 1105) | protected transformBinaryOperation(
    method transformUnaryOperation (line 1117) | protected transformUnaryOperation(
    method transformUsing (line 1128) | protected transformUsing(node: UsingNode, queryId?: QueryId): UsingNode {
    method transformFunction (line 1135) | protected transformFunction(
    method transformCase (line 1146) | protected transformCase(node: CaseNode, queryId?: QueryId): CaseNode {
    method transformWhen (line 1156) | protected transformWhen(node: WhenNode, queryId?: QueryId): WhenNode {
    method transformJSONReference (line 1164) | protected transformJSONReference(
    method transformJSONPath (line 1175) | protected transformJSONPath(
    method transformJSONPathLeg (line 1186) | protected transformJSONPathLeg(
    method transformJSONOperatorChain (line 1197) | protected transformJSONOperatorChain(
    method transformTuple (line 1208) | protected transformTuple(node: TupleNode, queryId?: QueryId): TupleNode {
    method transformMergeQuery (line 1215) | protected transformMergeQuery(
    method transformMatched (line 1232) | protected transformMatched(
    method transformAddIndex (line 1243) | protected transformAddIndex(
    method transformCast (line 1257) | protected transformCast(node: CastNode, queryId?: QueryId): CastNode {
    method transformFetch (line 1265) | protected transformFetch(node: FetchNode, queryId?: QueryId): FetchNode {
    method transformTop (line 1273) | protected transformTop(node: TopNode, _queryId?: QueryId): TopNode {
    method transformOutput (line 1281) | protected transformOutput(node: OutputNode, queryId?: QueryId): Output...
    method transformDataType (line 1288) | protected transformDataType(
    method transformSelectAll (line 1296) | protected transformSelectAll(
    method transformIdentifier (line 1304) | protected transformIdentifier(
    method transformValue (line 1312) | protected transformValue(node: ValueNode, _queryId?: QueryId): ValueNo...
    method transformPrimitiveValueList (line 1317) | protected transformPrimitiveValueList(
    method transformOperator (line 1325) | protected transformOperator(
    method transformDefaultInsertValue (line 1333) | protected transformDefaultInsertValue(
    method transformOrAction (line 1341) | protected transformOrAction(
    method transformCollate (line 1349) | protected transformCollate(

FILE: src/operation-node/operation-node-visitor.ts
  method parentNode (line 107) | protected get parentNode(): OperationNode | undefined {

FILE: src/operation-node/operation-node.ts
  type OperationNodeKind (line 1) | type OperationNodeKind =
  type OperationNode (line 100) | interface OperationNode {

FILE: src/operation-node/operator-node.ts
  constant COMPARISON_OPERATORS (line 4) | const COMPARISON_OPERATORS = [
  constant ARITHMETIC_OPERATORS (line 45) | const ARITHMETIC_OPERATORS = [
  constant JSON_OPERATORS (line 59) | const JSON_OPERATORS = ['->', '->>'] as const
  constant BINARY_OPERATORS (line 61) | const BINARY_OPERATORS = [
  constant UNARY_FILTER_OPERATORS (line 68) | const UNARY_FILTER_OPERATORS = ['exists', 'not exists'] as const
  constant UNARY_OPERATORS (line 69) | const UNARY_OPERATORS = ['not', '-', ...UNARY_FILTER_OPERATORS] as const
  constant OPERATORS (line 70) | const OPERATORS = [
  type ComparisonOperator (line 78) | type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number]
  type ArithmeticOperator (line 79) | type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number]
  type JSONOperator (line 80) | type JSONOperator = (typeof JSON_OPERATORS)[number]
  type JSONOperatorWith$ (line 81) | type JSONOperatorWith$ = JSONOperator | `${JSONOperator}$`
  type BinaryOperator (line 82) | type BinaryOperator = (typeof BINARY_OPERATORS)[number]
  type UnaryOperator (line 83) | type UnaryOperator = (typeof UNARY_OPERATORS)[number]
  type UnaryFilterOperator (line 84) | type UnaryFilterOperator = (typeof UNARY_FILTER_OPERATORS)[number]
  type Operator (line 85) | type Operator = (typeof OPERATORS)[number]
  type OperatorNode (line 87) | interface OperatorNode extends OperationNode {
  type OperatorNodeFactory (line 92) | type OperatorNodeFactory = Readonly<{
  method is (line 101) | is(node): node is OperatorNode {
  method create (line 105) | create(operator) {
  function isOperator (line 113) | function isOperator(op: unknown): op is Operator {
  function isBinaryOperator (line 117) | function isBinaryOperator(op: unknown): op is BinaryOperator {
  function isComparisonOperator (line 121) | function isComparisonOperator(op: unknown): op is ComparisonOperator {
  function isArithmeticOperator (line 125) | function isArithmeticOperator(op: unknown): op is ArithmeticOperator {
  function isJSONOperator (line 129) | function isJSONOperator(op: unknown): op is JSONOperator {

FILE: src/operation-node/or-action-node.ts
  type OrActionNode (line 4) | interface OrActionNode extends OperationNode {
  type OrActionNodeFactory (line 9) | type OrActionNodeFactory = Readonly<{
  method is (line 18) | is(node): node is OrActionNode {
  method create (line 22) | create(action) {

FILE: src/operation-node/or-node.ts
  type OrNode (line 4) | interface OrNode extends OperationNode {
  type OrNodeFactory (line 10) | type OrNodeFactory = Readonly<{
  method is (line 19) | is(node): node is OrNode {
  method create (line 23) | create(left, right) {

FILE: src/operation-node/order-by-item-node.ts
  type OrderByItemNodeProps (line 5) | type OrderByItemNodeProps = Omit<OrderByItemNode, 'kind' | 'orderBy'>
  type OrderByItemNode (line 7) | interface OrderByItemNode extends OperationNode {
  type OrderByItemNodeFactory (line 15) | type OrderByItemNodeFactory = Readonly<{
  method is (line 32) | is(node): node is OrderByItemNode {
  method create (line 36) | create(orderBy, direction?) {
  method cloneWith (line 44) | cloneWith(node, props) {

FILE: src/operation-node/order-by-node.ts
  type OrderByNode (line 5) | interface OrderByNode extends OperationNode {
  type OrderByNodeFactory (line 10) | type OrderByNodeFactory = Readonly<{
  method is (line 23) | is(node): node is OrderByNode {
  method create (line 27) | create(items) {
  method cloneWithItems (line 34) | cloneWithItems(orderBy, items) {

FILE: src/operation-node/output-node.ts
  type OutputNode (line 4) | interface OutputNode extends OperationNode {
  type OutputNodeFactory (line 9) | type OutputNodeFactory = Readonly<{
  method is (line 22) | is(node): node is OutputNode {
  method create (line 26) | create(selections) {
  method cloneWithSelections (line 33) | cloneWithSelections(output, selections) {

FILE: src/operation-node/over-node.ts
  type OverNode (line 8) | interface OverNode extends OperationNode {
  type OverNodeFactory (line 14) | type OverNodeFactory = Readonly<{
  method is (line 31) | is(node): node is OverNode {
  method create (line 35) | create() {
  method cloneWithOrderByItems (line 41) | cloneWithOrderByItems(overNode, items) {
  method cloneWithPartitionByItems (line 50) | cloneWithPartitionByItems(overNode, items) {

FILE: src/operation-node/parens-node.ts
  type ParensNode (line 4) | interface ParensNode extends OperationNode {
  type ParensNodeFactory (line 9) | type ParensNodeFactory = Readonly<{
  method is (line 18) | is(node): node is ParensNode {
  method create (line 22) | create(node) {

FILE: src/operation-node/partition-by-item-node.ts
  type PartitionByItemNode (line 5) | interface PartitionByItemNode extends OperationNode {
  type PartitionByItemNodeFactory (line 10) | type PartitionByItemNodeFactory = Readonly<{
  method is (line 22) | is(node): node is PartitionByItemNode {
  method create (line 26) | create(partitionBy) {

FILE: src/operation-node/partition-by-node.ts
  type PartitionByNode (line 5) | interface PartitionByNode extends OperationNode {
  type PartitionByNodeFactory (line 10) | type PartitionByNodeFactory = Readonly<{
  method is (line 24) | is(node): node is PartitionByNode {
  method create (line 28) | create(items) {
  method cloneWithItems (line 35) | cloneWithItems(partitionBy, items) {

FILE: src/operation-node/primary-key-constraint-node.ts
  type PrimaryKeyConstraintNode (line 6) | interface PrimaryKeyConstraintNode extends OperationNode {
  type PrimaryKeyConstraintNodeProps (line 14) | type PrimaryKeyConstraintNodeProps = Omit<
  type PrimaryKeyConstraintNodeFactory (line 19) | type PrimaryKeyConstraintNodeFactory = Readonly<{
  method is (line 36) | is(node): node is PrimaryKeyConstraintNode {
  method create (line 40) | create(columns, constraintName?) {
  method cloneWith (line 50) | cloneWith(node, props) {

FILE: src/operation-node/primitive-value-list-node.ts
  type PrimitiveValueListNode (line 9) | interface PrimitiveValueListNode extends OperationNode {
  type PrimitiveValueListNodeFactory (line 14) | type PrimitiveValueListNodeFactory = Readonly<{
  method is (line 24) | is(node): node is PrimitiveValueListNode {
  method create (line 28) | create(values) {

FILE: src/operation-node/query-node.ts
  type QueryNode (line 20) | type QueryNode =
  type HasJoins (line 27) | type HasJoins = { joins?: ReadonlyArray<JoinNode> }
  type HasWhere (line 28) | type HasWhere = { where?: WhereNode }
  type HasReturning (line 29) | type HasReturning = { returning?: ReturningNode }
  type HasExplain (line 30) | type HasExplain = { explain?: ExplainNode }
  type HasTop (line 31) | type HasTop = { top?: TopNode }
  type HasOutput (line 32) | type HasOutput = { output?: OutputNode }
  type HasEndModifiers (line 33) | type HasEndModifiers = { endModifiers?: ReadonlyArray<OperationNode> }
  type HasOrderBy (line 34) | type HasOrderBy = { orderBy?: OrderByNode }
  type QueryNodeFactory (line 36) | type QueryNodeFactory = Readonly<{
  method is (line 74) | is(node): node is QueryNode {
  method cloneWithEndModifier (line 84) | cloneWithEndModifier(node, modifier) {
  method cloneWithWhere (line 93) | cloneWithWhere(node, operation) {
  method cloneWithJoin (line 102) | cloneWithJoin(node, join) {
  method cloneWithReturning (line 109) | cloneWithReturning(node, selections) {
  method cloneWithoutReturning (line 118) | cloneWithoutReturning(node) {
  method cloneWithoutWhere (line 125) | cloneWithoutWhere(node) {
  method cloneWithExplain (line 132) | cloneWithExplain(node, format, options) {
  method cloneWithTop (line 139) | cloneWithTop(node, top) {
  method cloneWithOutput (line 146) | cloneWithOutput(node, selections) {
  method cloneWithOrderByItems (line 155) | cloneWithOrderByItems(node, items) {
  method cloneWithoutOrderBy (line 164) | cloneWithoutOrderBy(node) {

FILE: src/operation-node/raw-node.ts
  type RawNode (line 4) | interface RawNode extends OperationNode {
  type RawNodeFactory (line 10) | type RawNodeFactory = Readonly<{
  method is (line 25) | is(node): node is RawNode {
  method create (line 29) | create(sqlFragments, parameters) {
  method createWithSql (line 37) | createWithSql(sql) {
  method createWithChild (line 41) | createWithChild(child) {
  method createWithChildren (line 45) | createWithChildren(children) {

FILE: src/operation-node/reference-node.ts
  type ReferenceNode (line 7) | interface ReferenceNode extends OperationNode {
  type ReferenceNodeFactory (line 13) | type ReferenceNodeFactory = Readonly<{
  method is (line 24) | is(node): node is ReferenceNode {
  method create (line 28) | create(column, table?) {
  method createSelectAll (line 36) | createSelectAll(table) {

FILE: src/operation-node/references-node.ts
  constant ON_MODIFY_FOREIGN_ACTIONS (line 7) | const ON_MODIFY_FOREIGN_ACTIONS = [
  type OnModifyForeignAction (line 15) | type OnModifyForeignAction = ArrayItemType<
  type ReferencesNode (line 19) | interface ReferencesNode extends OperationNode {
  type ReferencesNodeFactory (line 27) | type ReferencesNodeFactory = Readonly<{
  method is (line 48) | is(node): node is ReferencesNode {
  method create (line 52) | create(table, columns) {
  method cloneWithOnDelete (line 60) | cloneWithOnDelete(references, onDelete) {
  method cloneWithOnUpdate (line 67) | cloneWithOnUpdate(references, onUpdate) {

FILE: src/operation-node/refresh-materialized-view-node.ts
  type RefreshMaterializedViewNodeParams (line 5) | type RefreshMaterializedViewNodeParams = Omit<
  type RefreshMaterializedViewNode (line 10) | interface RefreshMaterializedViewNode extends OperationNode {
  type RefreshMaterializedViewNodeFactory (line 17) | type RefreshMaterializedViewNodeFactory = Readonly<{
  method is (line 31) | is(node): node is RefreshMaterializedViewNode {
  method create (line 35) | create(name) {
  method cloneWith (line 42) | cloneWith(createView, params) {

FILE: src/operation-node/rename-column-node.ts
  type RenameColumnNode (line 5) | interface RenameColumnNode extends OperationNode {
  type RenameColumnNodeFactory (line 11) | type RenameColumnNodeFactory = Readonly<{
  method is (line 21) | is(node): node is RenameColumnNode {
  method create (line 25) | create(column, newColumn) {

FILE: src/operation-node/rename-constraint-node.ts
  type RenameConstraintNode (line 5) | interface RenameConstraintNode extends OperationNode {
  type RenameConstraintNodeFactory (line 11) | type RenameConstraintNodeFactory = Readonly<{
  method is (line 21) | is(node): node is RenameConstraintNode {
  method create (line 25) | create(oldName, newName) {

FILE: src/operation-node/returning-node.ts
  type ReturningNode (line 5) | interface ReturningNode extends OperationNode {
  type ReturningNodeFactory (line 10) | type ReturningNodeFactory = Readonly<{
  method is (line 24) | is(node): node is ReturningNode {
  method create (line 28) | create(selections) {
  method cloneWithSelections (line 35) | cloneWithSelections(returning, selections) {

FILE: src/operation-node/schemable-identifier-node.ts
  type SchemableIdentifierNode (line 5) | interface SchemableIdentifierNode extends OperationNode {
  type SchemableIdentifierNodeFactory (line 11) | type SchemableIdentifierNodeFactory = Readonly<{
  method is (line 25) | is(node): node is SchemableIdentifierNode {
  method create (line 29) | create(identifier) {
  method createWithSchema (line 36) | createWithSchema(schema, identifier) {

FILE: src/operation-node/select-all-node.ts
  type SelectAllNode (line 4) | interface SelectAllNode extends OperationNode {
  type SelectAllNodeFactory (line 8) | type SelectAllNodeFactory = Readonly<{
  method is (line 18) | is(node): node is SelectAllNode {
  method create (line 22) | create() {

FILE: src/operation-node/select-modifier-node.ts
  type SelectModifier (line 4) | type SelectModifier =
  type SelectModifierNode (line 13) | interface SelectModifierNode extends OperationNode {
  type SelectModifierNodeFactory (line 20) | type SelectModifierNodeFactory = Readonly<{
  method is (line 34) | is(node): node is SelectModifierNode {
  method create (line 38) | create(modifier, of?) {
  method createWithExpression (line 46) | createWithExpression(modifier) {

FILE: src/operation-node/select-query-node.ts
  type SelectQueryNode (line 22) | interface SelectQueryNode extends OperationNode {
  type SelectQueryNodeFactory (line 43) | type SelectQueryNodeFactory = Readonly<{
  method is (line 102) | is(node): node is SelectQueryNode {
  method create (line 106) | create(withNode?) {
  method createFrom (line 113) | createFrom(fromItems, withNode?) {
  method cloneWithSelections (line 121) | cloneWithSelections(select, selections) {
  method cloneWithDistinctOn (line 130) | cloneWithDistinctOn(select, expressions) {
  method cloneWithFrontModifier (line 139) | cloneWithFrontModifier(select, modifier) {
  method cloneWithGroupByItems (line 155) | cloneWithGroupByItems(selectNode, items) {
  method cloneWithLimit (line 164) | cloneWithLimit(selectNode, limit) {
  method cloneWithOffset (line 171) | cloneWithOffset(selectNode, offset) {
  method cloneWithFetch (line 178) | cloneWithFetch(selectNode, fetch) {
  method cloneWithHaving (line 185) | cloneWithHaving(selectNode, operation) {
  method cloneWithSetOperations (line 194) | cloneWithSetOperations(selectNode, setOperations) {
  method cloneWithoutSelections (line 203) | cloneWithoutSelections(select) {
  method cloneWithoutLimit (line 210) | cloneWithoutLimit(select) {
  method cloneWithoutOffset (line 217) | cloneWithoutOffset(select) {
  method cloneWithoutGroupBy (line 230) | cloneWithoutGroupBy(select) {

FILE: src/operation-node/selection-node.ts
  type SelectionNodeChild (line 9) | type SelectionNodeChild =
  type SelectionNode (line 14) | interface SelectionNode extends OperationNode {
  type SelectionNodeFactory (line 19) | type SelectionNodeFactory = Readonly<{
  method is (line 31) | is(node): node is SelectionNode {
  method create (line 35) | create(selection) {
  method createSelectAll (line 42) | createSelectAll() {
  method createSelectAllFromTable (line 49) | createSelectAllFromTable(table) {

FILE: src/operation-node/set-operation-node.ts
  type SetOperator (line 4) | type SetOperator = 'union' | 'intersect' | 'except'
  type SetOperationNode (line 6) | interface SetOperationNode extends OperationNode {
  type SetOperationNodeFactory (line 13) | type SetOperationNodeFactory = Readonly<{
  method is (line 27) | is(node): node is SetOperationNode {
  method create (line 31) | create(operator, expression, all) {

FILE: src/operation-node/simple-reference-expression-node.ts
  type SimpleReferenceExpressionNode (line 4) | type SimpleReferenceExpressionNode = ColumnNode | ReferenceNode

FILE: src/operation-node/table-node.ts
  type TableNode (line 5) | interface TableNode extends OperationNode {
  type TableNodeFactory (line 10) | type TableNodeFactory = Readonly<{
  method is (line 20) | is(node): node is TableNode {
  method create (line 24) | create(table) {
  method createWithSchema (line 31) | createWithSchema(schema, table) {

FILE: src/operation-node/top-node.ts
  type TopModifier (line 4) | type TopModifier = 'percent' | 'with ties' | 'percent with ties'
  type TopNode (line 6) | interface TopNode extends OperationNode {
  type TopNodeFactory (line 12) | type TopNodeFactory = Readonly<{
  method is (line 24) | is(node): node is TopNode {
  method create (line 28) | create(expression, modifiers?) {

FILE: src/operation-node/tuple-node.ts
  type TupleNode (line 4) | interface TupleNode extends OperationNode {
  type TupleNodeFactory (line 9) | type TupleNodeFactory = Readonly<{
  method is (line 18) | is(node): node is TupleNode {
  method create (line 22) | create(values) {

FILE: src/operation-node/unary-operation-node.ts
  type UnaryOperationNode (line 4) | interface UnaryOperationNode extends OperationNode {
  type UnaryOperationNodeFactory (line 10) | type UnaryOperationNodeFactory = Readonly<{
  method is (line 23) | is(node): node is UnaryOperationNode {
  method create (line 27) | create(operator, operand) {

FILE: src/operation-node/unique-constraint-node.ts
  type UniqueConstraintNode (line 6) | interface UniqueConstraintNode extends OperationNode {
  type UniqueConstraintNodeProps (line 15) | type UniqueConstraintNodeProps = Omit<
  type UniqueConstraintNodeFactory (line 20) | type UniqueConstraintNodeFactory = Readonly<{
  method is (line 38) | is(node): node is UniqueConstraintNode {
  method create (line 42) | create(columns, constraintName?, nullsNotDistinct?) {
  method cloneWith (line 53) | cloneWith(node, props) {

FILE: src/operation-node/update-query-node.ts
  type UpdateQueryNode (line 16) | interface UpdateQueryNode extends OperationNode {
  type UpdateQueryNodeFactory (line 33) | type UpdateQueryNodeFactory = Readonly<{
  method is (line 59) | is(node): node is UpdateQueryNode {
  method create (line 63) | create(tables, withNode?) {
  method createWithoutTable (line 73) | createWithoutTable() {
  method cloneWithFromItems (line 79) | cloneWithFromItems(updateQuery, fromItems) {
  method cloneWithUpdates (line 88) | cloneWithUpdates(updateQuery, updates) {
  method cloneWithLimit (line 97) | cloneWithLimit(updateQuery, limit) {

FILE: src/operation-node/using-node.ts
  type UsingNode (line 4) | interface UsingNode extends OperationNode {
  type UsingNodeFactory (line 9) | type UsingNodeFactory = Readonly<{
  method is (line 22) | is(node): node is UsingNode {
  method create (line 26) | create(tables) {
  method cloneWithTables (line 33) | cloneWithTables(using, tables) {

FILE: src/operation-node/value-list-node.ts
  type ValueListNode (line 4) | interface ValueListNode extends OperationNode {
  type ValueListNodeFactory (line 9) | type ValueListNodeFactory = Readonly<{
  method is (line 19) | is(node): node is ValueListNode {
  method create (line 23) | create(values) {

FILE: src/operation-node/value-node.ts
  type ValueNode (line 4) | interface ValueNode extends OperationNode {
  type ValueNodeFactory (line 10) | type ValueNodeFactory = Readonly<{
  method is (line 20) | is(node): node is ValueNode {
  method create (line 24) | create(value) {
  method createImmediate (line 31) | createImmediate(value) {

FILE: src/operation-node/values-node.ts
  type ValuesItemNode (line 6) | type ValuesItemNode = ValueListNode | PrimitiveValueListNode
  type ValuesNode (line 8) | interface ValuesNode extends OperationNode {
  type ValuesNodeFactory (line 13) | type ValuesNodeFactory = Readonly<{
  method is (line 22) | is(node): node is ValuesNode {
  method create (line 26) | create(values) {

FILE: src/operation-node/when-node.ts
  type WhenNode (line 4) | interface WhenNode extends OperationNode {
  type WhenNodeFactory (line 10) | type WhenNodeFactory = Readonly<{
  method is (line 20) | is(node): node is WhenNode {
  method create (line 24) | create(condition) {
  method cloneWithResult (line 31) | cloneWithResult(whenNode, result) {

FILE: src/operation-node/where-node.ts
  type WhereNode (line 6) | interface WhereNode extends OperationNode {
  type WhereNodeFactory (line 11) | type WhereNodeFactory = Readonly<{
  method is (line 25) | is(node): node is WhereNode {
  method create (line 29) | create(filter) {
  method cloneWithOperation (line 36) | cloneWithOperation(whereNode, operator, operation) {

FILE: src/operation-node/with-node.ts
  type WithNodeParams (line 5) | type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>
  type WithNode (line 7) | interface WithNode extends OperationNode {
  type WithNodeFactory (line 13) | type WithNodeFactory = Readonly<{
  method is (line 29) | is(node): node is WithNode {
  method create (line 33) | create(expression, params?) {
  method cloneWithExpression (line 41) | cloneWithExpression(withNode, expression) {

FILE: src/parser/binary-operation-parser.ts
  type OperandValueExpression (line 42) | type OperandValueExpression<
  type OperandValueExpressionOrList (line 48) | type OperandValueExpressionOrList<
  type OperatorExpression (line 58) | type OperatorExpression = Operator | Expression<unknown>
  type BinaryOperatorExpression (line 59) | type BinaryOperatorExpression = BinaryOperator | Expression<unknown>
  type ComparisonOperatorExpression (line 61) | type ComparisonOperatorExpression =
  type FilterObject (line 65) | type FilterObject<DB, TB extends keyof DB> = {
  function parseValueBinaryOperationOrExpression (line 73) | function parseValueBinaryOperationOrExpression(
  function parseValueBinaryOperation (line 85) | function parseValueBinaryOperation(
  function parseReferentialBinaryOperation (line 105) | function parseReferentialBinaryOperation(
  function parseFilterObject (line 117) | function parseFilterObject(
  function parseFilterList (line 131) | function parseFilterList(
  function isIsOperator (line 159) | function isIsOperator(
  function needsIsOperator (line 165) | function needsIsOperator(value: unknown): value is null | boolean {
  function parseOperator (line 169) | function parseOperator(operator: OperatorExpression): OperationNode {
  function toOperationNode (line 181) | function toOperationNode(

FILE: src/parser/coalesce-parser.ts
  type ExtractTypeFromCoalesce1 (line 3) | type ExtractTypeFromCoalesce1<
  type ExtractTypeFromCoalesce2 (line 9) | type ExtractTypeFromCoalesce2<
  type ExtractTypeFromCoalesceValues2 (line 19) | type ExtractTypeFromCoalesceValues2<V1, V2> = null extends V1
  type ExtractTypeFromCoalesce3 (line 25) | type ExtractTypeFromCoalesce3<
  type ExtractTypeFromCoalesceValues3 (line 37) | type ExtractTypeFromCoalesceValues3<V1, V2, V3> = null extends V1
  type ExtractTypeFromCoalesce4 (line 45) | type ExtractTypeFromCoalesce4<
  type ExtractTypeFromCoalesceValues4 (line 59) | type ExtractTypeFromCoalesceValues4<V1, V2, V3, V4> = null extends V1
  type ExtractTypeFromCoalesce5 (line 69) | type ExtractTypeFromCoalesce5<
  type ExtractTypeFromCoalesceValues5 (line 85) | type ExtractTypeFromCoalesceValues5<V1, V2, V3, V4, V5> = null extends V1
  type NotNull (line 97) | type NotNull<T> = Exclude<T, null>

FILE: src/parser/collate-parser.ts
  type Collation (line 1) | type Collation =

FILE: src/parser/data-type-parser.ts
  type DataTypeExpression (line 10) | type DataTypeExpression = ColumnDataType | Expression<any>
  function parseDataTypeExpression (line 12) | function parseDataTypeExpression(

FILE: src/parser/default-value-parser.ts
  type DefaultValueExpression (line 6) | type DefaultValueExpression = unknown | Expression<unknown>
  function parseDefaultValueExpression (line 8) | function parseDefaultValueExpression(

FILE: src/parser/delete-from-parser.ts
  type DeleteFrom (line 11) | type DeleteFrom<DB, TE extends TableExpressionOrList<DB, never>> = [

FILE: src/parser/expression-parser.ts
  type OperandExpression (line 22) | type OperandExpression<V> =
  type ExpressionOrFactory (line 29) | type ExpressionOrFactory<DB, TB extends keyof DB, V> =
  type AliasedExpressionOrFactory (line 33) | type AliasedExpressionOrFactory<DB, TB extends keyof DB> =
  type ExpressionFactory (line 37) | type ExpressionFactory<DB, TB extends keyof DB, V> = (
  type OperandExpressionFactory (line 41) | type OperandExpressionFactory<DB, TB extends keyof DB, V> = (
  type AliasedExpressionFactory (line 45) | type AliasedExpressionFactory<DB, TB extends keyof DB> = (
  function parseExpression (line 49) | function parseExpression(
  function parseAliasedExpression (line 61) | function parseAliasedExpression(
  function isExpressionOrFactory (line 73) | function isExpressionOrFactory(

FILE: src/parser/fetch-parser.ts
  function parseFetch (line 4) | function parseFetch(
  function isFetchModifier (line 19) | function isFetchModifier(value: any): value is FetchModifier {

FILE: src/parser/group-by-parser.ts
  type GroupByExpression (line 12) | type GroupByExpression<DB, TB extends keyof DB, O> =
  type GroupByArg (line 16) | type GroupByArg<DB, TB extends keyof DB, O> =
  function parseGroupBy (line 23) | function parseGroupBy(

FILE: src/parser/identifier-parser.ts
  function parseSchemableIdentifier (line 3) | function parseSchemableIdentifier(id: string): SchemableIdentifierNode {
  function trim (line 19) | function trim(str: string): string {

FILE: src/parser/insert-values-parser.ts
  type InsertObject (line 24) | type InsertObject<DB, TB extends keyof DB> = {
  type InsertObjectOrList (line 36) | type InsertObjectOrList<DB, TB extends keyof DB> =
  type InsertObjectOrListFactory (line 40) | type InsertObjectOrListFactory<
  type InsertExpression (line 46) | type InsertExpression<
  function parseInsertExpression (line 52) | function parseInsertExpression(
  function parseInsertColumnsAndValues (line 63) | function parseInsertColumnsAndValues(
  function parseColumnNamesAndIndexes (line 74) | function parseColumnNamesAndIndexes(
  function parseRowValues (line 92) | function parseRowValues(

FILE: src/parser/join-parser.ts
  type JoinReferenceExpression (line 17) | type JoinReferenceExpression<
  type JoinCallbackExpression (line 25) | type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (
  type AnyJoinColumn (line 29) | type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<
  type AnyJoinColumnWithTable (line 34) | type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWith...
  function parseJoin (line 39) | function parseJoin(joinType: JoinType, args: any[]): JoinNode {
  function parseCallbackJoin (line 51) | function parseCallbackJoin(
  function parseSingleOnJoin (line 59) | function parseSingleOnJoin(
  function parseOnlessJoin (line 72) | function parseOnlessJoin(

FILE: src/parser/merge-into-parser.ts
  type MergeInto (line 6) | type MergeInto<DB, TE extends SimpleTableReference<DB>> = [TE] extends [

FILE: src/parser/merge-parser.ts
  function parseMergeWhen (line 17) | function parseMergeWhen(
  function parseMergeThen (line 43) | function parseMergeThen(

FILE: src/parser/on-commit-action-parse.ts
  function parseOnCommitAction (line 6) | function parseOnCommitAction(action: OnCommitAction): OnCommitAction {

FILE: src/parser/on-modify-action-parser.ts
  function parseOnModifyForeignAction (line 6) | function parseOnModifyForeignAction(

FILE: src/parser/order-by-parser.ts
  type OrderByExpression (line 22) | type OrderByExpression<DB, TB extends keyof DB, O> =
  type OrderByModifiers (line 28) | type OrderByModifiers =
  type OrderByDirection (line 32) | type OrderByDirection = 'asc' | 'desc'
  function isOrderByDirection (line 34) | function isOrderByDirection(thing: unknown): thing is OrderByDirection {
  type OrderByModifiersCallbackExpression (line 38) | type OrderByModifiersCallbackExpression = (
  type DirectedOrderByStringReference (line 46) | type DirectedOrderByStringReference<DB, TB extends keyof DB, O> = `${
  type OrderByDirectionExpression (line 54) | type OrderByDirectionExpression = OrderByDirection | Expression<any>
  type UndirectedOrderByExpression (line 60) | type UndirectedOrderByExpression<DB, TB extends keyof DB, O> =
  function parseOrderBy (line 64) | function parseOrderBy(args: any[]): OrderByItemNode[] {
  function parseOrderByItem (line 88) | function parseOrderByItem(
  function parseOrderByExpression (line 105) | function parseOrderByExpression(
  function parseOrderByWithModifiers (line 129) | function parseOrderByWithModifiers(

FILE: src/parser/parse-utils.ts
  function createSelectQueryBuilder (line 19) | function createSelectQueryBuilder(): SelectQueryBuilder<any, any, any> {
  function createQueryCreator (line 27) | function createQueryCreator(): QueryCreator<any> {
  function createJoinBuilder (line 33) | function createJoinBuilder(
  function createOverBuilder (line 42) | function createOverBuilder(): OverBuilder<any, any> {

FILE: src/parser/partition-by-parser.ts
  type PartitionByExpression (line 9) | type PartitionByExpression<DB, TB extends keyof DB> =
  type PartitionByExpressionOrList (line 13) | type PartitionByExpressionOrList<DB, TB extends keyof DB> =
  function parsePartitionBy (line 17) | function parsePartitionBy(

FILE: src/parser/reference-parser.ts
  type StringReference (line 37) | type StringReference<DB, TB extends keyof DB> =
  type SimpleReferenceExpression (line 41) | type SimpleReferenceExpression<DB, TB extends keyof DB> =
  type ReferenceExpression (line 45) | type ReferenceExpression<DB, TB extends keyof DB> =
  type ReferenceExpressionOrList (line 49) | type ReferenceExpressionOrList<DB, TB extends keyof DB> =
  type ExtractTypeFromReferenceExpression (line 53) | type ExtractTypeFromReferenceExpression<
  type ExtractRawTypeFromReferenceExpression (line 60) | type ExtractRawTypeFromReferenceExpression<
  type ExtractTypeFromStringReference (line 77) | type ExtractTypeFromStringReference<
  type OrderedColumnName (line 98) | type OrderedColumnName<C extends string> =
  type ExtractColumnNameFromOrderedColumnName (line 105) | type ExtractColumnNameFromOrderedColumnName<C extends string> =
  function parseSimpleReferenceExpression (line 112) | function parseSimpleReferenceExpression(
  function parseReferenceExpressionOrList (line 122) | function parseReferenceExpressionOrList(
  function parseReferenceExpression (line 132) | function parseReferenceExpression(
  function parseJSONReference (line 142) | function parseJSONReference(
  function parseStringReference (line 167) | function parseStringReference(ref: string): ReferenceNode {
  function parseAliasedStringReference (line 187) | function parseAliasedStringReference(
  function parseColumnName (line 204) | function parseColumnName(column: AnyColumn<any, any>): ColumnNode {
  function parseOrderedColumnName (line 208) | function parseOrderedColumnName(column: string): OperationNode {
  function parseStringReferenceWithTableAndSchema (line 226) | function parseStringReferenceWithTableAndSchema(
  function parseStringReferenceWithTable (line 237) | function parseStringReferenceWithTable(parts: string[]): ReferenceNode {
  function trim (line 246) | function trim(str: string): string {

FILE: src/parser/returning-parser.ts
  type ReturningRow (line 11) | type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends
  type ReturningCallbackRow (line 19) | type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends
  type ReturningAllRow (line 27) | type ReturningAllRow<DB, TB extends keyof DB, O> = O extends

FILE: src/parser/savepoint-parser.ts
  type RollbackToSavepoint (line 4) | type RollbackToSavepoint<
  type ReleaseSavepoint (line 13) | type ReleaseSavepoint<
  function parseSavepointCommand (line 22) | function parseSavepointCommand(

FILE: src/parser/select-from-parser.ts
  type SelectFrom (line 10) | type SelectFrom<

FILE: src/parser/select-parser.ts
  type SelectExpression (line 29) | type SelectExpression<DB, TB extends keyof DB> =
  type SelectCallback (line 37) | type SelectCallback<DB, TB extends keyof DB> = (
  type Selection (line 44) | type Selection<
  type CallbackSelection (line 61) | type CallbackSelection<DB, TB extends keyof DB, CB> = CB extends (
  type SelectArg (line 67) | type SelectArg<
  type FlattenSelectExpression (line 76) | type FlattenSelectExpression<SE> =
  type ExtractAliasFromSelectExpression (line 81) | type ExtractAliasFromSelectExpression<SE> = SE extends string
  type ExtractAliasFromStringSelectExpression (line 91) | type ExtractAliasFromStringSelectExpression<SE extends string> =
  type ExtractTypeFromSelectExpression (line 104) | type ExtractTypeFromSelectExpression<
  type ExtractTypeFromStringSelectExpression (line 122) | type ExtractTypeFromStringSelectExpression<
  type AllSelection (line 158) | type AllSelection<DB, TB extends keyof DB> = DrainOuterGeneric<{
  function parseSelectArg (line 164) | function parseSelectArg(
  function parseSelectExpression (line 176) | function parseSelectExpression(
  function parseSelectAll (line 188) | function parseSelectAll(table?: string | string[]): SelectionNode[] {
  function parseSelectAllArg (line 198) | function parseSelectAllArg(table: string): SelectionNode {

FILE: src/parser/set-operation-parser.ts
  type SetOperandExpression (line 13) | type SetOperandExpression<DB, O> =
  function parseSetOperations (line 20) | function parseSetOperations(

FILE: src/parser/table-parser.ts
  type TableExpression (line 17) | type TableExpression<DB, TB extends keyof DB> =
  type TableExpressionOrList (line 23) | type TableExpressionOrList<DB, TB extends keyof DB> =
  type SimpleTableReference (line 27) | type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>
  type AnyAliasedTable (line 28) | type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`
  type AnyTable (line 29) | type AnyTable<DB> = keyof DB & string
  type From (line 31) | type From<DB, TE> = DrainOuterGeneric<{
  type FromTables (line 44) | type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<
  type ExtractTableAlias (line 48) | type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}`
  type ExtractAliasFromTableExpression (line 56) | type ExtractAliasFromTableExpression<DB, TE> = TE extends string
  type ExtractRowTypeFromTableExpression (line 70) | type ExtractRowTypeFromTableExpression<
  function parseTableExpressionOrList (line 100) | function parseTableExpressionOrList(
  function parseTableExpression (line 110) | function parseTableExpression(
  function parseAliasedTable (line 122) | function parseAliasedTable(from: string): TableNode | AliasNode {
  function parseTable (line 134) | function parseTable(from: string): TableNode {
  function trim (line 146) | function trim(str: string): string {

FILE: src/parser/top-parser.ts
  function parseTop (line 4) | function parseTop(
  function isTopModifiers (line 19) | function isTopModifiers(modifiers: string): modifiers is TopModifier {

FILE: src/parser/tuple-parser.ts
  type RefTuple2 (line 5) | type RefTuple2<DB, TB extends keyof DB, R1, R2> = DrainOuterGeneric<
  type RefTuple3 (line 12) | type RefTuple3<DB, TB extends keyof DB, R1, R2, R3> = DrainOuterGeneric<
  type RefTuple4 (line 20) | type RefTuple4<
  type RefTuple5 (line 36) | type RefTuple5<
  type ValTuple2 (line 54) | type ValTuple2<V1, V2> = DrainOuterGeneric<
  type ValTuple3 (line 58) | type ValTuple3<V1, V2, V3> = DrainOuterGeneric<
  type ValTuple4 (line 66) | type ValTuple4<V1, V2, V3, V4> = DrainOuterGeneric<
  type ValTuple5 (line 75) | type ValTuple5<V1, V2, V3, V4, V5> = DrainOuterGeneric<

FILE: src/parser/unary-operation-parser.ts
  type ExistsExpression (line 12) | type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<
  function parseExists (line 18) | function parseExists(
  function parseNotExists (line 24) | function parseNotExists(
  function parseUnaryOperation (line 30) | function parseUnaryOperation(

FILE: src/parser/update-parser.ts
  type UpdateTable (line 11) | type UpdateTable<DB, TE extends TableExpressionOrList<DB, never>> = [

FILE: src/parser/update-set-parser.ts
  type UpdateObject (line 17) | type UpdateObject<
  type UpdateObjectFactory (line 29) | type UpdateObjectFactory<
  type UpdateObjectExpression (line 35) | type UpdateObjectExpression<
  type ExtractUpdateTypeFromReferenceExpression (line 41) | type ExtractUpdateTypeFromReferenceExpression<
  function parseUpdate (line 48) | function parseUpdate(
  function parseUpdateObjectExpression (line 65) | function parseUpdateObjectExpression(

FILE: src/parser/value-parser.ts
  type ValueExpression (line 19) | type ValueExpression<DB, TB extends keyof DB, V> =
  type ValueExpressionOrList (line 23) | type ValueExpressionOrList<DB, TB extends keyof DB, V> =
  type ExtractTypeFromValueExpressionOrList (line 27) | type ExtractTypeFromValueExpressionOrList<VE> =
  type ExtractTypeFromValueExpression (line 32) | type ExtractTypeFromValueExpression<VE> =
  function parseValueExpressionOrList (line 39) | function parseValueExpressionOrList(
  function parseValueExpression (line 49) | function parseValueExpression(
  function isSafeImmediateValue (line 59) | function isSafeImmediateValue(
  function parseSafeImmediateValue (line 65) | function parseSafeImmediateValue(
  function parseValueExpressionList (line 75) | function parseValueExpressionList(

FILE: src/parser/with-parser.ts
  type CommonTableExpression (line 17) | type CommonTableExpression<DB, CN extends string> = (
  type RecursiveCommonTableExpression (line 21) | type RecursiveCommonTableExpression<DB, CN extends string> = (
  type QueryCreatorWithCommonTableExpression (line 30) | type QueryCreatorWithCommonTableExpression<
  type CommonTableExpressionOutput (line 40) | type CommonTableExpressionOutput<DB, CN extends string> =
  type ExtractRowFromCommonTableExpression (line 57) | type ExtractRowFromCommonTableExpression<CTE> = CTE extends (
  type ExtractTableFromCommonTableExpressionName (line 74) | type ExtractTableFromCommonTableExpressionName<CN extends string> =
  type ExtractRowFromCommonTableExpressionName (line 86) | type ExtractRowFromCommonTableExpressionName<CN extends string> =
  type ExtractColumnNamesFromColumnList (line 94) | type ExtractColumnNamesFromColumnList<R extends string> =
  function parseCommonTableExpression (line 99) | function parseCommonTableExpression(
  function cteBuilderFactory (line 117) | function cteBuilderFactory(expressionNode: OperationNode) {
  function parseCommonTableExpressionName (line 128) | function parseCommonTableExpressionName(

FILE: src/plugin/camel-case/camel-case-plugin.ts
  type CamelCasePluginOptions (line 17) | interface CamelCasePluginOptions {
  class CamelCasePlugin (line 121) | class CamelCasePlugin implements KyselyPlugin {
    method constructor (line 126) | constructor(readonly opt: CamelCasePluginOptions = {}) {
    method transformQuery (line 135) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 139) | async transformResult(
    method mapRow (line 152) | protected mapRow(row: UnknownRow): UnknownRow {
    method snakeCase (line 167) | protected snakeCase(str: string): string {
    method camelCase (line 171) | protected camelCase(str: string): string {
  function canMap (line 176) | function canMap(

FILE: src/plugin/camel-case/camel-case-transformer.ts
  class SnakeCaseTransformer (line 6) | class SnakeCaseTransformer extends OperationNodeTransformer {
    method constructor (line 9) | constructor(snakeCase: StringMapper) {
    method transformIdentifier (line 14) | protected override transformIdentifier(

FILE: src/plugin/camel-case/camel-case.ts
  type StringMapper (line 1) | type StringMapper = (str: string) => string
  function createSnakeCaseMapper (line 6) | function createSnakeCaseMapper({
  function createCamelCaseMapper (line 74) | function createCamelCaseMapper({
  function isAllUpperCaseSnakeCase (line 108) | function isAllUpperCaseSnakeCase(str: string): boolean {
  function isDigit (line 120) | function isDigit(char: string): boolean {
  function memoize (line 124) | function memoize(func: StringMapper): StringMapper {

FILE: src/plugin/deduplicate-joins/deduplicate-joins-plugin.ts
  class DeduplicateJoinsPlugin (line 16) | class DeduplicateJoinsPlugin implements KyselyPlugin {
    method transformQuery (line 19) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 23) | transformResult(

FILE: src/plugin/deduplicate-joins/deduplicate-joins-transformer.ts
  class DeduplicateJoinsTransformer (line 9) | class DeduplicateJoinsTransformer extends OperationNodeTransformer {
    method transformSelectQuery (line 10) | protected transformSelectQuery(
    method transformUpdateQuery (line 17) | protected transformUpdateQuery(
    method transformDeleteQuery (line 24) | protected transformDeleteQuery(
    method #transformQuery (line 31) | #transformQuery<
    method #deduplicateJoins (line 44) | #deduplicateJoins(joins: ReadonlyArray<JoinNode>): ReadonlyArray<JoinN...

FILE: src/plugin/handle-empty-in-lists/handle-empty-in-lists-plugin.ts
  class HandleEmptyInListsPlugin (line 155) | class HandleEmptyInListsPlugin implements KyselyPlugin {
    method constructor (line 158) | constructor(readonly opt: HandleEmptyInListsOptions) {
    method transformQuery (line 162) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 166) | async transformResult(

FILE: src/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.ts
  class HandleEmptyInListsTransformer (line 11) | class HandleEmptyInListsTransformer extends OperationNodeTransformer {
    method constructor (line 14) | constructor(strategy: EmptyInListsStrategy) {
    method transformBinaryOperation (line 19) | protected transformBinaryOperation(
    method #isEmptyInListNode (line 29) | #isEmptyInListNode(node: BinaryOperationNode): node is EmptyInListNode {

FILE: src/plugin/handle-empty-in-lists/handle-empty-in-lists.ts
  type HandleEmptyInListsOptions (line 11) | interface HandleEmptyInListsOptions {
  type EmptyInListNode (line 20) | type EmptyInListNode = BinaryOperationNode & {
  type EmptyInListsStrategy (line 29) | type EmptyInListsStrategy = (
  function replaceWithNoncontingentExpression (line 45) | function replaceWithNoncontingentExpression(
  function pushValueIntoList (line 78) | function pushValueIntoList(

FILE: src/plugin/immediate-value/immediate-value-plugin.ts
  class ImmediateValuePlugin (line 19) | class ImmediateValuePlugin implements KyselyPlugin {
    method transformQuery (line 22) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 26) | transformResult(

FILE: src/plugin/immediate-value/immediate-value-transformer.ts
  class ImmediateValueTransformer (line 14) | class ImmediateValueTransformer extends OperationNodeTransformer {
    method transformPrimitiveValueList (line 15) | override transformPrimitiveValueList(
    method transformValue (line 23) | override transformValue(node: ValueNode): ValueNode {

FILE: src/plugin/kysely-plugin.ts
  type KyselyPlugin (line 6) | interface KyselyPlugin {
  type PluginTransformQueryArgs (line 70) | interface PluginTransformQueryArgs {
  type PluginTransformResultArgs (line 75) | interface PluginTransformResultArgs {

FILE: src/plugin/noop-plugin.ts
  class NoopPlugin (line 10) | class NoopPlugin implements KyselyPlugin {
    method transformQuery (line 11) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 15) | async transformResult(

FILE: src/plugin/parse-json-results/parse-json-results-plugin.ts
  type ParseJSONResultsPluginOptions (line 11) | interface ParseJSONResultsPluginOptions {
  type ObjectStrategy (line 25) | type ObjectStrategy = 'in-place' | 'create'
  class ParseJSONResultsPlugin (line 71) | class ParseJSONResultsPlugin implements KyselyPlugin {
    method constructor (line 74) | constructor(readonly opt: ParseJSONResultsPluginOptions = {}) {
    method transformQuery (line 79) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 83) | async transformResult(
  function parseArray (line 93) | function parseArray<T>(arr: T[], objectStrategy: ObjectStrategy): T[] {
  function parse (line 103) | function parse(obj: unknown, objectStrategy: ObjectStrategy): unknown {
  function parseString (line 119) | function parseString(str: string): unknown {
  function maybeJson (line 131) | function maybeJson(value: string): boolean {
  function parseObject (line 135) | function parseObject(

FILE: src/plugin/with-schema/with-schema-plugin.ts
  class WithSchemaPlugin (line 11) | class WithSchemaPlugin implements KyselyPlugin {
    method constructor (line 14) | constructor(schema: string) {
    method transformQuery (line 18) | transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
    method transformResult (line 22) | async transformResult(

FILE: src/plugin/with-schema/with-schema-transformer.ts
  constant ROOT_OPERATION_NODES (line 24) | const ROOT_OPERATION_NODES: Record<RootOperationNode['kind'], true> = fr...
  constant SCHEMALESS_FUNCTIONS (line 45) | const SCHEMALESS_FUNCTIONS: Record<string, true> = {
  class WithSchemaTransformer (line 50) | class WithSchemaTransformer extends OperationNodeTransformer {
    method constructor (line 55) | constructor(schema: string) {
    method transformNodeImpl (line 60) | protected override transformNodeImpl<T extends OperationNode>(
    method transformSchemableIdentifier (line 93) | protected override transformSchemableIdentifier(
    method transformReferences (line 109) | protected override transformReferences(
    method transformAggregateFunction (line 128) | protected override transformAggregateFunction(
    method transformFunction (line 142) | protected override transformFunction(
    method transformSelectModifier (line 156) | protected override transformSelectModifier(
    method #transformTableArgsWithoutSchemas (line 173) | #transformTableArgsWithoutSchemas<
    method #isRootOperationNode (line 191) | #isRootOperationNode(node: OperationNode): node is RootOperationNode {
    method #collectSchemableIds (line 195) | #collectSchemableIds(node: RootOperationNode): Set<string> {
    method #collectCTEs (line 233) | #collectCTEs(node: RootOperationNode): Set<string> {
    method #collectSchemableIdsFromTableExpr (line 243) | #collectSchemableIdsFromTableExpr(
    method #collectSchemableId (line 270) | #collectSchemableId(
    method #collectCTEIds (line 281) | #collectCTEIds(node: WithNode, ctes: Set<string>): void {

FILE: src/query-builder/aggregate-function-builder.ts
  class AggregateFunctionBuilder (line 30) | class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown>
    method constructor (line 35) | constructor(props: AggregateFunctionBuilderProps) {
    method expressionType (line 40) | get expressionType(): O | undefined {
    method as (line 69) | as<A extends string>(
    method distinct (line 96) | distinct(): AggregateFunctionBuilder<DB, TB, O> {
    method orderBy (line 160) | orderBy(...args: any[]): any {
    method clearOrderBy (line 170) | clearOrderBy(): AggregateFunctionBuilder<DB, TB, O> {
    method withinGroupOrderBy (line 239) | withinGroupOrderBy(...args: any[]): any {
    method filterWhere (line 304) | filterWhere(...args: any[]): any {
    method filterWhereRef (line 346) | filterWhereRef<
    method over (line 405) | over(
    method $call (line 423) | $call<T>(func: (qb: this) => T): T {
    method $castTo (line 433) | $castTo<C>(): AggregateFunctionBuilder<DB, TB, C> {
    method $notNull (line 446) | $notNull(): AggregateFunctionBuilder<DB, TB, Exclude<O, null>> {
    method toOperationNode (line 450) | toOperationNode(): AggregateFunctionNode {
  class AliasedAggregateFunctionBuilder (line 458) | class AliasedAggregateFunctionBuilder<
    method constructor (line 467) | constructor(
    method expression (line 476) | get expression(): Expression<O> {
    method alias (line 481) | get alias(): A {
    method toOperationNode (line 485) | toOperationNode(): AliasNode {
  type AggregateFunctionBuilderProps (line 493) | interface AggregateFunctionBuilderProps {
  type OverBuilderCallback (line 497) | type OverBuilderCallback<DB, TB extends keyof DB> = (

FILE: src/query-builder/case-builder.ts
  class CaseBuilder (line 20) | class CaseBuilder<
    method constructor (line 28) | constructor(props: CaseBuilderProps) {
    method when (line 51) | when(...args: any[]): any {
  type CaseBuilderProps (line 62) | interface CaseBuilderProps {
  class CaseThenBuilder (line 66) | class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
    method constructor (line 69) | constructor(props: CaseBuilderProps) {
    method then (line 93) | then(valueExpression: any): any {
  class CaseWhenBuilder (line 106) | class CaseWhenBuilder<DB, TB extends keyof DB, W, O>
    method constructor (line 111) | constructor(props: CaseBuilderProps) {
    method when (line 134) | when(...args: any[]): any {
    method else (line 163) | else(valueExpression: any): any {
    method end (line 174) | end(): ExpressionWrapper<DB, TB, O | null> {
    method endCase (line 180) | endCase(): ExpressionWrapper<DB, TB, O | null> {
  class CaseEndBuilder (line 187) | class CaseEndBuilder<DB, TB extends keyof DB, O> implements Endable<
    method constructor (line 194) | constructor(props: CaseBuilderProps) {
    method end (line 198) | end(): ExpressionWrapper<DB, TB, O> {
    method endCase (line 204) | endCase(): ExpressionWrapper<DB, TB, O> {
  type Whenable (line 211) | interface Whenable<DB, TB extends keyof DB, W, O> {
  type Endable (line 237) | interface Endable<DB, TB extends keyof DB, O> {

FILE: src/query-builder/cte-builder.ts
  class CTEBuilder (line 5) | class CTEBuilder<N extends string> implements OperationNodeSource {
    method constructor (line 8) | constructor(props: CTEBuilderProps) {
    method materialized (line 15) | materialized(): CTEBuilder<N> {
    method notMaterialized (line 27) | notMaterialized(): CTEBuilder<N> {
    method toOperationNode (line 36) | toOperationNode(): CommonTableExpressionNode {
  type CTEBuilderProps (line 41) | interface CTEBuilderProps {
  type CTEBuilderCallback (line 45) | type CTEBuilderCallback<N extends string> = (

FILE: src/query-builder/delete-query-builder.ts
  class DeleteQueryBuilder (line 85) | class DeleteQueryBuilder<DB, TB extends keyof DB, O>
    method constructor (line 98) | constructor(props: DeleteQueryBuilderProps) {
    method where (line 115) | where(...args: any[]): any {
    method whereRef (line 125) | whereRef<
    method clearWhere (line 142) | clearWhere(): DeleteQueryBuilder<DB, TB, O> {
    method top (line 188) | top(
    method using (line 283) | using(tables: TableExpressionOrList<any, any>): any {
    method innerJoin (line 413) | innerJoin(...args: any): any {
    method leftJoin (line 431) | leftJoin(...args: any): any {
    method rightJoin (line 449) | rightJoin(...args: any): any {
    method fullJoin (line 467) | fullJoin(...args: any): any {
    method #join (line 471) | #join(joinType: JoinType, args: any[]): any {
    method returning (line 493) | returning<SE extends SelectExpression<DB, TB>>(
    method returningAll (line 607) | returningAll(table?: any): any {
    method output (line 641) | output(args: any): any {
    method outputAll (line 651) | outputAll(
    method clearReturning (line 682) | clearReturning(): DeleteQueryBuilder<DB, TB, DeleteResult> {
    method clearLimit (line 709) | clearLimit(): DeleteQueryBuilder<DB, TB, O> {
    method orderBy (line 754) | orderBy(...args: any[]): any {
    method clearOrderBy (line 764) | clearOrderBy(): DeleteQueryBuilder<DB, TB, O> {
    method limit (line 795) | limit(limit: ValueExpression<DB, TB, number>): DeleteQueryBuilder<DB, ...
    method modifyEnd (line 826) | modifyEnd(modifier: Expression<any>): DeleteQueryBuilder<DB, TB, O> {
    method $call (line 860) | $call<T>(func: (qb: this) => T): T {
    method $if (line 899) | $if<O2>(
    method $castTo (line 922) | $castTo<C>(): DeleteQueryBuilder<DB, TB, C> {
    method $narrowType (line 975) | $narrowType<T>(): DeleteQueryBuilder<DB, TB, NarrowPartial<O, T>> {
    method $assertType (line 1024) | $assertType<T extends O>(): O extends T
    method withPlugin (line 1033) | withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O> {
    method toOperationNode (line 1040) | toOperationNode(): DeleteQueryNode {
    method compile (line 1047) | compile(): CompiledQuery<SimplifyResult<O>> {
    method execute (line 1059) | async execute(): Promise<SimplifyResult<O>[]> {
    method executeTakeFirst (line 1081) | async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
    method executeTakeFirstOrThrow (line 1094) | async executeTakeFirstOrThrow(
    method stream (line 1112) | async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {
    method explain (line 1122) | async explain<ER extends Record<string, any> = Record<string, any>>(
  type DeleteQueryBuilderProps (line 1139) | interface DeleteQueryBuilderProps {
  type DeleteQueryBuilderWithInnerJoin (line 1145) | type DeleteQueryBuilderWithInnerJoin<
  type InnerJoinedBuilder (line 1162) | type InnerJoinedBuilder<
  type InnerJoinedDB (line 1173) | type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
  type DeleteQueryBuilderWithLeftJoin (line 1177) | type DeleteQueryBuilderWithLeftJoin<
  type LeftJoinedBuilder (line 1194) | type LeftJoinedBuilder<
  type LeftJoinedDB (line 1205) | type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
  type DeleteQueryBuilderWithRightJoin (line 1213) | type DeleteQueryBuilderWithRightJoin<
  type RightJoinedBuilder (line 1230) | type RightJoinedBuilder<
  type RightJoinedDB (line 1238) | type RightJoinedDB<
  type DeleteQueryBuilderWithFullJoin (line 1253) | type DeleteQueryBuilderWithFullJoin<
  type OuterJoinedBuilder (line 1270) | type OuterJoinedBuilder<
  type OuterJoinedBuilderDB (line 1278) | type OuterJoinedBuilderDB<

FILE: src/query-builder/delete-result.ts
  class DeleteResult (line 1) | class DeleteResult {
    method constructor (line 4) | constructor(numDeletedRows: bigint) {

FILE: src/query-builder/function-module.ts
  type FunctionModule (line 105) | interface FunctionModule<DB, TB extends keyof DB> {
  function createFunctionModule (line 774) | function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<

FILE: src/query-builder/having-interface.ts
  type HavingInterface (line 9) | interface HavingInterface<DB, TB extends keyof DB> {

FILE: src/query-builder/insert-query-builder.ts
  class InsertQueryBuilder (line 71) | class InsertQueryBuilder<DB, TB extends keyof DB, O>
    method constructor (line 82) | constructor(props: InsertQueryBuilderProps) {
    method values (line 263) | values(insert: InsertExpression<DB, TB>): InsertQueryBuilder<DB, TB, O> {
    method columns (line 298) | columns(
    method expression (line 341) | expression(
    method defaultValues (line 369) | defaultValues(): InsertQueryBuilder<DB, TB, O> {
    method modifyEnd (line 403) | modifyEnd(modifier: Expression<any>): InsertQueryBuilder<DB, TB, O> {
    method ignore (line 453) | ignore(): InsertQueryBuilder<DB, TB, O> {
    method orIgnore (line 497) | orIgnore(): InsertQueryBuilder<DB, TB, O> {
    method orAbort (line 532) | orAbort(): InsertQueryBuilder<DB, TB, O> {
    method orFail (line 567) | orFail(): InsertQueryBuilder<DB, TB, O> {
    method orReplace (line 604) | orReplace(): InsertQueryBuilder<DB, TB, O> {
    method orRollback (line 639) | orRollback(): InsertQueryBuilder<DB, TB, O> {
    method top (line 695) | top(
    method onConflict (line 881) | onConflict(
    method onDuplicateKeyUpdate (line 935) | onDuplicateKeyUpdate(
    method returning (line 960) | returning<SE extends SelectExpression<DB, TB>>(
    method returningAll (line 972) | returningAll(): InsertQueryBuilder<DB, TB, Selectable<DB[TB]>> {
    method output (line 1006) | output(args: any): any {
    method outputAll (line 1016) | outputAll(
    method clearReturning (line 1047) | clearReturning(): InsertQueryBuilder<DB, TB, InsertResult> {
    method $call (line 1079) | $call<T>(func: (qb: this) => T): T {
    method $if (line 1120) | $if<O2>(
    method $castTo (line 1143) | $castTo<C>(): InsertQueryBuilder<DB, TB, C> {
    method $narrowType (line 1205) | $narrowType<T>(): InsertQueryBuilder<DB, TB, NarrowPartial<O, T>> {
    method $assertType (line 1257) | $assertType<T extends O>(): O extends T
    method withPlugin (line 1266) | withPlugin(plugin: KyselyPlugin): InsertQueryBuilder<DB, TB, O> {
    method toOperationNode (line 1273) | toOperationNode(): InsertQueryNode {
    method compile (line 1280) | compile(): CompiledQuery<O> {
    method execute (line 1292) | async execute(): Promise<SimplifyResult<O>[]> {
    method executeTakeFirst (line 1319) | async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
    method executeTakeFirstOrThrow (line 1332) | async executeTakeFirstOrThrow(
    method stream (line 1350) | async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {
    method explain (line 1360) | async explain<ER extends Record<string, any> = Record<string, any>>(
  type InsertQueryBuilderProps (line 1377) | interface InsertQueryBuilderProps {

FILE: src/query-builder/insert-result.ts
  class InsertResult (line 29) | class InsertResult {
    method constructor (line 47) | constructor(

FILE: src/query-builder/join-builder.ts
  class JoinBuilder (line 15) | class JoinBuilder<
    method constructor (line 21) | constructor(props: JoinBuilderProps) {
    method on (line 39) | on(...args: any[]): JoinBuilder<DB, TB> {
    method onRef (line 55) | onRef(
    method onTrue (line 72) | onTrue(): JoinBuilder<DB, TB> {
    method $call (line 86) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 90) | toOperationNode(): JoinNode {
  type JoinBuilderProps (line 95) | interface JoinBuilderProps {

FILE: src/query-builder/json-path-builder.ts
  class JSONPathBuilder (line 19) | class JSONPathBuilder<S, O = S> {
    method constructor (line 22) | constructor(node: JSONReferenceNode | JSONPathNode) {
    method at (line 93) | at<
    method key (line 151) | key<
    method #createBuilderWithPathLeg (line 169) | #createBuilderWithPathLeg(
  class TraversedJSONPathBuilder (line 199) | class TraversedJSONPathBuilder<S, O>
    method constructor (line 205) | constructor(node: JSONReferenceNode | JSONPathNode) {
    method expressionType (line 211) | get expressionType(): O | undefined {
    method as (line 242) | as(alias: string | Expression<any>): AliasedExpression<O, string> {
    method $castTo (line 252) | $castTo<O2>(): TraversedJSONPathBuilder<S, O2> {
    method $notNull (line 256) | $notNull(): TraversedJSONPathBuilder<S, Exclude<O, null>> {
    method toOperationNode (line 260) | toOperationNode(): OperationNode {
  class AliasedJSONPathBuilder (line 265) | class AliasedJSONPathBuilder<
    method constructor (line 272) | constructor(
    method expression (line 281) | get expression(): Expression<O> {
    method alias (line 286) | get alias(): A | Expression<unknown> {
    method toOperationNode (line 290) | toOperationNode(): AliasNode {

FILE: src/query-builder/merge-query-builder.ts
  class MergeQueryBuilder (line 73) | class MergeQueryBuilder<DB, TT extends keyof DB, O>
    method constructor (line 78) | constructor(props: MergeQueryBuilderProps) {
    method modifyEnd (line 105) | modifyEnd(modifier: Expression<any>): MergeQueryBuilder<DB, TT, O> {
    method top (line 162) | top(
    method using (line 218) | using(...args: any): any {
    method returning (line 240) | returning(args: any): any {
    method returningAll (line 256) | returningAll(table?: any): any {
    method output (line 290) | output(args: any): any {
    method outputAll (line 300) | outputAll(
  type MergeQueryBuilderProps (line 313) | interface MergeQueryBuilderProps {
  class WheneableMergeQueryBuilder (line 319) | class WheneableMergeQueryBuilder<
    method constructor (line 333) | constructor(props: MergeQueryBuilderProps) {
    method modifyEnd (line 360) | modifyEnd(
    method top (line 375) | top(
    method whenMatched (line 416) | whenMatched(): MatchedThenableMergeQueryBuilder<DB, TT, ST, TT | ST, O> {
    method whenMatchedAnd (line 460) | whenMatchedAnd(
    method whenMatchedAndRef (line 473) | whenMatchedAndRef<
    method #whenMatched (line 484) | #whenMatched(
    method whenNotMatched (line 528) | whenNotMatched(): NotMatchedThenableMergeQueryBuilder<DB, TT, ST, O> {
    method whenNotMatchedAnd (line 577) | whenNotMatchedAnd(
    method whenNotMatchedAndRef (line 592) | whenNotMatchedAndRef<
    method whenNotMatchedBySource (line 610) | whenNotMatchedBySource(): MatchedThenableMergeQueryBuilder<
    method whenNotMatchedBySourceAnd (line 640) | whenNotMatchedBySourceAnd(
    method whenNotMatchedBySourceAndRef (line 652) | whenNotMatchedBySourceAndRef<
    method returning (line 680) | returning(args: any): any {
    method returningAll (line 701) | returningAll(table?: any): any {
    method output (line 738) | output(args: any): any {
    method outputAll (line 748) | outputAll(
    method #whenNotMatched (line 760) | #whenNotMatched(
    method $call (line 805) | $call<T>(func: (qb: this) => T): T {
    method $if (line 847) | $if<O2>(
    method toOperationNode (line 864) | toOperationNode(): MergeQueryNode {
    method compile (line 871) | compile(): CompiledQuery<O> {
    method execute (line 883) | async execute(): Promise<SimplifyResult<O>[]> {
    method executeTakeFirst (line 905) | async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
    method executeTakeFirstOrThrow (line 918) | async executeTakeFirstOrThrow(
  class MatchedThenableMergeQueryBuilder (line 937) | class MatchedThenableMergeQueryBuilder<
    method constructor (line 946) | constructor(props: MergeQueryBuilderProps) {
    method thenDelete (line 976) | thenDelete(): WheneableMergeQueryBuilder<DB, TT, ST, O> {
    method thenDoNothing (line 1014) | thenDoNothing(): WheneableMergeQueryBuilder<DB, TT, ST, O> {
    method thenUpdate (line 1060) | thenUpdate<QB extends UpdateQueryBuilder<DB, TT, UT, never>>(
    method thenUpdateSet (line 1127) | thenUpdateSet(...args: any[]): any {
  class NotMatchedThenableMergeQueryBuilder (line 1133) | class NotMatchedThenableMergeQueryBuilder<
    method constructor (line 1141) | constructor(props: MergeQueryBuilderProps) {
    method thenDoNothing (line 1171) | thenDoNothing(): WheneableMergeQueryBuilder<DB, TT, ST, O> {
    method thenInsertValues (line 1219) | thenInsertValues<IE extends InsertExpression<DB, TT, ST>>(
  type ExtractWheneableMergeQueryBuilder (line 1239) | type ExtractWheneableMergeQueryBuilder<
  type UsingBuilder (line 1256) | type UsingBuilder<

FILE: src/query-builder/merge-result.ts
  class MergeResult (line 1) | class MergeResult {
    method constructor (line 4) | constructor(numChangedRows: bigint | undefined) {

FILE: src/query-builder/no-result-error.ts
  type NoResultErrorConstructor (line 3) | type NoResultErrorConstructor = new (node: QueryNode) => Error
  class NoResultError (line 5) | class NoResultError extends Error {
    method constructor (line 11) | constructor(node: QueryNode) {
  function isNoResultErrorConstructor (line 17) | function isNoResultErrorConstructor(

FILE: src/query-builder/on-conflict-builder.ts
  class OnConflictBuilder (line 23) | class OnConflictBuilder<
    method constructor (line 29) | constructor(props: OnConflictBuilderProps) {
    method column (line 39) | column(column: AnyColumn<DB, TB>): OnConflictBuilder<DB, TB> {
    method columns (line 58) | columns(
    method constraint (line 79) | constraint(constraintName: string): OnConflictBuilder<DB, TB> {
    method expression (line 96) | expression(expression: Expression<any>): OnConflictBuilder<DB, TB> {
    method where (line 118) | where(...args: any[]): OnConflictBuilder<DB, TB> {
    method whereRef (line 128) | whereRef<
    method clearWhere (line 145) | clearWhere(): OnConflictBuilder<DB, TB> {
    method doNothing (line 181) | doNothing(): OnConflictDoNothingBuilder<DB, TB> {
    method doUpdateSet (line 251) | doUpdateSet(
    method $call (line 270) | $call<T>(func: (qb: this) => T): T {
  type OnConflictBuilderProps (line 275) | interface OnConflictBuilderProps {
  type OnConflictDatabase (line 279) | type OnConflictDatabase<DB, TB extends keyof DB> = {
  type OnConflictTables (line 283) | type OnConflictTables<TB> = TB | 'excluded'
  class OnConflictDoNothingBuilder (line 285) | class OnConflictDoNothingBuilder<
    method constructor (line 291) | constructor(props: OnConflictBuilderProps) {
    method toOperationNode (line 295) | toOperationNode(): OnConflictNode {
  class OnConflictUpdateBuilder (line 300) | class OnConflictUpdateBuilder<DB, TB extends keyof DB>
    method constructor (line 305) | constructor(props: OnConflictBuilderProps) {
    method where (line 327) | where(...args: any[]): OnConflictUpdateBuilder<DB, TB> {
    method whereRef (line 342) | whereRef<
    method clearWhere (line 359) | clearWhere(): OnConflictUpdateBuilder<DB, TB> {
    method $call (line 372) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 376) | toOperationNode(): OnConflictNode {

FILE: src/query-builder/order-by-interface.ts
  type OrderByInterface (line 8) | interface OrderByInterface<DB, TB extends keyof DB, O> {

FILE: src/query-builder/order-by-item-builder.ts
  class OrderByItemBuilder (line 8) | class OrderByItemBuilder implements OperationNodeSource {
    method constructor (line 11) | constructor(props: OrderByItemBuilderProps) {
    method desc (line 20) | desc(): OrderByItemBuilder {
    method asc (line 33) | asc(): OrderByItemBuilder {
    method nullsLast (line 48) | nullsLast(): OrderByItemBuilder {
    method nullsFirst (line 61) | nullsFirst(): OrderByItemBuilder {
    method collate (line 70) | collate(collation: Collation): OrderByItemBuilder {
    method toOperationNode (line 78) | toOperationNode(): OrderByItemNode {
  type OrderByItemBuilderProps (line 83) | interface OrderByItemBuilderProps {

FILE: src/query-builder/output-interface.ts
  type OutputInterface (line 12) | interface OutputInterface<
  type OutputPrefix (line 168) | type OutputPrefix = 'deleted' | 'inserted'
  type OutputDatabase (line 170) | type OutputDatabase<
  type OutputExpression (line 178) | type OutputExpression<
  type OutputCallback (line 189) | type OutputCallback<
  type SelectExpressionFromOutputExpression (line 197) | type SelectExpressionFromOutputExpression<OE> =
  type SelectExpressionFromOutputCallback (line 200) | type SelectExpressionFromOutputCallback<CB> = CB extends (

FILE: src/query-builder/over-builder.ts
  class OverBuilder (line 19) | class OverBuilder<DB, TB extends keyof DB>
    method constructor (line 24) | constructor(props: OverBuilderProps) {
    method orderBy (line 81) | orderBy(...args: any[]): any {
    method clearOrderBy (line 90) | clearOrderBy(): OverBuilder<DB, TB> {
    method partitionBy (line 125) | partitionBy(partitionBy: PartitionByExpressionOrList<DB, TB>): any {
    method $call (line 138) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 142) | toOperationNode(): OverNode {
  type OverBuilderProps (line 147) | interface OverBuilderProps {

FILE: src/query-builder/returning-interface.ts
  type ReturningInterface (line 12) | interface ReturningInterface<DB, TB extends keyof DB, O> {
  type MultiTableReturningInterface (line 93) | interface MultiTableReturningInterface<

FILE: src/query-builder/select-query-builder-expression.ts
  type SelectQueryBuilderExpression (line 4) | interface SelectQueryBuilderExpression<

FILE: src/query-builder/select-query-builder.ts
  type SelectQueryBuilder (line 87) | interface SelectQueryBuilder<DB, TB extends keyof DB, O>
  class SelectQueryBuilderImpl (line 2154) | class SelectQueryBuilderImpl<
    method constructor (line 2161) | constructor(props: SelectQueryBuilderProps) {
    method expressionType (line 2165) | get expressionType(): O | undefined {
    method isSelectQueryBuilder (line 2169) | get isSelectQueryBuilder(): true {
    method where (line 2173) | where(...args: any[]): any {
    method whereRef (line 2183) | whereRef(
    method having (line 2197) | having(...args: any[]): any {
    method havingRef (line 2207) | havingRef(
    method select (line 2221) | select<SE extends SelectExpression<DB, TB>>(
    method distinctOn (line 2233) | distinctOn(selection: ReferenceExpressionOrList<DB, TB>): any {
    method modifyFront (line 2243) | modifyFront(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O> {
    method modifyEnd (line 2253) | modifyEnd(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O> {
    method distinct (line 2263) | distinct(): SelectQueryBuilder<DB, TB, O> {
    method forUpdate (line 2273) | forUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O> {
    method forShare (line 2286) | forShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O> {
    method forKeyShare (line 2299) | forKeyShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O> {
    method forNoKeyUpdate (line 2312) | forNoKeyUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O> {
    method skipLocked (line 2325) | skipLocked(): SelectQueryBuilder<DB, TB, O> {
    method noWait (line 2335) | noWait(): SelectQueryBuilder<DB, TB, O> {
    method selectAll (line 2345) | selectAll(table?: any): any {
    method innerJoin (line 2355) | innerJoin(...args: any): any {
    method leftJoin (line 2359) | leftJoin(...args: any): any {
    method rightJoin (line 2363) | rightJoin(...args: any): any {
    method fullJoin (line 2367) | fullJoin(...args: any): any {
    method crossJoin (line 2371) | crossJoin(...args: any): any {
    method innerJoinLateral (line 2375) | innerJoinLateral(...args: any): any {
    method leftJoinLateral (line 2379) | leftJoinLateral(...args: any): any {
    method crossJoinLateral (line 2383) | crossJoinLateral(...args: any): any {
    method crossApply (line 2387) | crossApply(...args: any): any {
    method outerApply (line 2391) | outerApply(...args: any[]): any {
    method #join (line 2395) | #join(joinType: JoinType, args: any[]): any {
    method orderBy (line 2405) | orderBy(...args: any[]): SelectQueryBuilder<DB, TB, O> {
    method groupBy (line 2415) | groupBy(groupBy: GroupByArg<DB, TB, O>): SelectQueryBuilder<DB, TB, O> {
    method limit (line 2425) | limit(
    method offset (line 2437) | offset(
    method fetch (line 2449) | fetch(
    method top (line 2462) | top(
    method union (line 2475) | union(
    method unionAll (line 2487) | unionAll(
    method intersect (line 2499) | intersect(
    method intersectAll (line 2511) | intersectAll(
    method except (line 2523) | except(
    method exceptAll (line 2535) | exceptAll(
    method as (line 2547) | as<A extends string>(alias: A): AliasedSelectQueryBuilder<O, A> {
    method clearSelect (line 2551) | clearSelect(): SelectQueryBuilder<DB, TB, {}> {
    method clearWhere (line 2558) | clearWhere(): SelectQueryBuilder<DB, TB, O> {
    method clearLimit (line 2565) | clearLimit(): SelectQueryBuilder<DB, TB, O> {
    method clearOffset (line 2572) | clearOffset(): SelectQueryBuilder<DB, TB, O> {
    method clearOrderBy (line 2579) | clearOrderBy(): SelectQueryBuilder<DB, TB, O> {
    method clearGroupBy (line 2586) | clearGroupBy(): SelectQueryBuilder<DB, TB, O> {
    method $call (line 2593) | $call<T>(func: (qb: this) => T): T {
    method $if (line 2597) | $if<O2>(
    method $castTo (line 2610) | $castTo<C>(): SelectQueryBuilder<DB, TB, C> {
    method $narrowType (line 2614) | $narrowType<T>(): SelectQueryBuilder<DB, TB, NarrowPartial<O, T>> {
    method $assertType (line 2618) | $assertType<T extends O>(): O extends T
    method $asTuple (line 2624) | $asTuple(): ExpressionWrapper<DB, TB, any> {
    method $asScalar (line 2628) | $asScalar(): ExpressionWrapper<DB, TB, any> {
    method withPlugin (line 2632) | withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O> {
    method toOperationNode (line 2639) | toOperationNode(): SelectQueryNode {
    method compile (line 2646) | compile(): CompiledQuery<Simplify<O>> {
    method execute (line 2653) | async execute(): Promise<Simplify<O>[]> {
    method executeTakeFirst (line 2661) | async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
    method executeTakeFirstOrThrow (line 2666) | async executeTakeFirstOrThrow(
    method stream (line 2684) | async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {
    method explain (line 2694) | async explain<ER extends Record<string, any> = Record<string, any>>(
  function createSelectQueryBuilder (line 2711) | function createSelectQueryBuilder<DB, TB extends keyof DB, O>(
  type SelectQueryBuilderProps (line 2717) | interface SelectQueryBuilderProps {
  type AliasedSelectQueryBuilder (line 2723) | interface AliasedSelectQueryBuilder<
  class AliasedSelectQueryBuilderImpl (line 2733) | class AliasedSelectQueryBuilderImpl<
    method constructor (line 2742) | constructor(queryBuilder: SelectQueryBuilder<DB, TB, O>, alias: A) {
    method expression (line 2747) | get expression(): Expression<O> {
    method alias (line 2751) | get alias(): A {
    method isAliasedSelectQueryBuilder (line 2755) | get isAliasedSelectQueryBuilder(): true {
    method toOperationNode (line 2759) | toOperationNode(): AliasNode {
  type SelectQueryBuilderWithInnerJoin (line 2767) | type SelectQueryBuilderWithInnerJoin<
  type InnerJoinedBuilder (line 2784) | type InnerJoinedBuilder<
  type InnerJoinedDB (line 2795) | type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
  type SelectQueryBuilderWithLeftJoin (line 2799) | type SelectQueryBuilderWithLeftJoin<
  type LeftJoinedBuilder (line 2816) | type LeftJoinedBuilder<
  type LeftJoinedDB (line 2827) | type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
  type SelectQueryBuilderWithRightJoin (line 2835) | type SelectQueryBuilderWithRightJoin<
  type RightJoinedBuilder (line 2852) | type RightJoinedBuilder<
  type RightJoinedDB (line 2860) | type RightJoinedDB<
  type SelectQueryBuilderWithFullJoin (line 2875) | type SelectQueryBuilderWithFullJoin<
  type OuterJoinedBuilder (line 2892) | type OuterJoinedBuilder<
  type OuterJoinedBuilderDB (line 2900) | type OuterJoinedBuilderDB<
  type TableOrList (line 2915) | type TableOrList<TB extends keyof any> =

FILE: src/query-builder/update-query-builder.ts
  class UpdateQueryBuilder (line 91) | class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O>
    method constructor (line 104) | constructor(props: UpdateQueryBuilderProps) {
    method where (line 121) | where(...args: any[]): any {
    method whereRef (line 131) | whereRef<
    method clearWhere (line 148) | clearWhere(): UpdateQueryBuilder<DB, UT, TB, O> {
    method top (line 194) | top(
    method from (line 242) | from(from: TableExpressionOrList<any, any>): any {
    method innerJoin (line 376) | innerJoin(...args: any): any {
    method leftJoin (line 398) | leftJoin(...args: any): any {
    method rightJoin (line 420) | rightJoin(...args: any): any {
    method fullJoin (line 442) | fullJoin(...args: any): any {
    method #join (line 446) | #join(joinType: JoinType, args: any[]): any {
    method orderBy (line 494) | orderBy(...args: any[]): any {
    method clearOrderBy (line 504) | clearOrderBy(): UpdateQueryBuilder<DB, UT, TB, O> {
    method limit (line 532) | limit(
    method set (line 732) | set(
    method returning (line 758) | returning<SE extends SelectExpression<DB, TB>>(
    method returningAll (line 780) | returningAll(table?: any): any {
    method output (line 817) | output(args: any): any {
    method outputAll (line 827) | outputAll(
    method modifyEnd (line 862) | modifyEnd(modifier: Expression<any>): UpdateQueryBuilder<DB, UT, TB, O> {
    method clearReturning (line 891) | clearReturning(): UpdateQueryBuilder<DB, UT, TB, UpdateResult> {
    method $call (line 928) | $call<T>(func: (qb: this) => T): T {
    method $if (line 970) | $if<O2>(
    method $castTo (line 993) | $castTo<C>(): UpdateQueryBuilder<DB, UT, TB, C> {
    method $narrowType (line 1055) | $narrowType<T>(): UpdateQueryBuilder<DB, UT, TB, NarrowPartial<O, T>> {
    method $assertType (line 1113) | $assertType<T extends O>(): O extends T
    method withPlugin (line 1122) | withPlugin(plugin: KyselyPlugin): UpdateQueryBuilder<DB, UT, TB, O> {
    method toOperationNode (line 1129) | toOperationNode(): UpdateQueryNode {
    method compile (line 1136) | compile(): CompiledQuery<SimplifyResult<O>> {
    method execute (line 1148) | async execute(): Promise<SimplifyResult<O>[]> {
    method executeTakeFirst (line 1175) | async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
    method executeTakeFirstOrThrow (line 1188) | async executeTakeFirstOrThrow(
    method stream (line 1206) | async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {
    method explain (line 1216) | async explain<ER extends Record<string, any> = Record<string, any>>(
  type UpdateQueryBuilderProps (line 1233) | interface UpdateQueryBuilderProps {
  type UpdateQueryBuilderWithInnerJoin (line 1239) | type UpdateQueryBuilderWithInnerJoin<
  type InnerJoinedBuilder (line 1257) | type InnerJoinedBuilder<
  type InnerJoinedDB (line 1269) | type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
  type UpdateQueryBuilderWithLeftJoin (line 1273) | type UpdateQueryBuilderWithLeftJoin<
  type LeftJoinedBuilder (line 1291) | type LeftJoinedBuilder<
  type LeftJoinedDB (line 1303) | type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
  type UpdateQueryBuilderWithRightJoin (line 1311) | type UpdateQueryBuilderWithRightJoin<
  type RightJoinedBuilder (line 1329) | type RightJoinedBuilder<
  type RightJoinedDB (line 1338) | type RightJoinedDB<
  type UpdateQueryBuilderWithFullJoin (line 1353) | type UpdateQueryBuilderWithFullJoin<
  type OuterJoinedBuilder (line 1371) | type OuterJoinedBuilder<
  type OuterJoinedBuilderDB (line 1380) | type OuterJoinedBuilderDB<

FILE: src/query-builder/update-result.ts
  class UpdateResult (line 1) | class UpdateResult {
    method constructor (line 15) | constructor(numUpdatedRows: bigint, numChangedRows: bigint | undefined) {

FILE: src/query-builder/where-interface.ts
  type WhereInterface (line 10) | interface WhereInterface<DB, TB extends keyof DB> {

FILE: src/query-compiler/compiled-query.ts
  type CompiledQuery (line 6) | interface CompiledQuery<O = unknown> {
  type CompiledQueryFactory (line 13) | type CompiledQueryFactory = Readonly<{
  method raw (line 19) | raw(sql, parameters = []) {

FILE: src/query-compiler/default-query-compiler.ts
  constant LIT_WRAP_REGEX (line 121) | const LIT_WRAP_REGEX = /'/g
  class DefaultQueryCompiler (line 123) | class DefaultQueryCompiler
    method numParameters (line 130) | protected get numParameters(): number {
    method compileQuery (line 134) | compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery {
    method getSql (line 149) | protected getSql(): string {
    method visitSelectQuery (line 153) | protected override visitSelectQuery(node: SelectQueryNode): void {
    method visitFrom (line 258) | protected override visitFrom(node: FromNode): void {
    method visitSelection (line 263) | protected override visitSelection(node: SelectionNode): void {
    method visitColumn (line 267) | protected override visitColumn(node: ColumnNode): void {
    method compileDistinctOn (line 271) | protected compileDistinctOn(expressions: ReadonlyArray<OperationNode>)...
    method compileList (line 277) | protected compileList(
    method visitWhere (line 292) | protected override visitWhere(node: WhereNode): void {
    method visitHaving (line 297) | protected override visitHaving(node: HavingNode): void {
    method visitInsertQuery (line 302) | protected override visitInsertQuery(node: InsertQueryNode): void {
    method visitValues (line 394) | protected override visitValues(node: ValuesNode): void {
    method visitDeleteQuery (line 399) | protected override visitDeleteQuery(node: DeleteQueryNode): void {
    method visitReturning (line 473) | protected override visitReturning(node: ReturningNode): void {
    method visitAlias (line 478) | protected override visitAlias(node: AliasNode): void {
    method visitReference (line 484) | protected override visitReference(node: ReferenceNode): void {
    method visitSelectAll (line 493) | protected override visitSelectAll(_: SelectAllNode): void {
    method visitIdentifier (line 497) | protected override visitIdentifier(node: IdentifierNode): void {
    method compileUnwrappedIdentifier (line 503) | protected compileUnwrappedIdentifier(node: IdentifierNode): void {
    method visitAnd (line 513) | protected override visitAnd(node: AndNode): void {
    method visitOr (line 519) | protected override visitOr(node: OrNode): void {
    method visitValue (line 525) | protected override visitValue(node: ValueNode): void {
    method visitValueList (line 533) | protected override visitValueList(node: ValueListNode): void {
    method visitTuple (line 539) | protected override visitTuple(node: TupleNode): void {
    method visitPrimitiveValueList (line 545) | protected override visitPrimitiveValueList(
    method visitParens (line 562) | protected override visitParens(node: ParensNode): void {
    method visitJoin (line 568) | protected override visitJoin(node: JoinNode): void {
    method visitOn (line 579) | protected override visitOn(node: OnNode): void {
    method visitRaw (line 584) | protected override visitRaw(node: RawNode): void {
    method visitOperator (line 596) | protected override visitOperator(node: OperatorNode): void {
    method visitTable (line 600) | protected override visitTable(node: TableNode): void {
    method visitSchemableIdentifier (line 604) | protected override visitSchemableIdentifier(
    method visitCreateTable (line 615) | protected override visitCreateTable(node: CreateTableNode): void {
    method visitColumnDefinition (line 657) | protected override visitColumnDefinition(node: ColumnDefinitionNode): ...
    method getAutoIncrement (line 727) | protected getAutoIncrement(): string {
    method visitReferences (line 731) | protected override visitReferences(node: ReferencesNode): void {
    method visitDropTable (line 749) | protected override visitDropTable(node: DropTableNode): void {
    method visitDataType (line 763) | protected override visitDataType(node: DataTypeNode): void {
    method visitOrderBy (line 767) | protected override visitOrderBy(node: OrderByNode): void {
    method visitOrderByItem (line 772) | protected override visitOrderByItem(node: OrderByItemNode): void {
    method visitGroupBy (line 791) | protected override visitGroupBy(node: GroupByNode): void {
    method visitGroupByItem (line 796) | protected override visitGroupByItem(node: GroupByItemNode): void {
    method visitUpdateQuery (line 800) | protected override visitUpdateQuery(node: UpdateQueryNode): void {
    method visitColumnUpdate (line 890) | protected override visitColumnUpdate(node: ColumnUpdateNode): void {
    method visitLimit (line 896) | protected override visitLimit(node: LimitNode): void {
    method visitOffset (line 901) | protected override visitOffset(node: OffsetNode): void {
    method visitOnConflict (line 906) | protected override visitOnConflict(node: OnConflictNode): void {
    method visitOnDuplicateKey (line 940) | protected override visitOnDuplicateKey(node: OnDuplicateKeyNode): void {
    method visitCreateIndex (line 945) | protected override visitCreateIndex(node: CreateIndexNode): void {
    method visitDropIndex (line 986) | protected override visitDropIndex(node: DropIndexNode): void {
    method visitCreateSchema (line 1005) | protected override visitCreateSchema(node: CreateSchemaNode): void {
    method visitDropSchema (line 1015) | protected override visitDropSchema(node: DropSchemaNode): void {
    method visitPrimaryKeyConstraint (line 1029) | protected override visitPrimaryKeyConstraint(
    method buildDeferrable (line 1045) | protected buildDeferrable(node: {
    method visitUniqueConstraint (line 1066) | protected override visitUniqueConstraint(node: UniqueConstraintNode): ...
    method visitCheckConstraint (line 1086) | protected override visitCheckConstraint(node: CheckConstraintNode): vo...
    method visitForeignKeyConstraint (line 1098) | protected override visitForeignKeyConstraint(
    method visitList (line 1125) | protected override visitList(node: ListNode): void {
    method visitWith (line 1129) | protected override visitWith(node: WithNode): void {
    method visitCommonTableExpression (line 1139) | protected override visitCommonTableExpression(
    method visitCommonTableExpressionName (line 1156) | protected override visitCommonTableExpressionName(
    method visitAlterTable (line 1168) | protected override visitAlterTable(node: AlterTableNode): void {
    method visitAddColumn (line 1208) | protected override visitAddColumn(node: AddColumnNode): void {
    method visitRenameColumn (line 1213) | protected override visitRenameColumn(node: RenameColumnNode): void {
    method visitDropColumn (line 1220) | protected override visitDropColumn(node: DropColumnNode): void {
    method visitAlterColumn (line 1225) | protected override visitAlterColumn(node: AlterColumnNode): void {
    method visitModifyColumn (line 1261) | protected override visitModifyColumn(node: ModifyColumnNode): void {
    method visitAddConstraint (line 1266) | protected override visitAddConstraint(node: AddConstraintNode): void {
    method visitDropConstraint (line 1271) | protected override visitDropConstraint(node: DropConstraintNode): void {
    method visitRenameConstraint (line 1287) | protected override visitRenameConstraint(node: RenameConstraintNode): ...
    method visitSetOperation (line 1294) | protected override visitSetOperation(node: SetOperationNode): void {
    method visitCreateView (line 1305) | protected override visitCreateView(node: CreateViewNode): void {
    method visitRefreshMaterializedView (line 1341) | protected override visitRefreshMaterializedView(
    method visitDropView (line 1359) | protected override visitDropView(node: DropViewNode): void {
    method visitGenerated (line 1379) | protected override visitGenerated(node: GeneratedNode): void {
    method visitDefaultValue (line 1407) | protected override visitDefaultValue(node: DefaultValueNode): void {
    method visitSelectModifier (line 1412) | protected override visitSelectModifier(node: SelectModifierNode): void {
    method visitCreateType (line 1425) | protected override visitCreateType(node: CreateTypeNode): void {
    method visitDropType (line 1435) | protected override visitDropType(node: DropTypeNode): void {
    method visitExplain (line 1445) | protected override visitExplain(node: ExplainNode): void {
    method visitDefaultInsertValue (line 1470) | protected visitDefaultInsertValue(_: DefaultInsertValueNode): void {
    method visitAggregateFunction (line 1474) | protected override visitAggregateFunction(node: AggregateFunctionNode)...
    method visitOver (line 1509) | protected override visitOver(node: OverNode): void {
    method visitPartitionBy (line 1527) | protected override visitPartitionBy(node: PartitionByNode): void {
    method visitPartitionByItem (line 1532) | protected override visitPartitionByItem(node: PartitionByItemNode): vo...
    method visitBinaryOperation (line 1536) | protected override visitBinaryOperation(node: BinaryOperationNode): vo...
    method visitUnaryOperation (line 1544) | protected override visitUnaryOperation(node: UnaryOperationNode): void {
    method isMinusOperator (line 1554) | protected isMinusOperator(node: OperationNode): node is OperatorNode {
    method visitUsing (line 1558) | protected override visitUsing(node: UsingNode): void {
    method visitFunction (line 1563) | protected override visitFunction(node: FunctionNode): void {
    method visitCase (line 1570) | protected override visitCase(node: CaseNode): void {
    method visitWhen (line 1595) | protected override visitWhen(node: WhenNode): void {
    method visitJSONReference (line 1606) | protected override visitJSONReference(node: JSONReferenceNode): void {
    method visitJSONPath (line 1611) | protected override visitJSONPath(node: JSONPathNode): void {
    method visitJSONPathLeg (line 1625) | protected override visitJSONPathLeg(node: JSONPathLegNode): void {
    method visitJSONOperatorChain (line 1641) | protected override visitJSONOperatorChain(node: JSONOperatorChainNode)...
    method visitMergeQuery (line 1653) | protected override visitMergeQuery(node: MergeQueryNode): void {
    method visitMatched (line 1695) | protected override visitMatched(node: MatchedNode): void {
    method visitAddIndex (line 1707) | protected override visitAddIndex(node: AddIndexNode): void {
    method visitCast (line 1730) | protected override visitCast(node: CastNode): void {
    method visitFetch (line 1738) | protected override visitFetch(node: FetchNode): void {
    method visitOutput (line 1744) | protected override visitOutput(node: OutputNode): void {
    method visitTop (line 1749) | protected override visitTop(node: TopNode): void {
    method visitOrAction (line 1757) | protected override visitOrAction(node: OrActionNode): void {
    method visitCollate (line 1761) | protected override visitCollate(node: CollateNode): void {
    method append (line 1766) | protected append(str: string): void {
    method appendValue (line 1770) | protected appendValue(parameter: unknown): void {
    method getLeftIdentifierWrapper (line 1775) | protected getLeftIdentifierWrapper(): string {
    method getRightIdentifierWrapper (line 1779) | protected getRightIdentifierWrapper(): string {
    method getCurrentParameterPlaceholder (line 1783) | protected getCurrentParameterPlaceholder(): string {
    method getLeftExplainOptionsWrapper (line 1787) | protected getLeftExplainOptionsWrapper(): string {
    method getExplainOptionAssignment (line 1791) | protected getExplainOptionAssignment(): string {
    method getExplainOptionsDelimiter (line 1795) | protected getExplainOptionsDelimiter(): string {
    method getRightExplainOptionsWrapper (line 1799) | protected getRightExplainOptionsWrapper(): string {
    method sanitizeIdentifier (line 1803) | protected sanitizeIdentifier(identifier: string): string {
    method sanitizeStringLiteral (line 1821) | protected sanitizeStringLiteral(value: string): string {
    method addParameter (line 1825) | protected addParameter(parameter: unknown): void {
    method appendImmediateValue (line 1829) | protected appendImmediateValue(value: unknown): void {
    method appendStringLiteral (line 1843) | protected appendStringLiteral(value: string): void {
    method sortSelectModifiers (line 1849) | protected sortSelectModifiers(
    method compileColumnAlterations (line 1862) | protected compileColumnAlterations(
    method announcesNewColumnDataType (line 1872) | protected announcesNewColumnDataType(): boolean {
  constant SELECT_MODIFIER_SQL (line 1877) | const SELECT_MODIFIER_SQL: Readonly<Record<SelectModifier, string>> = fr...
  constant SELECT_MODIFIER_PRIORITY (line 1887) | const SELECT_MODIFIER_PRIORITY: Readonly<Record<SelectModifier, number>> =
  constant JOIN_TYPE_SQL (line 1898) | const JOIN_TYPE_SQL: Readonly<Record<JoinType, string>> = freeze({

FILE: src/query-compiler/query-compiler.ts
  type RootOperationNode (line 19) | type RootOperationNode =
  type QueryCompiler (line 39) | interface QueryCompiler {

FILE: src/query-creator.ts
  class QueryCreator (line 51) | class QueryCreator<DB> {
    method constructor (line 54) | constructor(props: QueryCreatorProps) {
    method selectFrom (line 165) | selectFrom<TE extends TableExpressionOrList<DB, never>>(
    method selectNoFrom (line 236) | selectNoFrom<SE extends SelectExpression<DB, never>>(
    method insertInto (line 287) | insertInto<T extends keyof DB & string>(
    method replaceInto (line 336) | replaceInto<T extends keyof DB & string>(
    method deleteFrom (line 399) | deleteFrom<TE extends TableExpressionOrList<DB, never>>(
    method updateTable (line 435) | updateTable<TE extends TableExpressionOrList<DB, never>>(
    method mergeInto (line 531) | mergeInto<TR extends SimpleTableReference<DB>>(
    method with (line 655) | with<N extends string, E extends CommonTableExpression<DB, N>>(
    method withRecursive (line 679) | withRecursive<
    method withPlugin (line 699) | withPlugin(plugin: KyselyPlugin): QueryCreator<DB> {
    method withoutPlugins (line 709) | withoutPlugins(): QueryCreator<DB> {
    method withSchema (line 763) | withSchema(schema: string): QueryCreator<DB> {
  type QueryCreatorProps (line 773) | interface QueryCreatorProps {

FILE: src/query-executor/default-query-executor.ts
  class DefaultQueryExecutor (line 13) | class DefaultQueryExecutor extends QueryExecutorBase {
    method constructor (line 18) | constructor(
    method adapter (line 31) | get adapter(): DialectAdapter {
    method compileQuery (line 35) | compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery {
    method provideConnection (line 39) | provideConnection<T>(
    method withPlugins (line 45) | withPlugins(plugins: ReadonlyArray<KyselyPlugin>): DefaultQueryExecutor {
    method withPlugin (line 54) | withPlugin(plugin: KyselyPlugin): DefaultQueryExecutor {
    method withPluginAtFront (line 63) | withPluginAtFront(plugin: KyselyPlugin): DefaultQueryExecutor {
    method withConnectionProvider (line 72) | withConnectionProvider(
    method withoutPlugins (line 83) | withoutPlugins(): DefaultQueryExecutor {

FILE: src/query-executor/noop-query-executor.ts
  class NoopQueryExecutor (line 11) | class NoopQueryExecutor extends QueryExecutorBase {
    method adapter (line 12) | get adapter(): DialectAdapter {
    method compileQuery (line 16) | compileQuery(): CompiledQuery {
    method provideConnection (line 20) | provideConnection<T>(): Promise<T> {
    method withConnectionProvider (line 24) | withConnectionProvider(): NoopQueryExecutor {
    method withPlugin (line 28) | withPlugin(plugin: KyselyPlugin): NoopQueryExecutor {
    method withPlugins (line 32) | withPlugins(plugins: ReadonlyArray<KyselyPlugin>): NoopQueryExecutor {
    method withPluginAtFront (line 36) | withPluginAtFront(plugin: KyselyPlugin): NoopQueryExecutor {
    method withoutPlugins (line 40) | withoutPlugins(): NoopQueryExecutor {
  constant NOOP_QUERY_EXECUTOR (line 45) | const NOOP_QUERY_EXECUTOR: NoopQueryExecutor = new NoopQueryExecutor()

FILE: src/query-executor/query-executor-base.ts
  constant NO_PLUGINS (line 16) | const NO_PLUGINS: ReadonlyArray<KyselyPlugin> = freeze([])
  method constructor (line 21) | constructor(plugins: ReadonlyArray<KyselyPlugin> = NO_PLUGINS) {
  method plugins (line 27) | get plugins(): ReadonlyArray<KyselyPlugin> {
  method transformQuery (line 31) | transformQuery<T extends RootOperationNode>(node: T, queryId: QueryId): T {
  method executeQuery (line 63) | async executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult...
  method stream (line 77) | async *stream<R>(
  method #transformResult (line 104) | async #transformResult<T>(

FILE: src/query-executor/query-executor-provider.ts
  type QueryExecutorProvider (line 7) | interface QueryExecutorProvider {

FILE: src/query-executor/query-executor.ts
  type QueryExecutor (line 15) | interface QueryExecutor extends ConnectionProvider {

FILE: src/raw-builder/raw-builder.ts
  type RawBuilder (line 25) | interface RawBuilder<O> extends AliasableExpression<O> {
  class RawBuilderImpl (line 143) | class RawBuilderImpl<O> implements RawBuilder<O> {
    method constructor (line 146) | constructor(props: RawBuilderProps) {
    method expressionType (line 150) | get expressionType(): O | undefined {
    method isRawBuilder (line 154) | get isRawBuilder(): true {
    method as (line 158) | as(alias: string | Expression<unknown>): AliasedRawBuilder<O, string> {
    method $castTo (line 162) | $castTo<C>(): RawBuilder<C> {
    method $notNull (line 166) | $notNull(): RawBuilder<Exclude<O, null>> {
    method withPlugin (line 170) | withPlugin(plugin: KyselyPlugin): RawBuilder<O> {
    method toOperationNode (line 180) | toOperationNode(): RawNode {
    method compile (line 184) | compile(executorProvider: QueryExecutorProvider): CompiledQuery<O> {
    method execute (line 188) | async execute(
    method #getExecutor (line 196) | #getExecutor(executorProvider?: QueryExecutorProvider): QueryExecutor {
    method #toOperationNode (line 207) | #toOperationNode(executor: QueryExecutor): RawNode {
    method #compile (line 211) | #compile(executor: QueryExecutor): CompiledQuery {
  type RawBuilderProps (line 219) | interface RawBuilderProps {
  function createRawBuilder (line 225) | function createRawBuilder<O>(props: RawBuilderProps): RawBuilder<O> {
  type AliasedRawBuilder (line 232) | interface AliasedRawBuilder<
  class AliasedRawBuilderImpl (line 239) | class AliasedRawBuilderImpl<
    method constructor (line 246) | constructor(rawBuilder: RawBuilder<O>, alias: A | Expression<unknown>) {
    method expression (line 251) | get expression(): Expression<O> {
    method alias (line 255) | get alias(): A | Expression<unknown> {
    method rawBuilder (line 259) | get rawBuilder(): RawBuilder<O> {
    method toOperationNode (line 263) | toOperationNode(): AliasNode {

FILE: src/raw-builder/sql.ts
  type Sql (line 12) | interface Sql {
  method ref (line 406) | ref<R = unknown>(columnReference: string): RawBuilder<R> {
  method val (line 413) | val<V>(value: V): RawBuilder<V> {
  method value (line 420) | value<V>(value: V): RawBuilder<V> {
  method table (line 424) | table<T = unknown>(tableReference: string): RawBuilder<T> {
  method id (line 431) | id<T = unknown>(...ids: readonly string[]): RawBuilder<T> {
  method lit (line 443) | lit<V>(value: V): RawBuilder<V> {
  method literal (line 450) | literal<V>(value: V): RawBuilder<V> {
  method raw (line 454) | raw<R = unknown>(sql: string): RawBuilder<R> {
  method join (line 461) | join<T = unknown>(
  function parseParameter (line 484) | function parseParameter(param: unknown): OperationNode {

FILE: src/schema/alter-column-builder.ts
  class AlterColumnBuilder (line 12) | class AlterColumnBuilder {
    method constructor (line 15) | constructor(column: string) {
    method setDataType (line 19) | setDataType(dataType: DataTypeExpression): AlteredColumnBuilder {
    method setDefault (line 29) | setDefault(value: DefaultValueExpression): AlteredColumnBuilder {
    method dropDefault (line 39) | dropDefault(): AlteredColumnBuilder {
    method setNotNull (line 45) | setNotNull(): AlteredColumnBuilder {
    method dropNotNull (line 51) | dropNotNull(): AlteredColumnBuilder {
    method $call (line 61) | $call<T>(func: (qb: this) => T): T {
  class AlteredColumnBuilder (line 95) | class AlteredColumnBuilder implements OperationNodeSource {
    method constructor (line 98) | constructor(alterColumnNode: AlterColumnNode) {
    method toOperationNode (line 102) | toOperationNode(): AlterColumnNode {
  type AlterColumnBuilderCallback (line 107) | type AlterColumnBuilderCallback = (

FILE: src/schema/alter-table-add-foreign-key-constraint-builder.ts
  class AlterTableAddForeignKeyConstraintBuilder (line 15) | class AlterTableAddForeignKeyConstraintBuilder
    method constructor (line 23) | constructor(props: AlterTableAddForeignKeyConstraintBuilderProps) {
    method onDelete (line 27) | onDelete(
    method onUpdate (line 36) | onUpdate(
    method deferrable (line 45) | deferrable(): AlterTableAddForeignKeyConstraintBuilder {
    method notDeferrable (line 52) | notDeferrable(): AlterTableAddForeignKeyConstraintBuilder {
    method initiallyDeferred (line 59) | initiallyDeferred(): AlterTableAddForeignKeyConstraintBuilder {
    method initiallyImmediate (line 66) | initiallyImmediate(): AlterTableAddForeignKeyConstraintBuilder {
    method $call (line 77) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 81) | toOperationNode(): AlterTableNode {
    method compile (line 92) | compile(): CompiledQuery {
    method execute (line 99) | async execute(): Promise<void> {
  type AlterTableAddForeignKeyConstraintBuilderProps (line 104) | interface AlterTableAddForeignKeyConstraintBuilderProps {

FILE: src/schema/alter-table-add-index-builder.ts
  class AlterTableAddIndexBuilder (line 17) | class AlterTableAddIndexBuilder
    method constructor (line 22) | constructor(props: AlterTableAddIndexBuilderProps) {
    method unique (line 46) | unique(): AlterTableAddIndexBuilder {
    method column (line 80) | column<CL extends string>(
    method columns (line 115) | columns<CL extends string>(
    method expression (line 150) | expression(expression: Expression<any>): AlterTableAddIndexBuilder {
    method using (line 183) | using(indexType: string): AlterTableAddIndexBuilder {
    method $call (line 198) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 202) | toOperationNode(): AlterTableNode {
    method compile (line 209) | compile(): CompiledQuery {
    method execute (line 216) | async execute(): Promise<void> {
  type AlterTableAddIndexBuilderProps (line 221) | interface AlterTableAddIndexBuilderProps {

FILE: src/schema/alter-table-builder.ts
  class AlterTableBuilder (line 62) | class AlterTableBuilder implements ColumnAlteringInterface {
    method constructor (line 65) | constructor(props: AlterTableBuilderProps) {
    method renameTo (line 69) | renameTo(newTableName: string): AlterTableExecutor {
    method setSchema (line 78) | setSchema(newSchema: string): AlterTableExecutor {
    method alterColumn (line 87) | alterColumn(
    method dropColumn (line 102) | dropColumn(column: string): AlterTableColumnAlteringBuilder {
    method renameColumn (line 112) | renameColumn(
    method addColumn (line 125) | addColumn(
    method modifyColumn (line 148) | modifyColumn(
    method addUniqueConstraint (line 174) | addUniqueConstraint(
    method addCheckConstraint (line 198) | addCheckConstraint(
    method addForeignKeyConstraint (line 229) | addForeignKeyConstraint(
    method addPrimaryKeyConstraint (line 256) | addPrimaryKeyConstraint(
    method dropConstraint (line 277) | dropConstraint(constraintName: string): AlterTableDropConstraintBuilder {
    method renameConstraint (line 286) | renameConstraint(
    method addIndex (line 317) | addIndex(indexName: string): AlterTableAddIndexBuilder {
    method dropIndex (line 343) | dropIndex(indexName: string): AlterTableExecutor {
    method $call (line 357) | $call<T>(func: (qb: this) => T): T {
  type AlterTableBuilderProps (line 362) | interface AlterTableBuilderProps {
  type ColumnAlteringInterface (line 368) | interface ColumnAlteringInterface {
  class AlterTableColumnAlteringBuilder (line 399) | class AlterTableColumnAlteringBuilder
    method constructor (line 404) | constructor(props: AlterTableColumnAlteringBuilderProps) {
    method alterColumn (line 408) | alterColumn(
    method dropColumn (line 423) | dropColumn(column: string): AlterTableColumnAlteringBuilder {
    method renameColumn (line 433) | renameColumn(
    method addColumn (line 446) | addColumn(
    method modifyColumn (line 469) | modifyColumn(
    method toOperationNode (line 492) | toOperationNode(): AlterTableNode {
    method compile (line 499) | compile(): CompiledQuery {
    method execute (line 506) | async execute(): Promise<void> {
  type AlterTableColumnAlteringBuilderProps (line 511) | interface AlterTableColumnAlteringBuilderProps extends AlterTableBuilder...

FILE: src/schema/alter-table-drop-constraint-builder.ts
  class AlterTableDropConstraintBuilder (line 10) | class AlterTableDropConstraintBuilder
    method constructor (line 15) | constructor(props: AlterTableDropConstraintBuilderProps) {
    method ifExists (line 19) | ifExists(): AlterTableDropConstraintBuilder {
    method cascade (line 33) | cascade(): AlterTableDropConstraintBuilder {
    method restrict (line 47) | restrict(): AlterTableDropConstraintBuilder {
    method $call (line 65) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 69) | toOperationNode(): AlterTableNode {
    method compile (line 76) | compile(): CompiledQuery {
    method execute (line 83) | async execute(): Promise<void> {
  type AlterTableDropConstraintBuilderProps (line 88) | interface AlterTableDropConstraintBuilderProps {

FILE: src/schema/alter-table-executor.ts
  class AlterTableExecutor (line 9) | class AlterTableExecutor implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: AlterTableExecutorProps) {
    method toOperationNode (line 16) | toOperationNode(): AlterTableNode {
    method compile (line 23) | compile(): CompiledQuery {
    method execute (line 30) | async execute(): Promise<void> {
  type AlterTableExecutorProps (line 35) | interface AlterTableExecutorProps {

FILE: src/schema/check-constraint-builder.ts
  class CheckConstraintBuilder (line 4) | class CheckConstraintBuilder implements OperationNodeSource {
    method constructor (line 7) | constructor(node: CheckConstraintNode) {
    method $call (line 15) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 19) | toOperationNode(): CheckConstraintNode {
  type CheckConstraintBuilderCallback (line 24) | type CheckConstraintBuilderCallback = (

FILE: src/schema/column-definition-builder.ts
  class ColumnDefinitionBuilder (line 19) | class ColumnDefinitionBuilder implements OperationNodeSource {
    method constructor (line 22) | constructor(node: ColumnDefinitionNode) {
    method autoIncrement (line 50) | autoIncrement(): ColumnDefinitionBuilder {
    method identity (line 80) | identity(): ColumnDefinitionBuilder {
    method primaryKey (line 108) | primaryKey(): ColumnDefinitionBuilder {
    method references (line 138) | references(ref: string): ColumnDefinitionBuilder {
    method onDelete (line 184) | onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder {
    method onUpdate (line 227) | onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder {
    method unique (line 262) | unique(): ColumnDefinitionBuilder {
    method notNull (line 288) | notNull(): ColumnDefinitionBuilder {
    method unsigned (line 316) | unsigned(): ColumnDefinitionBuilder {
    method defaultTo (line 366) | defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder {
    method check (line 398) | check(expression: Expression<any>): ColumnDefinitionBuilder {
    method generatedAlwaysAs (line 430) | generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder {
    method generatedAlwaysAsIdentity (line 464) | generatedAlwaysAsIdentity(): ColumnDefinitionBuilder {
    method generatedByDefaultAsIdentity (line 496) | generatedByDefaultAsIdentity(): ColumnDefinitionBuilder {
    method stored (line 530) | stored(): ColumnDefinitionBuilder {
    method modifyFront (line 572) | modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder {
    method nullsNotDistinct (line 606) | nullsNotDistinct(): ColumnDefinitionBuilder {
    method ifNotExists (line 630) | ifNotExists(): ColumnDefinitionBuilder {
    method modifyEnd (line 666) | modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder {
    method $call (line 679) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 683) | toOperationNode(): ColumnDefinitionNode {
  type ColumnDefinitionBuilderCallback (line 688) | type ColumnDefinitionBuilderCallback = (

FILE: src/schema/create-index-builder.ts
  class CreateIndexBuilder (line 28) | class CreateIndexBuilder<C = never>
    method constructor (line 33) | constructor(props: CreateIndexBuilderProps) {
    method ifNotExists (line 42) | ifNotExists(): CreateIndexBuilder<C> {
    method unique (line 54) | unique(): CreateIndexBuilder<C> {
    method nullsNotDistinct (line 85) | nullsNotDistinct(): CreateIndexBuilder<C> {
    method on (line 97) | on(table: string): CreateIndexBuilder<C> {
    method column (line 129) | column<CL extends string>(
    method columns (line 162) | columns<CL extends string>(
    method expression (line 195) | expression(expression: Expression<any>): CreateIndexBuilder<C> {
    method using (line 209) | using(indexType: string): CreateIndexBuilder<C> {
    method where (line 266) | where(...args: any[]): any {
    method $call (line 285) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 289) | toOperationNode(): CreateIndexNode {
    method compile (line 296) | compile(): CompiledQuery {
    method execute (line 303) | async execute(): Promise<void> {
  type CreateIndexBuilderProps (line 308) | interface CreateIndexBuilderProps {

FILE: src/schema/create-schema-builder.ts
  class CreateSchemaBuilder (line 9) | class CreateSchemaBuilder implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: CreateSchemaBuilderProps) {
    method ifNotExists (line 16) | ifNotExists(): CreateSchemaBuilder {
    method $call (line 27) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 31) | toOperationNode(): CreateSchemaNode {
    method compile (line 38) | compile(): CompiledQuery {
    method execute (line 45) | async execute(): Promise<void> {
  type CreateSchemaBuilderProps (line 50) | interface CreateSchemaBuilderProps {

FILE: src/schema/create-table-builder.ts
  class CreateTableBuilder (line 46) | class CreateTableBuilder<TB extends string, C extends string = never>
    method constructor (line 51) | constructor(props: CreateTableBuilderProps) {
    method temporary (line 60) | temporary(): CreateTableBuilder<TB, C> {
    method onCommit (line 75) | onCommit(onCommit: OnCommitAction): CreateTableBuilder<TB, C> {
    method ifNotExists (line 89) | ifNotExists(): CreateTableBuilder<TB, C> {
    method addColumn (line 152) | addColumn<CN extends string>(
    method addPrimaryKeyConstraint (line 192) | addPrimaryKeyConstraint(
    method addUniqueConstraint (line 247) | addUniqueConstraint(
    method addCheckConstraint (line 285) | addCheckConstraint(
    method addForeignKeyConstraint (line 346) | addForeignKeyConstraint(
    method modifyFront (line 402) | modifyFront(modifier: Expression<any>): CreateTableBuilder<TB, C> {
    method modifyEnd (line 441) | modifyEnd(modifier: Expression<any>): CreateTableBuilder<TB, C> {
    method as (line 471) | as(expression: Expression<unknown>): CreateTableBuilder<TB, C> {
    method $call (line 514) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 518) | toOperationNode(): CreateTableNode {
    method compile (line 525) | compile(): CompiledQuery {
    method execute (line 532) | async execute(): Promise<void> {
  type CreateTableBuilderProps (line 537) | interface CreateTableBuilderProps {
  type ColumnBuilderCallback (line 543) | type ColumnBuilderCallback = (

FILE: src/schema/create-type-builder.ts
  class CreateTypeBuilder (line 9) | class CreateTypeBuilder implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: CreateTypeBuilderProps) {
    method toOperationNode (line 16) | toOperationNode(): CreateTypeNode {
    method asEnum (line 32) | asEnum(values: readonly string[]): CreateTypeBuilder {
    method $call (line 43) | $call<T>(func: (qb: this) => T): T {
    method compile (line 47) | compile(): CompiledQuery {
    method execute (line 54) | async execute(): Promise<void> {
  type CreateTypeBuilderProps (line 59) | interface CreateTypeBuilderProps {

FILE: src/schema/create-view-builder.ts
  class CreateViewBuilder (line 13) | class CreateViewBuilder implements OperationNodeSource, Compilable {
    method constructor (line 16) | constructor(props: CreateViewBuilderProps) {
    method temporary (line 25) | temporary(): CreateViewBuilder {
    method materialized (line 34) | materialized(): CreateViewBuilder {
    method ifNotExists (line 46) | ifNotExists(): CreateViewBuilder {
    method orReplace (line 55) | orReplace(): CreateViewBuilder {
    method columns (line 64) | columns(columns: string[]): CreateViewBuilder {
    method as (line 82) | as(
    method $call (line 101) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 105) | toOperationNode(): CreateViewNode {
    method compile (line 112) | compile(): CompiledQuery {
    method execute (line 119) | async execute(): Promise<void> {
  type CreateViewBuilderProps (line 124) | interface CreateViewBuilderProps {

FILE: src/schema/drop-index-builder.ts
  class DropIndexBuilder (line 10) | class DropIndexBuilder implements OperationNodeSource, Compilable {
    method constructor (line 13) | constructor(props: DropIndexBuilderProps) {
    method on (line 21) | on(table: string): DropIndexBuilder {
    method ifExists (line 30) | ifExists(): DropIndexBuilder {
    method cascade (line 39) | cascade(): DropIndexBuilder {
    method $call (line 52) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 56) | toOperationNode(): DropIndexNode {
    method compile (line 63) | compile(): CompiledQuery {
    method execute (line 70) | async execute(): Promise<void> {
  type DropIndexBuilderProps (line 75) | interface DropIndexBuilderProps {

FILE: src/schema/drop-schema-builder.ts
  class DropSchemaBuilder (line 9) | class DropSchemaBuilder implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: DropSchemaBuilderProps) {
    method ifExists (line 16) | ifExists(): DropSchemaBuilder {
    method cascade (line 25) | cascade(): DropSchemaBuilder {
    method $call (line 38) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 42) | toOperationNode(): DropSchemaNode {
    method compile (line 49) | compile(): CompiledQuery {
    method execute (line 56) | async execute(): Promise<void> {
  type DropSchemaBuilderProps (line 61) | interface DropSchemaBuilderProps {

FILE: src/schema/drop-table-builder.ts
  class DropTableBuilder (line 9) | class DropTableBuilder implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: DropTableBuilderProps) {
    method ifExists (line 16) | ifExists(): DropTableBuilder {
    method cascade (line 25) | cascade(): DropTableBuilder {
    method $call (line 38) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 42) | toOperationNode(): DropTableNode {
    method compile (line 49) | compile(): CompiledQuery {
    method execute (line 56) | async execute(): Promise<void> {
  type DropTableBuilderProps (line 61) | interface DropTableBuilderProps {

FILE: src/schema/drop-type-builder.ts
  class DropTypeBuilder (line 9) | class DropTypeBuilder implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: DropTypeBuilderProps) {
    method ifExists (line 16) | ifExists(): DropTypeBuilder {
    method $call (line 29) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 33) | toOperationNode(): DropTypeNode {
    method compile (line 40) | compile(): CompiledQuery {
    method execute (line 47) | async execute(): Promise<void> {
  type DropTypeBuilderProps (line 52) | interface DropTypeBuilderProps {

FILE: src/schema/drop-view-builder.ts
  class DropViewBuilder (line 9) | class DropViewBuilder implements OperationNodeSource, Compilable {
    method constructor (line 12) | constructor(props: DropViewBuilderProps) {
    method materialized (line 16) | materialized(): DropViewBuilder {
    method ifExists (line 25) | ifExists(): DropViewBuilder {
    method cascade (line 34) | cascade(): DropViewBuilder {
    method $call (line 47) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 51) | toOperationNode(): DropViewNode {
    method compile (line 58) | compile(): CompiledQuery {
    method execute (line 65) | async execute(): Promise<void> {
  type DropViewBuilderProps (line 70) | interface DropViewBuilderProps {

FILE: src/schema/foreign-key-constraint-builder.ts
  type ForeignKeyConstraintBuilderInterface (line 6) | interface ForeignKeyConstraintBuilderInterface<R> {
  class ForeignKeyConstraintBuilder (line 15) | class ForeignKeyConstraintBuilder
    method constructor (line 22) | constructor(node: ForeignKeyConstraintNode) {
    method onDelete (line 26) | onDelete(onDelete: OnModifyForeignAction): ForeignKeyConstraintBuilder {
    method onUpdate (line 34) | onUpdate(onUpdate: OnModifyForeignAction): ForeignKeyConstraintBuilder {
    method deferrable (line 42) | deferrable(): ForeignKeyConstraintBuilder {
    method notDeferrable (line 48) | notDeferrable(): ForeignKeyConstraintBuilder {
    method initiallyDeferred (line 54) | initiallyDeferred(): ForeignKeyConstraintBuilder {
    method initiallyImmediate (line 62) | initiallyImmediate(): ForeignKeyConstraintBuilder {
    method $call (line 74) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 78) | toOperationNode(): ForeignKeyConstraintNode {
  type ForeignKeyConstraintBuilderCallback (line 83) | type ForeignKeyConstraintBuilderCallback = (

FILE: src/schema/primary-key-constraint-builder.ts
  class PrimaryKeyConstraintBuilder (line 4) | class PrimaryKeyConstraintBuilder implements OperationNodeSource {
    method constructor (line 7) | constructor(node: PrimaryKeyConstraintNode) {
    method deferrable (line 11) | deferrable(): PrimaryKeyConstraintBuilder {
    method notDeferrable (line 17) | notDeferrable(): PrimaryKeyConstraintBuilder {
    method initiallyDeferred (line 23) | initiallyDeferred(): PrimaryKeyConstraintBuilder {
    method initiallyImmediate (line 31) | initiallyImmediate(): PrimaryKeyConstraintBuilder {
    method $call (line 43) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 47) | toOperationNode(): PrimaryKeyConstraintNode {
  type PrimaryKeyConstraintBuilderCallback (line 52) | type PrimaryKeyConstraintBuilderCallback = (

FILE: src/schema/refresh-materialized-view-builder.ts
  class RefreshMaterializedViewBuilder (line 9) | class RefreshMaterializedViewBuilder
    method constructor (line 14) | constructor(props: RefreshMaterializedViewBuilderProps) {
    method concurrently (line 26) | concurrently(): RefreshMaterializedViewBuilder {
    method withData (line 41) | withData(): RefreshMaterializedViewBuilder {
    method withNoData (line 58) | withNoData(): RefreshMaterializedViewBuilder {
    method $call (line 72) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 76) | toOperationNode(): RefreshMaterializedViewNode {
    method compile (line 83) | compile(): CompiledQuery {
    method execute (line 90) | async execute(): Promise<void> {
  type RefreshMaterializedViewBuilderProps (line 95) | interface RefreshMaterializedViewBuilderProps {

FILE: src/schema/schema.ts
  class SchemaModule (line 35) | class SchemaModule {
    method constructor (line 38) | constructor(executor: QueryExecutor) {
    method createTable (line 93) | createTable<TB extends string>(table: TB): CreateTableBuilder<TB, neve...
    method dropTable (line 112) | dropTable(table: string): DropTableBuilder {
    method createIndex (line 133) | createIndex(indexName: string): CreateIndexBuilder {
    method dropIndex (line 152) | dropIndex(indexName: string): DropIndexBuilder {
    method createSchema (line 171) | createSchema(schema: string): CreateSchemaBuilder {
    method dropSchema (line 190) | dropSchema(schema: string): DropSchemaBuilder {
    method alterTable (line 210) | alterTable(table: string): AlterTableBuilder {
    method createView (line 231) | createView(viewName: string): CreateViewBuilder {
    method refreshMaterializedView (line 251) | refreshMaterializedView(viewName: string): RefreshMaterializedViewBuil...
    method dropView (line 271) | dropView(viewName: string): DropViewBuilder {
    method createType (line 293) | createType(typeName: string): CreateTypeBuilder {
    method dropType (line 315) | dropType(typeName: string): DropTypeBuilder {
    method withPlugin (line 326) | withPlugin(plugin: KyselyPlugin): SchemaModule {
    method withoutPlugins (line 333) | withoutPlugins(): SchemaModule {
    method withSchema (line 340) | withSchema(schema: string): SchemaModule {

FILE: src/schema/unique-constraint-builder.ts
  class UniqueConstraintNodeBuilder (line 4) | class UniqueConstraintNodeBuilder implements OperationNodeSource {
    method constructor (line 7) | constructor(node: UniqueConstraintNode) {
    method nullsNotDistinct (line 16) | nullsNotDistinct(): UniqueConstraintNodeBuilder {
    method deferrable (line 22) | deferrable(): UniqueConstraintNodeBuilder {
    method notDeferrable (line 28) | notDeferrable(): UniqueConstraintNodeBuilder {
    method initiallyDeferred (line 34) | initiallyDeferred(): UniqueConstraintNodeBuilder {
    method initiallyImmediate (line 42) | initiallyImmediate(): UniqueConstraintNodeBuilder {
    method $call (line 54) | $call<T>(func: (qb: this) => T): T {
    method toOperationNode (line 58) | toOperationNode(): UniqueConstraintNode {
  type UniqueConstraintNodeBuilderCallback (line 63) | type UniqueConstraintNodeBuilderCallback = (

FILE: src/util/assert.ts
  function assertNotNullOrUndefined (line 1) | function assertNotNullOrUndefined<T>(
  function assertIsString (line 9) | function assertIsString(value: any): asserts value is string {

FILE: src/util/column-type.ts
  type ColumnType (line 38) | type ColumnType<
  type Generated (line 57) | type Generated<S> = ColumnType<S, S | undefined, S>
  type GeneratedAlways (line 64) | type GeneratedAlways<S> = ColumnType<S, never, never>
  type JSONColumnType (line 70) | type JSONColumnType<
  type IfNullable (line 79) | type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : n...
  type IfNotNullable (line 84) | type IfNotNullable<T, K> = undefined extends T
  type IfNotNever (line 95) | type IfNotNever<T, K> = T extends never ? never : K
  type SelectType (line 97) | type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T
  type InsertType (line 98) | type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T
  type UpdateType (line 99) | type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T
  type NullableInsertKeys (line 104) | type NullableInsertKeys<R> = {
  type NonNullableInsertKeys (line 111) | type NonNullableInsertKeys<R> = {
  type NonNeverSelectKeys (line 118) | type NonNeverSelectKeys<R> = {
  type UpdateKeys (line 125) | type UpdateKeys<R> = {
  type Selectable (line 150) | type Selectable<R> = DrainOuterGeneric<{
  type Insertable (line 175) | type Insertable<R> = DrainOuterGeneric<
  type Updateable (line 203) | type Updateable<R> = DrainOuterGeneric<{

FILE: src/util/compilable.ts
  type Compilable (line 4) | interface Compilable<O = unknown> {
  function isCompilable (line 8) | function isCompilable(value: unknown): value is Compilable {

FILE: src/util/deferred.ts
  class Deferred (line 1) | class Deferred<T> {
    method constructor (line 7) | constructor() {
    method promise (line 14) | get promise(): Promise<T> {

FILE: src/util/explainable.ts
  type ExplainFormat (line 3) | type ExplainFormat =
  type Explainable (line 11) | interface Explainable {

FILE: src/util/infer-result.ts
  type InferResult (line 47) | type InferResult<C extends Compilable<any> | CompiledQuery<any>> =
  type ResolveResult (line 54) | type ResolveResult<O> = O extends

FILE: src/util/json-object-args.ts
  function getJsonObjectArgs (line 11) | function getJsonObjectArgs(
  function colName (line 35) | function colName(col: string): Expression<unknown> {
  function colRef (line 39) | function colRef(table: string, col: string): Expression<unknown> {

FILE: src/util/log-once.ts
  constant LOGGED_MESSAGES (line 1) | const LOGGED_MESSAGES: Set<string> = new Set()
  function logOnce (line 7) | function logOnce(message: string): void {

FILE: src/util/log.ts
  constant LOG_LEVELS (line 6) | const LOG_LEVELS: Readonly<typeof logLevels> = freeze(logLevels)
  type LogLevel (line 8) | type LogLevel = ArrayItemType<typeof LOG_LEVELS>
  type QueryLogEvent (line 10) | interface QueryLogEvent {
  type ErrorLogEvent (line 17) | interface ErrorLogEvent {
  type LogEvent (line 24) | type LogEvent = QueryLogEvent | ErrorLogEvent
  type Logger (line 25) | type Logger = (event: LogEvent) => void | Promise<void>
  type LogConfig (line 26) | type LogConfig = ReadonlyArray<LogLevel> | Logger
  class Log (line 28) | class Log {
    method constructor (line 32) | constructor(config: LogConfig) {
    method isLevelEnabled (line 50) | isLevelEnabled(level: LogLevel): boolean {
    method query (line 54) | async query(getEvent: () => QueryLogEvent) {
    method error (line 60) | async error(getEvent: () => ErrorLogEvent) {
  function defaultLogger (line 67) | function defaultLogger(event: LogEvent): void {

FILE: src/util/object-utils.ts
  function isEmpty (line 3) | function isEmpty(obj: ArrayLike<unknown> | string | object): boolean {
  function isUndefined (line 13) | function isUndefined(obj: unknown): obj is undefined {
  function isString (line 17) | function isString(obj: unknown): obj is string {
  function isNumber (line 21) | function isNumber(obj: unknown): obj is number {
  function isBoolean (line 25) | function isBoolean(obj: unknown): obj is boolean {
  function isNull (line 29) | function isNull(obj: unknown): obj is null {
  function isDate (line 33) | function isDate(obj: unknown): obj is Date {
  function isBigInt (line 37) | function isBigInt(obj: unknown): obj is bigint {
  function isBuffer (line 43) | function isBuffer(obj: unknown): obj is { length: number } {
  function isFunction (line 47) | function isFunction(obj: unknown): obj is Function {
  function isObject (line 51) | function isObject(obj: unknown): obj is ShallowRecord<string, unknown> {
  function isArrayBufferOrView (line 55) | function isArrayBufferOrView(
  function isPlainObject (line 61) | function isPlainObject(obj: unknown): obj is Record<string, unknown> {
  function getLast (line 78) | function getLast<T>(arr: ArrayLike<T>): T | undefined {
  function freeze (line 82) | function freeze<T>(obj: T): Readonly<T> {
  function asArray (line 86) | function asArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T> {
  function asReadonlyArray (line 94) | function asReadonlyArray<T>(
  function isReadonlyArray (line 104) | function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown> {
  function noop (line 108) | function noop<T>(obj: T): T {
  function compare (line 112) | function compare(obj1: unknown, obj2: unknown): boolean {
  function compareArrays (line 122) | function compareArrays(
  function compareObjects (line 139) | function compareObjects(
  function compareBuffers (line 152) | function compareBuffers(buf1: unknown, buf2: unknown): boolean {
  function compareDates (line 156) | function compareDates(date1: Date, date2: Date) {
  function compareGenericObjects (line 160) | function compareGenericObjects(
  function getTag (line 182) | function getTag(value: unknown): string {

FILE: src/util/performance-now.ts
  function performanceNow (line 3) | function performanceNow() {

FILE: src/util/provide-controlled-connection.ts
  type ControlledConnection (line 6) | interface ControlledConnection {
  function provideControlledConnection (line 11) | async function provideControlledConnection(

FILE: src/util/query-id.ts
  type QueryId (line 3) | interface QueryId {
  function createQueryId (line 7) | function createQueryId(): QueryId {
  class LazyQueryId (line 11) | class LazyQueryId implements QueryId {
    method queryId (line 14) | get queryId(): string {

FILE: src/util/random-string.ts
  constant CHARS (line 1) | const CHARS = [
  function randomString (line 66) | function randomString(length: number): string {
  function randomChar (line 76) | function randomChar() {

FILE: src/util/require-all-props.ts
  type AllProps (line 6) | type AllProps<T> = T & { [P in keyof T]-?: unknown }
  function requireAllProps (line 43) | function requireAllProps<T>(obj: AllProps<T>): T {

FILE: src/util/stack-trace-utils.ts
  function extendStackTrace (line 3) | function extendStackTrace(err: unknown, stackError: Error): unknown {
  type StackHolder (line 15) | interface StackHolder {
  function isStackHolder (line 19) | function isStackHolder(obj: unknown): obj is StackHolder {

FILE: src/util/streamable.ts
  type Streamable (line 1) | interface Streamable<O> {

FILE: src/util/type-error.ts
  type KyselyTypeError (line 1) | interface KyselyTypeError<E extends string> {

FILE: src/util/type-utils.ts
  type AnyColumn (line 38) | type AnyColumn<DB, TB extends keyof DB> = {
  type ExtractColumnType (line 46) | type ExtractColumnType<DB, TB extends keyof DB, C> = {
  type AnyColumnWithTable (line 81) | type AnyColumnWithTable<DB, TB extends keyof DB> = {
  type AnyAliasedColumn (line 88) | type AnyAliasedColumn<DB, TB extends keyof DB> = `${AnyColumn<
  type AnyAliasedColumnWithTable (line 96) | type AnyAliasedColumnWithTable<
  type ArrayItemType (line 104) | type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never
  type SimplifySingleResult (line 106) | type SimplifySingleResult<O> = O extends InsertResult
  type SimplifyResult (line 116) | type SimplifyResult<O> = O extends InsertResult
  type Simplify (line 126) | type Simplify<T> = DrainOuterGeneric<{ [K in keyof T]: T[K] } & {}>
  type UnknownRow (line 131) | type UnknownRow = Record<string, unknown>
  type Nullable (line 136) | type Nullable<T> = { [P in keyof T]: T[P] | null }
  type IsNever (line 141) | type IsNever<T> = [T] extends [never] ? true : false
  type IsAny (line 146) | type IsAny<T> = 0 extends T & 1 ? true : false
  type Equals (line 151) | type Equals<T, U> =
  type NarrowPartial (line 156) | type NarrowPartial<O, T> = DrainOuterGeneric<
  type NotNull (line 185) | type NotNull = { readonly __notNull__: unique symbol }
  type SqlBool (line 187) | type SqlBool = boolean | 0 | 1
  type DrainOuterGeneric (line 216) | type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never
  type ShallowRecord (line 218) | type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
  type ShallowDehydrateObject (line 227) | type ShallowDehydrateObject<O> = {
  type ShallowDehydrateValue (line 237) | type ShallowDehydrateValue<T> = T extends null | undefined
  type StringsWhenDataTypeNotAvailable (line 253) | type StringsWhenDataTypeNotAvailable =
  type NumbersWhenDataTypeNotAvailable (line 260) | type NumbersWhenDataTypeNotAvailable = bigint | NumericString
  type NumericString (line 262) | type NumericString = `${number}`

FILE: test/browser/main.ts
  type Person (line 10) | interface Person {
  type Database (line 16) | interface Database {
  method createAdapter (line 22) | createAdapter() {
  method createDriver (line 25) | createDriver() {
  method createIntrospector (line 28) | createIntrospector(db: Kysely<any>) {
  method createQueryCompiler (line 31) | createQueryCompiler() {

FILE: test/browser/test.js
  constant EXPECTED_SQL (line 11) | const EXPECTED_SQL = 'select "id" from "person"'

FILE: test/bun/bun.test.ts
  type Person (line 14) | interface Person {
  type Database (line 20) | interface Database {

FILE: test/cloudflare-workers/api.ts
  type Person (line 5) | interface Person {
  type Database (line 11) | interface Database {

FILE: test/deno/cdn.test.ts
  type Person (line 5) | interface Person {
  type Database (line 11) | interface Database {

FILE: test/deno/local.test.ts
  type Person (line 11) | interface Person {
  type Database (line 17) | interface Database {

FILE: test/node/src/aggregate-function.test.ts
  function getAggregateFunctionFromTestContext (line 1202) | function getAggregateFunctionFromTestContext<TB extends keyof Database>(
  function getAggregateFunctionFromExpressionBuilder (line 1209) | function getAggregateFunctionFromExpressionBuilder<TB extends keyof Data...
  type AggregateFunction (line 1216) | type AggregateFunction<

FILE: test/node/src/array.test.ts
  type PersonWithArrays (line 15) | interface PersonWithArrays extends Person {

FILE: test/node/src/async-dispose.test.ts
  method acquireConnection (line 26) | async acquireConnection() {
  method destroy (line 37) | async destroy(): Promise<void> {
  method compileQuery (line 44) | compileQuery(

FILE: test/node/src/camel-case.test.ts
  type CamelPerson (line 26) | interface CamelPerson {
  type CamelDatabase (line 36) | interface CamelDatabase {
  function json (line 397) | function json<T>(obj: T): RawBuilder<T> {

FILE: test/node/src/controlled-transaction.test.ts
  method log (line 48) | log(event) {
  method createDriver (line 637) | createDriver(): Driver {
  function insertSomething (line 691) | async function insertSomething(db: Kysely<Database>) {
  function insertSomethingElse (line 702) | async function insertSomethingElse(db: Kysely<Database>) {

FILE: test/node/src/execute.test.ts
  class MyNotFoundError (line 79) | class MyNotFoundError extends Error {
    method constructor (line 82) | constructor(node: QueryNode) {

FILE: test/node/src/insert.test.ts
  function getNewestPerson (line 1137) | async function getNewestPerson(
  function values (line 1152) | function values<R extends Record<string, unknown>, A extends string>(

FILE: test/node/src/introspect.test.ts
  function createView (line 876) | async function createView() {
  function dropView (line 883) | async function dropView() {
  function createSchema (line 887) | async function createSchema() {
  function dropSchema (line 930) | async function dropSchema() {

FILE: test/node/src/json-traversal.test.ts
  type TestContext (line 20) | type TestContext = Awaited<ReturnType<typeof initJSONTest>>
  function initJSONTest (line 726) | async function initJSONTest<D extends BuiltInDialect>(
  function resolveJSONColumnDataType (line 778) | function resolveJSONColumnDataType(dialect: BuiltInDialect) {
  function insertDefaultJSONDataSet (line 791) | async function insertDefaultJSONDataSet(ctx: TestContext) {
  function clearJSONDatabase (line 837) | async function clearJSONDatabase(ctx: TestContext) {
  function destroyJSONTest (line 842) | async function destroyJSONTest(ctx: TestContext) {

FILE: test/node/src/json.test.ts
  type JsonTable (line 44) | interface JsonTable {
  function toJson (line 590) | function toJson<T>(obj: T): RawBuilder<T> {

FILE: test/node/src/logging.test.ts
  function getKysely (line 165) | function getKysely(
  function run (line 190) | async function run(db: Kysely<Database>) {

FILE: test/node/src/migration.test.ts
  constant CUSTOM_MIGRATION_SCHEMA (line 28) | const CUSTOM_MIGRATION_SCHEMA = 'migrate'
  constant CUSTOM_MIGRATION_TABLE (line 29) | const CUSTOM_MIGRATION_TABLE = 'custom_migrations'
  constant CUSTOM_MIGRATION_LOCK_TABLE (line 30) | const CUSTOM_MIGRATION_LOCK_TABLE = 'custom_migrations_lock'
  function dropTestMigrationTables (line 349) | async function dropTestMigrationTables(): Promise<void> {
  function deleteMigrationTables (line 1020) | async function deleteMigrationTables(): Promise<void> {
  function createMigrations (line 1051) | function createMigrations(
  function doesTableExists (line 1104) | async function doesTableExists(
  function sleep (line 1114) | function sleep(millis: number): Promise<void> {
  function getMessage (line 1120) | function getMessage(obj: unknown): string | undefined {
  function isObject (line 1126) | function isObject(obj: unknown): obj is Record<string, unknown> {

FILE: test/node/src/object-util.test.ts
  class SomeClass (line 7) | class SomeClass {}

FILE: test/node/src/performance.test.ts
  function test (line 33) | function test() {

FILE: test/node/src/query-id.test.ts
  method acquireConnection (line 22) | async acquireConnection(): Promise<DatabaseConnection> {
  method compileQuery (line 38) | compileQuery(node: RootOperationNode, queryId: QueryId) {
  function checkIn (line 72) | function checkIn(queryId: QueryId, place: string): void {

FILE: test/node/src/replace.test.ts
  function getNewestPerson (line 211) | async function getNewestPerson(

FILE: test/node/src/schema.test.ts
  function cleanup (line 2138) | async function cleanup() {
  function cleanup (line 2388) | async function cleanup() {
  function cleanup (line 2484) | async function cleanup() {
  function cleanup (line 2513) | async function cleanup() {
  function cleanup (line 2558) | async function cleanup() {
  function cleanup (line 3771) | async function cleanup() {
  function dropTestTables (line 3961) | async function dropTestTables(): Promise<void> {
  function getColumnMeta (line 3966) | async function getColumnMeta(ref: string): Promise<ColumnMetadata> {

FILE: test/node/src/sql-injection.test.ts
  function assertDidNotDropTable (line 127) | async function assertDidNotDropTable(ctx: TestContext, tableName: string) {

FILE: test/node/src/stream.test.ts
  constant CHUNK_SIZE (line 14) | const CHUNK_SIZE = 10
  constant DIALECT (line 15) | const DIALECT = 'mssql'
  constant ITEM_COUNT (line 16) | const ITEM_COUNT = 100
  constant TABLE (line 17) | const TABLE = 'stream_test'

FILE: test/node/src/test-migrations/migration1.ts
  function up (line 3) | async function up(db: Kysely<any>): Promise<void> {
  function down (line 10) | async function down(db: Kysely<any>): Promise<void> {

FILE: test/node/src/test-migrations/migration2.ts
  function up (line 3) | async function up(db: Kysely<any>): Promise<void> {

FILE: test/node/src/test-setup.ts
  type Gender (line 43) | type Gender = 'male' | 'female' | 'other'
  type MaritalStatus (line 44) | type MaritalStatus = 'single' | 'married' | 'divorced' | 'widowed'
  type Species (line 45) | type Species = 'dog' | 'cat' | 'hamster'
  type Person (line 47) | interface Person {
  type Pet (line 57) | interface Pet {
  type Toy (line 64) | interface Toy {
  type Database (line 71) | interface Database {
  type PersonInsertParams (line 78) | interface PersonInsertParams extends InsertObject<Database, 'person'> {
  type PetInsertParams (line 82) | interface PetInsertParams extends Omit<Pet, 'id' | 'owner_id'> {
  type TestContext (line 86) | interface TestContext {
  type BuiltInDialect (line 92) | type BuiltInDialect = 'postgres' | 'mysql' | 'mssql' | 'sqlite'
  type PerDialect (line 93) | type PerDialect<T> = Record<BuiltInDialect, T>
  constant DIALECTS (line 95) | const DIALECTS: BuiltInDialect[] = (
  constant TEST_INIT_TIMEOUT (line 105) | const TEST_INIT_TIMEOUT = 5 * 60 * 1000
  constant NOT_SUPPORTED (line 108) | const NOT_SUPPORTED = { sql: '', parameters: [] }
  constant PLUGINS (line 110) | const PLUGINS: KyselyPlugin[] = []
  constant POOL_SIZE (line 120) | const POOL_SIZE = 20
  constant POSTGRES_CONFIG (line 122) | const POSTGRES_CONFIG: PoolConfig = {
  constant MYSQL_CONFIG (line 130) | const MYSQL_CONFIG: PoolOptions = {
  constant MSSQL_CONFIG (line 146) | const MSSQL_CONFIG: ConnectionConfiguration = {
  constant SQLITE_CONFIG (line 163) | const SQLITE_CONFIG = {
  constant DIALECT_CONFIGS (line 167) | const DIALECT_CONFIGS = {
  constant DB_CONFIGS (line 174) | const DB_CONFIGS: PerDialect<KyselyConfig> = {
  function initTest (line 221) | async function initTest(
  function destroyTest (line 235) | async function destroyTest(ctx: TestContext): Promise<void> {
  function insertPersons (line 240) | async function insertPersons(
  constant DEFAULT_DATA_SET (line 258) | const DEFAULT_DATA_SET: PersonInsertParams[] = [
  function insertDefaultDataSet (line 282) | async function insertDefaultDataSet(ctx: TestContext): Promise<void> {
  function clearDatabase (line 286) | async function clearDatabase(ctx: TestContext): Promise<void> {
  function testSql (line 292) | function testSql(
  function createDatabase (line 318) | async function createDatabase(
  function createTableWithId (line 383) | function createTableWithId(
  function connect (line 409) | async function connect(config: KyselyConfig): Promise<Kysely<Database>> {
  function dropDatabase (line 435) | async function dropDatabase(db: Kysely<Database>): Promise<void> {
  function insertPetForPerson (line 443) | async function insertPetForPerson(
  function insertToysForPet (line 460) | async function insertToysForPet(
  function insert (line 471) | async function insert<TB extends keyof Database>(
  function createNoopTransformerPlugin (line 497) | function createNoopTransformerPlugin(): KyselyPlugin {
  function sleep (line 513) | function sleep(millis: number): Promise<void> {
  function limit (line 517) | function limit<QB extends SelectQueryBuilder<any, any, any>>(
  function orderBy (line 530) | function orderBy<QB extends SelectQueryBuilder<any, any, any>>(

FILE: test/node/src/transaction.test.ts
  method log (line 42) | log(event) {
  function executeThread (line 230) | async function executeThread(id: number, fails: boolean): Promise<void> {
  function insertPet (line 346) | async function insertPet(
  function insertPerson (line 360) | async function insertPerson(
  function doesPersonExists (line 385) | async function doesPersonExists(id: number): Promise<boolean> {
  function doesPetExists (line 394) | async function doesPetExists(ownerId: number): Promise<boolean> {

FILE: test/node/src/with-schema.test.ts
  function createTables (line 653) | async function createTables(): Promise<void> {
  function dropTables (line 682) | async function dropTables(): Promise<void> {

FILE: test/outdated-ts/outdated-ts.test.ts
  function expectOutdatedTSError (line 4) | function expectOutdatedTSError(

FILE: test/typings/shared.d.ts
  type Pet (line 8) | interface Pet {
  type Toy (line 15) | interface Toy {
  type Movie (line 21) | interface Movie {
  type Book (line 26) | interface Book {
  type Database (line 31) | interface Database {
  type Action (line 42) | type Action =
  type Person (line 56) | interface Person {
  type PersonMetadata (line 71) | interface PersonMetadata {

FILE: test/typings/test-d/aggregate-function.test-d.ts
  function testSelectWithoutAs (line 10) | async function testSelectWithoutAs(db: Kysely<Database>) {
  function testSelectWithDefaultGenerics (line 80) | async function testSelectWithDefaultGenerics(db: Kysely<Database>) {
  function testSelectExpressionBuilderWithDefaultGenerics (line 110) | async function testSelectExpressionBuilderWithDefaultGenerics(
  function testSelectExpressionBuilderWithCustomGenerics (line 142) | async function testSelectExpressionBuilderWithCustomGenerics(
  function testSelectExpressionBuilderWithSubExpressions (line 169) | async function testSelectExpressionBuilderWithSubExpressions(
  function testSelectWithCustomGenerics (line 195) | async function testSelectWithCustomGenerics(db: Kysely<Database>) {
  function testSelectUnexpectedColumn (line 233) | async function testSelectUnexpectedColumn(db: Kysely<Database>) {
  function testSelectWithDynamicReference (line 307) | async function testSelectWithDynamicReference(db: Kysely<Database>) {
  function testSelectWithDistinct (line 362) | async function testSelectWithDistinct(db: Kysely<Database>) {
  function testWithFilterWhere (line 381) | async function testWithFilterWhere(db: Kysely<Database>) {
  function testWithFilterWhereRef (line 536) | async function testWithFilterWhereRef(db: Kysely<Database>) {
  function testSelectWithOver (line 684) | async function testSelectWithOver(db: Kysely<Database>) {
  function testSelectWithOverAndPartitionBySingle (line 703) | async function testSelectWithOverAndPartitionBySingle(db: Kysely<Databas...
  function testSelectWithOverAndPartitionByMultiple (line 742) | async function testSelectWithOverAndPartitionByMultiple(db: Kysely<Datab...
  function testSelectWithOverAndPartitionByUnexpectedColumns (line 789) | async function testSelectWithOverAndPartitionByUnexpectedColumns(
  function testSelectWithOverAndOrderBySingle (line 896) | async function testSelectWithOverAndOrderBySingle(db: Kysely<Database>) {
  function testSelectWithOverAndOrderByMultiple (line 935) | async function testSelectWithOverAndOrderByMultiple(db: Kysely<Database>) {
  function testSelectWithOverAndOrderByUnexpectedColumns (line 974) | async function testSelectWithOverAndOrderByUnexpectedColumns(
  function testSelectAsCustomFunctionArgument (line 1031) | async function testSelectAsCustomFunctionArgument(db: Kysely<Database>) {
  type DB764 (line 1090) | interface DB764 {
  type OrderDetails764 (line 1095) | interface OrderDetails764 {
  type Order764 (line 1104) | interface Order764 {
  type ItemType764 (line 1108) | enum ItemType764 {
  function testIssue764 (line 1114) | async function testIssue764(db: Kysely<DB764>) {

FILE: test/typings/test-d/alter-table.test-d.ts
  function testAlterTableWithAddUniqueConstraint (line 6) | async function testAlterTableWithAddUniqueConstraint(db: Kysely<Database...

FILE: test/typings/test-d/assert-type.test-d.ts
  function testAssertType (line 5) | async function testAssertType(db: Kysely<Database>) {

FILE: test/typings/test-d/case.test-d.ts
  function testCase (line 5) | async function testCase(eb: ExpressionBuilder<Database, 'person'>) {
  function testCaseValue (line 114) | function testCaseValue(eb: ExpressionBuilder<Database, 'person'>) {

FILE: test/typings/test-d/clear.test-d.ts
  function testClearSelect (line 5) | async function testClearSelect(db: Kysely<Database>) {
  function testClearInsert (line 25) | async function testClearInsert(db: Kysely<Database>) {
  function testClearUpdate (line 57) | async function testClearUpdate(db: Kysely<Database>) {
  function testClearDelete (line 81) | async function testClearDelete(db: Kysely<Database>) {

FILE: test/typings/test-d/coalesce.test-d.ts
  function testCoalesceSingle (line 5) | async function testCoalesceSingle(db: Kysely<Database>) {
  function testCoalesceMultiple (line 65) | async function testCoalesceMultiple(db: Kysely<Database>) {
  function value (line 107) | function value<V>(value: V): RawBuilder<V> {

FILE: test/typings/test-d/create-table.test-d.ts
  function testCreateTableWithSeveralColumns (line 5) | async function testCreateTableWithSeveralColumns(db: Kysely<Database>) {
  function testCreateTableWithAddUniqueConstraint (line 32) | async function testCreateTableWithAddUniqueConstraint(db: Kysely<Databas...
  function testCreateTableWithAsStatement (line 85) | async function testCreateTableWithAsStatement(db: Kysely<Database>) {

FILE: test/typings/test-d/delete-query-builder.test-d.ts
  function testDelete (line 5) | async function testDelete(db: Kysely<Database>) {
  function testReturning (line 90) | async function testReturning(db: Kysely<Database>) {
  function testIf (line 208) | async function testIf(db: Kysely<Database>) {
  function testOutput (line 259) | async function testOutput(db: Kysely<Database>) {

FILE: test/typings/test-d/expression.test-d.ts
  function testExpression (line 20) | function testExpression(db: Kysely<Database>) {
  function testExpressionBuilder (line 37) | async function testExpressionBuilder(
  function textExpressionBuilderAny (line 178) | async function textExpressionBuilderAny(
  function testExpressionBuilderAnyWithColumnType (line 213) | async function testExpressionBuilderAnyWithColumnType(
  function testExpressionBuilderTuple (line 237) | function testExpressionBuilderTuple(db: Kysely<Database>) {
  function testExpressionBuilderConstructor (line 302) | function testExpressionBuilderConstructor(db: Kysely<Database>) {

FILE: test/typings/test-d/generic-pre-5.4.test-d.ts
  function testSelectQueryBuilderExtends (line 14) | function testSelectQueryBuilderExtends() {
  function testExpressionBuilderExtends (line 28) | function testExpressionBuilderExtends() {
  function testExpressionBuilderExtendsFuncArg (line 42) | function testExpressionBuilderExtendsFuncArg() {
  function testGenericSelectHelper (line 59) | async function testGenericSelectHelper() {
  function testSelectsInVariable (line 85) | async function testSelectsInVariable(db: Kysely<Database>) {
  function testSelectFromDynamic (line 104) | async function testSelectFromDynamic(db: Kysely<Database>) {
  function getIdDynamic (line 121) | async function getIdDynamic<T extends 'person' | 'pet'>(
  function getRowDynamic (line 133) | async function getRowDynamic<T extends keyof Database>(
  function getRowByIdDynamic (line 145) | async function getRowByIdDynamic<
  function getRowByColumnDynamic (line 158) | async function getRowByColumnDynamic<

FILE: test/typings/test-d/generic.test-d.ts
  function testSelectQueryBuilderExtends (line 15) | function testSelectQueryBuilderExtends() {
  function testExpressionBuilderExtends (line 29) | function testExpressionBuilderExtends() {
  function testExpressionBuilderExtendsFuncArg (line 43) | function testExpressionBuilderExtendsFuncArg() {
  function testGenericSelectHelper (line 60) | async function testGenericSelectHelper() {
  function testSelectsInVariable (line 86) | async function testSelectsInVariable(db: Kysely<Database>) {
  function testSelectFromDynamic (line 105) | async function testSelectFromDynamic(db: Kysely<Database>) {
  function getIdDynamic (line 122) | async function getIdDynamic<T extends 'person' | 'pet'>(
  function getRowDynamic (line 134) | async function getRowDynamic<T extends keyof Database>(
  function getRowByIdDynamic (line 146) | async function getRowByIdDynamic<
  function getRowByColumnDynamic (line 159) | async function getRowByColumnDynamic<

FILE: test/typings/test-d/huge-db.test-d.ts
  type Decimal (line 9) | type Decimal = ColumnType<string, number | string, number | string>
  type Generated (line 11) | type Generated<T> =
  type Table0ec723c3d4ee7229ffba2a11539b0129 (line 16) | interface Table0ec723c3d4ee7229ffba2a11539b0129 {
  type Tablec67d8be002857dd3a70a2c4edaa4671a (line 22) | interface Tablec67d8be002857dd3a70a2c4edaa4671a {
  type Table3face097074d5d4ea47610accdd3ffc1 (line 37) | interface Table3face097074d5d4ea47610accdd3ffc1 {
  type Tableed617265d2d72c8e748ff8796bfa04c4 (line 47) | interface Tableed617265d2d72c8e748ff8796bfa04c4 {
  type Table6dc0e4bf3b08bdf7391e5d833d1673d6 (line 56) | interface Table6dc0e4bf3b08bdf7391e5d833d1673d6 {
  type Table2f01d1d7b29ae047871b62964df1ecc3 (line 64) | interface Table2f01d1d7b29ae047871b62964df1ecc3 {
  type Table9f50dbe0b662b9cea0d016836eb72504 (line 70) | interface Table9f50dbe0b662b9cea0d016836eb72504 {
  type Table4b8e90e811d962e132f9550bc90d5443 (line 77) | interface Table4b8e90e811d962e132f9550bc90d5443 {
  type Table0ae6c699b7b44b166093c052150a0d36 (line 87) | interface Table0ae6c699b7b44b166093c052150a0d36 {
  type Table2e45370c867ddf8f0ca7710b63dd2746 (line 96) | interface Table2e45370c867ddf8f0ca7710b63dd2746 {
  type Table19f57540d944441abc6dcebc976adf96 (line 103) | interface Table19f57540d944441abc6dcebc976adf96 {
  type Table1d1b84f13a74383d5b0324a011b609c6 (line 110) | interface Table1d1b84f13a74383d5b0324a011b609c6 {
  type Table42dbaa8105cb92599360aa5169283403 (line 121) | interface Table42dbaa8105cb92599360aa5169283403 {
  type Table2f81c25612f8fefd026b753a1753974a (line 129) | interface Table2f81c25612f8fefd026b753a1753974a {
  type Tableded2bdb12664e58a26152ebb5fe676bb (line 145) | interface Tableded2bdb12664e58a26152ebb5fe676bb {
  type Table1c765aad5af6c98fb0ef475fadda911b (line 152) | interface Table1c765aad5af6c98fb0ef475fadda911b {
  type Table23e7a1e5ab953d2a85a5958458d0d824 (line 163) | interface Table23e7a1e5ab953d2a85a5958458d0d824 {
  type Table41bb6a93b802fe08f0b054ae835e2fe4 (line 174) | interface Table41bb6a93b802fe08f0b054ae835e2fe4 {
  type Table8be6c29eada2e2ef68bef0c9c1401a97 (line 180) | interface Table8be6c29eada2e2ef68bef0c9c1401a97 {
  type Tablee91e54a2c273ec3221b4d98ae8d79d12 (line 189) | interface Tablee91e54a2c273ec3221b4d98ae8d79d12 {
  type Tablebb08e5d0fa8fd6089eeeb1ba950944a1 (line 195) | interface Tablebb08e5d0fa8fd6089eeeb1ba950944a1 {
  type Tablecaf406ab258ff4b54413265206d55b45 (line 206) | interface Tablecaf406ab258ff4b54413265206d55b45 {
  type Table90ffcbc2bfc57b68acac037b0aeae3d4 (line 215) | interface Table90ffcbc2bfc57b68acac037b0aeae3d4 {
  type Table1e2c9919a848fb2673ac28780aba041c (line 224) | interface Table1e2c9919a848fb2673ac28780aba041c {
  type Table4f240fba2b420e220c97e6e14c4819c6 (line 230) | interface Table4f240fba2b420e220c97e6e14c4819c6 {
  type Tablec97e3cdd896ff553853d7817e4a866e2 (line 248) | interface Tablec97e3cdd896ff553853d7817e4a866e2 {
  type Table4974bbdf9d728fb538d7507cb9f84842 (line 292) | interface Table4974bbdf9d728fb538d7507cb9f84842 {
  type Tablea3c8286fc7df926fbf05e09a03e2ac77 (line 299) | interface Tablea3c8286fc7df926fbf05e09a03e2ac77 {
  type Table39bdacc8b55267ffc8bf75ff8ec564ce (line 306) | interface Table39bdacc8b55267ffc8bf75ff8ec564ce {
  type Table3d68aac4deb5f76aaffa0df8c01e305a (line 328) | interface Table3d68aac4deb5f76aaffa0df8c01e305a {
  type Table90a64fc3cea5bc905374973771cafcd3 (line 335) | interface Table90a64fc3cea5bc905374973771cafcd3 {
  type Tablec479a580bb37024884d940eeacc9c4aa (line 341) | interface Tablec479a580bb37024884d940eeacc9c4aa {
  type Table1d62a6c4a9763009cda042181b0c48af (line 347) | interface Table1d62a6c4a9763009cda042181b0c48af {
  type Table916f65bd1433290f26613ccd976c68a7 (line 353) | interface Table916f65bd1433290f26613ccd976c68a7 {
  type Tabledb34593d7377d2007d44ba4b47dcec97 (line 362) | interface Tabledb34593d7377d2007d44ba4b47dcec97 {
  type Tablef7d7a7557d9db50bd40fe14bd830b9d4 (line 368) | interface Tablef7d7a7557d9db50bd40fe14bd830b9d4 {
  type Table309c66af6ff8ccb2dcf123e1af40c9c4 (line 386) | interface Table309c66af6ff8ccb2dcf123e1af40c9c4 {
  type Table8921b63f9cb21e8293a8c1ddd9edc866 (line 401) | interface Table8921b63f9cb21e8293a8c1ddd9edc866 {
  type Table2037e68416ae40369fba0a939e7ac693 (line 410) | interface Table2037e68416ae40369fba0a939e7ac693 {
  type Table2b3f160083004c6c92a2ce1faf87067d (line 416) | interface Table2b3f160083004c6c92a2ce1faf87067d {
  type Table5135075fea7b2d1c93603df216620907 (line 434) | interface Table5135075fea7b2d1c93603df216620907 {
  type Table5d4433ff31ef75511e70aa6e71495afe (line 442) | interface Table5d4433ff31ef75511e70aa6e71495afe {
  type Table9e258b1708bd64e877d6cca1467dee66 (line 449) | interface Table9e258b1708bd64e877d6cca1467dee66 {
  type Table4ed17d356988e97fe63e4b4e3b060917 (line 487) | interface Table4ed17d356988e97fe63e4b4e3b060917 {
  type Tablea95d291bccf0be8becb18282bcbf93a9 (line 497) | interface Tablea95d291bccf0be8becb18282bcbf93a9 {
  type Tablee12f5b7476cba16c3b1480cd551d2b42 (line 507) | interface Tablee12f5b7476cba16c3b1480cd551d2b42 {
  type Tablea6ca43be611a38117221fef4c761f97d (line 524) | interface Tablea6ca43be611a38117221fef4c761f97d {
  type Tablef83eda9e66948a4da342fadf183e32c3 (line 538) | interface Tablef83eda9e66948a4da342fadf183e32c3 {
  type Tabledfc2f0e19fe1c0e8dd04191a3035bac8 (line 548) | interface Tabledfc2f0e19fe1c0e8dd04191a3035bac8 {
  type Table93f030da0924f35ab2e57081dad1e2fb (line 558) | interface Table93f030da0924f35ab2e57081dad1e2fb {
  type Table59fc5666d6be52faaeb255fb48a401ef (line 568) | interface Table59fc5666d6be52faaeb255fb48a401ef {
  type Table29c7f8f8df026c49d8ea3ad088e8780a (line 578) | interface Table29c7f8f8df026c49d8ea3ad088e8780a {
  type Table2e5e86f744edaeea91caedf4496cd21e (line 588) | interface Table2e5e86f744edaeea91caedf4496cd21e {
  type Table27112b32955bc32b3cf3abc78f6041f7 (line 613) | interface Table27112b32955bc32b3cf3abc78f6041f7 {
  type Table6a8129f282adc469ee9233bcf63f20b7 (line 623) | interface Table6a8129f282adc469ee9233bcf63f20b7 {
  type Table55cda7b389c3f5e26b58e806dc82d6cd (line 629) | interface Table55cda7b389c3f5e26b58e806dc82d6cd {
  type Tabledddb567693b67dedccc76feeaf305885 (line 650) | interface Tabledddb567693b67dedccc76feeaf305885 {
  type Tableb45f137169628885a5507a98a1fd203b (line 669) | interface Tableb45f137169628885a5507a98a1fd203b {
  type Table4d0fb43fef8f71d027e1c62ff7b83c1f (line 675) | interface Table4d0fb43fef8f71d027e1c62ff7b83c1f {
  type Table26d9e67842818bfccbbfca6020d3441a (line 681) | interface Table26d9e67842818bfccbbfca6020d3441a {
  type Tablee6de3a3fdf132b2b794ad9358fe01719 (line 687) | interface Tablee6de3a3fdf132b2b794ad9358fe01719 {
  type Table5bdeb7407d8776f9295b3ae2eb482855 (line 696) | interface Table5bdeb7407d8776f9295b3ae2eb482855 {
  type Table259a82d9d67d1b779666191753027e2d (line 702) | interface Table259a82d9d67d1b779666191753027e2d {
  type Tabledfcfa50cfe70d46b898ed0fe276855e4 (line 715) | interface Tabledfcfa50cfe70d46b898ed0fe276855e4 {
  type Table11e00101e1b2f60d0a2acfcf46151908 (line 720) | interface Table11e00101e1b2f60d0a2acfcf46151908 {
  type Tableaa828347830464c8d6fb6070585f8786 (line 811) | interface Tableaa828347830464c8d6fb6070585f8786 {
  type Table5e1a250360f2e59810faaec5dec74bfb (line 819) | interface Table5e1a250360f2e59810faaec5dec74bfb {
  type Tablecb67af6a70220cf4b2c4e1121d9351c6 (line 832) | interface Tablecb67af6a70220cf4b2c4e1121d9351c6 {
  type Table01687ac6f71bbab86d7fb8482bf71301 (line 838) | interface Table01687ac6f71bbab86d7fb8482bf71301 {
  type Tablee4612831426584576f2d39997ccac9c8 (line 848) | interface Tablee4612831426584576f2d39997ccac9c8 {
  type Tablebca1b3f3c2526216b2f01c01fa85f3f9 (line 858) | interface Tablebca1b3f3c2526216b2f01c01fa85f3f9 {
  type Tablecac2eaeb16e94e019e7e98240c4bac17 (line 867) | interface Tablecac2eaeb16e94e019e7e98240c4bac17 {
  type Table7eb5460a0c6690c1dff53fe4940240db (line 876) | interface Table7eb5460a0c6690c1dff53fe4940240db {
  type Table5c88bed5704d2054a84d44150bf10f21 (line 885) | interface Table5c88bed5704d2054a84d44150bf10f21 {
  type Table148eb9256ed9e01df75e345bd7e5c9f7 (line 894) | interface Table148eb9256ed9e01df75e345bd7e5c9f7 {
  type Tablee2c77a8b952bdea3bc2cb7261168ec45 (line 907) | interface Tablee2c77a8b952bdea3bc2cb7261168ec45 {
  type Tableabd2380e09dc7a608bb7e5c33654540e (line 915) | interface Tableabd2380e09dc7a608bb7e5c33654540e {
  type Table7117bf3bff290101f4fa6d6de627b58f (line 925) | interface Table7117bf3bff290101f4fa6d6de627b58f {
  type Table202a1f7684d2c58afd3885112de82158 (line 936) | interface Table202a1f7684d2c58afd3885112de82158 {
  type Table93aeee94c0d8d4e08a56c97185d68ae7 (line 945) | interface Table93aeee94c0d8d4e08a56c97185d68ae7 {
  type Table70c085cf2d0edd14f7dbae474f064b1c (line 954) | interface Table70c085cf2d0edd14f7dbae474f064b1c {
  type Table2b11443e8af088b453d5119d135803ac (line 960) | interface Table2b11443e8af088b453d5119d135803ac {
  type Table0a542ca892cb0eea27538d7360f718ec (line 983) | interface Table0a542ca892cb0eea27538d7360f718ec {
  type Tableb8378493b92a26626ae5745222c8ba69 (line 1003) | interface Tableb8378493b92a26626ae5745222c8ba69 {
  type Table565a308ecf3782bb5eb0197187361913 (line 1015) | interface Table565a308ecf3782bb5eb0197187361913 {
  type Tablede86128413dcd68bd6d1ca009b6bae17 (line 1023) | interface Tablede86128413dcd68bd6d1ca009b6bae17 {
  type Table57dadc25e9a34c53f66b5cb499d75904 (line 1030) | interface Table57dadc25e9a34c53f66b5cb499d75904 {
  type Table366c7f7bccaea5ff455a9b9265448ebf (line 1037) | interface Table366c7f7bccaea5ff455a9b9265448ebf {
  type Tablea4ca5018c98bd7912524f97ccd0a8757 (line 1064) | interface Tablea4ca5018c98bd7912524f97ccd0a8757 {
  type Table402dd89f94d2a88ccdf049224dfc8700 (line 1073) | interface Table402dd89f94d2a88ccdf049224dfc8700 {
  type Table92498a6babb7032cdcad6e43158a3359 (line 1099) | interface Table92498a6babb7032cdcad6e43158a3359 {
  type Tablee90356817b37536144c4cf962e9e5165 (line 1108) | interface Tablee90356817b37536144c4cf962e9e5165 {
  type Table61a79fc440f7ca2d4190d47ee809f66c (line 1115) | interface Table61a79fc440f7ca2d4190d47ee809f66c {
  type Table7051320fedfb456818eb15cdf217186d (line 1146) | interface Table7051320fedfb456818eb15cdf217186d {
  type Table2d7cdf1ccac4544f81ac78a12d5fba7a (line 1155) | interface Table2d7cdf1ccac4544f81ac78a12d5fba7a {
  type Tablea8e3bfebcd001eac1185867f7dec94a5 (line 1164) | interface Tablea8e3bfebcd001eac1185867f7dec94a5 {
  type Table148ce21c70970d2809c4028c229445be (line 1172) | interface Table148ce21c70970d2809c4028c229445be {
  type Tablef650c769203b8bd7eed5a8b7e249c0a5 (line 1277) | interface Tablef650c769203b8bd7eed5a8b7e249c0a5 {
  type Table8b9070a970ee019dd472ce6c4a08418b (line 1287) | interface Table8b9070a970ee019dd472ce6c4a08418b {
  type Tabled580c05f239408ff0392e235078a0ac9 (line 1297) | interface Tabled580c05f239408ff0392e235078a0ac9 {
  type Tabledd7d780df70068dcb36a8d8b86bd5298 (line 1312) | interface Tabledd7d780df70068dcb36a8d8b86bd5298 {
  type Table48df920caa8cc60fd47820e9d94ea940 (line 1325) | interface Table48df920caa8cc60fd47820e9d94ea940 {
  type Table9bb0301f7ca02953fac2add8dcd7630c (line 1332) | interface Table9bb0301f7ca02953fac2add8dcd7630c {
  type Table5492e76278a71210d7231f4bf905ec2f (line 1345) | interface Table5492e76278a71210d7231f4bf905ec2f {
  type Tableea8e45026529937b0cecd544d8801cfd (line 1405) | interface Tableea8e45026529937b0cecd544d8801cfd {
  type Table574ff9acd571619424cd55716f5f1dfb (line 1412) | interface Table574ff9acd571619424cd55716f5f1dfb {
  type Tablea79aeca54482635868f02356a51fa369 (line 1417) | interface Tablea79aeca54482635868f02356a51fa369 {
  type Tablee7a44a84d410fa64377504e3aa7f72b6 (line 1422) | interface Tablee7a44a84d410fa64377504e3aa7f72b6 {
  type Tabledcc9250fc52d5fbc25a56cf9c4089073 (line 1430) | interface Tabledcc9250fc52d5fbc25a56cf9c4089073 {
  type Table4d82bf6c52ed1355768c73593994c5c2 (line 1437) | interface Table4d82bf6c52ed1355768c73593994c5c2 {
  type Table73f359bc2658d254af39135aed8c3bf2 (line 1442) | interface Table73f359bc2658d254af39135aed8c3bf2 {
  type Table8cf85c63dc3200ef8145fc0344d00f16 (line 1452) | interface Table8cf85c63dc3200ef8145fc0344d00f16 {
  type Table401ef7ed8ddaa97932ede0de0b157c04 (line 1457) | interface Table401ef7ed8ddaa97932ede0de0b157c04 {
  type Table3e875ede7feab48a89082e0c87c364f0 (line 1462) | interface Table3e875ede7feab48a89082e0c87c364f0 {
  type Table7822bcc86140bf34bc6cdacbd734c0ef (line 1472) | interface Table7822bcc86140bf34bc6cdacbd734c0ef {
  type Table459dc31349051f20a755552adaf60c81 (line 1485) | interface Table459dc31349051f20a755552adaf60c81 {
  type Table1b8610f190607dfbdafa9c71f72acd43 (line 1495) | interface Table1b8610f190607dfbdafa9c71f72acd43 {
  type Table1edc1b921ba66176c3ec62961c248f78 (line 1504) | interface Table1edc1b921ba66176c3ec62961c248f78 {
  type Table9b72afad4afd63d81ab6ef56c926765d (line 1511) | interface Table9b72afad4afd63d81ab6ef56c926765d {
  type Table309e0b9a80a4ad911a672f7174429e35 (line 1523) | interface Table309e0b9a80a4ad911a672f7174429e35 {
  type Tablea0eb46b195e5cbd5e85384a9a1622c14 (line 1528) | interface Tablea0eb46b195e5cbd5e85384a9a1622c14 {
  type Tableea5b8f9c56ff4ae4cb3c8f22541b33ba (line 1543) | interface Tableea5b8f9c56ff4ae4cb3c8f22541b33ba {
  type Table3a87f98012aa2362e8eb64ed4d9e8f65 (line 1557) | interface Table3a87f98012aa2362e8eb64ed4d9e8f65 {
  type Tablefe2e32091534caf00911fc7435cbc97b (line 1565) | interface Tablefe2e32091534caf00911fc7435cbc97b {
  type Table3cdcee0d77b622e8a2ec654a21270877 (line 1576) | interface Table3cdcee0d77b622e8a2ec654a21270877 {
  type Table8077f242ad5e05394a3dd81ce79565f7 (line 1586) | interface Table8077f242ad5e05394a3dd81ce79565f7 {
  type Table52a8644bfd17799495525f2fd8adc480 (line 1594) | interface Table52a8644bfd17799495525f2fd8adc480 {
  type Table74bb684c41a71a06f561e10ffa4e3323 (line 1616) | interface Table74bb684c41a71a06f561e10ffa4e3323 {
  type Table64ac7b9a171e9af222924b693d44887c (line 1631) | interface Table64ac7b9a171e9af222924b693d44887c {
  type Tablefd230cdd0c0d7bc04b06cffa3bc3fa3e (line 1640) | interface Tablefd230cdd0c0d7bc04b06cffa3bc3fa3e {
  type Table2bf8003c7e2a7344f4d30c3a351926c5 (line 1652) | interface Table2bf8003c7e2a7344f4d30c3a351926c5 {
  type Table5c1f23359d009924d75dac9200da99ab (line 1661) | interface Table5c1f23359d009924d75dac9200da99ab {
  type Tablea6cdaf7c2c1c27d8389fb8ec7831b240 (line 1682) | interface Tablea6cdaf7c2c1c27d8389fb8ec7831b240 {
  type Table618b14672aa41a4ddbaa07b4668e9ceb (line 1694) | interface Table618b14672aa41a4ddbaa07b4668e9ceb {
  type Tablee0ac1a12db533e45722bf75854c5f68f (line 1705) | interface Tablee0ac1a12db533e45722bf75854c5f68f {
  type Table6b64130a9ac5e9179051a15684e76956 (line 1723) | interface Table6b64130a9ac5e9179051a15684e76956 {
  type Tablec3c4b9ba46ff23ee52e9fa59ba4cbd42 (line 1732) | interface Tablec3c4b9ba46ff23ee52e9fa59ba4cbd42 {
  type Tableac8f964f7407177bed83d5a1b563c4be (line 1741) | interface Tableac8f964f7407177bed83d5a1b563c4be {
  type Table0e3703752e6fb26a7c95ffbf9ba62354 (line 1748) | interface Table0e3703752e6fb26a7c95ffbf9ba62354 {
  type Table051ebef2507af0ef791ed665f9df9f69 (line 1755) | interface Table051ebef2507af0ef791ed665f9df9f69 {
  type Tablea85ed4b894e81fcae5b5f32832c0a4aa (line 1763) | interface Tablea85ed4b894e81fcae5b5f32832c0a4aa {
  type Tablef2e554fc6e599ca882cad3f9c8944c5f (line 1771) | interface Tablef2e554fc6e599ca882cad3f9c8944c5f {
  type Table92318b69e7164d55b1815a563a4f0fda (line 1779) | interface Table92318b69e7164d55b1815a563a4f0fda {
  type Table11c3ad790c98516ecb794068e8fe4332 (line 1796) | interface Table11c3ad790c98516ecb794068e8fe4332 {
  type Table0b9fd044caf91b1c9c0decf463f48479 (line 1804) | interface Table0b9fd044caf91b1c9c0decf463f48479 {
  type Tablecb5f0e2e2a6bb82fe0ec713f3001adae (line 1816) | interface Tablecb5f0e2e2a6bb82fe0ec713f3001adae {
  type Table05f7a75fd9ce14b6ff3abafe6a0315cd (line 1823) | interface Table05f7a75fd9ce14b6ff3abafe6a0315cd {
  type Tablef9d0cc88ca4af2fc064f9fe28c1cae51 (line 1838) | interface Tablef9d0cc88ca4af2fc064f9fe28c1cae51 {
  type Tabledf515f554daadb410af199b9d2af4968 (line 1853) | interface Tabledf515f554daadb410af199b9d2af4968 {
  type Tablee7013b1aa66ff80026b9594533e73417 (line 1861) | interface Tablee7013b1aa66ff80026b9594533e73417 {
  type Table6fc94749b5f65b04e1364bc84a3b675a (line 1875) | interface Table6fc94749b5f65b04e1364bc84a3b675a {
  type Table7e5a6e895e47f444ce7042734df8ce92 (line 1890) | interface Table7e5a6e895e47f444ce7042734df8ce92 {
  type Table03fcd39a79bd9fbbc8f2f32371eb6a9b (line 1898) | interface Table03fcd39a79bd9fbbc8f2f32371eb6a9b {
  type Table3edc0e801929e10d8dd381561aa2bd31 (line 1906) | interface Table3edc0e801929e10d8dd381561aa2bd31 {
  type Table75f7cd025a872d2698d2a6e53a8cd953 (line 1914) | interface Table75f7cd025a872d2698d2a6e53a8cd953 {
  type Table075f9410d29eaec83d4f68c3dfa82a10 (line 1920) | interface Table075f9410d29eaec83d4f68c3dfa82a10 {
  type Tableb91d0a254d43344084dc0efd98b90946 (line 1930) | interface Tableb91d0a254d43344084dc0efd98b90946 {
  type Table4d4605d2d071f927c338880fcda7b540 (line 1938) | interface Table4d4605d2d071f927c338880fcda7b540 {
  type Table14a5541144254091c320909a95c4c614 (line 1948) | interface Table14a5541144254091c320909a95c4c614 {
  type Tableb16695c526d6fa5e20b329d5eabfd364 (line 1970) | interface Tableb16695c526d6fa5e20b329d5eabfd364 {
  type Table9eb67e79e0e2abbb0a295904fd81d805 (line 1980) | interface Table9eb67e79e0e2abbb0a295904fd81d805 {
  type Tablea700a17706246884b5a04cafcebeaa55 (line 1990) | interface Tablea700a17706246884b5a04cafcebeaa55 {
  type Table6a853060686c878e7535e29bc3772d73 (line 2002) | interface Table6a853060686c878e7535e29bc3772d73 {
  type Table2c1e8df56b265a10929de25e4593033b (line 2015) | interface Table2c1e8df56b265a10929de25e4593033b {
  type Table3c8b015b7697cce06653b215afc8acd5 (line 2023) | interface Table3c8b015b7697cce06653b215afc8acd5 {
  type Tablef058a40da08114d390fcea4b81b4f0a8 (line 2030) | interface Tablef058a40da08114d390fcea4b81b4f0a8 {
  type Tablea6a7b2d92feb037592b7ed49c34d1e54 (line 2038) | interface Tablea6a7b2d92feb037592b7ed49c34d1e54 {
  type Table4aba31682ab92f6f2baae3f68f9dc1ad (line 2043) | interface Table4aba31682ab92f6f2baae3f68f9dc1ad {
  type Table75d4ed2c1cedc7a0f7e36059177a8837 (line 2056) | interface Table75d4ed2c1cedc7a0f7e36059177a8837 {
  type Tablec3ba8dac5adcbeb93ed2dd458b6ad4a1 (line 2062) | interface Tablec3ba8dac5adcbeb93ed2dd458b6ad4a1 {
  type Tablee53ad4b421c58913d023a3296c13419e (line 2069) | interface Tablee53ad4b421c58913d023a3296c13419e {
  type Table980786dce470ebfd2621534ebcd5e6e9 (line 2079) | interface Table980786dce470ebfd2621534ebcd5e6e9 {
  type Table1a270e99026f39aaf8e33546e1c2c39e (line 2086) | interface Table1a270e99026f39aaf8e33546e1c2c39e {
  type Table380b3be3b993931074af40f4e0af76f3 (line 2111) | interface Table380b3be3b993931074af40f4e0af76f3 {
  type Table4a03b332b99d0dab4e359b9b2e9132f3 (line 2148) | interface Table4a03b332b99d0dab4e359b9b2e9132f3 {
  type Tableb690efdc73ab53d741824e87ddf41a0a (line 2155) | interface Tableb690efdc73ab53d741824e87ddf41a0a {
  type Table80586ee503601f161507ee3f207fa19a (line 2173) | interface Table80586ee503601f161507ee3f207fa19a {
  type Table138bb88f13d65a10a42882c2578d7839 (line 2180) | interface Table138bb88f13d65a10a42882c2578d7839 {
  type Tablef8ad778cddf738c853992b7f5446b4f1 (line 2202) | interface Tablef8ad778cddf738c853992b7f5446b4f1 {
  type Table9f6e2daac23f8ae268d4557cb47cb202 (line 2239) | interface Table9f6e2daac23f8ae268d4557cb47cb202 {
  type Table7ff09e5ace1dbf00f39b6358c5aa3817 (line 2258) | interface Table7ff09e5ace1dbf00f39b6358c5aa3817 {
  type Table3527de031c6623c0eba6355dcdd45a6b (line 2268) | interface Table3527de031c6623c0eba6355dcdd45a6b {
  type Table09612d694974820d8807b91ecde8f26e (line 2281) | interface Table09612d694974820d8807b91ecde8f26e {
  type Table38195ba8de22a862c0f40f70ebec25bb (line 2290) | interface Table38195ba8de22a862c0f40f70ebec25bb {
  type Table93037210a648b88105c5ee2473337821 (line 2304) | interface Table93037210a648b88105c5ee2473337821 {
  type Table0b5857bb9e98480275f017b7af173e3f (line 2315) | interface Table0b5857bb9e98480275f017b7af173e3f {
  type Tablef27ebdbd2754995818491c1018692ce5 (line 2324) | interface Tablef27ebdbd2754995818491c1018692ce5 {
  type Table6009b7b4db0ba922eead74b775f40f8c (line 2357) | interface Table6009b7b4db0ba922eead74b775f40f8c {
  type Tableb6b0fa946d389417c5c3f14aa8ff718a (line 2364) | interface Tableb6b0fa946d389417c5c3f14aa8ff718a {
  type Table3edf238f7262a23abe0751a2ac0af6ff (line 2377) | interface Table3edf238f7262a23abe0751a2ac0af6ff {
  type Table55ac07dee59e4a2d00136b025cc01d9e (line 2397) | interface Table55ac07dee59e4a2d00136b025cc01d9e {
  type Table09e8ea41829a99131a2920761d339204 (line 2405) | interface Table09e8ea41829a99131a2920761d339204 {
  type Table7a616917b50007f39137fa41d2f51ab3 (line 2422) | interface Table7a616917b50007f39137fa41d2f51ab3 {
  type Table5d8df59e64a9eeca85daebca610e21a7 (line 2439) | interface Table5d8df59e64a9eeca85daebca610e21a7 {
  type Table526124c9359353a7e56271d12d9fcf0c (line 2448) | interface Table526124c9359353a7e56271d12d9fcf0c {
  type Table6bba2bdcbf233fb7649d1f614417da41 (line 2462) | interface Table6bba2bdcbf233fb7649d1f614417da41 {
  type Table390f512e2274731b2d168d8f19da171c (line 2473) | interface Table390f512e2274731b2d168d8f19da171c {
  type Table1899f801ed13e5910d18c6b08028d7bc (line 2487) | interface Table1899f801ed13e5910d18c6b08028d7bc {
  type Table1082c28dec8a8ffd8ce641335442372f (line 2501) | interface Table1082c28dec8a8ffd8ce641335442372f {
  type Table72909a5ac37995f967b619c9cafa07d6 (line 2513) | interface Table72909a5ac37995f967b619c9cafa07d6 {
  type Table81a2bed79d9365d1982e76dca5a676bd (line 2521) | interface Table81a2bed79d9365d1982e76dca5a676bd {
  type Table9b567a9f0bdf26ccd8202eff33ff637b (line 2540) | interface Table9b567a9f0bdf26ccd8202eff33ff637b {
  type Tablecb69558ad9c32a83ec1e61169d89de2f (line 2544) | interface Tablecb69558ad9c32a83ec1e61169d89de2f {
  type Table69cb4926463c11065ab61382047dd490 (line 2550) | interface Table69cb4926463c11065ab61382047dd490 {
  type Table3d90cba85411f05feed564dbcd2e6e55 (line 2558) | interface Table3d90cba85411f05feed564dbcd2e6e55 {
  type Table32254855b1a9a81426acafd370a0edc3 (line 2567) | interface Table32254855b1a9a81426acafd370a0edc3 {
  type Tableccc5e7a07cecf45f43c5c4efb6bbcd8a (line 2573) | interface Tableccc5e7a07cecf45f43c5c4efb6bbcd8a {
  type Tablef9ce3585ff20a0b1dd731bdd34cf0ad9 (line 2589) | interface Tablef9ce3585ff20a0b1dd731bdd34cf0ad9 {
  type Table1e275afc8276112b99cfc6f49842958c (line 2601) | interface Table1e275afc8276112b99cfc6f49842958c {
  type Table24139be0f90bb33600380f06b12b7f1e (line 2613) | interface Table24139be0f90bb33600380f06b12b7f1e {
  type Tablee0ce7ca1270b4541c302833574025ff0 (line 2619) | interface Tablee0ce7ca1270b4541c302833574025ff0 {
  type Table129722fe7124ca893b45b3f11aa2797c (line 2628) | interface Table129722fe7124ca893b45b3f11aa2797c {
  type Table361ca453b125de0694d45757ce574ac8 (line 2637) | interface Table361ca453b125de0694d45757ce574ac8 {
  type Table682bfd8f39f1d3c2f141f8d1bfaba332 (line 2643) | interface Table682bfd8f39f1d3c2f141f8d1bfaba332 {
  type Tablea4885bc4409d5d6aeca7a333deb32f36 (line 2651) | interface Tablea4885bc4409d5d6aeca7a333deb32f36 {
  type Tabled0b3106159632181125a90621e656efe (line 2656) | interface Tabled0b3106159632181125a90621e656efe {
  type Tablef8d58e2b9ad74400d9d3b73e1c56b24c (line 2662) | interface Tablef8d58e2b9ad74400d9d3b73e1c56b24c {
  type Table7f3edc307df1ebe46a26c3cdcce01825 (line 2667) | interface Table7f3edc307df1ebe46a26c3cdcce01825 {
  type Table4cb9cce2545216afbbe27fd7f598670d (line 2672) | interface Table4cb9cce2545216afbbe27fd7f598670d {
  type Table075be2c4bc1569d9e2a0f43c706845cd (line 2677) | interface Table075be2c4bc1569d9e2a0f43c706845cd {
  type Tableb0475c12dae1800e6f9bed0ecc74d8ac (line 2683) | interface Tableb0475c12dae1800e6f9bed0ecc74d8ac {
  type Table9273711f2c37ed469c438c6e604205ad (line 2688) | interface Table9273711f2c37ed469c438c6e604205ad {
  type Table674852753d920a7b8c85e3d7f0741d69 (line 2693) | interface Table674852753d920a7b8c85e3d7f0741d69 {
  type Table93fcd1b734496b580b42aff395ed8deb (line 2698) | interface Table93fcd1b734496b580b42aff395ed8deb {
  type Tablee8de821cfe0519477927d4aceb53aedb (line 2703) | interface Tablee8de821cfe0519477927d4aceb53aedb {
  type Tabled97726553a6203a2e1fe24edf923c1bf (line 2708) | interface Tabled97726553a6203a2e1fe24edf923c1bf {
  type Table10a7b3d08bae6a280681dd4b1b4d03ea (line 2720) | interface Table10a7b3d08bae6a280681dd4b1b4d03ea {
  type MyTable (line 2727) | interface MyTable {
  type Table5e096b65e80874785e32076304380404 (line 2746) | interface Table5e096b65e80874785e32076304380404 {
  type Tablef3ed8107e22455983dfec1061f270c5b (line 2759) | interface Tablef3ed8107e22455983dfec1061f270c5b {
  type Tablec051ae09c6cf6d7d3ea3732241b7ec9d (line 2768) | interface Tablec051ae09c6cf6d7d3ea3732241b7ec9d {
  type Table58d873381dd856073dc8af727f75a83c (line 2775) | interface Table58d873381dd856073dc8af727f75a83c {
  type Table2efbbc557d528fa0179d8200f20bd375 (line 2795) | interface Table2efbbc557d528fa0179d8200f20bd375 {
  type Tableb1c2cd01d00c7351140f576d84e64fc1 (line 2817) | interface Tableb1c2cd01d00c7351140f576d84e64fc1 {
  type Table173d3cc6670ed190157f57b6fc5f789f (line 2825) | interface Table173d3cc6670ed190157f57b6fc5f789f {
  type Tableea7fc406759eeeabe58177f5dc5b2749 (line 2834) | interface Tableea7fc406759eeeabe58177f5dc5b2749 {
  type Table5d31333676303c399518c2fc4cf6ce6b (line 2843) | interface Table5d31333676303c399518c2fc4cf6ce6b {
  type Table411a4da56c483124eeb78d27496b6bcc (line 2852) | interface Table411a4da56c483124eeb78d27496b6bcc {
  type Table90b86be76e1fe1dcbfeb23aac1268f60 (line 2861) | interface Table90b86be76e1fe1dcbfeb23aac1268f60 {
  type Tablead803551807f7dd640a7431281e60024 (line 2870) | interface Tablead803551807f7dd640a7431281e60024 {
  type Tableacd9c0e145638abbf38c6c9982b5d978 (line 2879) | interface Tableacd9c0e145638abbf38c6c9982b5d978 {
  type Table03d5e3f6a5a1305f36b6f5e7b40f8607 (line 2888) | interface Table03d5e3f6a5a1305f36b6f5e7b40f8607 {
  type Table1ad14a94caab8e7087a497085d7136ee (line 2897) | interface Table1ad14a94caab8e7087a497085d7136ee {
  type Table13e2dfe71a6146bf0f7286309cee804f (line 2906) | interface Table13e2dfe71a6146bf0f7286309cee804f {
  type Tablec227d3e74b291218da01d96ad8e3cbf3 (line 2915) | interface Tablec227d3e74b291218da01d96ad8e3cbf3 {
  type Tabled861babbb2f5fa7cd7537704e5000a83 (line 2924) | interface Tabled861babbb2f5fa7cd7537704e5000a83 {
  type DB (line 2943) | interface DB {
  function testHugeDBSelect (line 3192) | function testHugeDBSelect(db: Kysely<DB>) {
  function testHugeDBInsert (line 3214) | function testHugeDBInsert(db: Kysely<DB>) {
  function testHugeDBUpdate (line 3220) | function testHugeDBUpdate(db: Kysely<DB>) {
  function testHugeDBDelete (line 3232) | function testHugeDBDelete(db: Kysely<DB>) {

FILE: test/typings/test-d/if.test-d.ts
  function testIfInSelect (line 5) | async function testIfInSelect(db: Kysely<Database>) {
  function testIfInInsert (line 60) | async function testIfInInsert(db: Kysely<Database>) {
  function testIfInUpdate (line 102) | async function testIfInUpdate(db: Kysely<Database>) {
  function testIfInDelete (line 144) | async function testIfInDelete(db: Kysely<Database>) {

FILE: test/typings/test-d/index.test-d.ts
  function testOrderBy (line 15) | async function testOrderBy(db: Kysely<Database>) {
  function testKyselyAndTransactionTypes (line 25) | async function testKyselyAndTransactionTypes(db: Kysely<Database>) {
  function testExecuteTakeFirstOrThrow (line 35) | async function testExecuteTakeFirstOrThrow(db: Kysely<Database>) {
  function testCall (line 45) | async function testCall(db: Kysely<Database>) {
  function testReplace (line 56) | async function testReplace(db: Kysely<Database>) {

FILE: test/typings/test-d/infer-result.test-d.ts
  function testInferResultSelectQuery (line 15) | function testInferResultSelectQuery(db: Kysely<Database>) {
  function testInferResultInsertQuery (line 41) | function testInferResultInsertQuery(db: Kysely<Database>) {
  function testInferResultUpdateQuery (line 69) | function testInferResultUpdateQuery(db: Kysely<Database>) {
  function testInferResultDeleteQuery (line 110) | function testInferResultDeleteQuery(db: Kysely<Database>) {
  function testInferResultMergeQuery (line 133) | function testInferResultMergeQuery(db: Kysely<Database>) {

FILE: test/typings/test-d/insert.test-d.ts
  function testInsert (line 5) | async function testInsert(db: Kysely<Database>) {
  function testReturning (line 136) | async function testReturning(db: Kysely<Database>) {
  function testOutput (line 206) | async function testOutput(db: Kysely<Database>) {
  function testInsertable (line 272) | function testInsertable() {

FILE: test/typings/test-d/join.test-d.ts
  function testJoin (line 5) | async function testJoin(db: Kysely<Database>) {
  function testManyJoins (line 270) | async function testManyJoins(db: Kysely<Database>) {

FILE: test/typings/test-d/json-traversal.test-d.ts
  function testJSONReference (line 6) | async function testJSONReference(db: Kysely<Database>) {
  function testJSONPath (line 220) | async function testJSONPath(eb: ExpressionBuilder<Database, keyof Databa...

FILE: test/typings/test-d/kysely-any.test-d.ts
  function testKyselyAnySelects (line 4) | async function testKyselyAnySelects(db: Kysely<any>) {
  function testKyselyAnyInserts (line 54) | async function testKyselyAnyInserts(db: Kysely<any>) {
  function testKyselyAnyUpdates (line 89) | async function testKyselyAnyUpdates(db: Kysely<any>) {
  function testKyselyAnyDeletes (line 134) | async function testKyselyAnyDeletes(db: Kysely<any>) {

FILE: test/typings/test-d/merge.test-d.ts
  function testMergeInto (line 19) | async function testMergeInto(db: Kysely<Database>) {
  function testUsing (line 38) | async function testUsing(db: Kysely<Database>) {
  function testWhenMatched (line 74) | async function testWhenMatched(
  function testWhenNotMatched (line 124) | async function testWhenNotMatched(
  function testWhenNotMatchedBySource (line 189) | async function testWhenNotMatchedBySource(
  function testThenDelete (line 267) | async function testThenDelete(
  function testThenDoNothing (line 285) | async function testThenDoNothing(
  function testThenUpdate (line 315) | async function testThenUpdate(
  function testThenInsert (line 381) | async function testThenInsert(
  function testReturning (line 427) | async function testReturning(
  function testOutput (line 504) | async function testOutput(

FILE: test/typings/test-d/postgres-json.test-d.ts
  function testPostgresJsonSelects (line 13) | async function testPostgresJsonSelects(db: Kysely<Database>) {
  function testPostgresConditionalJsonSelects (line 121) | async function testPostgresConditionalJsonSelects(db: Kysely<Database>) {
  function testPostgresJsonAgg (line 139) | async function testPostgresJsonAgg(db: Kysely<Database>) {
  function testPostgresToJson (line 282) | async function testPostgresToJson(db: Kysely<Database>) {
  function withPets (line 306) | function withPets(eb: ExpressionBuilder<Database, 'person'>) {
  function withDoggo (line 316) | function withDoggo(eb: ExpressionBuilder<Database, 'person'>) {

FILE: test/typings/test-d/select-from.test-d.ts
  function testFromSingle (line 5) | async function testFromSingle(db: Kysely<Database>) {
  function testFromMultiple (line 117) | async function testFromMultiple(db: Kysely<Database>) {

FILE: test/typings/test-d/select-no-from.test-d.ts
  function testSelectNoFrom (line 5) | async function testSelectNoFrom(db: Kysely<Database>) {

FILE: test/typings/test-d/select.test-d.ts
  function testSelectSingle (line 14) | async function testSelectSingle(db: Kysely<Database>) {
  function testSelectAll (line 144) | async function testSelectAll(db: Kysely<Database>) {
  function testSelectMultiple (line 211) | async function testSelectMultiple(db: Kysely<Database>) {
  function testSelectDynamic (line 254) | async function testSelectDynamic(db: Kysely<Database>) {
  function testIf (line 299) | async function testIf(db: Kysely<Database>) {
  function testManyNestedSubqueries (line 350) | async function testManyNestedSubqueries(db: Kysely<Database>) {
  function jsonArrayFrom (line 455) | function jsonArrayFrom<O>(
  function jsonObjectFrom (line 461) | function jsonObjectFrom<O>(

FILE: test/typings/test-d/set-operation.test-d.ts
  function testUnion (line 5) | async function testUnion(db: Kysely<Database>) {

FILE: test/typings/test-d/update.test-d.ts
  function testUpdate (line 5) | async function testUpdate(db: Kysely<Database>) {

FILE: test/typings/test-d/where.test-d.ts
  function testWhere (line 5) | function testWhere(db: Kysely<Database>) {

FILE: test/typings/test-d/with.test-d.ts
  function testWith (line 5) | async function testWith(db: Kysely<Database>) {
  function testManyWith (line 159) | async function testManyWith(db: Kysely<Database>) {