import DataTableCore, { Api, Config, ConfigColumns } from 'datatables.net';
export { AjaxData, AjaxResponse, AjaxSettings, Api, Config, ConfigColumnDefs, ConfigColumns, ConfigLanguage, ConfigSearch } from 'datatables.net';
import * as _angular_core from '@angular/core';
import { InjectionToken, TemplateRef, Provider, EnvironmentProviders } from '@angular/core';
import { Observable } from 'rxjs';
import { DomSanitizer } from '@angular/platform-browser';

/**
 * Type re-exports from DataTables' own bundled type definitions.
 *
 * DataTables 2.x ships its own `.d.ts` (`datatables.net/types/types.d.ts`). We re-export the
 * relevant types so consumers never have to import from `datatables.net` directly and never
 * install the obsolete `@types/datatables.net` DefinitelyTyped package (which conflicts).
 */

/** Convenience alias mirroring DataTables' `Config` (options object). */
type DtConfig = Config;
/** Convenience generic alias for the DataTables `Api` instance, typed over the row shape. */
type DtApi<T = unknown> = Api<T>;

/**
 * The shape of the DataTables constructor (`new (element, options) => Api`).
 *
 * This is the framework-agnostic, **non-jQuery** entry point. The default export of
 * `datatables.net` (and of every styling package such as `datatables.net-dt`) is exactly
 * this constructor, the styling packages return the *same* constructor after registering
 * their CSS classes as a side-effect of import.
 */
type DataTableConstructor = typeof DataTableCore;
/**
 * DI token for the DataTable constructor the directive instantiates.
 *
 * Defaults to the unstyled core (`datatables.net`). Styling adapters
 * (`ngx-datatables-net/dt`, `/bs5`, `/tailwind`, `/material`) override this token so the
 * directive constructs a styled table without any per-adapter code in the directive itself.
 */
declare const DATA_TABLE: InjectionToken<DataTableCore<any>>;
/**
 * DI token for application-wide default DataTables options. Merged *under* each table's own
 * `dtOptions` (per-table options win). Provide via `provideDataTables(withOptions({...}))`.
 */
declare const DT_DEFAULT_OPTIONS: InjectionToken<Config>;
/**
 * DI token for a CSS class the directive adds to the DataTables container element after init.
 *
 * Styling adapters that ship their own scoped stylesheet (Tailwind, Material) provide this so the
 * directive auto-scopes their CSS, e.g. `ngxdt-tailwind` / `ngxdt-material`. This lets the authored
 * adapter CSS be self-contained and lets multiple styling themes coexist on one page.
 */
declare const DT_STYLE_SCOPE: InjectionToken<string>;
/**
 * When true, the directive escapes every column that has no explicit `render`, overriding
 * DataTables' unsafe HTML-by-default behavior. Enabled via `provideDataTables(withSafeDefaults())`.
 */
declare const DT_ESCAPE_DEFAULTS: InjectionToken<boolean>;

/**
 * Edit-in-place public contract for `[dtEditable]`.
 *
 * A column opts into editing by carrying an {@link DtEditorConfig} on its `editor` field (see
 * `DtColumn` in `dt-cell-template.ts`). A column with no `editor` is read-only. Double-clicking an
 * editable cell opens the configured editor; committing writes back through the DataTables `Api`
 * (`cell().data()`), keeping sort/filter/search correct.
 *
 * SECURITY: editor controls are rendered through Angular templates (bindings, never `innerHTML`),
 * and the committed value flows back to the cell's normal display path, which still runs through
 * the library's escaping/sanitising renderers. No edit path introduces an HTML sink.
 */
/** A single option for `select` / `multiselect` editors. */
interface DtEditorOption {
    /** The underlying value written to the cell when this option is chosen. */
    readonly value: unknown;
    /** Human-readable label shown in the control. */
    readonly label: string;
    /** When true the option is shown but cannot be picked. */
    readonly disabled?: boolean;
}
/**
 * Options for a choice editor: either a static list or a function resolved per cell (so the choice
 * set can depend on the row being edited).
 */
type DtEditorOptions<T = unknown> = readonly DtEditorOption[] | ((ctx: DtEditContext<T>) => readonly DtEditorOption[]);
/**
 * Context describing the cell being edited. Passed to `disabled`, option providers, and carried by
 * every edit event. `value` is always the cell's CURRENT underlying value (pre-edit).
 */
