opacacms 0.2.1 → 0.3.1

package/dist/db/index.js

@@ -1,34 +1,32 @@
 import {
   D1Adapter,
   createD1Adapter
-} from "../chunk-06ks4ggh.js";
+} from "../chunk-qhdsjek6.js";
 import {
   PostgresAdapter,
   createPostgresAdapter
-} from "../chunk-tfnaf41w.js";
+} from "../chunk-5422w4eq.js";
 import {
   SQLiteAdapter,
   createSQLiteAdapter
-} from "../chunk-6d1vdfwa.js";
+} from "../chunk-e0g6gn7n.js";
 import {
   BunSQLiteAdapter,
   createBunSQLiteAdapter
-} from "../chunk-n133qpsm.js";
+} from "../chunk-qsh2nqz3.js";
 import {
   BetterSQLiteAdapter,
   createBetterSQLiteAdapter
-} from "../chunk-bygjkgrx.js";
-import"../chunk-dykn5hr6.js";
+} from "../chunk-naqcqj8n.js";
+import"../chunk-j8js1y0h.js";
 import {
   BaseDatabaseAdapter
 } from "../chunk-s8mqwnm1.js";
+import"../chunk-q5sb5dcr.js";
 import"../chunk-qxt9vge8.js";
-import"../chunk-v9z61v3g.js";
-import"../chunk-t0zg026p.js";
-import"../chunk-8sqjbsgt.js";
-
-// src/db/index.ts
-import { sql } from "kysely";
+import"../chunk-jq1drsen.js";
+import"../chunk-6qs0g65f.js";
+import"../chunk-6bywt602.js";
 export {
   sql,
   createSQLiteAdapter,

package/dist/db/kysely/factory.d.ts

@@ -0,0 +1,29 @@
+import { type Dialect, Kysely } from "kysely";
+import type { OpacaConfig } from "../../types";
+/**
+ * Options for creating an OpacaCMS Kysely instance.
+ */
+export interface CreateOpacaKyselyOptions {
+    dialect: Dialect;
+    config: OpacaConfig;
+    /**
+     * If true, administrative/system features (like masking) might be adjusted.
+     * Defaults to false.
+     */
+    isAdmin?: boolean;
+    /**
+     * Function to get the current user ID for audit logging.
+     */
+    getUserId?: () => string | null;
+}
+/**
+ * Factory for creating a Kysely instance pre-configured with all OpacaCMS plugins.
+ *
+ * This is the central entry point for database initialization in OpacaCMS.
+ * It ensures that all specialized plugins (JSON, Masking, Audit, etc.) are
+ * correctly configured and applied in the right order.
+ *
+ * @param options - Configuration including dialect and CMS schema.
+ * @returns A "super-charged" Kysely instance.
+ */
+export declare function createOpacaKysely(options: CreateOpacaKyselyOptions): Kysely<any>;

package/dist/db/kysely/plugins/audit-logging.d.ts

@@ -0,0 +1,48 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the AuditLoggingPlugin.
+ */
+export interface AuditLoggingPluginConfig {
+    /**
+     * Name of the audit log table. Defaults to '_audit_logs'.
+     */
+    auditTable?: string;
+    /**
+     * Function to get the current user ID for logging.
+     */
+    getUserId?: () => string | null;
+}
+/**
+ * Kysely plugin that automatically records all database changes for auditing.
+ *
+ * Security and transparency are critical in a CMS. This plugin ensures that every
+ * insertion, update, or deletion is logged with the corresponding data changes.
+ *
+ * This plugin:
+ * 1. Intercepts `INSERT`, `UPDATE`, and `DELETE` queries.
+ * 2. Records the operation, collection/table, entity ID, and the data payload.
+ * 3. Saves the audit trail to the defined system audit log table.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new AuditLoggingPlugin({ getUserId: () => authContext.userId })]
+ * });
+ * ```
+ */
+export declare class AuditLoggingPlugin implements KyselyPlugin {
+    private auditTable;
+    private getUserId?;
+    private db;
+    private queryNodes;
+    constructor(config?: AuditLoggingPluginConfig);
+    /**
+     * Called by the factory to provide the database instance for logging.
+     */
+    setDb(db: any): void;
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+    private getTableName;
+    private logOperation;
+}

package/dist/db/kysely/plugins/auto-timestamps.d.ts

@@ -0,0 +1,38 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the AutoTimestampsPlugin.
+ */
+export interface AutoTimestampsPluginConfig {
+    /** The name of the creation timestamp column. Defaults to 'created_at'. */
+    createdAtColumn?: string;
+    /** The name of the update timestamp column. Defaults to 'updated_at'. */
+    updatedAtColumn?: string;
+}
+/**
+ * Kysely plugin that automatically manages creation and modification timestamps.
+ *
+ * In a database-driven application, tracking when a record was created or last
+ * modified is a standard requirement.
+ *
+ * This plugin:
+ * 1. Intercepts `INSERT` queries and injects values for both `createdAt` and `updatedAt`.
+ * 2. Intercepts `UPDATE` queries and automatically refreshes the `updatedAt` value.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new AutoTimestampsPlugin({ createdAtColumn: 'created_at', updatedAtColumn: 'updated_at' })]
+ * });
+ *
+ * // No need to manually pass timestamps anymore
+ * await db.insertInto('posts').values({ title: 'Hello' }).execute();
+ * ```
+ */
+export declare class AutoTimestampsPlugin implements KyselyPlugin {
+    private createdAtColumn;
+    private updatedAtColumn;
+    constructor(config?: AutoTimestampsPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}

package/dist/db/kysely/plugins/cursor-pagination.d.ts

@@ -0,0 +1,42 @@
+import { type KyselyPlugin, type PluginTransformQueryArgs, type PluginTransformResultArgs, type QueryResult, type RootOperationNode } from "kysely";
+/**
+ * Configuration for the CursorPaginationPlugin.
+ */
+export interface CursorPaginationPluginConfig {
+    /**
+     * The cursor value for pagination (typically the 'id' or 'createdAt' encoded).
+     */
+    after?: string | number;
+    /**
+     * The column to use for the cursor. Defaults to 'id'.
+     */
+    cursorColumn?: string;
+}
+/**
+ * Kysely plugin that simplifies cursor-based pagination.
+ *
+ * Traditional OFFSET/LIMIT pagination gets slow on large datasets.
+ * Cursor-based pagination provides a stable performance by using a unique index (like 'id').
+ *
+ * This plugin:
+ * 1. Automatically injects `WHERE column > ?` into the query if an `after` cursor is provided.
+ * 2. Ensures the order matches the cursor direction.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new CursorPaginationPlugin({ after: lastId })]
+ * });
+ *
+ * // Query remains simple, but gets the next page optimized
+ * await db.selectFrom('posts').selectAll().limit(10).execute();
+ * ```
+ */
+export declare class CursorPaginationPlugin implements KyselyPlugin {
+    private after;
+    private cursorColumn;
+    constructor(config: CursorPaginationPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}

package/dist/db/kysely/plugins/deadlock-handler.d.ts

@@ -0,0 +1,47 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the DeadlockRetryPlugin.
+ */
+export interface DeadlockRetryPluginConfig {
+    /**
+     * Maximum number of retry attempts. Defaults to 3.
+     */
+    maxRetries?: number;
+    /**
+     * Initial delay in milliseconds for exponential backoff. Defaults to 50.
+     */
+    initialDelay?: number;
+}
+/**
+ * Kysely plugin that automatically handles database deadlocks and retries.
+ *
+ * Databases like SQLite (especially in highly concurrent environments like
+ * Cloudflare Workers with D1) can throw 'BUSY' or 'LOCKED' errors.
+ *
+ * This plugin implements an Exponential Backoff retry strategy to ensure
+ * that temporary lock issues don't crash your CMS operations.
+ *
+ * @note Because Kysely plugins are designed to transform queries and results,
+ * catching execution errors is best handled at the Dialect or Adapter layer.
+ * This plugin serves as a standard implementation of the retry logic.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new DeadlockRetryPlugin({ maxRetries: 5 })]
+ * });
+ * ```
+ */
+export declare class DeadlockRetryPlugin implements KyselyPlugin {
+    private maxRetries;
+    private initialDelay;
+    constructor(config: DeadlockRetryPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+    /**
+     * Helper method to execute a function with retry logic.
+     * Can be used by adapters to wrap their execution calls.
+     */
+    retry<T>(fn: () => Promise<T>): Promise<T>;
+}

package/dist/db/kysely/plugins/draft-swapper.d.ts

@@ -0,0 +1,33 @@
+import { type KyselyPlugin, type PluginTransformQueryArgs, type PluginTransformResultArgs, type QueryResult, type RootOperationNode } from "kysely";
+import type { Collection, Global } from "../../../types";
+/**
+ * Configuration for the DraftSwapperPlugin.
+ */
+export interface DraftSwapperPluginConfig {
+    /**
+     * If true, queries will be redirected to the centralized versions table.
+     */
+    draftMode?: boolean;
+    /**
+     * Optional list of table names that should be swapped.
+     */
+    tables?: string[];
+    /**
+     * Full collection registry to help with query rewriting.
+     */
+    collections?: Collection[];
+    globals?: Global[];
+}
+/**
+ * Kysely plugin that redirects queries to the centralized `_doc_versions` table when in draft mode.
+ *
+ * Instead of having per-collection shadow tables, OpacaCMS uses a single `_doc_versions` table
+ * storing data as JSON blobs. This plugin intercepts queries and redirects them.
+ */
+export declare class DraftSwapperPlugin implements KyselyPlugin {
+    private draftMode;
+    private tables;
+    constructor(config: DraftSwapperPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}

package/dist/db/kysely/plugins/field-masking.d.ts

@@ -0,0 +1,45 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+import type { Collection, Global } from "../../../types";
+/**
+ * Configuration for the FieldMaskingPlugin.
+ */
+export interface FieldMaskingPluginConfig {
+    /** The list of CMS collections. */
+    collections: Collection[];
+    /** The list of CMS globals. */
+    globals?: Global[];
+    /**
+     * If true, masking is disabled.
+     * Useful in Admin context or when performing internal system operations
+     * where sensitive data should be visible.
+     */
+    disabled?: boolean;
+}
+/**
+ * Kysely plugin for automated data redaction.
+ *
+ * Prevents sensitive data (like password hashes, secret tokens, or fields marked
+ * as hidden in the CMS) from leaking into public API responses.
+ *
+ * This plugin:
+ * 1. Reads the Zod-based CMS schema to identify sensitive fields.
+ * 2. Intercepts query results and masks or removes those fields.
+ * 3. Supports a "disabled" flag for administrative or trusted contexts.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: dialect,
+ *   plugins: [new FieldMaskingPlugin({ collections, globals, disabled: isInternalContext })]
+ * });
+ * ```
+ */
+export declare class FieldMaskingPlugin implements KyselyPlugin {
+    private maskedFields;
+    private disabled;
+    constructor(config: FieldMaskingPluginConfig);
+    private parseConfig;
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+    private maskRow;
+}

package/dist/db/kysely/plugins/fts-normalizer.d.ts

@@ -0,0 +1,38 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the FtsNormalizerPlugin.
+ */
+export interface FtsNormalizerPluginConfig {
+    /** The database dialect (e.g. 'sqlite', 'postgres'). */
+    dialect: "sqlite" | "postgres" | "mysql" | "better-sqlite3" | "d1" | string;
+}
+/**
+ * Kysely plugin that provides a dialect-agnostic interface for Full-Text Search (FTS).
+ *
+ * Writing performant FTS queries is different for every database (e.g., `MATCH` in SQLite
+ * vs `to_tsvector` in Postgres).
+ *
+ * This plugin:
+ * 1. Intercepts specific search predicates like `.where('search', '=', 'term')`.
+ * 2. Automatically translates them to the native optimized FTS syntax of the current dialect.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: sqliteDialect,
+ *   plugins: [new FtsNormalizerPlugin({ dialect: 'sqlite' })]
+ * });
+ *
+ * // Generic search query
+ * await db.selectFrom('posts').where('search', '=', 'Hello').execute();
+ *
+ * // Translates to (SQLite):
+ * // SELECT * FROM posts WHERE posts MATCH 'Hello';
+ * ```
+ */
+export declare class FtsNormalizerPlugin implements KyselyPlugin {
+    private dialect;
+    constructor(config: FtsNormalizerPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}

package/dist/db/kysely/plugins/i18n-fallback.d.ts

@@ -0,0 +1,48 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+import type { Collection, Global } from "../../../types";
+/**
+ * Configuration for the AutoTranslationFallbackPlugin.
+ */
+export interface AutoTranslationFallbackPluginConfig {
+    /** The list of CMS collections. */
+    collections: Collection[];
+    /** The list of CMS globals. */
+    globals?: Global[];
+    /** The default locale to fallback to (e.g. 'en'). */
+    defaultLocale: string;
+    /** The currently requested locale (e.g. 'pt'). */
+    currentLocale: string;
+}
+/**
+ * Kysely plugin that automatically fallbacks to the default language for empty localized fields.
+ *
+ * In a multilingual CMS, if a field is requested in a specific language (e.g. 'pt')
+ * but that field is empty/null in the database, the plugin automatically copies
+ * the value from the default language (e.g. 'en') to ensure the frontend doesn't break.
+ *
+ * This plugin:
+ * 1. Identifies localized fields from the CMS schema.
+ * 2. Intercepts query results.
+ * 3. For each row, if the current locale field is empty, it populates it with the default locale's value.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new AutoTranslationFallbackPlugin({
+ *     collections,
+ *     defaultLocale: 'en',
+ *     currentLocale: 'pt'
+ *   })]
+ * });
+ * ```
+ */
+export declare class AutoTranslationFallbackPlugin implements KyselyPlugin {
+    private localizedFields;
+    private config;
+    constructor(config: AutoTranslationFallbackPluginConfig);
+    private parseConfig;
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+    private fallbackRow;
+}

package/dist/db/kysely/plugins/id-generation.d.ts

@@ -0,0 +1,42 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the IdGenerationPlugin.
+ */
+export interface IdGenerationPluginConfig {
+    /**
+     * The generation function to use. Defaults to crypto.randomUUID().
+     */
+    generateId?: () => string;
+    /**
+     * The primary key column name. Defaults to 'id'.
+     */
+    idColumn?: string;
+}
+/**
+ * Kysely plugin that automatically generates unique identifiers for new records.
+ *
+ * Manually injecting IDs (like UUIDs or CUIDs) for every insert can be
+ * repetitive. This plugin automates the process at the database layer.
+ *
+ * This plugin:
+ * 1. Intercepts `INSERT` queries.
+ * 2. If the `id` column is missing from the values, it generates and injects one.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new IdGenerationPlugin({ idColumn: 'id' })]
+ * });
+ *
+ * // 'id' will be automatically generated and injected
+ * await db.insertInto('posts').values({ title: 'New Post' }).execute();
+ * ```
+ */
+export declare class IdGenerationPlugin implements KyselyPlugin {
+    private generateId;
+    private idColumn;
+    constructor(config?: IdGenerationPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}

package/dist/db/kysely/plugins/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./audit-logging";
+export * from "./auto-timestamps";
+export * from "./cursor-pagination";
+export * from "./deadlock-handler";
+export * from "./draft-swapper";
+export * from "./field-masking";
+export * from "./fts-normalizer";
+export * from "./i18n-fallback";
+export * from "./id-generation";
+export * from "./json-flattener";
+export * from "./relationship-preloading";
+export * from "./slug-generation";
+export * from "./soft-delete";
+export * from "./tree-resolver";
+export * from "./virtual-field-resolver";
+export * from "./zod-coercion";

package/dist/db/kysely/plugins/json-flattener.d.ts

@@ -0,0 +1,38 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+import type { Collection, Global } from "../../../types";
+/**
+ * Configuration for the JsonFlattenerPlugin.
+ */
+export interface JsonFlattenerPluginConfig {
+    /** The list of CMS collections. */
+    collections: Collection[];
+    /** The list of CMS globals. */
+    globals?: Global[];
+}
+/**
+ * Kysely plugin that automatically handles JSON serialization and deserialization
+ * for SQLite and Cloudflare D1 databases.
+ *
+ * In a headless CMS, many fields like 'blocks', 'richtext', or 'localized' are stored
+ * as JSON strings in the database but should be treated as objects in the application.
+ *
+ * This plugin:
+ * 1. Inspects the CMS schema to identify JSON-compatible fields.
+ * 2. Automatically `JSON.parse`es results from the database.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: new SqliteDialect({ database }),
+ *   plugins: [new JsonFlattenerPlugin({ collections, globals })]
+ * });
+ * ```
+ */
+export declare class JsonFlattenerPlugin implements KyselyPlugin {
+    private jsonFields;
+    constructor(config: JsonFlattenerPluginConfig);
+    private parseConfig;
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+    private mapRow;
+}

package/dist/db/kysely/plugins/relationship-preloading.d.ts

@@ -0,0 +1,39 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the RelationshipPreloadingPlugin.
+ */
+export interface RelationshipPreloadingPluginConfig {
+    /**
+     * The maximum depth of the relationship expansion. Defaults to 2.
+     */
+    maxDepth?: number;
+}
+/**
+ * Kysely plugin that automatically pre-loads and nests related entities (Virtual Joins).
+ *
+ * Manually performing multiple joins or manual relationship resolution from foreign keys
+ * can be complex. This plugin handles the process transparently by fetching and
+ * nesting related documents.
+ *
+ * This plugin:
+ * 1. Identifies relationship fields in the returning result.
+ * 2. If expansion is requested, it batch-fetches related documents using a DataLoader pattern.
+ * 3. Replaces foreign key strings (UUIDs) with the expanded nested objects.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new RelationshipPreloadingPlugin({ maxDepth: 5 })]
+ * });
+ *
+ * // Query result will have { author: { id: '...', name: 'João' } }
+ * // instead of { author_id: '...' }
+ * ```
+ */
+export declare class RelationshipPreloadingPlugin implements KyselyPlugin {
+    private maxDepth;
+    constructor(config?: RelationshipPreloadingPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}

package/dist/db/kysely/plugins/slug-generation.d.ts

@@ -0,0 +1,37 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the SlugGenerationPlugin.
+ */
+export interface SlugGenerationPluginConfig {
+    /** The source column to generate the slug from. Defaults to 'title'. */
+    sourceColumn?: string;
+    /** The target slug column. Defaults to 'slug'. */
+    slugColumn?: string;
+}
+/**
+ * Kysely plugin that automatically generates URL-friendly slugs from content.
+ *
+ * Manually creating slugs can be error-prone and tedious. This plugin
+ * ensures that every record has a clean slug derived from its title or name.
+ *
+ * This plugin:
+ * 1. Intercepts `INSERT` and `UPDATE` queries.
+ * 2. If the `slug` field is empty or missing, it generates one from the `sourceColumn`.
+ * 3. Applies standard slugification (lowercase, hyphens, alphanumeric only).
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new SlugGenerationPlugin({ sourceColumn: 'name' })]
+ * });
+ * ```
+ */
+export declare class SlugGenerationPlugin implements KyselyPlugin {
+    private sourceColumn;
+    private slugColumn;
+    constructor(config?: SlugGenerationPluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+    private slugify;
+}

package/dist/db/kysely/plugins/soft-delete.d.ts

@@ -0,0 +1,42 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode } from "kysely";
+/**
+ * Configuration for the SoftDeletePlugin.
+ */
+export interface SoftDeletePluginConfig {
+    /** The name of the soft delete column. Defaults to 'deleted_at'. */
+    deletedAtColumn?: string;
+    /** List of tables that should support soft delete. If empty, applies to all. */
+    tables?: string[];
+}
+/**
+ * Kysely plugin that implements soft deletion logic.
+ *
+ * Instead of physically removing records from the database, this plugin
+ * marks them as deleted using a timestamp. This allows for data recovery
+ * and audit trails.
+ *
+ * This plugin:
+ * 1. Intercepts `DELETE` queries and rewrites them as `UPDATE` queries setting `deletedAt`.
+ * 2. Intercepts `SELECT` queries and automatically adds a `WHERE deletedAt IS NULL` filter.
+ *
+ * @example
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect,
+ *   plugins: [new SoftDeletePlugin({ deletedAtColumn: 'deleted_at' })]
+ * });
+ *
+ * // This will now perform an UPDATE instead of a DELETE
+ * await db.deleteFrom('posts').where('id', '=', 1).execute();
+ *
+ * // This will automatically exclude soft-deleted records
+ * await db.selectFrom('posts').selectAll().execute();
+ * ```
+ */
+export declare class SoftDeletePlugin implements KyselyPlugin {
+    private deletedAtColumn;
+    private tables;
+    constructor(config?: SoftDeletePluginConfig);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<any>>;
+}