eslint-plugin-slonik 1.0.0

package/LICENSE

@@ -0,0 +1,48 @@
+Copyright (c) 2026, Gajus Kuizinas (https://gajus.com/)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Gajus Kuizinas (https://gajus.com/) nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL GAJUS KUIZINAS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+MIT License
+
+Copyright (c) 2022 ts-safeql
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,368 @@
+# eslint-plugin-slonik
+
+Provides compile-time SQL query validation by checking your raw SQL strings against your actual database schema, catching errors before runtime.
+
+This is a fork of [@ts-safeql/eslint-plugin](https://github.com/ts-safeql/safeql) with native support for Slonik's SQL tag builders (`sql.array`, `sql.fragment`, `sql.identifier`, `sql.unnest`, etc.).
+
+## Features
+
+- 🔍 **SQL Validation** — Validates SQL queries against your PostgreSQL database schema at lint time
+- 🏷️ **Slonik SQL Tags** — Native support for all Slonik SQL tag builders
+- 🎯 **Type Inference** — Extracts type hints from `sql.array()`, `sql.unnest()`, and `sql.identifier()`
+- 📝 **Fragment Support** — Properly handles `sql.fragment` for dynamic query composition
+- ✨ **Graceful Degradation** — Skips validation for runtime-dependent constructs like `sql.join()`
+
+## Installation
+
+```bash
+npm install eslint-plugin-slonik --save-dev
+# or
+pnpm add eslint-plugin-slonik --save-dev
+# or
+yarn add eslint-plugin-slonik --dev
+```
+
+### Peer Dependencies
+
+```bash
+npm install @typescript-eslint/utils libpg-query --save-dev
+```
+
+## Configuration
+
+### ESLint Flat Config (eslint.config.js)
+
+```js
+import slonik from "eslint-plugin-slonik/config";
+
+export default [
+  // ... other configs
+  slonik.configs.connections({
+    databaseUrl: process.env.DATABASE_URL,
+    overrides: {
+      types: {
+        // Map PostgreSQL types to Slonik token types
+        date: "DateSqlToken",
+        timestamp: "TimestampSqlToken",
+        interval: "IntervalSqlToken",
+        json: "JsonSqlToken",
+        jsonb: "JsonBinarySqlToken",
+        uuid: "UuidSqlToken",
+        "int4[]": 'ArraySqlToken<"int4">',
+        "text[]": 'ArraySqlToken<"text">',
+        "uuid[]": 'ArraySqlToken<"uuid">',
+        "numeric[]": 'ArraySqlToken<"numeric">',
+        "real[]": "VectorSqlToken",
+      },
+    },
+    targets: [
+      {
+        // Match Slonik's typed query methods
+        tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
+        skipTypeAnnotations: true,
+      },
+    ],
+  }),
+];
+```
+
+### Using a Config File (slonik.config.ts)
+
+Alternatively, use a separate config file:
+
+**eslint.config.js:**
+```js
+import slonik from "eslint-plugin-slonik/config";
+
+export default [
+  slonik.configs.useConfigFile,
+];
+```
+
+**slonik.config.ts:**
+```ts
+import { defineConfig } from "eslint-plugin-slonik";
+
+export default defineConfig({
+  connections: {
+    databaseUrl: process.env.DATABASE_URL,
+    overrides: {
+      types: {
+        date: "DateSqlToken",
+        timestamp: "TimestampSqlToken",
+        interval: "IntervalSqlToken",
+        json: "JsonSqlToken",
+        jsonb: "JsonBinarySqlToken",
+        uuid: "UuidSqlToken",
+        "int4[]": 'ArraySqlToken<"int4">',
+        "text[]": 'ArraySqlToken<"text">',
+        "uuid[]": 'ArraySqlToken<"uuid">',
+      },
+    },
+    targets: [
+      {
+        tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
+        skipTypeAnnotations: true,
+      },
+    ],
+  },
+});
+```
+
+## Slonik SQL Tag Support
+
+| SQL Tag | Support | Behavior |
+|---------|---------|----------|
+| `sql.array([1,2], 'int4')` | ✅ Full | Extracts type → `$1::int4[]` |
+| `sql.array([1,2], sql.fragment\`int[]\`)` | ✅ Graceful | Falls back to `$1` |
+| `sql.unnest([[...]], ['int4','text'])` | ✅ Full | Extracts types → `unnest($1::int4[], $2::text[])` |
+| `sql.identifier(['schema','table'])` | ✅ Full | Embeds → `"schema"."table"` |
+| `sql.fragment\`...\`` | ✅ Full | Embeds SQL content directly |
+| `sql.join([...], glue)` | ✅ Skip | Skipped (runtime content) |
+| `sql.binary(buffer)` | ✅ Skip | Skipped |
+| `sql.date(date)` | ✅ Skip | Skipped |
+| `sql.timestamp(date)` | ✅ Skip | Skipped |
+| `sql.interval({...})` | ✅ Skip | Skipped |
+| `sql.json(value)` | ✅ Skip | Skipped |
+| `sql.jsonb(value)` | ✅ Skip | Skipped |
+| `sql.uuid(str)` | ✅ Skip | Skipped |
+| `sql.literalValue(str)` | ✅ Skip | Skipped |
+
+### How It Works
+
+**Full Support** means the plugin extracts type information and generates accurate PostgreSQL placeholders for validation:
+
+```ts
+// sql.array with type hint
+sql.type(z.object({ ids: z.array(z.number()) }))`
+  SELECT * FROM users WHERE id = ANY(${sql.array(userIds, 'int4')})
+`;
+// → Validates: SELECT * FROM users WHERE id = ANY($1::int4[])
+
+// sql.identifier for dynamic table/column names
+sql.type(z.object({ id: z.number() }))`
+  SELECT id FROM ${sql.identifier(['public', 'users'])}
+`;
+// → Validates: SELECT id FROM "public"."users"
+
+// sql.fragment for query composition
+const whereClause = sql.fragment`WHERE active = true`;
+sql.type(z.object({ id: z.number() }))`
+  SELECT id FROM users ${whereClause}
+`;
+// → Validates: SELECT id FROM users WHERE active = true
+```
+
+**Graceful Skip** means the plugin recognizes Slonik tokens and skips validation for those expressions, preventing false positives:
+
+```ts
+// sql.join - content determined at runtime
+sql.unsafe`
+  SELECT * FROM users WHERE ${sql.join([
+    sql.fragment`name = ${name}`,
+    sql.fragment`age > ${age}`,
+  ], sql.fragment` AND `)}
+`;
+// → Plugin skips validation for the join expression
+```
+
+## Type Override Reference
+
+When using Slonik, you'll want to map PostgreSQL types to Slonik's token types:
+
+```ts
+overrides: {
+  types: {
+    // Date/Time types
+    date: "DateSqlToken",
+    timestamp: "TimestampSqlToken",
+    timestamptz: "TimestampSqlToken",
+    interval: "IntervalSqlToken",
+
+    // JSON types
+    json: "JsonSqlToken",
+    jsonb: "JsonBinarySqlToken",
+
+    // UUID
+    uuid: "UuidSqlToken",
+
+    // Array types (use ArraySqlToken<"element_type">)
+    "int4[]": 'ArraySqlToken<"int4">',
+    "int8[]": 'ArraySqlToken<"int8">',
+    "text[]": 'ArraySqlToken<"text">',
+    "uuid[]": 'ArraySqlToken<"uuid">',
+    "numeric[]": 'ArraySqlToken<"numeric">',
+    "bool[]": 'ArraySqlToken<"bool">',
+
+    // Vector types (for pgvector)
+    "real[]": "VectorSqlToken",
+    vector: "VectorSqlToken",
+  },
+}
+```
+
+## Target Pattern Reference
+
+The `tag` option uses regex to match Slonik's query methods:
+
+```ts
+targets: [
+  {
+    // Matches: sql.type(...)``, sql.typeAlias(...)``, sql.unsafe``
+    tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
+    skipTypeAnnotations: true,
+  },
+]
+```
+
+## Example Project Setup
+
+### 1. Install dependencies
+
+```bash
+pnpm add slonik zod
+pnpm add -D eslint-plugin-slonik @typescript-eslint/utils libpg-query
+```
+
+### 2. Create your SQL tag with type aliases
+
+```ts
+// src/db/sql.ts
+import { createSqlTag } from "slonik";
+import { z } from "zod";
+
+export const sql = createSqlTag({
+  typeAliases: {
+    id: z.object({ id: z.number() }),
+    void: z.object({}).strict(),
+  },
+});
+```
+
+### 3. Configure ESLint
+
+```js
+// eslint.config.js
+import slonik from "eslint-plugin-slonik/config";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  ...tseslint.configs.recommended,
+  slonik.configs.connections({
+    databaseUrl: process.env.DATABASE_URL,
+    overrides: {
+      types: {
+        date: "DateSqlToken",
+        timestamp: "TimestampSqlToken",
+        json: "JsonSqlToken",
+        jsonb: "JsonBinarySqlToken",
+        uuid: "UuidSqlToken",
+        "int4[]": 'ArraySqlToken<"int4">',
+        "text[]": 'ArraySqlToken<"text">',
+      },
+    },
+    targets: [
+      {
+        tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
+        skipTypeAnnotations: true,
+      },
+    ],
+  })
+);
+```
+
+### 4. Write validated queries
+
+```ts
+import { sql } from "./db/sql";
+import { pool } from "./db/pool";
+
+// ✅ Valid - query matches schema
+const users = await pool.many(
+  sql.type(z.object({ id: z.number(), name: z.string() }))`
+    SELECT id, name FROM users WHERE active = true
+  `
+);
+
+// ✅ Valid - using sql.array with type hint
+const usersByIds = await pool.many(
+  sql.type(z.object({ id: z.number(), name: z.string() }))`
+    SELECT id, name FROM users WHERE id = ANY(${sql.array(ids, 'int4')})
+  `
+);
+
+// ✅ Valid - using sql.fragment for composition
+const orderBy = sql.fragment`ORDER BY created_at DESC`;
+const recentUsers = await pool.many(
+  sql.type(z.object({ id: z.number(), name: z.string() }))`
+    SELECT id, name FROM users ${orderBy}
+  `
+);
+
+// ❌ Error - column 'naem' does not exist
+const typo = await pool.many(
+  sql.type(z.object({ id: z.number(), name: z.string() }))`
+    SELECT id, naem FROM users
+  `
+);
+```
+
+## Differences from @ts-safeql/eslint-plugin
+
+This plugin is specifically designed for Slonik and includes:
+
+1. **Native Slonik token recognition** — Recognizes all Slonik SQL token types (`ArraySqlToken`, `FragmentSqlToken`, etc.)
+2. **Type hint extraction** — Extracts PostgreSQL types from `sql.array()` and `sql.unnest()` calls
+3. **Fragment embedding** — Properly embeds `sql.fragment` content into the query for validation
+4. **Identifier support** — Converts `sql.identifier()` to quoted identifiers
+5. **Graceful degradation** — Skips validation for runtime-dependent constructs instead of erroring
+
+## Development
+
+### Prerequisites
+
+- Node.js 24+
+- pnpm 10+
+- PostgreSQL 18
+
+### Setup
+
+```bash
+# Install dependencies
+pnpm install
+
+# Start PostgreSQL (e.g., using Docker)
+docker run -d --name postgres -p 5432:5432 \
+  -e POSTGRES_USER=postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=postgres \
+  postgres:18
+```
+
+### Running Tests
+
+```bash
+# Set PostgreSQL environment variables
+export PGUSER=postgres
+export PGPASSWORD=postgres
+export PGHOST=localhost
+export PGDATABASE=postgres
+
+# Run tests
+pnpm run test:vitest
+```
+
+### Linting
+
+```bash
+pnpm run lint:eslint    # ESLint
+pnpm run lint:tsc       # TypeScript type checking
+pnpm run lint:cspell    # Spell checking
+pnpm run lint:knip      # Unused code detection
+```
+
+### Building
+
+```bash
+pnpm run build
+```

package/dist/config.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const index = require('./shared/eslint-plugin-slonik.BxexVlk1.cjs');
+require('./shared/eslint-plugin-slonik.rlOTrCdf.cjs');
+require('path');
+require('postgres');
+require('crypto');
+require('fs');
+require('ts-pattern');
+require('@typescript-eslint/utils');
+require('fp-ts/lib/Either.js');
+require('fp-ts/lib/function.js');
+require('fp-ts/lib/Option.js');
+require('fp-ts/lib/TaskEither.js');
+require('fp-ts/lib/Json.js');
+require('pg-connection-string');
+require('typescript');
+require('synckit');
+require('node:url');
+require('zod');
+require('module');
+
+const version = "1.0.0";
+
+const slonikPlugin = {
+  rules: index.rules,
+  meta: {
+    name: "eslint-plugin-slonik",
+    version
+  }
+};
+
+const config = {
+  configs: {
+    /**
+     * If you prefer configuring via a config file (slonik.config.ts), use this config.
+     */
+    useConfigFile: {
+      plugins: {
+        slonik: slonikPlugin
+      },
+      rules: {
+        "slonik/check-sql": ["error", { useConfigFile: true }]
+      }
+    },
+    /**
+     * If you prefer configuring via a flat config, use this config.
+     */
+    connections: (connections) => ({
+      plugins: {
+        slonik: slonikPlugin
+      },
+      rules: {
+        "slonik/check-sql": ["error", { connections }]
+      }
+    })
+  }
+};
+
+module.exports = config;
+//# sourceMappingURL=config.cjs.map

package/dist/config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.cjs","sources":["../src/plugin.ts","../src/config.ts"],"sourcesContent":["import { FlatConfig } from \"@typescript-eslint/utils/ts-eslint\";\nimport rules from \"./rules\";\nimport { version } from \"../package.json\";\n\nexport default {\n  rules: rules,\n  meta: {\n    name: \"eslint-plugin-slonik\",\n    version: version,\n  },\n} satisfies FlatConfig.Plugin;\n","import { FlatConfig } from \"@typescript-eslint/utils/ts-eslint\";\nimport { Config } from \"./rules/RuleOptions\";\nimport slonikPlugin from \"./plugin\";\n\nexport default {\n  configs: {\n    /**\n     * If you prefer configuring via a config file (slonik.config.ts), use this config.\n     */\n    useConfigFile: {\n      plugins: {\n        slonik: slonikPlugin,\n      },\n      rules: {\n        \"slonik/check-sql\": [\"error\", { useConfigFile: true }],\n      },\n    } satisfies FlatConfig.Config,\n\n    /**\n     * If you prefer configuring via a flat config, use this config.\n     */\n    connections: (connections: Config[\"connections\"]): FlatConfig.Config => ({\n      plugins: {\n        slonik: slonikPlugin,\n      },\n      rules: {\n        \"slonik/check-sql\": [\"error\", { connections }],\n      },\n    }),\n  },\n};\n"],"names":["rules"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAIA,qBAAe;AAAA,SACbA,WAAA;AAAA,EACA,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM,sBAAA;AAAA,IACN;AAAA;AAEJ,CAAA;;ACNA,eAAe;AAAA,EACb,OAAA,EAAS;AAAA;AAAA;AAAA;AAAA,IAIP,aAAA,EAAe;AAAA,MACb,OAAA,EAAS;AAAA,QACP,MAAA,EAAQ;AAAA,OACV;AAAA,MACA,KAAA,EAAO;AAAA,QACL,oBAAoB,CAAC,OAAA,EAAS,EAAE,aAAA,EAAe,MAAM;AAAA;AACvD,KACF;AAAA;AAAA;AAAA;AAAA,IAKA,WAAA,EAAa,CAAC,WAAA,MAA2D;AAAA,MACvE,OAAA,EAAS;AAAA,QACP,MAAA,EAAQ;AAAA,OACV;AAAA,MACA,KAAA,EAAO;AAAA,QACL,kBAAA,EAAoB,CAAC,OAAA,EAAS,EAAE,aAAa;AAAA;AAC/C,KACF;AAAA;AAEJ,CAAA;;;;"}

package/dist/config.d.cts

@@ -0,0 +1,192 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+import { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+import { C as Config } from './shared/eslint-plugin-slonik.1m1xlVmw.cjs';
+import 'zod';
+
+declare const _default: {
+    configs: {
+        /**
+         * If you prefer configuring via a config file (slonik.config.ts), use this config.
+         */
+        useConfigFile: {
+            plugins: {
+                slonik: {
+                    rules: {
+                        "check-sql": _typescript_eslint_utils_ts_eslint.RuleModule<"error" | "typeInferenceFailed" | "invalidQuery" | "missingTypeAnnotations" | "incorrectTypeAnnotations" | "invalidTypeAnnotations", ({
+                            connections: {
+                                targets: ({
+                                    wrapper: string | {
+                                        regex: string;
+                                    };
+                                    maxDepth?: number | undefined;
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                } | {
+                                    tag: string | {
+                                        regex: string;
+                                    };
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                })[];
+                                migrationsDir: string;
+                                keepAlive?: boolean | undefined;
+                                overrides?: {
+                                    types?: Record<"bigint" | "boolean" | "int" | "null" | "void" | "date" | "int2" | "int4" | "int8" | "smallint" | "real" | "float4" | "float" | "float8" | "numeric" | "decimal" | "smallserial" | "serial" | "bigserial" | "uuid" | "text" | "varchar" | "char" | "bpchar" | "citext" | "bit" | "bool" | "timestamp" | "timestamptz" | "time" | "timetz" | "interval" | "inet" | "cidr" | "macaddr" | "macaddr8" | "money" | "json" | "jsonb" | "bytea", string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | Record<string, string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | undefined;
+                                    columns?: Record<string, string> | undefined;
+                                } | undefined;
+                                nullAsUndefined?: boolean | undefined;
+                                nullAsOptional?: boolean | undefined;
+                                inferLiterals?: boolean | ("string" | "number" | "boolean")[] | undefined;
+                                connectionUrl?: string | undefined;
+                                databaseName?: string | undefined;
+                                watchMode?: boolean | undefined;
+                            } | {
+                                targets: ({
+                                    wrapper: string | {
+                                        regex: string;
+                                    };
+                                    maxDepth?: number | undefined;
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                } | {
+                                    tag: string | {
+                                        regex: string;
+                                    };
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                })[];
+                                databaseUrl: string;
+                                keepAlive?: boolean | undefined;
+                                overrides?: {
+                                    types?: Record<"bigint" | "boolean" | "int" | "null" | "void" | "date" | "int2" | "int4" | "int8" | "smallint" | "real" | "float4" | "float" | "float8" | "numeric" | "decimal" | "smallserial" | "serial" | "bigserial" | "uuid" | "text" | "varchar" | "char" | "bpchar" | "citext" | "bit" | "bool" | "timestamp" | "timestamptz" | "time" | "timetz" | "interval" | "inet" | "cidr" | "macaddr" | "macaddr8" | "money" | "json" | "jsonb" | "bytea", string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | Record<string, string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | undefined;
+                                    columns?: Record<string, string> | undefined;
+                                } | undefined;
+                                nullAsUndefined?: boolean | undefined;
+                                nullAsOptional?: boolean | undefined;
+                                inferLiterals?: boolean | ("string" | "number" | "boolean")[] | undefined;
+                            } | ({
+                                targets: ({
+                                    wrapper: string | {
+                                        regex: string;
+                                    };
+                                    maxDepth?: number | undefined;
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                } | {
+                                    tag: string | {
+                                        regex: string;
+                                    };
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                })[];
+                                migrationsDir: string;
+                                keepAlive?: boolean | undefined;
+                                overrides?: {
+                                    types?: Record<"bigint" | "boolean" | "int" | "null" | "void" | "date" | "int2" | "int4" | "int8" | "smallint" | "real" | "float4" | "float" | "float8" | "numeric" | "decimal" | "smallserial" | "serial" | "bigserial" | "uuid" | "text" | "varchar" | "char" | "bpchar" | "citext" | "bit" | "bool" | "timestamp" | "timestamptz" | "time" | "timetz" | "interval" | "inet" | "cidr" | "macaddr" | "macaddr8" | "money" | "json" | "jsonb" | "bytea", string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | Record<string, string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | undefined;
+                                    columns?: Record<string, string> | undefined;
+                                } | undefined;
+                                nullAsUndefined?: boolean | undefined;
+                                nullAsOptional?: boolean | undefined;
+                                inferLiterals?: boolean | ("string" | "number" | "boolean")[] | undefined;
+                                connectionUrl?: string | undefined;
+                                databaseName?: string | undefined;
+                                watchMode?: boolean | undefined;
+                            } | {
+                                targets: ({
+                                    wrapper: string | {
+                                        regex: string;
+                                    };
+                                    maxDepth?: number | undefined;
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                } | {
+                                    tag: string | {
+                                        regex: string;
+                                    };
+                                    transform?: string | (string | [string, string])[] | undefined;
+                                    fieldTransform?: "snake" | "pascal" | "camel" | "screaming snake" | undefined;
+                                    skipTypeAnnotations?: boolean | undefined;
+                                })[];
+                                databaseUrl: string;
+                                keepAlive?: boolean | undefined;
+                                overrides?: {
+                                    types?: Record<"bigint" | "boolean" | "int" | "null" | "void" | "date" | "int2" | "int4" | "int8" | "smallint" | "real" | "float4" | "float" | "float8" | "numeric" | "decimal" | "smallserial" | "serial" | "bigserial" | "uuid" | "text" | "varchar" | "char" | "bpchar" | "citext" | "bit" | "bool" | "timestamp" | "timestamptz" | "time" | "timetz" | "interval" | "inet" | "cidr" | "macaddr" | "macaddr8" | "money" | "json" | "jsonb" | "bytea", string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | Record<string, string | {
+                                        parameter: string | {
+                                            regex: string;
+                                        };
+                                        return: string;
+                                    }> | undefined;
+                                    columns?: Record<string, string> | undefined;
+                                } | undefined;
+                                nullAsUndefined?: boolean | undefined;
+                                nullAsOptional?: boolean | undefined;
+                                inferLiterals?: boolean | ("string" | "number" | "boolean")[] | undefined;
+                            })[];
+                        } | {
+                            useConfigFile: boolean;
+                        })[], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+                            name: string;
+                        };
+                    };
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                };
+            };
+            rules: {
+                "slonik/check-sql": ["error", {
+                    useConfigFile: boolean;
+                }];
+            };
+        };
+        /**
+         * If you prefer configuring via a flat config, use this config.
+         */
+        connections: (connections: Config["connections"]) => FlatConfig.Config;
+    };
+};
+
+export = _default;