interface DtEditContext<T = unknown> {
    /** The live DataTables `Api` for the table. */
    readonly api: Api<T>;
    /** The full row object being edited. */
    readonly row: T;
    /** Row index in the DataTables data set. */
    readonly rowIndex: number;
    /** Column index (DataTables column order). */
    readonly colIndex: number;
    /** The column's `data` key (e.g. `'name'`), or `null` for a `data: null` column. */
    readonly columnKey: string | number | null;
    /** The cell's current underlying value (what `cell().data()` returns). */
    readonly value: unknown;
    /** The `<td>` element hosting the cell. */
    readonly cell: HTMLTableCellElement;
}
/** Payload for a committed edit: the old and new underlying values plus the cell context. */
interface DtCellEditCommit<T = unknown> extends DtEditContext<T> {
    /** Value before the edit (same as `value`). */
    readonly oldValue: unknown;
    /** Value the user committed. */
    readonly newValue: unknown;
}
/** Why an in-progress edit was cancelled without committing. */
type DtCellEditCancelReason = 'escape' | 'blur' | 'unchanged' | 'invalid' | 'programmatic';
/** Payload emitted when an edit is cancelled. */
interface DtCellEditCancel<T = unknown> extends DtEditContext<T> {
    readonly reason: DtCellEditCancelReason;
}
/** Payload emitted when an async save handler rejects; the cell has been reverted to `oldValue`. */
interface DtCellEditError<T = unknown> extends DtCellEditCommit<T> {
    /** The rejection reason / thrown error from the save handler. */
    readonly error: unknown;
}
/**
 * Optional save handler bound via the `dtSave` input. Runs on commit BEFORE the cell is written
 * (pessimistic). Return:
 * - `void` / a resolved value — synchronous success, the cell is written immediately;
 * - a `Promise` / `Observable` — the cell shows a busy state until it settles, then is written on
 *   success or left unchanged on failure (a `dtCellEditError` is emitted).
 *
 * Throwing (or rejecting) reverts the edit. This is the async contract Angular `output()`s cannot
 * express (an output's return value is discarded), which is why saving uses a callback input.
 */
type DtCellSaveHandler<T = unknown> = (commit: DtCellEditCommit<T>) => void | unknown | Promise<unknown> | Observable<unknown>;
/**
 * Context handed to a `custom` editor's `<ng-template>`. In the template these are the `let-` vars,
 * plus `commit` / `cancel` callbacks the custom control invokes to report its result:
 *
 * ```html
 * <ng-template #myEditor let-value let-commit="commit" let-cancel="cancel">
 *   <my-fancy-picker [value]="value" (picked)="commit($event)" (dismissed)="cancel()" />
 * </ng-template>
 * ```
 */
interface DtEditorTemplateContext<T = unknown> {
    /** Current underlying value (alias of `value`). */
    $implicit: unknown;
    /** Current underlying value. */
    value: unknown;
    /** The full row being edited. */
    row: T;
    /** Row index in the data set. */
    rowIndex: number;
    /** Column index. */
    colIndex: number;
    /** Commit the edit with a new value (runs validation + save). */
    commit: (value: unknown) => void;
    /** Abandon the edit, restoring the cell. */
    cancel: () => void;
}
/** Fields shared by every editor variant. */
interface DtEditorBase<T = unknown> {
    /** Accessible label for the generated control (falls back to the column title). */
    readonly ariaLabel?: string;
    /**
     * Per-cell guard. Return `true` to make a specific cell non-editable even though the column has
     * an editor (e.g. terminated employees). Omit to keep every cell in the column editable.
     */
    readonly disabled?: (ctx: DtEditContext<T>) => boolean;
    /**
     * Synchronous validation run on the candidate value before commit. Return an error message to
     * block the commit (shown inline), or `null`/`undefined` to allow it.
     */
    readonly validate?: (value: unknown, row: T) => string | null | undefined;
}
/** Single-line text editor. */
interface DtTextEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'text';
    readonly placeholder?: string;
    readonly maxLength?: number;
}
/** Multi-line text editor. */
interface DtTextareaEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'textarea';
    readonly placeholder?: string;
    readonly rows?: number;
    readonly maxLength?: number;
}
/** Numeric editor backed by `<input type="number">`. Commits a `number` (or `null` when blank). */
interface DtNumberEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'number';
    readonly min?: number;
    readonly max?: number;
    readonly step?: number;
    readonly placeholder?: string;
}
/** Date editor backed by `<input type="date">`. Commits an ISO `yyyy-mm-dd` string (or `null`). */
interface DtDateEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'date';
    /** ISO `yyyy-mm-dd` lower bound. */
    readonly min?: string;
    /** ISO `yyyy-mm-dd` upper bound. */
    readonly max?: string;
}
/** Boolean toggle editor. Commits a `boolean`. */
interface DtCheckboxEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'checkbox';
}
/** Single-choice editor backed by `<select>`. Commits the chosen option's `value`. */
interface DtSelectEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'select';
    readonly options: DtEditorOptions<T>;
    /** Optional placeholder shown as a leading empty option. */
    readonly placeholder?: string;
}
/**
 * Multi-choice editor backed by `<select multiple>`. Commits an ARRAY of the chosen option values.
 * The column's display/sort value is the array joined by {@link separator} (default `', '`).
 */
