import * as i0 from '@angular/core';
import { TemplateRef, InputSignal, Signal, InputSignalWithTransform, TrackByFunction, InjectionToken, OutputEmitterRef } from '@angular/core';
import { VariantProps } from 'class-variance-authority';

/**
 * Structural directive that captures the template for a header cell.
 *
 * Use with the star syntax inside a `comColumnDef` container.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <ng-container comColumnDef="name">
 *   <th *comHeaderCellDef>Name</th>
 *   <td *comCellDef="let row">{{ row.name }}</td>
 * </ng-container>
 * ```
 */
declare class ComHeaderCellDef {
    readonly templateRef: TemplateRef<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComHeaderCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComHeaderCellDef, "[comHeaderCellDef]", never, {}, {}, never, never, true, never>;
}

/** Template context for body cell definitions. */
interface CellDefContext<T> {
    $implicit: T;
    index: number;
}

/**
 * Structural directive that captures the template for a body cell.
 *
 * Use with the star syntax inside a `comColumnDef` container.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <ng-container comColumnDef="name">
 *   <th *comHeaderCellDef>Name</th>
 *   <td *comCellDef="let row">{{ row.name }}</td>
 * </ng-container>
 * ```
 */
declare class ComCellDef<T = unknown> {
    readonly templateRef: TemplateRef<CellDefContext<T>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComCellDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComCellDef<any>, "[comCellDef]", never, {}, {}, never, never, true, never>;
}

/**
 * Structural directive that captures the template for a footer cell.
 *
 * Use with the star syntax inside a `comColumnDef` container.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <ng-container comColumnDef="amount">
 *   <th *comHeaderCellDef>Amount</th>
 *   <td *comCellDef="let row">{{ row.amount | currency }}</td>
 *   <td *comFooterCellDef>{{ total() | currency }}</td>
 * </ng-container>
 * ```
 */
declare class ComFooterCellDef {
    readonly templateRef: TemplateRef<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComFooterCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComFooterCellDef, "[comFooterCellDef]", never, {}, {}, never, never, true, never>;
}

/**
 * Defines a single column in a `com-table`.
 *
 * Contains a header cell template, a body cell template, and an optional footer cell template.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <ng-container comColumnDef="name">
 *   <th *comHeaderCellDef>Name</th>
 *   <td *comCellDef="let row">{{ row.name }}</td>
 * </ng-container>
 * ```
 */
declare class ComColumnDef {
    /** The column name — used to match header/row column lists. */
    readonly name: InputSignal<string>;
    /** @internal Header cell template for this column. */
    readonly headerCellDef: Signal<ComHeaderCellDef | undefined>;
    /** @internal Body cell template for this column. */
    readonly cellDef: Signal<ComCellDef | undefined>;
    /** @internal Optional footer cell template for this column. */
    readonly footerCellDef: Signal<ComFooterCellDef | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComColumnDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComColumnDef, "[comColumnDef]", ["comColumnDef"], { "name": { "alias": "comColumnDef"; "required": true; "isSignal": true; }; }, {}, ["headerCellDef", "cellDef", "footerCellDef"], never, true, never>;
}

/**
 * Defines which columns appear in the header row and their order.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <tr comHeaderRowDef="['name', 'email', 'role']"></tr>
 * ```
 *
 * @example Sticky header row
 * ```html
 * <tr comHeaderRowDef="['name', 'email']" comHeaderRowDefSticky></tr>
 * ```
 *
 * @example Custom class on header row
 * ```html
 * <tr [comHeaderRowDef]="['name', 'email']" comHeaderRowDefClass="uppercase"></tr>
 * ```
 */
