Skip to content

@dzgrid/angular

Every public name of @dzgrid/angular, entry by entry, with its declaration as the published types give it. Made from api/dzgrid-angular.api.txt, the surface a test keeps from shrinking between versions; the guides and the option pages say what each name does.

declare const DZGRID_ANGULAR_VERSION = "1.12.0";
declare const DZG_DEFAULTS: InjectionToken<DzGridDefaults>;
declare const DZG_ENV: InjectionToken<GridEnv>;
declare const DZG_MESSAGES: InjectionToken<GridMessages | null>;
declare const DZG_PARTS: InjectionToken<Readonly<Record<string, SlotPart<keyof _dzgrid_dom.SlotContext>>>>;
declare class DzGrid<T> implements AfterContentInit {
readonly rows: _angular_core.InputSignal<Iterable<T> | undefined>;
readonly source: _angular_core.InputSignal<_dzgrid_core.SourceBinding<T> | undefined>;
readonly columns: _angular_core.InputSignal<DzgColumns<T> | readonly ColumnOrGroup<T>[]>;
readonly getRowId: _angular_core.InputSignal<(row: T) => RowIdInput>;
readonly messages: _angular_core.InputSignal<GridMessages | undefined>;
readonly locale: _angular_core.InputSignal<string | undefined>;
readonly timeZone: _angular_core.InputSignal<string | undefined>;
readonly numerals: _angular_core.InputSignal<"latn" | "locale" | undefined>;
readonly direction: _angular_core.InputSignal<"auto" | "ltr" | "rtl" | undefined>;
readonly density: _angular_core.InputSignal<"compact" | "comfortable" | "spacious" | undefined>;
readonly headers: _angular_core.InputSignal<"shown" | "hidden" | undefined>;
readonly rowHeight: _angular_core.InputSignal<number | undefined>;
readonly headerHeight: _angular_core.InputSignal<number | _dzgrid_dom.HeaderHeights | undefined>;
readonly theme: _angular_core.InputSignal<_dzgrid_dom.GridTheme | undefined>;
readonly icons: _angular_core.InputSignal<_dzgrid_dom.GridIcons | undefined>;
readonly overlay: _angular_core.InputSignal<"loading" | "error" | null | undefined>;
readonly busy: _angular_core.InputSignal<boolean | undefined>;
readonly label: _angular_core.InputSignal<string | undefined>;
readonly tooltips: _angular_core.InputSignal<{
readonly delayMs?: number;
} | undefined>;
readonly overscan: _angular_core.InputSignal<{
readonly rows?: number;
readonly cols?: number;
} | undefined>;
readonly searchWarmup: _angular_core.InputSignal<"idle" | "off" | undefined>;
readonly selection: _angular_core.InputSignal<{
readonly mode: "none" | "single" | "multi";
readonly checkbox?: boolean;
readonly click?: boolean;
readonly keepOnFilter?: boolean;
readonly canSelect?: ((row: _dzgrid_core.DataNode<T>, selection: SelectionState, context: unknown) => boolean | string) | undefined;
} | undefined>;
readonly context: _angular_core.InputSignal<unknown>;
readonly rowClass: _angular_core.InputSignal<((c: _dzgrid_dom.RowClassContext<T>) => string | null | undefined) | undefined>;
readonly fullWidth: _angular_core.InputSignal<((row: Readonly<T>) => boolean | {
readonly part?: string;
}) | undefined>;
readonly parts: _angular_core.InputSignal<Readonly<Record<string, SlotPart<keyof SlotContext>>> | undefined>;
readonly dzgNested: _angular_core.InputSignal<(_dzgrid_dom.PartBase & {
readonly row: Readonly<unknown>;
readonly key: RowKey;
readonly master: RowKey;
readonly height: number;
readonly depth?: number;
leave?(): void;
}) | undefined>;
readonly operations: _angular_core.InputSignal<_dzgrid_core.OperationsInput | undefined>;
readonly pagination: _angular_core.InputSignal<_dzgrid_core.PageOptions | undefined>;
readonly filterKinds: _angular_core.InputSignal<readonly _dzgrid_core.AnyFilterKind[] | undefined>;
readonly clock: _angular_core.InputSignal<(() => number) | undefined>;
readonly injectStyles: _angular_core.InputSignal<boolean | undefined>;
readonly nonce: _angular_core.InputSignal<string | undefined>;
readonly features: _angular_core.InputSignal<readonly GridFeature[] | undefined>;
readonly multiSort: _angular_core.InputSignal<boolean | undefined>;
readonly sameRow: _angular_core.InputSignal<((a: T, b: T) => boolean) | undefined>;
readonly motion: _angular_core.InputSignal<boolean | undefined>;
readonly floatingFilters: _angular_core.InputSignal<boolean | undefined>;
readonly save: _angular_core.InputSignal<SaveHandler<T> | undefined>;
readonly state: _angular_core.InputSignal<GridState | null | undefined>;
readonly pinnedRows: _angular_core.InputSignal<{
readonly top?: readonly T[];
readonly bottom?: readonly T[];
} | undefined>;
readonly quick: _angular_core.ModelSignal<string | undefined>;
readonly filter: _angular_core.ModelSignal<Readonly<Record<string, _dzgrid_core.ColumnFilter>> | undefined>;
readonly selected: _angular_core.ModelSignal<SelectionState | undefined>;
readonly expanded: _angular_core.ModelSignal<ReadonlySet<RowKey> | undefined>;
readonly groupBy: _angular_core.ModelSignal<readonly string[] | undefined>;
readonly gridEvent: OutputEmitterRef<GridEvent<T>>;
readonly cellClicked: OutputEmitterRef<{
readonly type: "cellClicked";
readonly source: "user";
readonly row: _dzgrid_core.RowNode<T>;
readonly column: string;
}>;
readonly rowClicked: OutputEmitterRef<{
readonly type: "rowClicked";
readonly source: "user";
readonly row: _dzgrid_core.RowNode<T>;
}>;
readonly cellAction: OutputEmitterRef<{
readonly type: "cellAction";
readonly source: "user";
readonly column: string;
readonly key: RowKey;
readonly name: string;
readonly detail: unknown;
}>;
readonly partAction: OutputEmitterRef<{
readonly type: "partAction";
readonly source: "user";
readonly slot: string;
readonly column: string | null;
readonly name: string;
readonly detail: unknown;
}>;
readonly fetchFailed: OutputEmitterRef<{
readonly type: "fetchFailed";
readonly source: "data";
readonly error: unknown;
readonly key: string;
readonly page: number | null;
}>;
readonly rowExpanded: OutputEmitterRef<{
readonly type: "rowExpanded";
readonly source: _dzgrid_core.ChangeSource;
readonly rows: readonly RowKey[];
readonly expanded: boolean;
}>;
readonly cellEdited: OutputEmitterRef<{
readonly type: "cellEdited";
readonly source: _dzgrid_core.ChangeSource;
readonly key: RowKey;
readonly column: string;
readonly value: unknown;
readonly previous: unknown;
readonly origin: _dzgrid_core.SaveOrigin;
}>;
readonly saveFailed: OutputEmitterRef<{
readonly type: "saveFailed";
readonly source: "data";
readonly key: RowKey;
readonly column: string;
readonly value: unknown;
readonly error: unknown;
readonly reason: string | null;
readonly code: string | null;
}>;
readonly orderStale: OutputEmitterRef<{
readonly type: "orderStale";
readonly source: _dzgrid_core.ChangeSource;
readonly stale: boolean;
}>;
readonly undoChanged: OutputEmitterRef<{
readonly type: "undoChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly canUndo: boolean;
readonly canRedo: boolean;
}>;
readonly rangeChanged: OutputEmitterRef<{
readonly type: "rangeChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly range: _dzgrid_core.CellRange | null;
}>;
readonly rangeCopied: OutputEmitterRef<{
readonly type: "rangeCopied";
readonly source: _dzgrid_core.ChangeSource;
readonly rows: number;
readonly columns: number;
readonly cells: number;
readonly cut: boolean;
}>;
readonly stateChanged: OutputEmitterRef<{
readonly type: "stateChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly state: GridState;
}>;
readonly densityChanged: OutputEmitterRef<{
readonly type: "densityChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly density: "compact" | "comfortable" | "spacious";
}>;
readonly selectionChanged: OutputEmitterRef<{
readonly type: "selectionChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly selection: SelectionState;
readonly count: number | null;
readonly query: Query | null;
readonly scope: _dzgrid_core.RowScope | null;
readonly reason: _dzgrid_core.SelectionReason | null;
}>;
readonly rowMove: OutputEmitterRef<{
readonly type: "rowMove";
readonly source: _dzgrid_core.ChangeSource;
readonly via: "pointer" | "keys" | "menu" | "api";
readonly keys: readonly RowKey[];
readonly rows: readonly T[];
readonly target: {
readonly key: RowKey | null;
readonly where: "before" | "after" | "inside";
};
readonly parent: RowKey | null;
readonly applied: boolean;
}>;
readonly modelUpdated: OutputEmitterRef<Ev<T, 'modelUpdated'>>;
readonly sortChanged: OutputEmitterRef<{
readonly type: "sortChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly sort: readonly _dzgrid_core.SortItem[];
}>;
readonly filterChanged: OutputEmitterRef<{
readonly type: "filterChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly filter: FilterModel;
}>;
readonly quickChanged: OutputEmitterRef<{
readonly type: "quickChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly text: string;
}>;
readonly pageChanged: OutputEmitterRef<{
readonly type: "pageChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly page: _dzgrid_core.PageState;
}>;
readonly columnsChanged: OutputEmitterRef<{
readonly type: "columnsChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly changed: readonly string[];
readonly layoutChanged: boolean;
}>;
readonly columnResized: OutputEmitterRef<{
readonly type: "columnResized";
readonly source: _dzgrid_core.ChangeSource;
readonly column: string;
readonly width: number;
readonly finished: boolean;
}>;
readonly pinnedChanged: OutputEmitterRef<{
readonly type: "pinnedChanged";
readonly source: _dzgrid_core.ChangeSource;
}>;
readonly focusChanged: OutputEmitterRef<{
readonly type: "focusChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly focus: _dzgrid_core.FocusPos | null;
}>;
readonly firstDataRendered: OutputEmitterRef<{
readonly type: "firstDataRendered";
readonly source: "data";
}>;
readonly selectionRefused: OutputEmitterRef<{
readonly type: "selectionRefused";
readonly source: _dzgrid_core.ChangeSource;
} & _dzgrid_core.SelectionRefusal>;
readonly editingStarted: OutputEmitterRef<{
readonly type: "editingStarted";
readonly source: "user";
readonly key: RowKey;
readonly column: string;
readonly start: "f2" | "enter" | "key" | "dblclick" | "tap" | "tab";
}>;
readonly editingStopped: OutputEmitterRef<{
readonly type: "editingStopped";
readonly source: "user";
readonly key: RowKey;
readonly column: string;
readonly kept: boolean;
readonly via: "enter" | "tab" | "escape" | "blur" | "lost";
}>;
readonly editStates: OutputEmitterRef<{
readonly type: "editStates";
readonly source: _dzgrid_core.ChangeSource;
readonly cells: readonly {
readonly key: RowKey;
readonly column: string;
}[];
}>;
readonly stateRestored: OutputEmitterRef<{
readonly type: "stateRestored";
readonly source: _dzgrid_core.ChangeSource;
readonly problems: readonly Problem[];
}>;
readonly groupByChanged: OutputEmitterRef<{
readonly type: "groupByChanged";
readonly source: _dzgrid_core.ChangeSource;
readonly by: readonly string[];
}>;
readonly exportRequested: OutputEmitterRef<{
readonly type: "exportRequested";
} & _dzgrid_core.ExportTrace & {
readonly columns: readonly string[];
readonly query: Query;
readonly queryKey: string;
readonly server?: _dzgrid_core.ExportServerPart;
readonly count: number | null;
readonly selection?: {
readonly mode: "include" | "exclude";
readonly count: number | null;
};
readonly zone: string;
readonly locale: string;
}>;
readonly exportFinished: OutputEmitterRef<{
readonly type: "exportFinished";
} & _dzgrid_core.ExportTrace & {
readonly outcome: "done" | "failed" | "cancelled";
readonly via: "browser" | "server";
readonly rows: number | null;
readonly columns: number;
readonly bytes: number | null;
readonly fileName: string | null;
readonly hidden?: number;
readonly durationMs: number;
readonly blank?: number;
readonly invalid?: number;
readonly failure?: {
readonly stage: "load" | "rows" | "canExport" | "exportAll" | "build" | "download";
readonly name: string;
};
}>;
readonly exportRefused: OutputEmitterRef<{
readonly type: "exportRefused";
} & _dzgrid_core.ExportTrace & {
readonly refusal: "host" | "too-large" | "error";
readonly reason?: string;
}>;
readonly problems: OutputEmitterRef<readonly Problem[]>;
readonly gridReady: OutputEmitterRef<DzgController<T>>;
readonly controller: DzgController<T>;
private readonly _defaults;
private readonly _provided;
private readonly _messages;
private readonly _env;
private readonly _zone;
private readonly _el;
private readonly _browser;
private readonly _templates;
private readonly _grid;
private _k;
private readonly _b;
private readonly _bound;
private readonly _told;
private _last;
private _gone;
private _saves;
private _st?;
private _sn?;
private _early;
private _seen?;
private _pend;
private _closed;
private readonly _registry;
private readonly _settings;
constructor();
ngAfterContentInit(): void;
private _write;
private _shut;
private _save;
private _miss;
private _state;
private _group;
private _nest;
private _open;
private _tell;
private _q;
private readonly _real;
private _hear;
private _one;
static ɵfac: _angular_core.ɵɵFactoryDeclaration<DzGrid<any>, never>;
static ɵcmp: _angular_core.ɵɵComponentDeclaration<DzGrid<any>, "dz-grid", [
"dzGrid"
], {
"rows": {
"alias": "rows";
"required": false;
"isSignal": true;
};
"source": {
"alias": "source";
"required": false;
"isSignal": true;
};
"columns": {
"alias": "columns";
"required": true;
"isSignal": true;
};
"getRowId": {
"alias": "getRowId";
"required": true;
"isSignal": true;
};
"messages": {
"alias": "messages";
"required": false;
"isSignal": true;
};
"locale": {
"alias": "locale";
"required": false;
"isSignal": true;
};
"timeZone": {
"alias": "timeZone";
"required": false;
"isSignal": true;
};
"numerals": {
"alias": "numerals";
"required": false;
"isSignal": true;
};
"direction": {
"alias": "direction";
"required": false;
"isSignal": true;
};
"density": {
"alias": "density";
"required": false;
"isSignal": true;
};
"headers": {
"alias": "headers";
"required": false;
"isSignal": true;
};
"rowHeight": {
"alias": "rowHeight";
"required": false;
"isSignal": true;
};
"headerHeight": {
"alias": "headerHeight";
"required": false;
"isSignal": true;
};
"theme": {
"alias": "theme";
"required": false;
"isSignal": true;
};
"icons": {
"alias": "icons";
"required": false;
"isSignal": true;
};
"overlay": {
"alias": "overlay";
"required": false;
"isSignal": true;
};
"busy": {
"alias": "busy";
"required": false;
"isSignal": true;
};
"label": {
"alias": "label";
"required": false;
"isSignal": true;
};
"tooltips": {
"alias": "tooltips";
"required": false;
"isSignal": true;
};
"overscan": {
"alias": "overscan";
"required": false;
"isSignal": true;
};
"searchWarmup": {
"alias": "searchWarmup";
"required": false;
"isSignal": true;
};
"selection": {
"alias": "selection";
"required": false;
"isSignal": true;
};
"context": {
"alias": "context";
"required": false;
"isSignal": true;
};
"rowClass": {
"alias": "rowClass";
"required": false;
"isSignal": true;
};
"fullWidth": {
"alias": "fullWidth";
"required": false;
"isSignal": true;
};
"parts": {
"alias": "parts";
"required": false;
"isSignal": true;
};
"dzgNested": {
"alias": "dzgNested";
"required": false;
"isSignal": true;
};
"operations": {
"alias": "operations";
"required": false;
"isSignal": true;
};
"pagination": {
"alias": "pagination";
"required": false;
"isSignal": true;
};
"filterKinds": {
"alias": "filterKinds";
"required": false;
"isSignal": true;
};
"clock": {
"alias": "clock";
"required": false;
"isSignal": true;
};
"injectStyles": {
"alias": "injectStyles";
"required": false;
"isSignal": true;
};
"nonce": {
"alias": "nonce";
"required": false;
"isSignal": true;
};
"features": {
"alias": "features";
"required": false;
"isSignal": true;
};
"multiSort": {
"alias": "multiSort";
"required": false;
"isSignal": true;
};
"sameRow": {
"alias": "sameRow";
"required": false;
"isSignal": true;
};
"motion": {
"alias": "motion";
"required": false;
"isSignal": true;
};
"floatingFilters": {
"alias": "floatingFilters";
"required": false;
"isSignal": true;
};
"save": {
"alias": "save";
"required": false;
"isSignal": true;
};
"state": {
"alias": "state";
"required": false;
"isSignal": true;
};
"pinnedRows": {
"alias": "pinnedRows";
"required": false;
"isSignal": true;
};
"quick": {
"alias": "quick";
"required": false;
"isSignal": true;
};
"filter": {
"alias": "filter";
"required": false;
"isSignal": true;
};
"selected": {
"alias": "selected";
"required": false;
"isSignal": true;
};
"expanded": {
"alias": "expanded";
"required": false;
"isSignal": true;
};
"groupBy": {
"alias": "groupBy";
"required": false;
"isSignal": true;
};
}, {
"quick": "quickChange";
"filter": "filterChange";
"selected": "selectedChange";
"expanded": "expandedChange";
"groupBy": "groupByChange";
"gridEvent": "gridEvent";
"cellClicked": "cellClicked";
"rowClicked": "rowClicked";
"cellAction": "cellAction";
"partAction": "partAction";
"fetchFailed": "fetchFailed";
"rowExpanded": "rowExpanded";
"cellEdited": "cellEdited";
"saveFailed": "saveFailed";
"orderStale": "orderStale";
"undoChanged": "undoChanged";
"rangeChanged": "rangeChanged";
"rangeCopied": "rangeCopied";
"stateChanged": "stateChanged";
"densityChanged": "densityChanged";
"selectionChanged": "selectionChanged";
"rowMove": "rowMove";
"modelUpdated": "modelUpdated";
"sortChanged": "sortChanged";
"filterChanged": "filterChanged";
"quickChanged": "quickChanged";
"pageChanged": "pageChanged";
"columnsChanged": "columnsChanged";
"columnResized": "columnResized";
"pinnedChanged": "pinnedChanged";
"focusChanged": "focusChanged";
"firstDataRendered": "firstDataRendered";
"selectionRefused": "selectionRefused";
"editingStarted": "editingStarted";
"editingStopped": "editingStopped";
"editStates": "editStates";
"stateRestored": "stateRestored";
"groupByChanged": "groupByChanged";
"exportRequested": "exportRequested";
"exportFinished": "exportFinished";
"exportRefused": "exportRefused";
"problems": "problems";
"gridReady": "gridReady";
}, [
"_templates"
], never, true, never>;
}
interface DzGridConfig {
readonly messages?: GridMessages;
readonly parts?: Readonly<Record<string, SlotPart>>;
readonly defaults?: DzGridDefaults;
}
type DzGridDefaults = Pick<GridSettings<unknown>, 'locale' | 'timeZone' | 'direction' | 'density' | 'rowHeight' | 'numerals' | 'features'>;
type DzgCell = DzgPartComponent<'cell'>;
type DzgColumnDef<T, V = unknown> = Omit<ColumnDef<T, V>, 'ui'> & {
readonly ui?: DzgColumnUi<T, V>;
};
type DzgColumnGroup<T> = Omit<ColumnGroupDef<T>, 'children'> & {
readonly children: readonly DzgColumnOrGroup<T>[];
};
type DzgColumnOrGroup<T> = DzgColumnDef<T, any> | DzgColumnGroup<T>;
type DzgColumnUi<T, V = unknown> = Omit<NonNullable<ColumnDef<T, V>['ui']>, 'cell' | 'header' | 'tooltip'> & {
readonly cell?: string | Type<DzgPartComponent<'cell'>>;
readonly header?: string | Type<DzgPartComponent<'header'>>;
readonly tooltip?: string | Type<DzgPartComponent<'tooltip'>>;
};
type DzgColumns<T> = readonly DzgColumnOrGroup<T>[];
declare class DzgController<T = unknown> {
#private;
readonly ready: _angular_core.Signal<boolean>;
readonly kernel: _angular_core.Signal<GridKernel<T, RowModel<T>> | null>;
_attach(k: GridKernel<T, RowModel<T>> | null, g?: GridInstance<T, RowModel<T>> | null, features?: readonly GridFeature[]): void;
dispatch(cmd: GridCommand): GridCommandResult;
focusCell(row: RowKey, column: string): void;
ensureVisible(row: RowKey, column?: string): void;
ensureColumnVisible(column: string): void;
refresh(): void;
refresh(o: {
readonly purge?: boolean;
}): void;
reload(): void;
applyTransaction(tx: RowTransaction<T>): TransactionResult | null;
applyTransactionAsync(tx: RowTransaction<T>, done?: (r: TransactionResult) => void): void;
announce(text: string): void;
openFilter(column: string): boolean;
closeFilter(): void;
clearFilters(): boolean;
resetState(): Problem[] | null;
edit(): EditApi<T> | null;
range(): RangeApi | null;
fill(): FillApi | null;
grouping(): GroupingApi | null;
rowDrag(): RowDragApi | null;
use<A>(feature: {
api(grid: GridInstance<T, RowModel<T>>): A | null;
}): A | null;
grid(): GridInstance<T, RowModel<T>> | null;
_by<A>(id: string): A | null;
static ɵfac: _angular_core.ɵɵFactoryDeclaration<DzgController<any>, never>;
static ɵprov: _angular_core.ɵɵInjectableDeclaration<DzgController<any>>;
}
interface DzgEditorComponent extends DzgPartComponent<'editor'> {
read?(): CellInput | undefined;
}
declare class DzgExport {
readonly dzgExport: _angular_core.InputSignal<CsvExport>;
readonly dzgExportScope: _angular_core.InputSignal<_dzgrid_core.ExportScope | undefined>;
constructor();
static ɵfac: _angular_core.ɵɵFactoryDeclaration<DzgExport, never>;
static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DzgExport, "button[dzgExport]", never, {
"dzgExport": {
"alias": "dzgExport";
"required": true;
"isSignal": true;
};
"dzgExportScope": {
"alias": "dzgExportScope";
"required": false;
"isSignal": true;
};
}, {}, never, never, true, never>;
}
declare class DzgPart<S extends WiredSlot = 'cell'> {
readonly dzgPart: _angular_core.InputSignal<string>;
readonly slot: _angular_core.InputSignal<S>;
readonly template: TemplateRef<DzgTemplateContext<S>>;
static ngTemplateContextGuard<S extends WiredSlot>(_d: DzgPart<S>, _c: unknown): _c is DzgTemplateContext<S>;
static ɵfac: _angular_core.ɵɵFactoryDeclaration<DzgPart<any>, never>;
static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DzgPart<any>, "ng-template[dzgPart]", never, {
"dzgPart": {
"alias": "dzgPart";
"required": true;
"isSignal": true;
};
"slot": {
"alias": "slot";
"required": false;
"isSignal": true;
};
}, {}, never, never, true, never>;
}
interface DzgPartComponent<S extends WiredSlot = 'cell'> {
readonly cell: InputSignal<DzgPartContext<S>>;
focus?(): boolean;
}
type DzgPartContext<S extends WiredSlot = 'cell'> = SlotContext[S] & {
emit(name: string, detail?: unknown): void;
} & (S extends 'editor' ? {
reads(fn: () => CellInput | undefined): void;
} : unknown);
declare class DzgSearch {
readonly dzgSearch: _angular_core.InputSignal<QuickSearch>;
readonly dzgSearchDebounce: _angular_core.InputSignal<number | undefined>;
constructor();
static ɵfac: _angular_core.ɵɵFactoryDeclaration<DzgSearch, never>;
static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DzgSearch, "input[dzgSearch]", never, {
"dzgSearch": {
"alias": "dzgSearch";
"required": true;
"isSignal": true;
};
"dzgSearchDebounce": {
"alias": "dzgSearchDebounce";
"required": false;
"isSignal": true;
};
}, {}, never, never, true, never>;
}
interface DzgTemplateContext<S extends WiredSlot = 'cell'> {
$implicit: DzgPartContext<S>;
cell: DzgPartContext<S>;
}
interface ObservableLike<V> {
subscribe(o: {
next(v: V): void;
error(e: unknown): void;
complete(): void;
}): {
unsubscribe(): void;
};
}
type WiredSlot = keyof SlotContext;
declare function componentPart<S extends WiredSlot>(slot: S, cmp: Type<DzgPartComponent<S>>): SlotPart<S>;
declare function expandedIds<T>(controller: DzgController<T>): string[] | null;
declare function fromObservable<T>(fetch: (req: DataRequest) => ObservableLike<DataResponse<T>>, values?: (req: ValuesRequest) => ObservableLike<ValuesResponse>): DataSource<T>;
declare function provideDzGrid(c: DzGridConfig): Provider[];
declare function selectedIds<T>(controller: DzgController<T>): {
readonly mode: 'include' | 'exclude';
readonly ids: string[];
readonly query: Query;
} | null;
declare function uiData<D = Readonly<Record<string, unknown>>>(c: {
readonly column: ResolvedColumn<any>;
}): D | undefined;