interface DtMultiSelectEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'multiselect';
    readonly options: DtEditorOptions<T>;
    /** Separator used to render the chosen array as text. Defaults to `', '`. */
    readonly separator?: string;
}
/** Escape-hatch editor: the consumer supplies any Angular control via a `<ng-template>`. */
interface DtCustomEditor<T = unknown> extends DtEditorBase<T> {
    readonly type: 'custom';
    readonly template: TemplateRef<DtEditorTemplateContext<T>>;
}
/** Discriminated union of every supported in-place editor. */
type DtEditorConfig<T = unknown> = DtTextEditor<T> | DtTextareaEditor<T> | DtNumberEditor<T> | DtDateEditor<T> | DtCheckboxEditor<T> | DtSelectEditor<T> | DtMultiSelectEditor<T> | DtCustomEditor<T>;

/**
 * Context handed to a cell's Angular template. In the `<ng-template>` these are the `let-` vars:
 *
 * ```html
 * <ng-template #cell let-value let-row="row">
 *   <a [routerLink]="['/user', row.id]">{{ value | titlecase }}</a>
 * </ng-template>
 * ```
 *
 * - `$implicit` / `cellData`, the column's data value (what `columns.data` points at).
 * - `row`, the full row object.
 * - `rowIndex` / `colIndex`, the DataTables row/column indices.
 */
interface DtCellContext<T = unknown> {
    $implicit: unknown;
    cellData: unknown;
    row: T;
    rowIndex: number;
    colIndex: number;
}
/**
 * A DataTables column that can render its cell with an Angular `<ng-template>` instead of an HTML
 * string. Set `dtTemplate` to a `TemplateRef` and the cell renders with full Angular context:
 * pipes, `routerLink`, child components, and event bindings all work, because the template keeps
 * the injector and change-detection of the component that declared it.
 *
 * Sorting, filtering and global search still operate on the column's underlying `data` (the
 * template only controls what is displayed), so ordering and search stay correct.
 *
 * ```ts
 * columns: DtColumn<User>[] = [
 *   { data: 'name', title: 'Name', dtTemplate: this.nameTpl },
 *   { data: null, title: '', orderable: false, dtTemplate: this.actionsTpl },
 * ];
 * ```
 *
 * A column may also carry an `editor` (`DtEditorConfig`) to opt into edit-in-place via the
 * companion `[dtEditable]` directive. A column with no `editor` is read-only.
 */
type DtColumn<T = unknown> = ConfigColumns & {
    dtTemplate?: TemplateRef<DtCellContext<T>>;
    editor?: DtEditorConfig<T>;
};

