@fundamental-ngx/cdk 0.38.3-rc.4

package/utils/directives/repeat/repeat.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./repeat.directive";
+export declare class RepeatModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RepeatModule, never, [typeof i1.RepeatDirective, typeof i1.DeprecatedRepeatDirective], [typeof i1.RepeatDirective, typeof i1.DeprecatedRepeatDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RepeatModule>;
+}

package/utils/directives/resize/resize-handle.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedResizeHandleDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedResizeHandleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedResizeHandleDirective, "[fdResizeHandle], [fd-resize-handle]", never, {}, {}, never, never, true, never>;
+}
+export declare class ResizeHandleDirective {
+    elementRef: ElementRef;
+    /** @hidden */
+    constructor(elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeHandleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeHandleDirective, "[fdkResizeHandle], [fdResizeHandle], [fd-resize-handle]", never, {}, {}, never, never, true, never>;
+}

package/utils/directives/resize/resize.directive.d.ts

@@ -0,0 +1,57 @@
+import { AfterContentInit, ElementRef, EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { ResizeHandleDirective } from './resize-handle.directive';
+import { RtlService } from '../../services/rtl.service';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedResizeDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedResizeDirective, "[fdResize], [fd-resize]", never, {}, {}, never, never, true, never>;
+}
+export declare class ResizeDirective implements OnChanges, AfterContentInit, OnDestroy {
+    private _elementRef;
+    private _rtlService;
+    /** Element limiting resizable container growth */
+    resizeBoundary: string | HTMLElement;
+    /** Whether resizable behaviour should be disabled */
+    disabled: boolean;
+    /** Localization of resize handle inside resizable container */
+    resizeHandleLocation: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+    /** Resize handle reference - should be used if Resize handle is not a ContentChild of resizable container */
+    set setResizeHandleReference(value: ResizeHandleDirective);
+    /** Emits event when resizing has tarted */
+    onResizeStart: EventEmitter<void>;
+    /** Emits event when resizing has ended */
+    onResizeEnd: EventEmitter<void>;
+    /** @hidden Reference to Resize handle */
+    resizeHandleReference: any;
+    /** @hidden */
+    private _subscriptions;
+    /** @hidden */
+    private _isRtl;
+    /** @hidden */
+    constructor(_elementRef: ElementRef<HTMLElement>, _rtlService: RtlService);
+    /** @hidden */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @hidden */
+    ngAfterContentInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /** @hidden */
+    private get _direction();
+    /** @hidden Sets Resize listeners */
+    private _setResizeListeners;
+    /** @hidden Creates resize function*/
+    private _getResizeFunction;
+    /** @hidden Creates move function */
+    private _getMoveOffsetFunction;
+    /** @hidden Return boundary container */
+    private _findResizeContainer;
+    /** @hidden Check whether resizable container is overflowing boundary container */
+    private _getBoundaryOverflowFunction;
+    /** @hidden Create Observable notifying on resize actions */
+    private _getResizeEventsNotifiers;
+    /** @hidden Block resizable container pointer events when resizing  */
+    private _blockOtherPointerEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeDirective, "[fdkResize], [fdResize], [fd-resize]", never, { "resizeBoundary": "fdkResizeBoundary"; "disabled": "fdkResizeDisabled"; "resizeHandleLocation": "fdkResizeHandleLocation"; "setResizeHandleReference": "fdkResizeResizeHandleRef"; }, { "onResizeStart": "onResizeStart"; "onResizeEnd": "onResizeEnd"; }, ["resizeHandleReference"], never, true, never>;
+}

package/utils/directives/resize/resize.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./resize.directive";
+import * as i2 from "./resize-handle.directive";
+export declare class ResizeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ResizeModule, never, [typeof i1.ResizeDirective, typeof i1.DeprecatedResizeDirective, typeof i2.ResizeHandleDirective, typeof i2.DeprecatedResizeHandleDirective], [typeof i1.ResizeDirective, typeof i1.DeprecatedResizeDirective, typeof i2.ResizeHandleDirective, typeof i2.DeprecatedResizeHandleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ResizeModule>;
+}

package/utils/directives/selectable-list/index.d.ts

@@ -0,0 +1,7 @@
+export * from './selection.service';
+export * from './selectable-list.directive';
+export * from './selectable-item.directive';
+export * from './selectable-list.module';
+export * from './selectable-list.tokens';
+export * from './selectable-item.token';
+export * from './select-component-root.token';

package/utils/directives/selectable-list/select-component-root.token.d.ts

@@ -0,0 +1,10 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+export declare type SelectableListValueType<T> = T extends any[] ? Array<any> : any;
+export declare abstract class SelectComponentRootToken<T = any> {
+    abstract selected?: SelectableListValueType<T>;
+    abstract selectedChange: Observable<SelectableListValueType<T>>;
+    abstract multiple?: BooleanInput;
+    abstract toggle?: BooleanInput;
+    abstract onChange: (value: SelectableListValueType<T>) => void;
+}

package/utils/directives/selectable-list/selectable-item.directive.d.ts

@@ -0,0 +1,47 @@
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SelectableItemToken } from './selectable-item.token';
+import { FdkDisabledProvider } from '../disabled';
+import { FdkReadonlyProvider } from '../readonly';
+import { SelectionService } from './selection.service';
+import { FdkClickedProvider } from '../clicked';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class SelectableItemDirective<ElementType extends Element = HTMLElement, ValueType = any> implements SelectableItemToken<ElementType, ValueType> {
+    private provider;
+    private disabled$;
+    private readonly$;
+    private selectionService;
+    private _elementRef;
+    private _cd;
+    /** @hidden */
+    set value(val: ValueType);
+    get value(): ValueType;
+    /** @hidden */
+    set fdkSelectableItem(value: BooleanInput);
+    get fdkSelectableItem(): boolean;
+    /** @hidden */
+    clicked: Observable<MouseEvent | KeyboardEvent>;
+    /** @hidden */
+    private _value;
+    /** @hidden */
+    private _selected;
+    /** @hidden */
+    private _selectable;
+    /** @hidden */
+    constructor(provider: Partial<SelectableItemToken<ElementType, ValueType>>, disabled$: FdkDisabledProvider, readonly$: FdkReadonlyProvider, selectionService: SelectionService<ElementType, ValueType>, _elementRef: ElementRef<ElementType>, _cd: ChangeDetectorRef, _clicked: FdkClickedProvider);
+    /** @hidden */
+    getSelected(): boolean;
+    /** @hidden */
+    setSelected(isSelected: boolean): void;
+    /** @hidden */
+    elementRef(): ElementRef<ElementType>;
+    /** @hidden */
+    private _listenToDisablingEvents;
+    /** @hidden */
+    private _updateSelectionAndSelectableWatcher;
+    /** @hidden */
+    private _updateSelectableWatcher;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableItemDirective<any, any>, [{ optional: true; }, null, null, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableItemDirective<any, any>, "[fdkSelectableItem]", ["fdkSelectableItem"], { "value": "value"; "fdkSelectableItem": "fdkSelectableItem"; }, { "clicked": "clicked"; }, never, never, true, never>;
+}

package/utils/directives/selectable-list/selectable-item.token.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HasElementRef } from '../../interfaces/has-element-ref.interface';
+export declare abstract class SelectableItemToken<ElementType extends Element = HTMLElement, TValue = ElementType> implements HasElementRef<ElementType> {
+    abstract value: TValue;
+    abstract fdkSelectableItem?: boolean;
+    abstract elementRef(): ElementRef<ElementType>;
+    abstract setSelected(isSelected: boolean): void;
+    abstract getSelected(): boolean;
+    abstract clicked: Observable<MouseEvent | KeyboardEvent>;
+}