declare class ComHeaderRowDef {
    /** Ordered list of column names to display. */
    readonly columns: InputSignal<string[]>;
    /** Makes this header row sticky (alternative to table-level `stickyHeader`). */
    readonly sticky: InputSignalWithTransform<boolean, unknown>;
    /** Additional CSS classes to merge onto the header `<tr>`. */
    readonly headerRowClass: InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComHeaderRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComHeaderRowDef, "[comHeaderRowDef]", never, { "columns": { "alias": "comHeaderRowDef"; "required": true; "isSignal": true; }; "sticky": { "alias": "comHeaderRowDefSticky"; "required": false; "isSignal": true; }; "headerRowClass": { "alias": "comHeaderRowDefClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Defines which columns appear in each body row and their order.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <tr comRowDef [comRowDefColumns]="['name', 'email', 'role']"></tr>
 * ```
 *
 * @example Custom class on body rows
 * ```html
 * <tr comRowDef [comRowDefColumns]="['name', 'email']" comRowDefClass="even:bg-blue-50"></tr>
 * ```
 */
declare class ComRowDef {
    /** Ordered list of column names to display per body row. */
    readonly columns: InputSignal<string[]>;
    /** Additional CSS classes to merge onto each body `<tr>`. */
    readonly rowClass: InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComRowDef, "[comRowDef]", never, { "columns": { "alias": "comRowDefColumns"; "required": true; "isSignal": true; }; "rowClass": { "alias": "comRowDefClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Defines which columns appear in the footer row and their order.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <tr comFooterRowDef="['description', 'amount']"></tr>
 * ```
 *
 * @example Custom class on footer row
 * ```html
 * <tr comFooterRowDef="['description', 'amount']" comFooterRowDefClass="font-bold"></tr>
 * ```
 */
declare class ComFooterRowDef {
    /** Ordered list of column names in the footer. */
    readonly columns: InputSignal<string[]>;
    /** Additional CSS classes to merge onto the footer `<tr>`. */
    readonly footerRowClass: InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComFooterRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComFooterRowDef, "[comFooterRowDef]", never, { "columns": { "alias": "comFooterRowDef"; "required": true; "isSignal": true; }; "footerRowClass": { "alias": "comFooterRowDefClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Structural directive for the empty-state row shown when the data source is empty.
 *
 * Place inside `com-table`. The template receives the column count for colspan.
 *
 * @tokens none
 *
 * @example
 * ```html
 * <com-table [dataSource]="data()">
 *   <!-- column defs... -->
 *
 *   <ng-template comNoDataRow>
 *     <td [attr.colspan]="displayedColumns().length" class="text-center py-8">
 *       No results found.
 *     </td>
 *   </ng-template>
 * </com-table>
 * ```
 */
declare class ComNoDataRow {
    readonly templateRef: TemplateRef<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComNoDataRow, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComNoDataRow, "[comNoDataRow]", never, {}, {}, never, never, true, never>;
}

/**
 * Abstract data source for ComTable.
 *
 * Implement `connect()` to provide a signal of data, and `disconnect()` to clean up.
 * The table calls `connect()` on init and `disconnect()` on destroy.
 *
 * @example Signal-based data source
 * ```typescript
 * class MyDataSource extends ComDataSource<User> {
 *   private readonly data = signal<User[]>([]);
 *
 *   connect(): Signal<readonly User[]> {
 *     return this.data.asReadonly();
 *   }
 *
 *   disconnect(): void {
 *     // cleanup if needed
 *   }
 *
 *   setData(users: User[]): void {
 *     this.data.set(users);
 *   }
 * }
 * ```
 */
declare abstract class ComDataSource<T> {
    /** Returns a signal of the current data set. Called once when the table initializes. */
    abstract connect(): Signal<readonly T[]>;
    /** Cleanup resources. Called when the table is destroyed. */
    abstract disconnect(): void;
}
/**
 * Simple array-backed data source.
 *
 * Wraps a plain array in a writable signal so it can be used with ComTable's DataSource API.
 */
declare class ComArrayDataSource<T> extends ComDataSource<T> {
    private readonly data;
    constructor(initialData?: T[]);
    connect(): Signal<readonly T[]>;
    disconnect(): void;
    /** Replace the entire data set. */
    setData(data: T[]): void;
}
/**
 * Type guard to check if a value is a ComDataSource instance.
 */
declare function isDataSource<T>(value: unknown): value is ComDataSource<T>;
/** The types that ComTable accepts for its dataSource input. */
type ComTableDataSourceInput<T> = T[] | ComDataSource<T>;

type TableVariant = 'default' | 'striped';
type TableDensity = 'compact' | 'default' | 'comfortable';
type HeaderVariant = 'default' | 'muted';
/**
 * CVA variants for the table container wrapper.
 */
declare const tableContainerVariants: (props?: Record<string, never>) => string;
type TableContainerVariants = VariantProps<typeof tableContainerVariants>;
/**
 * CVA variants for the `<table>` element.
 *
 * @tokens `--color-foreground`
 */
declare const tableVariants: (props?: Record<string, never>) => string;
type TableVariants = VariantProps<typeof tableVariants>;
/**
 * CVA variants for the `<thead>` element.
 *
 * @tokens `--color-background`, `--color-muted`, `--color-muted-foreground`, `--color-border`
 */
declare const tableHeaderVariants: (props?: {
    sticky?: boolean;
    headerVariant?: HeaderVariant;
}) => string;
type TableHeaderVariants = VariantProps<typeof tableHeaderVariants>;
/**
 * CVA variants for the header `<tr>` — applies base styles to child `<th>` cells via child selectors.
 *
 * @tokens `--color-muted-foreground`
 */
declare const tableHeaderRowVariants: (props?: {
    density?: TableDensity;
}) => string;
type TableHeaderRowVariants = VariantProps<typeof tableHeaderRowVariants>;
/**
 * CVA variants for `<tbody> <tr>` rows — includes row-level styles and child `<td>` cell styles.
 *
 * @tokens `--color-border-subtle`, `--color-muted`, `--color-muted-hover`
 */
declare const tableRowVariants: (props?: {
    variant?: TableVariant;
    density?: TableDensity;
}) => string;
type TableRowVariants = VariantProps<typeof tableRowVariants>;
/**
 * CVA variants for the footer `<tr>` — applies base styles to child `<td>` cells via child selectors.
 *
 * @tokens `--color-foreground`, `--color-border`
 */
declare const tableFooterRowVariants: (props?: {
    density?: TableDensity;
}) => string;
type TableFooterRowVariants = VariantProps<typeof tableFooterRowVariants>;
/** @deprecated Use `tableHeaderRowVariants` instead. */
declare const tableHeaderCellVariants: typeof tableHeaderRowVariants;
/** @deprecated Use `tableHeaderRowVariants` instead. */
type TableHeaderCellVariants = TableHeaderRowVariants;
/** @deprecated Body cell styles are now part of `tableRowVariants`. */
declare const tableBodyCellVariants: typeof tableRowVariants;
/** @deprecated Body cell styles are now part of `tableRowVariants`. */
type TableBodyCellVariants = TableRowVariants;
/** @deprecated Use `tableFooterRowVariants` instead. */
declare const tableFooterCellVariants: typeof tableFooterRowVariants;
/** @deprecated Use `tableFooterRowVariants` instead. */
type TableFooterCellVariants = TableFooterRowVariants;

/**
 * Declarative data table component using native HTML `<table>` semantics.
 *
 * Define columns via `comColumnDef` with `*comHeaderCellDef` and `*comCellDef`,
 * then declare row structure via `comHeaderRowDef` and `comRowDef`.
 *
 * Accepts either a plain `T[]` or a `ComDataSource<T>` for the data source.
 *
 * @tokens `--color-background`, `--color-foreground`, `--color-muted`, `--color-muted-foreground`,
 *         `--color-muted-hover`, `--color-border`, `--color-border-subtle`
 *
 * @example Basic table
 * ```html
 * <com-table [dataSource]="users()">
 *   <ng-container comColumnDef="name">
 *     <th *comHeaderCellDef>Name</th>
 *     <td *comCellDef="let row">{{ row.name }}</td>
 *   </ng-container>
 *
 *   <ng-container comColumnDef="email">
 *     <th *comHeaderCellDef>Email</th>
 *     <td *comCellDef="let row">{{ row.email }}</td>
 *   </ng-container>
 *
 *   <tr comHeaderRowDef="['name', 'email']"></tr>
 *   <tr comRowDef [comRowDefColumns]="['name', 'email']"></tr>
 * </com-table>
 * ```
 *
 * @example With DataSource
 * ```typescript
 * class UserDataSource extends ComDataSource<User> {
 *   private data = signal<User[]>([]);
 *   connect() { return this.data.asReadonly(); }
 *   disconnect() {}
 *   setData(users: User[]) { this.data.set(users); }
 * }
 * ```
 * ```html
 * <com-table [dataSource]="userDataSource">
 *   ...
 * </com-table>
 * ```
 */
declare class ComTable<T> {
    private readonly destroyRef;
    private readonly rowClickRef;
    /** The data to render — accepts a plain array or a ComDataSource. */
    readonly dataSource: InputSignal<ComTableDataSourceInput<T>>;
    /** Track function for `@for`. Defaults to tracking by index. */
    readonly trackByFn: InputSignal<TrackByFunction<T>>;
    /** Visual treatment of body rows. */
    readonly variant: InputSignal<TableVariant>;
    /** Row height / cell padding. */
    readonly density: InputSignal<TableDensity>;
    /** Whether the header row sticks on scroll. */
    readonly stickyHeader: InputSignalWithTransform<boolean, unknown>;
    /** Shows a loading overlay with spinner. */
    readonly loading: InputSignalWithTransform<boolean, unknown>;
    /** Accessible label for the table element. */
    readonly ariaLabel: InputSignal<string | undefined>;
    /** Additional CSS classes to merge onto the host element. */
    readonly userClass: InputSignal<string>;
    /** Additional CSS classes to merge onto the container `<div>`. */
    readonly containerClass: InputSignal<string>;
    /** Additional CSS classes to merge onto the `<table>` element. */
    readonly tableClass: InputSignal<string>;
    /** Additional CSS classes to merge onto the `<thead>` element. */
    readonly theadClass: InputSignal<string>;
    /** Visual treatment of the header — `'muted'` adds a filled background. */
    readonly headerVariant: InputSignal<HeaderVariant>;
    /** @internal All column definitions projected into the table. */
    readonly columnDefs: Signal<readonly ComColumnDef[]>;
    /** @internal Header row definition. */
    readonly headerRowDef: Signal<ComHeaderRowDef | undefined>;
    /** @internal Body row definition. */
    readonly rowDef: Signal<ComRowDef | undefined>;
    /** @internal Optional footer row definition. */
    readonly footerRowDef: Signal<ComFooterRowDef | undefined>;
    /** @internal Optional no-data row template. */
    readonly noDataRow: Signal<ComNoDataRow | undefined>;
    /** @internal Map of column name → column definition for O(1) lookup. */
    protected readonly columnDefMap: Signal<Map<string, ComColumnDef>>;
    /** @internal Resolved render data — handles both array and DataSource inputs. */
    readonly renderData: Signal<readonly T[]>;
    /** @internal Header column names. */
    protected readonly headerColumns: Signal<string[]>;
    /** @internal Body column names — public for ComRowClick event delegation. */
    readonly bodyColumns: Signal<string[]>;
    /** @internal Footer column names. */
    protected readonly footerColumns: Signal<string[]>;
    /** @internal Whether the header should be sticky. */
    private readonly isSticky;
    /** @internal Whether body rows are clickable (ComRowClick directive is active). */
    protected readonly isRowClickable: Signal<boolean>;
    protected readonly hostClass: Signal<string>;
    protected readonly containerClasses: Signal<string>;
    protected readonly tableClasses: Signal<string>;
    protected readonly theadClasses: Signal<string>;
    protected readonly headerTrClasses: Signal<string>;
    protected readonly trClasses: Signal<string>;
    protected readonly footerTrClasses: Signal<string>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<ComTable<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ComTable<any>, "com-table", ["comTable"], { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "trackByFn": { "alias": "trackByFn"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; "tableClass": { "alias": "tableClass"; "required": false; "isSignal": true; }; "theadClass": { "alias": "theadClass"; "required": false; "isSignal": true; }; "headerVariant": { "alias": "headerVariant"; "required": false; "isSignal": true; }; }, {}, ["columnDefs", "headerRowDef", "rowDef", "footerRowDef", "noDataRow"], never, true, never>;
}

/** Data context that ComTable pushes to ComRowClick to avoid circular DI. */
interface ComRowClickContext<T = unknown> {
    readonly renderData: Signal<readonly T[]>;
    readonly bodyColumns: Signal<string[]>;
}
/** Minimal interface that ComTable reads to detect an active row-click directive. */
interface ComRowClickRef<T = unknown> {
    /** Whether row-click behavior is currently active (exists and not disabled). */
    readonly isActive: Signal<boolean>;
    /** Called by ComTable to provide data context — avoids circular injection. */
    _setContext(ctx: ComRowClickContext<T>): void;
}
/**
 * Injection token used by ComTable to optionally detect a ComRowClick directive.
 * Breaks the circular dependency between ComTable and ComRowClick.
 */
declare const COM_ROW_CLICK: InjectionToken<ComRowClickRef>;

/**
 * Attribute directive that enables click-to-act on `<com-table>` body rows.
 *
 * Uses event delegation — a single click/keydown listener on the `<table>` element —
 * rather than per-row bindings. When a user clicks or presses Enter/Space on a body row,
 * the directive resolves the row data and emits it, unless the click originated from an
 * excluded column's cell.
 *
 * @tokens `--color-ring`
 *
 * @example Basic
 * ```html
 * <com-table [dataSource]="users()" comRowClick (comRowClick)="openDetail($event)">
 *   ...
 * </com-table>
 * ```
 *
 * @example With column exclusion
 * ```html
 * <com-table [dataSource]="users()" comRowClick
 *            [comRowClickExclude]="['select', 'actions']"
 *            (comRowClick)="openDetail($event)">
 *   ...
 * </com-table>
 * ```
 */
declare class ComRowClick<T = unknown> implements ComRowClickRef<T> {
    private readonly elementRef;
    private readonly renderer;
    private readonly destroyRef;
    private readonly document;
    /** @internal Context pushed by ComTable — avoids circular DI. */
    private context;
    /** Column names whose cells do NOT trigger the row click output. */
    readonly comRowClickExclude: InputSignal<string[]>;
    /** Disables all row click behavior — removes cursor, tabindex, and event handling. */
    readonly comRowClickDisabled: InputSignalWithTransform<boolean, unknown>;
    /** Emits the row data object when a non-excluded cell is clicked or activated via keyboard. */
    readonly comRowClick: OutputEmitterRef<T>;
    /** Whether row-click behavior is currently active. */
    readonly isActive: Signal<boolean>;
    /** @internal Called by ComTable to provide data context. */
    _setContext(ctx: ComRowClickContext<T>): void;
    constructor();
    private handleEvent;
    private emitRow;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComRowClick<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComRowClick<any>, "com-table[comRowClick]", ["comRowClick"], { "comRowClickExclude": { "alias": "comRowClickExclude"; "required": false; "isSignal": true; }; "comRowClickDisabled": { "alias": "comRowClickDisabled"; "required": false; "isSignal": true; }; }, { "comRowClick": "comRowClick"; }, never, never, true, never>;
}

export { COM_ROW_CLICK, ComArrayDataSource, ComCellDef, ComColumnDef, ComDataSource, ComFooterCellDef, ComFooterRowDef, ComHeaderCellDef, ComHeaderRowDef, ComNoDataRow, ComRowClick, ComRowDef, ComTable, isDataSource, tableBodyCellVariants, tableContainerVariants, tableFooterCellVariants, tableFooterRowVariants, tableHeaderCellVariants, tableHeaderRowVariants, tableHeaderVariants, tableRowVariants, tableVariants };
export type { CellDefContext, ComRowClickRef, ComTableDataSourceInput, HeaderVariant, TableBodyCellVariants, TableContainerVariants, TableDensity, TableFooterCellVariants, TableFooterRowVariants, TableHeaderCellVariants, TableHeaderRowVariants, TableHeaderVariants, TableRowVariants, TableVariant, TableVariants };