/**
 * `[dtEditable]` — double-click-to-edit-in-place companion to `[dtTable]`.
 *
 * Put it on the same `<table>` as `dtTable`. Columns opt in by carrying an `editor` config
 * (`DtColumn.editor`); a column with no `editor` is read-only. Double-clicking an editable cell
 * opens the configured control (text, textarea, number, date, checkbox, select, multiselect, or a
 * custom `<ng-template>`). Enter / blur commits, Escape cancels.
 *
 * Design mirrors `DtTableDirective`:
 * - The dblclick listener is delegated on the persistent `<tbody>` and (re)attached via an
 *   `afterRenderEffect` keyed on the host's `instance()` signal, so it survives table recreation.
 * - Native controls are built as real DOM elements (full control over parsing, keyboard and a11y);
 *   only `custom` editors use `createEmbeddedView`, attached to `ApplicationRef` like cell templates.
 * - Zoneless-correct: DataTables writes run via `runOutsideAngular`; output emissions re-enter
 *   Angular and `markForCheck()`. Native control listeners fire outside Angular and re-enter on emit.
 * - Commit writes through the DataTables `Api` (`cell().data(v).draw(false)`), keeping sort, filter
 *   and search correct. Cancel restores the exact original cell nodes without a redraw.
 *
 * @typeParam T row data shape (matched to the host `dtTable`).
 */
declare class DtEditableDirective<T = unknown> {
    private readonly host;
    private readonly hostEl;
    private readonly zone;
    private readonly cdr;
    private readonly appRef;
    private readonly destroyRef;
    /**
     * Type-inference anchor ONLY. `[dtData]` is owned by `dtTable`; declaring the same alias here
     * lets Angular's template type-checker infer this directive's row type `T` from the bound data
     * (sibling directives can't otherwise share a generic), so `(dtCellEdit)` etc. are typed. The
     * value is never read here — `dtTable` is the single source of truth for the data.
     */
    readonly dataTypeAnchor: _angular_core.InputSignal<readonly T[] | undefined>;
    /**
     * Optional pessimistic save handler. Runs on commit BEFORE the cell is written. Return a Promise
     * or Observable to defer the write until it settles (the control shows a busy state); reject/throw
     * to keep the cell unchanged, surface `dtCellEditError`, and leave the editor open for retry.
     * Return `void` (or any non-thenable) for a synchronous commit.
     */
    readonly save: _angular_core.InputSignal<DtCellSaveHandler<T> | undefined>;
    /** Emitted when an edit begins (editor opened). */
    readonly editStart: _angular_core.OutputEmitterRef<DtEditContext<T>>;
    /** Emitted after a changed value is validated, saved and written to the cell. */
    readonly edit: _angular_core.OutputEmitterRef<DtCellEditCommit<T>>;
    /** Emitted when an edit is abandoned (Escape, blur-with-no-change, programmatic close, …). */
    readonly editCancel: _angular_core.OutputEmitterRef<DtCellEditCancel<T>>;
    /** Emitted when an async/sync save handler fails; the cell is left unchanged. */
    readonly editError: _angular_core.OutputEmitterRef<DtCellEditError<T>>;
    private active;
    /** Guard against re-entrant commit/cancel from blur events fired while the cell DOM is changing. */
    private finishing;
    /** When the next close was keyboard-initiated, return focus to the cell (not on blur/redraw). */
    private refocusCell;
    /** Set once the directive is destroyed, so a late async save resolution does nothing. */
    private destroyed;
    /** A Tab move queued behind an in-flight async save, applied once the save commits. */
    private pendingAdvance;
    private listenerCleanup?;
    constructor();
    private attachListener;
    private detachListener;
    private onPreDraw;
    private onDblClick;
    private buildContext;
    /** Open the editor for an explicit (rowIndex, colIndex) — used by Tab navigation. */
    private openCellByIndex;
    /**
     * Tab / Shift+Tab: commit the current cell, then open the next/previous editable cell in the SAME
     * row. Cross-row movement is intentionally not performed (it would be ambiguous under paging and
     * sorting); Tab from the last editable cell simply commits and lets focus leave the table.
     */
    private handleTab;
    /** Open the next/previous editable cell in the row, if any. */
    private advanceTo;
    private findEditableColumn;
    private openEditor;
    /** Native commit trigger (Enter / blur / Tab): read the control and commit. */
    private requestCommit;
    private doCommit;
    /** Write the committed value through the Api, close the editor, and emit `dtCellEdit`. */
    private write;
    /** A save handler failed: keep the cell unchanged, show the error, and leave the editor open. */
    private handleSaveError;
    private cancel;
    /** Close any open editor on destroy WITHOUT emitting (the component is going away). */
    private discardActive;
    /** Commit the active editor (used before opening another). Returns true if it closed. */
    private finalizeActive;
    private teardownControl;
    private isAsync;
    /**
     * Normalize a Promise/Observable save result to a Promise that resolves on first value/complete.
     * For an Observable, registers `a.saveCleanup` so an in-flight subscription is torn down if the
     * editor closes or the directive is destroyed before it settles (no leaked subscriptions).
     */
    private toPromise;
    private beginSaving;
    private endSaving;
    private showError;
    private clearError;
    private errorMessage;
    private buildControl;
    private inputControl;
    private textareaControl;
    private checkboxControl;
    private selectControl;
    private customControl;
    /** Attach Enter/Escape/blur handling shared by every native control. */
    private wireControl;
    private editorFor;
    private resolvedColumns;
    private columnKey;
    private valuesEqual;
    private applyAria;
    private columnTitle;
    private styleFill;
    private focusFirst;
    /** Return focus to the edited cell after a keyboard-initiated close, for keyboard continuity. */
    private maybeRefocus;
    private emitInZone;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DtEditableDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DtEditableDirective<any>, "table[dtEditable]", ["dtEditable"], { "dataTypeAnchor": { "alias": "dtData"; "required": false; "isSignal": true; }; "save": { "alias": "dtSave"; "required": false; "isSignal": true; }; }, { "editStart": "dtCellEditStart"; "edit": "dtCellEdit"; "editCancel": "dtCellEditCancel"; "editError": "dtCellEditError"; }, never, never, true, never>;
}