package/utils/directives/selectable-list/selectable-list.directive.d.ts

@@ -0,0 +1,33 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { AfterViewInit, EventEmitter, QueryList } from '@angular/core';
+import { SelectionService } from './selection.service';
+import { SelectableListValueType, SelectComponentRootToken } from './select-component-root.token';
+import { SelectableItemToken } from './selectable-item.token';
+import * as i0 from "@angular/core";
+export declare class SelectableListDirective<T extends Element = HTMLElement, V = any> implements SelectComponentRootToken<T>, AfterViewInit {
+    private _selectionService;
+    /** @hidden */
+    selectedChange: EventEmitter<SelectableListValueType<T>>;
+    /** @hidden */
+    toggle: BooleanInput;
+    /** @hidden */
+    multiple: BooleanInput;
+    /** @hidden */
+    set selected(value: SelectableListValueType<T>);
+    /** @hidden */
+    selectableItems: QueryList<SelectableItemToken<T, V>>;
+    /** @hidden */
+    constructor(_selectionService: SelectionService<T, V>);
+    /** @hidden */
+    select(item: SelectableItemToken<T, V>): void;
+    /** @hidden */
+    deselect(item: SelectableItemToken<T, V>): void;
+    /** @hidden */
+    toggleSelect(item: SelectableItemToken<T, V>): void;
+    /** @hidden */
+    onChange(value: SelectableListValueType<T>): void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableListDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectableListDirective<any, any>, "[fdkSelectableList]", ["fdkSelectableList"], { "toggle": "toggle"; "multiple": "multiple"; "selected": "selected"; }, { "selectedChange": "selectedChange"; }, ["selectableItems"], never, true, never>;
+}

