@angular-bootstrap/ngbootstrap 0.0.1

package/types/angular-bootstrap-ngbootstrap.d.ts

@@ -0,0 +1,747 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, AfterContentInit, OnChanges, EventEmitter, SimpleChanges, InjectionToken, OnDestroy, QueryList, ElementRef, AfterViewInit } from '@angular/core';
+import { AbstractControl, FormGroup, FormControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+
+type ColumnType = 'text' | 'number' | 'email' | 'boolean' | 'date' | 'select';
+interface ColumnDef<T = any> {
+    /** key of the property on your row object */
+    field: Extract<keyof T, string>;
+    /** human‐readable header text */
+    header: string;
+    /** enable clicking to sort */
+    sortable?: boolean;
+    /** enable filtering on this column */
+    filterable?: boolean;
+    editable?: boolean;
+    type?: ColumnType;
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    required?: boolean;
+}
+
+interface CellCtx<T = any> {
+    $implicit: any;
+    row: T;
+    col: ColumnDef<T>;
+    index: number;
+}
+interface EditCtx<T = any> {
+    $implicit: AbstractControl | null;
+    control: AbstractControl | null;
+    row: T;
+    col: ColumnDef<T>;
+    form: FormGroup;
+    index: number;
+    isNew: boolean;
+}
+interface FilterCtx<T = any> {
+    $implicit: AbstractControl | null;
+    control: AbstractControl | null;
+    col: ColumnDef<T>;
+}
+interface GlobalFilterCtx {
+    $implicit: AbstractControl;
+}
+declare class NgbCellTemplate<T = any> {
+    readonly template: TemplateRef<CellCtx<T>>;
+    field: string;
+    constructor(template: TemplateRef<CellCtx<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCellTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCellTemplate<any>, "ng-template[ngbCell]", never, { "field": { "alias": "ngbCell"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class NgbEditorTemplate<T = any> {
+    readonly template: TemplateRef<EditCtx<T>>;
+    field: string;
+    constructor(template: TemplateRef<EditCtx<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbEditorTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbEditorTemplate<any>, "ng-template[ngbEditor]", never, { "field": { "alias": "ngbEditor"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class NgbFilterTemplate<T = any> {
+    readonly template: TemplateRef<FilterCtx<T>>;
+    field: string;
+    constructor(template: TemplateRef<FilterCtx<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbFilterTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbFilterTemplate<any>, "ng-template[ngbFilter]", never, { "field": { "alias": "ngbFilter"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class NgbGlobalFilterTemplate {
+    readonly template: TemplateRef<GlobalFilterCtx>;
+    constructor(template: TemplateRef<GlobalFilterCtx>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbGlobalFilterTemplate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbGlobalFilterTemplate, "ng-template[ngbGlobalFilter]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbRowDetailTemplate<T = any> {
+    readonly template: TemplateRef<{
+        $implicit: T;
+        index: number;
+    }>;
+    constructor(template: TemplateRef<{
+        $implicit: T;
+        index: number;
+    }>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbRowDetailTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbRowDetailTemplate<any>, "ng-template[ngbRowDetail]", never, {}, {}, never, never, true, never>;
+}
+/** Handy constant to import in consumer apps */
+declare const DATAGRID_TEMPLATE_DIRECTIVES: (typeof NgbCellTemplate | typeof NgbGlobalFilterTemplate)[];
+
+type NgbDataGridExportType = 'pdf' | 'excel' | 'both';
+type NgbDataGridExportPages = 'all' | 'current' | 'selection';
+type NgbDataGridTheme = 'material' | 'tailwind' | 'bootstrap';
+interface NgbDataGridExportOptions {
+    enabled: boolean;
+    type: NgbDataGridExportType;
+    pages: NgbDataGridExportPages;
+    fileName?: string;
+    pdf?: {
+        pageSize?: 'A4' | 'Letter' | string;
+        landscape?: boolean;
+        margins?: [number, number, number, number];
+    };
+    excel?: {
+        sheetName?: string;
+    };
+}
+interface NgbDataGridResponsiveOptions {
+    enabled: boolean;
+    breakpoints?: {
+        mobile?: number;
+        tablet?: number;
+        desktop?: number;
+    };
+}
+
+interface ExportButtonContext {
+    $implicit: (kind: 'pdf' | 'excel') => void;
+}
+declare class ExportButtonDirective {
+    readonly templateRef: TemplateRef<ExportButtonContext>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExportButtonDirective, "[ngbExportButton]", never, {}, {}, never, never, true, never>;
+}
+
+type SortDir = 'asc' | 'desc' | '';
+type KeyOf<T> = Extract<keyof T, string>;
+declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
+    /** Column definitions to render */
+    columns: ColumnDef<T>[];
+    /** Row data to display */
+    data: T[];
+    enableSorting: boolean;
+    enableFiltering: boolean;
+    enableGlobalFilter: boolean;
+    enablePagination: boolean;
+    enableEdit: boolean;
+    enableDelete: boolean;
+    pageSizeOptions: number[];
+    enableAdd: boolean;
+    /** Accessible label (aria-label) applied to the add-row button. */
+    addButtonAriaLabel: string | null;
+    /** Visible text rendered inside the add-row button. */
+    addButtonText: string;
+    /** Accessible label for the global filter input. */
+    globalFilterAriaLabel: string;
+    /** Accessible label announced when expanding a row. */
+    expandRowAriaLabel: string;
+    /** Accessible label announced when collapsing a row. */
+    collapseRowAriaLabel: string;
+    /** Accessible label for the PDF export button. */
+    exportPdfAriaLabel: string;
+    /** Accessible label for the Excel export button. */
+    exportExcelAriaLabel: string;
+    /** Optional defaults for new rows */
+    newRowDefaults: Partial<Record<KeyOf<T>, any>> | (() => Partial<Record<KeyOf<T>, any>>) | null;
+    strictEmail: boolean;
+    editOnRowClick: boolean;
+    singleExpand: boolean;
+    exportOptions: NgbDataGridExportOptions;
+    theme: NgbDataGridTheme;
+    responsive: NgbDataGridResponsiveOptions | boolean;
+    dataProviderAll?: () => Observable<any[]> | Promise<any[]> | any[];
+    dataProviderSelection?: () => any[];
+    exportButtonDir?: ExportButtonDirective;
+    exporting: boolean;
+    rowAdd: EventEmitter<{
+        newRow: T;
+    }>;
+    rowEdit: EventEmitter<{
+        row: T;
+        index: number;
+    }>;
+    rowSave: EventEmitter<{
+        original: T;
+        updated: T;
+        index: number;
+    }>;
+    rowCancel: EventEmitter<{
+        row: T;
+        index: number;
+    }>;
+    rowDelete: EventEmitter<{
+        row: T;
+        index: number;
+    }>;
+    sortChange: EventEmitter<{
+        active: string | null;
+        direction: "asc" | "desc" | "";
+    }>;
+    filtersChange: EventEmitter<{
+        global: string;
+        columns: Record<string, string>;
+    }>;
+    pageChange: EventEmitter<{
+        page: number;
+        pageSize: number;
+    }>;
+    rowDetailTpl?: NgbRowDetailTemplate<T>;
+    private exporter;
+    expanded: Set<number>;
+    private fb;
+    filterForm: FormGroup;
+    globalFilterCtrl: FormControl<string>;
+    addingNew: boolean;
+    draftNew: Partial<Record<KeyOf<T>, any>> | null;
+    errorsNew: Partial<Record<KeyOf<T>, string>>;
+    sort: {
+        active: Extract<keyof T, string> | null;
+        direction: SortDir;
+    };
+    globalFilter: string;
+    filters: Record<string, string>;
+    page: number;
+    pageSize: number;
+    /** Inline editing state */
+    editingIndex: number | null;
+    editForm: FormGroup;
+    saveAttemptedEdit: boolean;
+    addForm: FormGroup;
+    saveAttemptedNew: boolean;
+    private norm;
+    private keyOf;
+    private passesRowFilters;
+    private getDefaults;
+    private defaultFor;
+    private numberValidator;
+    private dateValidator;
+    private buildFormFromRow;
+    private rowIsValidAgainst;
+    private strictEmailValidator;
+    get exportButtonTpl(): TemplateRef<ExportButtonContext> | null;
+    get filtered(): T[];
+    private compare;
+    get sorted(): T[];
+    get paged(): T[];
+    get anyFilterable(): boolean;
+    get startIndex(): number;
+    get endIndex(): number;
+    get detailColspan(): number;
+    headerText(col: ColumnDef<T>): string;
+    columnFilterAriaLabel(col: ColumnDef<T>): string;
+    inputAriaLabel(col: ColumnDef<T>): string;
+    ariaSortFor(field: Extract<keyof T, string>): 'ascending' | 'descending' | 'none';
+    sortButtonAriaLabel(col: ColumnDef<T>): string;
+    exportAriaLabel(kind: 'pdf' | 'excel'): string;
+    private dataIndexFromPaged;
+    private rebuildFilterForm;
+    private cellTplQ;
+    private editTplQ;
+    private filterTplQ;
+    private globalTplQ;
+    /** Internal lookup maps */
+    cellTpls: Record<string, NgbCellTemplate<T>>;
+    editTpls: Record<string, NgbEditorTemplate<T>>;
+    filterTpls: Record<string, NgbFilterTemplate<T>>;
+    globalTpl: NgbGlobalFilterTemplate | null;
+    private toRecord;
+    export(kind: 'pdf' | 'excel'): Promise<void>;
+    private resolveDataset;
+    ngAfterContentInit(): void;
+    ngOnChanges(ch: SimpleChanges): void;
+    startAdd(): void;
+    saveAdd(): void;
+    cancelAdd(): void;
+    startEdit(i: number): void;
+    saveEdit(i: number): void;
+    cancelEdit(i: number): void;
+    onNewDraftChange(col: ColumnDef<T>): void;
+    validateInto(col: ColumnDef<T>, targetDraft: Partial<Record<KeyOf<T>, any>> | null, targetErrors: Partial<Record<KeyOf<T>, string>>): void;
+    deleteRow(i: number): void;
+    trackRow: (_: number, row: T) => T;
+    toggleSort(field: Extract<keyof T, string>): void;
+    onGlobalFilterChange(): void;
+    onColumnFilterChange(): void;
+    onPageChange(p: number): void;
+    onPageSizeChange(): void;
+    toggleExpand(i: number): void;
+    isExpanded(i: number): boolean;
+    onRowClick(ev: MouseEvent, i: number): void;
+    onPage(p: number): void;
+    onPageSize(sz: number): void;
+    asBool(v: any): boolean;
+    triggerExport(kind: 'pdf' | 'excel'): void;
+    isResponsiveEnabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Datagrid<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Datagrid<any>, "ngb-datagrid", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "enableSorting": { "alias": "enableSorting"; "required": false; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; }; "enableGlobalFilter": { "alias": "enableGlobalFilter"; "required": false; }; "enablePagination": { "alias": "enablePagination"; "required": false; }; "enableEdit": { "alias": "enableEdit"; "required": false; }; "enableDelete": { "alias": "enableDelete"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "enableAdd": { "alias": "enableAdd"; "required": false; }; "addButtonAriaLabel": { "alias": "addButtonAriaLabel"; "required": false; }; "addButtonText": { "alias": "addButtonText"; "required": false; }; "globalFilterAriaLabel": { "alias": "globalFilterAriaLabel"; "required": false; }; "expandRowAriaLabel": { "alias": "expandRowAriaLabel"; "required": false; }; "collapseRowAriaLabel": { "alias": "collapseRowAriaLabel"; "required": false; }; "exportPdfAriaLabel": { "alias": "exportPdfAriaLabel"; "required": false; }; "exportExcelAriaLabel": { "alias": "exportExcelAriaLabel"; "required": false; }; "newRowDefaults": { "alias": "newRowDefaults"; "required": false; }; "strictEmail": { "alias": "strictEmail"; "required": false; }; "editOnRowClick": { "alias": "editOnRowClick"; "required": false; }; "singleExpand": { "alias": "singleExpand"; "required": false; }; "exportOptions": { "alias": "exportOptions"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "dataProviderAll": { "alias": "dataProviderAll"; "required": false; }; "dataProviderSelection": { "alias": "dataProviderSelection"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "rowAdd": "rowAdd"; "rowEdit": "rowEdit"; "rowSave": "rowSave"; "rowCancel": "rowCancel"; "rowDelete": "rowDelete"; "sortChange": "sortChange"; "filtersChange": "filtersChange"; "pageChange": "pageChange"; }, ["exportButtonDir", "rowDetailTpl", "cellTplQ", "editTplQ", "filterTplQ", "globalTplQ"], never, true, never>;
+}
+
+interface PdfExportPayload {
+    fileName: string;
+    columns: string[];
+    rows: any[];
+    options?: any;
+}
+interface ExcelExportPayload {
+    fileName: string;
+    sheetName: string;
+    columns: Array<{
+        key: string;
+        title: string;
+    }>;
+    rows: any[];
+}
+declare abstract class PdfExportAdapter {
+    abstract export(p: PdfExportPayload): Promise<void>;
+}
+declare abstract class ExcelExportAdapter {
+    abstract export(p: ExcelExportPayload): Promise<void>;
+}
+declare class NgbExportService {
+    private pdf;
+    private excel;
+    exportPdf(p: PdfExportPayload): Promise<void>;
+    exportExcel(p: ExcelExportPayload): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgbExportService>;
+}
+
+declare class JsPdfAdapter implements PdfExportAdapter {
+    export({ fileName, columns, rows, options }: PdfExportPayload): Promise<void>;
+}
+
+declare class XlsxAdapter implements ExcelExportAdapter {
+    export({ fileName, sheetName, columns, rows }: ExcelExportPayload): Promise<void>;
+}
+
+type DndI18n = {
+    listLabel: (name?: string) => string;
+    pickedUp: () => string;
+    dropped: () => string;
+    moveToIndex: (pos: number, total: number) => string;
+    dropHere: () => string;
+    cannotDropHere: () => string;
+};
+declare const DND_I18N: InjectionToken<DndI18n>;
+declare const defaultDndI18n: DndI18n;
+
+interface DndSession<T = unknown> {
+    item: T;
+    group?: string;
+    fromList?: T[];
+    fromIndex?: number;
+    fromIsPalette?: boolean;
+}
+declare class NgbDndState {
+    readonly active: i0.WritableSignal<boolean>;
+    private store;
+    private currentId;
+    i18n: DndI18n;
+    announce?: (m: string) => void;
+    constructor(announceFn: ((m: string) => void) | null, i18n: DndI18n | null);
+    createSession<T>(session: DndSession<T>): string;
+    get(id: string | null): DndSession | null;
+    getCurrent(): DndSession | null;
+    clear(id?: string | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndState, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgbDndState>;
+}
+
+interface NgbDndDropEvent<T> {
+    item: T;
+    fromIndex: number;
+    toIndex: number;
+    fromList: T[];
+    toList: T[];
+    sameList: boolean;
+}
+interface DndCanDropPayload<T = any> {
+    dragItem: T;
+    srcList: T[];
+    srcIndex: number;
+    dstList: T[];
+    dstIndex: number;
+    isExternal: boolean;
+}
+/** Guard function; return true to allow, false to block */
+type DndCanDropFn<T = any> = (payload: DndCanDropPayload<T>) => boolean;
+declare class NgbDndListDirective<T = unknown> {
+    private el;
+    private state;
+    dndChildrenKey: string | null;
+    /** Bind your array here: <div [ngbDndList]="items"> */
+    list: T[];
+    /** Optional: group barrier across lists */
+    dndGroup?: string;
+    /** Disable this list */
+    dndDisabled: boolean;
+    /** NEW: clone if source wasn't a list (e.g. palette) */
+    dndCloneOnDrop: boolean;
+    /** NEW: custom clone function */
+    dndCloneFn?: (item: T) => T;
+    dndIsPalette: boolean;
+    dndCanDrop: boolean | DndCanDropFn<any>;
+    private _denied;
+    get denied(): boolean;
+    dndAriaLabel?: string;
+    get ariaLabel(): string;
+    /** Fires after item is inserted */
+    dndDropped: EventEmitter<NgbDndDropEvent<T>>;
+    role: string;
+    hostClass: boolean;
+    private hover;
+    get isOver(): boolean;
+    private canDrop;
+    get dataDropValid(): "true" | "false";
+    private placeholder?;
+    private lastIndex;
+    onDragEnter(ev: DragEvent): void;
+    onDragOver(ev: DragEvent): void;
+    onDragLeave(ev: DragEvent): void;
+    onDocumentDrop(ev: DragEvent): void;
+    onDrop(ev: DragEvent): void;
+    private getSession;
+    private ensurePlaceholder;
+    private removePlaceholder;
+    private positionPlaceholderAt;
+    private indexFromPointer;
+    private cloneItem;
+    private isDroppingIntoOwnDescendant;
+    /**
+     * Build a guard payload using whatever drag context you already store.
+     * If some fields don’t exist in your code, the fallbacks keep it working.
+     */
+    private _buildGuardPayload;
+    /**
+     * Compute destination index from the event position (no placeholder var needed).
+     * Uses vertical list heuristics; adjust for horizontal if your list is horizontal.
+     */
+    private _computeDropIndex;
+    private _allowDrop;
+    private performDrop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndListDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndListDirective<any>, "[ngbDndList]", never, { "dndChildrenKey": { "alias": "dndChildrenKey"; "required": false; }; "list": { "alias": "ngbDndList"; "required": false; }; "dndGroup": { "alias": "dndGroup"; "required": false; }; "dndDisabled": { "alias": "dndDisabled"; "required": false; }; "dndCloneOnDrop": { "alias": "dndCloneOnDrop"; "required": false; }; "dndCloneFn": { "alias": "dndCloneFn"; "required": false; }; "dndIsPalette": { "alias": "dndIsPalette"; "required": false; }; "dndCanDrop": { "alias": "dndCanDrop"; "required": false; }; "dndAriaLabel": { "alias": "dndAriaLabel"; "required": false; }; }, { "dndDropped": "dndDropped"; }, never, never, true, never>;
+}
+
+declare class NgbDndItemDirective<T = unknown> {
+    private parentList?;
+    private el;
+    private state;
+    constructor(parentList?: NgbDndListDirective<T>);
+    /** required: the value carried by this row/panel */
+    item: T;
+    /** optional: constrain cross-list drops */
+    dndGroup?: string;
+    /** index inside its parent list (bind to *ngFor index) */
+    dndIndex?: number;
+    dndDisabled: boolean;
+    dndDragStart: EventEmitter<T>;
+    dndDragEnd: EventEmitter<void>;
+    get draggable(): boolean;
+    dragging: boolean;
+    get ariaGrabbed(): "true" | "false";
+    role: string;
+    tabIndex: number;
+    private sessionId;
+    onDragStart(ev: DragEvent): void;
+    onDragEnd(): void;
+    onKeydown(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndItemDirective<any>, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndItemDirective<any>, "[ngbDndItem]", never, { "item": { "alias": "ngbDndItem"; "required": false; }; "dndGroup": { "alias": "dndGroup"; "required": false; }; "dndIndex": { "alias": "dndIndex"; "required": false; }; "dndDisabled": { "alias": "dndDisabled"; "required": false; }; }, { "dndDragStart": "dndDragStart"; "dndDragEnd": "dndDragEnd"; }, never, never, true, never>;
+}
+
+declare class NgbLiveAnnouncer {
+    private node;
+    announce(message: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbLiveAnnouncer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgbLiveAnnouncer>;
+}
+declare const DND_LIVE_ANNOUNCE: InjectionToken<(m: string) => void>;
+
+declare class NgbPaginationComponent {
+    page: number;
+    pageSize: number;
+    collectionSize: number;
+    maxSize: number;
+    pageChange: EventEmitter<number>;
+    get totalPages(): number;
+    get pages(): Array<number | '…'>;
+    go(p: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbPaginationComponent, "ngb-pagination", never, { "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "collectionSize": { "alias": "collectionSize"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+type NgbStepperOrientation = 'horizontal' | 'vertical';
+type NgbStepperLabelPosition = 'top' | 'bottom' | 'left' | 'right';
+type NgbStepperContentPosition = 'top' | 'bottom';
+type NgbStepperTheme = 'bootstrap' | 'material' | 'tailwind';
+type NgbStepperState = 'number' | 'done' | 'active' | 'error' | 'disabled' | string;
+interface NgbStepperStep {
+    /** Unique id for the step, otherwise index is used */
+    id?: string;
+    /** Simple text label (used when no custom label template is provided) */
+    label?: string;
+    /** Optional description / helper text */
+    description?: string;
+    /** Current state of the step (maps to icon + CSS classes) */
+    state?: NgbStepperState;
+    /** Error message to display when step is invalid and visited */
+    errorMessage?: string | null;
+    /** Whether this step is optional (used only for styling / a11y text) */
+    optional?: boolean;
+    /** Whether this step is disabled */
+    disabled?: boolean;
+}
+
+declare class NgbStepLabelDirective {
+    template: TemplateRef<unknown>;
+    for?: string | number;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbStepLabelDirective, "[ngbStepLabel]", never, { "for": { "alias": "ngbStepLabel"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface NgbStepperSelectionChangeEvent {
+    previousIndex: number;
+    currentIndex: number;
+    step: NgbStepperStep | undefined;
+}
+declare class NgbStepperComponent implements AfterContentInit {
+    /** Steps definition */
+    steps: NgbStepperStep[];
+    /** Orientation of the stepper */
+    orientation: NgbStepperOrientation;
+    /** Position of labels around the indicator */
+    labelPosition: NgbStepperLabelPosition;
+    /** Position of content relative to header (horizontal only) */
+    contentPosition: NgbStepperContentPosition;
+    /** Allow navigating back to previous steps by clicking header */
+    allowRevisit: boolean;
+    /** Enable lazy loading of step content (default true) */
+    lazy: boolean;
+    /** Theme keyword (only CSS classes, no external deps) */
+    theme: NgbStepperTheme;
+    /** Whether to apply responsive helper class */
+    responsive: boolean;
+    /** Disable transition / animation helpers */
+    disableAnimation: boolean;
+    /** Animation duration (ms) for step transitions when enabled */
+    animationDuration: number;
+    /** Label strings (for i18n) */
+    nextLabel: string;
+    previousLabel: string;
+    resetLabel: string;
+    cancelLabel: string;
+    optionalLabel: string;
+    /** Custom mapping from state -> icon text */
+    stateIcons: Record<string, string>;
+    /** Current selected index */
+    selectedIndex: number;
+    /** Emits when selectedIndex changes (programmatically or by user) */
+    selectedIndexChange: EventEmitter<number>;
+    /** Emits when selection changes with rich event */
+    selectionChange: EventEmitter<NgbStepperSelectionChangeEvent>;
+    /** Navigation events */
+    nextClicked: EventEmitter<number>;
+    prevClicked: EventEmitter<number>;
+    resetClicked: EventEmitter<void>;
+    cancelClicked: EventEmitter<void>;
+    /** Custom label template (applied for all steps) */
+    stepLabelTplDir?: NgbStepLabelDirective;
+    /** Custom icon template for step indicator */
+    customIconTpl?: TemplateRef<any>;
+    /** Content template; user will typically use <ng-template #stepContent ...> */
+    stepContentTpl?: TemplateRef<any>;
+    /** Track which steps have been visited */
+    private visited;
+    /** Used when allowRevisit=false to block earlier steps */
+    visitedFrom: number;
+    ngAfterContentInit(): void;
+    get stepLabelTpl(): TemplateRef<any> | null;
+    get labelPositionClass(): string;
+    get currentErrorMessage(): string | null;
+    stepId(i: number): string;
+    contentId(i: number): string;
+    private markVisited;
+    stepState(i: number): NgbStepperState;
+    isStepInError(i: number): boolean;
+    indicatorClass(i: number): string;
+    defaultIconForState(state: NgbStepperState, index: number): string;
+    onHeaderClick(i: number): void;
+    onHeaderKeydown(event: KeyboardEvent | Event, i: number): void;
+    next(): void;
+    prev(): void;
+    onReset(): void;
+    onCancel(): void;
+    private changeIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbStepperComponent, "ngb-stepper", never, { "steps": { "alias": "steps"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "contentPosition": { "alias": "contentPosition"; "required": false; }; "allowRevisit": { "alias": "allowRevisit"; "required": false; }; "lazy": { "alias": "lazy"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "disableAnimation": { "alias": "disableAnimation"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "previousLabel": { "alias": "previousLabel"; "required": false; }; "resetLabel": { "alias": "resetLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; }; "stateIcons": { "alias": "stateIcons"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "selectionChange": "selectionChange"; "nextClicked": "nextClicked"; "prevClicked": "prevClicked"; "resetClicked": "resetClicked"; "cancelClicked": "cancelClicked"; }, ["stepLabelTplDir", "customIconTpl", "stepContentTpl"], never, true, never>;
+}
+
+declare class NgbSplitterPaneComponent {
+    templateRef: TemplateRef<any>;
+    size?: string;
+    min?: string;
+    max?: string;
+    collapsible: boolean;
+    collapsed: boolean;
+    collapsedChange: EventEmitter<boolean>;
+    toggleCollapsed(next?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSplitterPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSplitterPaneComponent, "ngb-splitter-pane", never, { "size": { "alias": "size"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; }, { "collapsedChange": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+type NgbSplitterOrientation = 'horizontal' | 'vertical';
+interface NgbSplitterPaneSize {
+    size?: string;
+    min?: string;
+    max?: string;
+}
+
+type PaneState = {
+    sizePx?: number;
+    minPx?: number;
+    maxPx?: number;
+    id: string;
+};
+declare class NgbSplitterComponent implements AfterContentInit, OnDestroy, OnChanges {
+    panes: QueryList<NgbSplitterPaneComponent>;
+    container: ElementRef<HTMLElement>;
+    orientation: NgbSplitterOrientation;
+    handleThickness: number;
+    paneStates: PaneState[];
+    private resizeSub?;
+    private currentDrag?;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onWindowResize(): void;
+    startResize(index: number, event: MouseEvent): void;
+    onHandleKeydown(index: number, event: KeyboardEvent): void;
+    toggleFromHandle(index: number): void;
+    private onDrag;
+    private stopDrag;
+    private adjustPaneSizes;
+    private initStates;
+    private computePaneSizes;
+    private resolveSize;
+    private getLimits;
+    private clamp;
+    private pointerPosition;
+    private getContainerSize;
+    private detachDragListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSplitterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSplitterComponent, "ngb-splitter", never, { "orientation": { "alias": "orientation"; "required": false; }; "handleThickness": { "alias": "handleThickness"; "required": false; }; }, {}, ["panes"], never, true, never>;
+}
+
+interface NgbTypeaheadItem {
+    id: string | number;
+    label: string;
+    value?: any;
+    disabled?: boolean;
+}
+interface NgbTypeaheadI18n {
+    placeholder?: string;
+    noResults?: string;
+    clearSelection?: string;
+}
+
+declare class NgbTypeaheadComponent implements AfterViewInit, OnChanges, OnDestroy {
+    data: NgbTypeaheadItem[];
+    debounceTime: number;
+    characterTyped: number;
+    limit: number;
+    selectExact: boolean;
+    multiSelect: boolean;
+    i18n?: NgbTypeaheadI18n;
+    itemTemplate?: TemplateRef<any>;
+    selectedItems: EventEmitter<NgbTypeaheadItem[]>;
+    selectionChange: EventEmitter<NgbTypeaheadItem[]>;
+    onChange: EventEmitter<string>;
+    onScrollEvent: EventEmitter<void>;
+    scroller: ElementRef<HTMLElement>;
+    inputEl: ElementRef<HTMLInputElement>;
+    itemButtons?: QueryList<ElementRef<HTMLButtonElement>>;
+    query: string;
+    filtered: NgbTypeaheadItem[];
+    visible: NgbTypeaheadItem[];
+    selected: NgbTypeaheadItem[];
+    viewportHeight: number;
+    itemHeight: number;
+    beforePadding: number;
+    afterPadding: number;
+    private debounceId?;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get selectionSummary(): string;
+    onInput(value: string): void;
+    onKeydown(event: KeyboardEvent): void;
+    onScroll(event: Event): void;
+    selectItem(item: NgbTypeaheadItem): void;
+    clearSelection(): void;
+    isSelected(item: NgbTypeaheadItem): boolean;
+    trackById: (_: number, item: NgbTypeaheadItem) => string | number;
+    private applyFilter;
+    private updateViewport;
+    private focusSibling;
+    private validateItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTypeaheadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTypeaheadComponent, "ngb-typeahead", never, { "data": { "alias": "data"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; "characterTyped": { "alias": "characterTyped"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "selectExact": { "alias": "selectExact"; "required": false; }; "multiSelect": { "alias": "multiSelect"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; }, { "selectedItems": "selectedItems"; "selectionChange": "selectionChange"; "onChange": "onChange"; "onScrollEvent": "onScrollEvent"; }, ["itemTemplate"], never, true, never>;
+}
+
+type NgbTreeType = 'text' | 'json';
+interface NgbTreeNode {
+    id: string;
+    label: string;
+    children?: NgbTreeNode[];
+    expanded?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+}
+interface NgbTreeI18n {
+    treeLabel?: string;
+    expand?: string;
+    collapse?: string;
+    expandAll?: string;
+    collapseAll?: string;
+    select?: string;
+}
+
+declare class NgbTreeComponent {
+    nodes: NgbTreeNode[];
+    type: NgbTreeType;
+    showCheckbox: boolean;
+    i18n?: NgbTreeI18n;
+    expand: EventEmitter<NgbTreeNode>;
+    collapse: EventEmitter<NgbTreeNode>;
+    expandAll: EventEmitter<void>;
+    collapseAll: EventEmitter<void>;
+    selectionChange: EventEmitter<NgbTreeNode[]>;
+    nodeButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    trackById: (_: number, node: NgbTreeNode) => string;
+    hasChildren(node: NgbTreeNode): boolean;
+    toggleNode(node: NgbTreeNode): void;
+    toggleSelection(node: NgbTreeNode, value: boolean): void;
+    expandAllNodes(): void;
+    collapseAllNodes(): void;
+    onNodeKeydown(event: KeyboardEvent, node: NgbTreeNode): void;
+    private focusSibling;
+    private setExpanded;
+    private collectSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTreeComponent, "ngb-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "type": { "alias": "type"; "required": false; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; }, { "expand": "expand"; "collapse": "collapse"; "expandAll": "expandAll"; "collapseAll": "collapseAll"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+export { DATAGRID_TEMPLATE_DIRECTIVES, DND_I18N, DND_LIVE_ANNOUNCE, Datagrid, ExcelExportAdapter, ExportButtonDirective, JsPdfAdapter, NgbCellTemplate, NgbDndItemDirective, NgbDndListDirective, NgbDndState, NgbEditorTemplate, NgbExportService, NgbFilterTemplate, NgbGlobalFilterTemplate, NgbLiveAnnouncer, NgbPaginationComponent, NgbRowDetailTemplate, NgbSplitterComponent, NgbStepLabelDirective, NgbStepperComponent, NgbTreeComponent, NgbTypeaheadComponent, PdfExportAdapter, XlsxAdapter, defaultDndI18n };
+export type { CellCtx, ColumnDef, ColumnType, DndCanDropFn, DndCanDropPayload, DndI18n, DndSession, EditCtx, ExcelExportPayload, ExportButtonContext, FilterCtx, GlobalFilterCtx, NgbDataGridExportOptions, NgbDataGridExportPages, NgbDataGridExportType, NgbDataGridResponsiveOptions, NgbDataGridTheme, NgbDndDropEvent, NgbSplitterOrientation, NgbSplitterPaneSize, NgbStepperContentPosition, NgbStepperLabelPosition, NgbStepperOrientation, NgbStepperSelectionChangeEvent, NgbStepperState, NgbStepperStep, NgbStepperTheme, NgbTreeI18n, NgbTreeNode, NgbTreeType, NgbTypeaheadI18n, NgbTypeaheadItem, PdfExportPayload };