/** Base payload emitted for DataTables lifecycle events. */
interface DtEvent<T = unknown> {
    /** The live DataTables `Api` instance for the table. */
    readonly api: Api<T>;
    /** The originating DOM event from DataTables. */
    readonly event: Event;
    /** Any extra positional arguments DataTables passed to the event handler. */
    readonly args: readonly unknown[];
}
/** Payload emitted when a row is clicked (delegated listener on `<tbody>`). */
interface DtRowClickEvent<T = unknown> {
    readonly api: Api<T>;
    /** The row's data object. */
    readonly row: T;
    /** The row's index in the DataTables data set. */
    readonly index: number;
    /** The `<tr>` element that was clicked. */
    readonly element: HTMLTableRowElement;
    /** The originating click event. */
    readonly event: MouseEvent;
}
/** Payload emitted on `select` / `deselect` (requires the Select extension). */
interface DtSelectEvent<T = unknown> {
    readonly api: Api<T>;
    readonly event: Event;
    /** `'row'`, `'column'` or `'cell'`, the type of items affected. */
    readonly itemType: 'row' | 'column' | 'cell' | string;
    /** Indexes affected by the (de)selection. */
    readonly indexes: unknown;
    /** The full current selection (row data), recomputed after the event. */
    readonly selected: readonly T[];
}

/**
 * A DataTables column render function: `(data, type, row, meta) => cell-output`.
 * Mirrors the signature DataTables passes to `columns.render`.
 */
type DtRenderFn<T = unknown> = (data: unknown, type: 'display' | 'filter' | 'sort' | 'type' | string, row: T, meta: {
    row: number;
    col: number;
    settings: unknown;
}) => unknown;
/**
 * SECURITY, why this exists.
 *
 * DataTables writes cell content to the DOM directly (via jQuery), which **bypasses Angular's
 * template sanitization**. `DomSanitizer` only guards values bound through Angular templates, so
 * an HTML cell renderer fed user data is a live XSS sink. This helper funnels HTML output through
 * `DomSanitizer.sanitize(SecurityContext.HTML, value)` before it ever reaches DataTables.
 *
 * Use it ONLY for the `'display'` (and optionally `'filter'`) render types, sort/type values
 * should remain the raw underlying data so ordering and filtering stay correct.
 *
 * @example
 * columns: [{ data: 'bio', render: createSanitizedHtmlRenderer(sanitizer, r => r.bioHtml) }]
 */
declare function createSanitizedHtmlRenderer<T = unknown>(sanitizer: DomSanitizer, 
/** Extract the raw HTML string to render for a row. Defaults to the cell `data`. */
html?: (row: T, data: unknown) => string | null | undefined): DtRenderFn<T>;
/**
 * A render function that ESCAPES HTML for display/filter, leaving raw data for sort/type.
 *
 * IMPORTANT: DataTables does **not** escape cell content by default, it writes data as innerHTML,
 * which is an XSS sink for untrusted data. This renderer makes a column render as plain, escaped
 * text. It is what `withSafeDefaults()` applies to every column that has no explicit `render`.
 */