package/utils/directives/selectable-list/selectable-list.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./selectable-list.directive";
+import * as i2 from "./selectable-item.directive";
+export declare class SelectableListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectableListModule, never, [typeof i1.SelectableListDirective, typeof i2.SelectableItemDirective], [typeof i1.SelectableListDirective, typeof i2.SelectableItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectableListModule>;
+}

package/utils/directives/selectable-list/selectable-list.tokens.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export declare const FDK_SELECTABLE_ITEM_PROVIDER: InjectionToken<unknown>;

package/utils/directives/selectable-list/selection.service.d.ts

@@ -0,0 +1,65 @@
+import { ChangeDetectorRef, OnDestroy, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SelectableItemToken } from './selectable-item.token';
+import { SelectableListValueType, SelectComponentRootToken } from './select-component-root.token';
+import * as i0 from "@angular/core";
+export declare class SelectionService<ElementType extends Element, ValueType = ElementType> implements OnDestroy {
+    private _cd;
+    /** @hidden */
+    value$: Observable<SelectableListValueType<ValueType>>;
+    /** @hidden */
+    private _items$;
+    /** @hidden */
+    private _value$;
+    /** @hidden */
+    private _normalizedValue$;
+    /** @hidden */
+    private _rootComponent;
+    /** @hidden */
+    private _destroy$;
+    /** @hidden */
+    private _clear$;
+    /** @hidden */
+    private _value;
+    /** @hidden */
+    constructor(_cd: ChangeDetectorRef);
+    /**
+     * Register main select component, which holds config
+     * */
+    registerRootComponent(rootComponent: SelectComponentRootToken<ElementType>): void;
+    /**
+     * Clear listeners
+     */
+    clear(): void;
+    /**
+     * Initialize watcher for selection changes and user interactions
+     * */
+    initialize(queryList: QueryList<SelectableItemToken<ElementType, ValueType>>): void;
+    /**
+     * Sets Value, on which service looks at and updates UI accordingly
+     * */
+    setValue(v: SelectableListValueType<ElementType>): void;
+    /** @hidden */
+    getValue(): SelectableListValueType<ElementType>;
+    /**
+     * Start listening for item interactions. Will destroy() first.
+     * Will silently continue if service was not initialized first.
+     * */
+    listenToItemInteractions(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /** @hidden */
+    selectItem(item: SelectableItemToken<ElementType, ValueType>): void;
+    /** @hidden */
+    deselectItem(item: SelectableItemToken<ElementType, ValueType>): void;
+    /** @hidden */
+    private get _isMultipleMode();
+    /** @hidden */
+    private _itemClicked;
+    /** @hidden */
+    private _getSelectedValues;
+    /** @hidden */
+    private _getProperValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionService<any, any>>;
+}

package/utils/directives/template/template.directive.d.ts

@@ -0,0 +1,18 @@
+import { TemplateRef } from '@angular/core';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedTemplateSelectorDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedTemplateSelectorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedTemplateSelectorDirective, "[fdTemplate]", never, {}, {}, never, never, true, never>;
+}
+export declare class TemplateDirective {
+    templateRef: TemplateRef<any>;
+    /** Name of the template */
+    name: string;
+    /** @hidden */
+    constructor(templateRef: TemplateRef<any>);
+    /** @hidden */
+    getName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateDirective, "[fdkTemplate], [fdTemplate]", never, { "name": "fdkTemplate"; }, {}, never, never, true, never>;
+}