declare function escapeHtmlRenderer<T = unknown>(): DtRenderFn<T>;
/**
 * Injectable convenience: returns a factory bound to the current injector's `DomSanitizer`.
 * Call within an injection context (constructor / field initializer).
 *
 * @example
 * private readonly safeHtml = injectSanitizedHtmlRenderer();
 * // ...
 * { data: 'note', render: this.safeHtml(r => r.noteHtml) }
 */
declare function injectSanitizedHtmlRenderer(): <T = unknown>(html?: (row: T, data: unknown) => string | null | undefined) => DtRenderFn<T>;

/**
 * `[dtTable]`, wraps a native `<table>` as a DataTables instance using the non-jQuery API.
 *
 * Design (see `docs/ARCHITECTURE.md`):
 * - Init happens in `afterNextRender` (browser-only), so SSR renders plain HTML and the table is
 *   enhanced only on the client (no `document`/layout access on the server).
 * - Reconciliation runs in an `afterRenderEffect`: a new `dtData` reference takes the cheap path
 *   (`clear -> rows.add -> draw`); a new `dtOptions`/`dtColumns` reference recreates the table.
 * - Zoneless-correct: construction and data writes run via `runOutsideAngular`; event callbacks
 *   re-enter Angular and `markForCheck()`. Selection/instance are also exposed as signals.
 * - Angular cell templates: columns may carry a `dtTemplate` (`DtColumn`), rendered as live
 *   EmbeddedViews into the cells so pipes, `routerLink`, components and bindings work.
 * - Teardown via `DestroyRef`: detaches listeners, destroys cell views, and calls `destroy()`.
 *
 * @typeParam T row data shape.
 */
declare class DtTableDirective<T = unknown> {
    private readonly host;
    private readonly zone;
    private readonly cdr;
    private readonly appRef;
    private readonly destroyRef;
    private readonly ctor;
    private readonly appDefaults;
    private readonly styleScope;
    private readonly escapeDefaults;
    /** DataTables options object (`Config`). A new reference recreates the table. */
    readonly options: _angular_core.InputSignal<Config>;
    /** Row data. A new array reference reconciles via the cheap `clear/rows.add/draw` path. */
    readonly data: _angular_core.InputSignal<readonly T[] | undefined>;
    /**
     * Column definitions. A new reference recreates the table. Convenience for `options.columns`.
     * Columns may carry a `dtTemplate` (`DtColumn`) to render the cell with an Angular template.
     */
    readonly columns: _angular_core.InputSignal<DtColumn<T>[] | undefined>;
    private readonly _instance;
    /** The live DataTables `Api` instance, or `undefined` until initialized (SSR / pre-render). */
    readonly instance: _angular_core.Signal<Api<T> | undefined>;
    /** `true` once the table has been constructed on the client. */
    readonly ready: _angular_core.Signal<boolean>;
    private readonly _selected;
    /** Current selection (row data). Requires the Select extension; otherwise stays empty. */
    readonly selected: _angular_core.Signal<readonly T[]>;
    /** Emits the `Api` instance once, immediately after the table is created. */
    readonly initialized: _angular_core.OutputEmitterRef<Api<T>>;
    /** DataTables `draw` event. */
    readonly draw: _angular_core.OutputEmitterRef<DtEvent<T>>;
    /** DataTables `page` event. */
    readonly page: _angular_core.OutputEmitterRef<DtEvent<T>>;
    /** DataTables `xhr` event (Ajax/server-side data load). */
    readonly xhr: _angular_core.OutputEmitterRef<DtEvent<T>>;
    /** Select extension `select` event. */
    readonly select: _angular_core.OutputEmitterRef<DtSelectEvent<T>>;
    /** Select extension `deselect` event. */
    readonly deselect: _angular_core.OutputEmitterRef<DtSelectEvent<T>>;
    /** Row click (delegated listener on `<tbody>`), with resolved row data. */
    readonly rowClick: _angular_core.OutputEmitterRef<DtRowClickEvent<T>>;
    private lastOptionsKey;
    private lastColumnsKey;
    private lastData;
    private rowClickCleanup?;
    private cellTemplates;
    private readonly cellViews;
    /** Stable structural key; functions and TemplateRefs collapse to markers so the key serializes. */
    private structuralKey;
    constructor();
    /** Build the merged DataTables config from app defaults + inputs. */
    private buildConfig;
    /**
     * Pull any `dtTemplate` off the columns into `this.cellTemplates`, returning DataTables-safe
     * column clones. A templated column without its own `render` gets a shim that renders empty for
     * `display` (the Angular template fills the cell) while keeping the raw value for sort/filter/type
     * so ordering and search stay correct.
     */
    private extractCellTemplates;
    /** Construct the DataTables instance and wire events. */
    private create;
    /** Destroy and rebuild, used when options/columns change. */
    private recreate;
    /** Cheap data reconciliation: replace rows without a full re-init. */
    private applyData;
    private bindEvents;
    /** Delegated row-click listener on the persistent `<tbody>` element. */
    private bindRowClick;
    /** Read the current Select-extension selection as row data; empty if Select isn't loaded. */
    private readSelection;
    /**
     * (Re)mount Angular cell templates into the current page's cells. Old views are destroyed first
     * so paging/sort/filter/data redraws never leak EmbeddedViews. No-op when no column uses a
     * template.
     */
    private renderCellTemplates;
    /** Detach and destroy all mounted cell-template views. */
    private destroyCellViews;
    /** Re-enter Angular for an event emission so zoned and zoneless consumers both update. */
    private emitInZone;
    private teardownInstance;
    private destroy;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DtTableDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DtTableDirective<any>, "table[dtTable]", ["dtTable"], { "options": { "alias": "dtOptions"; "required": false; "isSignal": true; }; "data": { "alias": "dtData"; "required": false; "isSignal": true; }; "columns": { "alias": "dtColumns"; "required": false; "isSignal": true; }; }, { "initialized": "dtInit"; "draw": "dtDraw"; "page": "dtPage"; "xhr": "dtXhr"; "select": "dtSelect"; "deselect": "dtDeselect"; "rowClick": "dtRowClick"; }, never, never, true, never>;
}

/**
 * A composable unit of DataTables configuration. Styling adapters
 * (`ngx-datatables-net/dt`, `/bs5`, `/tailwind`, `/material`) each export a `with*()` feature
 * returning one of these.
 */
interface DataTablesFeature {
    readonly providers: Provider[];
}
/**
 * Configure ngx-datatables-net at the application (or route/component) level.
 *
 * @example
 * // app.config.ts
 * providers: [provideDataTables(withDefaultStyling(), withOptions({ pageLength: 25 }))]
 */
declare function provideDataTables(...features: DataTablesFeature[]): EnvironmentProviders;
/**
 * Set application-wide default DataTables options, merged *under* each table's own `dtOptions`.
 */
declare function withOptions(defaults: Config): DataTablesFeature;
/**
 * Escape every column that has no explicit `render`, overriding DataTables' unsafe
 * HTML-by-default behavior. Strongly recommended whenever a table can display untrusted data.
 * Columns with their own `render` (including the sanitized-HTML renderer) are left untouched.
 *
 * @example
 * provideDataTables(withDefaultStyling(), withSafeDefaults())
 */
declare function withSafeDefaults(): DataTablesFeature;

export { DATA_TABLE, DT_DEFAULT_OPTIONS, DT_ESCAPE_DEFAULTS, DT_STYLE_SCOPE, DtEditableDirective, DtTableDirective, createSanitizedHtmlRenderer, escapeHtmlRenderer, injectSanitizedHtmlRenderer, provideDataTables, withOptions, withSafeDefaults };
export type { DataTableConstructor, DataTablesFeature, DtApi, DtCellContext, DtCellEditCancel, DtCellEditCancelReason, DtCellEditCommit, DtCellEditError, DtCellSaveHandler, DtCheckboxEditor, DtColumn, DtConfig, DtCustomEditor, DtDateEditor, DtEditContext, DtEditorBase, DtEditorConfig, DtEditorOption, DtEditorOptions, DtEditorTemplateContext, DtEvent, DtMultiSelectEditor, DtNumberEditor, DtRenderFn, DtRowClickEvent, DtSelectEditor, DtSelectEvent, DtTextEditor, DtTextareaEditor };