package/utils/directives/template/template.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./template.directive";
+export declare class TemplateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TemplateModule, never, [typeof i1.TemplateDirective, typeof i1.DeprecatedTemplateSelectorDirective], [typeof i1.TemplateDirective, typeof i1.DeprecatedTemplateSelectorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TemplateModule>;
+}

package/utils/directives/truncate/truncate.directive.d.ts

@@ -0,0 +1,51 @@
+import { AfterViewInit, ElementRef, OnChanges } from '@angular/core';
+import { Nullable } from '../../models/nullable';
+import { DeprecatedSelector } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export declare class DeprecatedTruncateSelectorDirective extends DeprecatedSelector {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeprecatedTruncateSelectorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DeprecatedTruncateSelectorDirective, "[fdTruncate], [fd-truncate]", never, {}, {}, never, never, true, never>;
+}
+export declare class TruncateDirective implements OnChanges, AfterViewInit {
+    private readonly _elementRef;
+    /**
+     * Width in pixel for truncation of an element , by default
+     */
+    set fdkTruncateWidth(value: Nullable<number>);
+    /**
+     * Truncating state
+     */
+    fdkTruncateState: boolean;
+    /** @hidden */
+    private _customWidthCount;
+    /** @hidden */
+    private _truncateTarget;
+    /** @hidden
+     * saves default style of element before truncating
+     */
+    private _defaultStyle;
+    /** @hidden */
+    private takeDefaultStyleOnce;
+    /** @hidden
+     * truncation style for truncating element
+     */
+    private _truncationStyle;
+    /** @hidden */
+    constructor(_elementRef: ElementRef);
+    /**
+     * Root native element
+     */
+    get rootElement(): HTMLElement;
+    /**
+     * Method saves default style of target element before first truncate.
+     */
+    setDefaultStyle(): void;
+    /** @hidden */
+    ngAfterViewInit(): void;
+    /** @hidden */
+    ngOnChanges(): void;
+    /** @hidden */
+    private _truncate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncateDirective, "[fdkTruncate], [fdTruncate], [fd-truncate]", never, { "fdkTruncateWidth": "fdkTruncateWidth"; "fdkTruncateState": "fdkTruncateState"; }, {}, never, never, true, never>;
+}

package/utils/directives/truncate/truncate.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./truncate.directive";
+export declare class TruncateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TruncateModule, never, [typeof i1.TruncateDirective, typeof i1.DeprecatedTruncateSelectorDirective], [typeof i1.TruncateDirective, typeof i1.DeprecatedTruncateSelectorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TruncateModule>;
+}

package/utils/drag-and-drop/dnd-item/dnd-item.directive.d.ts

@@ -0,0 +1,86 @@
+import { AfterContentInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { DragDrop } from '@angular/cdk/drag-drop';
+import { DndItem, ElementChord, ElementPosition, LinkPosition } from '../dnd.interfaces';
+import * as i0 from "@angular/core";
+export declare class DndItemDirective implements DndItem, AfterContentInit, OnDestroy {
+    elementRef: ElementRef;
+    private _dragDrop;
+    /**
+     * Whether to apply "fd-dnd-item" class.
+     * @default true
+     */
+    applyDragItemClass: boolean;
+    /** Container selector */
+    containerSelector?: string;
+    /** Event thrown when the element is moved by 1px */
+    readonly moved: EventEmitter<ElementPosition>;
+    /** Event thrown when the element is released */
+    readonly released: EventEmitter<void>;
+    /** Event thrown when the element is started to be dragged */
+    readonly started: EventEmitter<void>;
+    /**
+     *  Defines if the item is prevented from being moved by other elements.
+     * So nothing can be placed just before and just after it
+     */
+    stickInPlace: boolean;
+    /** Defines if element is draggable */
+    set draggable(draggable: boolean);
+    /** Class added to element, when it's dragged. */
+    classWhenElementDragged: string;
+    /** Defines if every element in list is draggable */
+    listDraggable: boolean;
+    /** @hidden
+     * Drag reference, object created from DND CDK Service
+     */
+    private _dragRef;
+    /** @hidden */
+    private _draggable;
+    /** @hidden */
+    private _subscriptions;
+    /** @hidden */
+    private _placeholderElement;
+    /** @hidden */
+    private _lineElement;
+    /** @hidden */
+    private _replaceIndicator;
+    /** @hidden */
+    constructor(elementRef: ElementRef, _dragDrop: DragDrop);
+    /** @hidden */
+    getElementCoordinates(isBefore: boolean): ElementChord;
+    /** @hidden */
+    ngAfterContentInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /** @hidden */
+    onCdkMove(position: ElementPosition): void;
+    /** @hidden */
+    onCdkDragReleased(): void;
+    /** @hidden */
+    onCdkDragStart(): void;
+    /** @hidden */
+    removePlaceholder(): void;
+    /** @hidden */
+    removeLine(): void;
+    /** @hidden */
+    removeReplaceIndicator(): void;
+    /** @hidden */
+    createReplaceIndicator(): void;
+    /** @hidden */
+    createLine(position: LinkPosition, gridMode: boolean): void;
+    /** @hidden */
+    changeCDKDragState(): void;
+    /** @hidden */
+    private createPlaceholder;
+    /** @hidden */
+    private _setPlaceholderStyles;
+    /** @hidden */
+    private _getOffsetToParent;
+    /** @hidden */
+    private _setCDKDrag;
+    /** IE11 equivalent of Node.after() Method */
+    private _placeAfter;
+    /** @hidden */
+    private _listenElementEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DndItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DndItemDirective, "[fdkDndItem], [fd-dnd-item]", never, { "applyDragItemClass": "applyDragItemClass"; "containerSelector": "containerSelector"; "stickInPlace": "stickInPlace"; "draggable": "draggable"; "classWhenElementDragged": "classWhenElementDragged"; }, { "moved": "moved"; "released": "released"; "started": "started"; }, never, never, false, never>;
+}

package/utils/drag-and-drop/dnd-keyboard-group/dnd-keyboard-group.directive.d.ts

@@ -0,0 +1,32 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { RtlService } from '../../services/rtl.service';
+import * as i0 from "@angular/core";
+/**
+ * This directive is used to provide drag & drop with keyboard support.
+ * It should be used together with directive fdDndKeyboardItem.
+ */
+export declare class DndKeyboardGroupDirective {
+    private readonly _cdr;
+    private readonly _rtlService;
+    /** Group of items */
+    groups: any[][];
+    /** Whether to disable drag & drop */
+    disableKeyboardDragDrop: boolean;
+    /** Used to apply indexes when moving between groups */
+    orientation: 'horizontal' | 'vertical';
+    /** @hidden */
+    _onDndItemFocus$: Subject<[number, number]>;
+    /** Custom function to call when moving item inside the group */
+    customMoveFn: (group: any[], fromIndex: number, toIndex: number) => void;
+    /** Custom function to call when moving item between groups */
+    customTransferFn: (group: any[], nextGroup: any[], fromIndex: number, toIndex: number) => void;
+    /** @hidden */
+    constructor(_cdr: ChangeDetectorRef, _rtlService: RtlService);
+    /** Process drag & drop */
+    processDragDrop(event: KeyboardEvent, itemIndex: number, groupIndex: number): void;
+    /** @hidden Focus after moving elements with keyboard */
+    private _focusDndItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DndKeyboardGroupDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DndKeyboardGroupDirective, "[fdkDndKeyboardGroup], [fdDndKeyboardGroup]", never, { "groups": "groups"; "disableKeyboardDragDrop": "disableKeyboardDragDrop"; "orientation": "orientation"; "customMoveFn": "customMoveFn"; "customTransferFn": "customTransferFn"; }, {}, never, never, false, never>;
+}

package/utils/drag-and-drop/dnd-keyboard-item/dnd-keyboard-item.directive.d.ts

@@ -0,0 +1,61 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { DndKeyboardGroupDirective } from '../dnd-keyboard-group/dnd-keyboard-group.directive';
+import * as i0 from "@angular/core";
+/**
+ * This directive is used to provide drag & drop with keyboard support.
+ * It should be used together with directive fdDndKeyboardGroup.
+ * We are using _groups from fdDndKeyboardGroup and adding a possibility to move cards.
+ * Please see example below:
+ * @Component({
+ * selector: 'cdk-drag-drop-example',
+ * template: `<div
+ *               cdkDragListGroup
+ *               fdDndKeyboardGroup
+ *               [groups]="groups"
+ *           >
+ *               <div
+ *                   *ngFor="let group of groups; let groupIndex = index"
+ *                   cdkDragList
+ *               >
+ *                   Group #{{ groupIndex }}
+ *                   <div
+ *                       *ngFor="let item of group; let index = index"
+ *                       cdkDrag
+ *                       fdDndKeyboardItem
+ *                       [itemIndex]="index"
+ *                       [groupIndex]="groupIndex"
+ *                       [dndKeyboardDisabled]="flag for disable/enable keyboard navigation if needed"
+ *                       tabindex="0"
+ *                   >
+ *                       Item #{{ item }}
+ *                   </div>
+ *               </div>
+ *           </div>`,
+ * })
+ * export class CdkDragDropExample {
+ *   groups = [
+ *        [1, 2, 3],
+ *        [4, 5, 6],
+ *      ];
+ *   }
+ */
+export declare class DndKeyboardItemDirective implements OnInit, OnDestroy {
+    private readonly _dndGroup;
+    private readonly _elementRef;
+    /** item index in group(column) */
+    itemIndex: number;
+    /** group(column) index */
+    groupIndex: number;
+    /** @hidden */
+    private readonly _onDestroy$;
+    /** @hidden */
+    constructor(_dndGroup: DndKeyboardGroupDirective, _elementRef: ElementRef);
+    /** @hidden */
+    ngOnInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /** @hidden */
+    _onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DndKeyboardItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DndKeyboardItemDirective, "[fdkDndKeyboardItem], [fdDndKeyboardItem]", never, { "itemIndex": "itemIndex"; "groupIndex": "groupIndex"; }, {}, never, never, false, never>;
+}

package/utils/drag-and-drop/dnd-list/dnd-list.directive.d.ts

@@ -0,0 +1,65 @@
+import { AfterContentInit, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { FdDropEvent, ElementPosition, DndItem } from '../dnd.interfaces';
+import * as i0 from "@angular/core";
+export declare class DndListDirective<T> implements AfterContentInit, OnDestroy {
+    /**
+     * Defines if the the element is allowed to be dragged in 2 dimensions,
+     * When true - replace indicator will be displayed vertically
+     */
+    gridMode: boolean;
+    /** When enabled, replace indicator will appear on whole element, instead of horizontal/vertical line before/after element */
+    replaceMode: boolean;
+    /** Array of items, that will be sorted */
+    items: Array<T>;
+    /** Defines if drag and drop feature should be enabled for list items */
+    set draggable(draggable: boolean);
+    /** Event that is thrown, when items are reordered */
+    readonly itemsChange: EventEmitter<T[]>;
+    /** Event that is thrown, when the item is dropped */
+    readonly itemDropped: EventEmitter<FdDropEvent<T>>;
+    /** @hidden */
+    dndItems: QueryList<DndItem>;
+    /** @hidden */
+    private _elementsCoordinates;
+    /** @hidden */
+    private _closestItemIndex;
+    /** @hidden */
+    private _closestItemPosition;
+    /** An RxJS Subject that will kill the current data stream (for unsubscribing)  */
+    private readonly _refresh$;
+    /** @hidden */
+    private readonly _onDestroy$;
+    /** @hidden  */
+    private _dndItemReference;
+    /** @hidden */
+    private _draggable;
+    /** @hidden */
+    ngAfterContentInit(): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /** Method called, when the item is being moved by 1 px */
+    onMove(mousePosition: ElementPosition, draggedItemIndex: number): void;
+    /** Method called, when element is started to be dragged */
+    dragStart(index: number): void;
+    /** Method called, when element is released */
+    dragEnd(draggedItemIndex: number): void;
+    /** @hidden */
+    private _removeAllLines;
+    /** @hidden */
+    private _removeAllReplaceIndicators;
+    /** @hidden */
+    private _createLine;
+    /** @hidden */
+    private _createReplaceIndicator;
+    /** @hidden */
+    private _refreshQueryList;
+    /**
+     *  @hidden
+     * Return information if element is placed before the dragged element
+     */
+    private _isBefore;
+    /** @hidden */
+    private _changeDraggableState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DndListDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DndListDirective<any>, "[fdkDndList], [fd-dnd-list]", never, { "gridMode": "gridMode"; "replaceMode": "replaceMode"; "items": "items"; "draggable": "draggable"; }, { "itemsChange": "itemsChange"; "itemDropped": "itemDropped"; }, ["dndItems"], never, false, never>;
+}