ngx-edu-sharing-ui 0.7.0 → 9.0.1

package/{src/lib/services/local-events.service.ts → lib/services/local-events.service.d.ts}

@@ -1,13 +1,10 @@
-import { EventEmitter, Injectable } from '@angular/core';
+import { EventEmitter } from '@angular/core';
 import { Node } from 'ngx-edu-sharing-api';
-
+import * as i0 from "@angular/core";
 /**
  * An application-wide event broker.
  */
-@Injectable({
-    providedIn: 'root',
-})
-export class LocalEventsService {
+export declare class LocalEventsService {
     /**
      * The metadata of one or more nodes have been updated.
      *
@@ -15,7 +12,7 @@ export class LocalEventsService {
      *
      * The emitter should not be triggered with an empty array or null.
      */
-    readonly nodesChanged = new EventEmitter<Node[]>();
+    readonly nodesChanged: EventEmitter<Node[]>;
     /**
      * One or more nodes have been moved to the recycle bin.
      *
@@ -23,7 +20,7 @@ export class LocalEventsService {
      *
      * The emitter should not be triggered with an empty array or null.
      */
-    // FIXME: Maybe a `nodesMoved` emitter would make for sense for updating lists that used to
-    // include a node and lists that the node was moved to.
-    readonly nodesDeleted = new EventEmitter<Node[]>();
+    readonly nodesDeleted: EventEmitter<Node[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalEventsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalEventsService>;
 }

package/lib/services/node-entries.service.d.ts

@@ -0,0 +1,69 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { FetchEvent, GridConfig, InteractionType, ListDragGropConfig, ListEventInterface, ListOptions, ListSortConfig, NodeClickEvent, NodeEntriesDataType, NodeEntriesDisplayType } from '../node-entries/entries-model';
+import { NodeDataSource } from '../node-entries/node-data-source';
+import { NodeEntriesGlobalService, PaginationStrategy } from '../node-entries/node-entries-global.service';
+import { OptionItem, Scope } from '../types/option-item';
+import { ListItem } from '../types/list-item';
+import { UIService } from './ui.service';
+import * as i0 from "@angular/core";
+export declare class NodeEntriesService<T extends NodeEntriesDataType> {
+    private uiService;
+    private entriesGlobal;
+    list: ListEventInterface<T>;
+    readonly dataSource$: BehaviorSubject<NodeDataSource<T>>;
+    /**
+     * scope the current list is in, e.g. workspace
+     * This is used for additional config injection based on the scope
+     */
+    scope: Scope;
+    get dataSource(): NodeDataSource<T>;
+    set dataSource(value: NodeDataSource<T>);
+    get paginationStrategy(): PaginationStrategy;
+    /**
+     * Subject that reflects the current columns configuration.
+     *
+     * Updated when loading configuration and through user interaction.
+     */
+    columnsSubject: BehaviorSubject<ListItem[]>;
+    get columns(): ListItem[];
+    set columns(value: ListItem[]);
+    configureColumns: boolean;
+    /** Emits when the columns configuration changes through user interaction. */
+    columnsChange: EventEmitter<ListItem[]>;
+    displayType: NodeEntriesDisplayType;
+    selection: SelectionModel<T>;
+    elementInteractionType: InteractionType;
+    options$: BehaviorSubject<ListOptions>;
+    get options(): ListOptions;
+    set options(options: ListOptions);
+    checkbox: boolean;
+    globalOptions: OptionItem[];
+    sortSubject: BehaviorSubject<ListSortConfig>;
+    get sort(): ListSortConfig;
+    set sort(value: ListSortConfig);
+    sortChange: EventEmitter<ListSortConfig>;
+    dragDrop: ListDragGropConfig<T>;
+    clickItem: EventEmitter<NodeClickEvent<T>>;
+    dblClickItem: EventEmitter<NodeClickEvent<T>>;
+    fetchData: EventEmitter<FetchEvent>;
+    readonly gridConfig$: BehaviorSubject<GridConfig>;
+    get gridConfig(): GridConfig;
+    set gridConfig(value: GridConfig);
+    primaryInstance: boolean;
+    singleClickHint: 'dynamic' | 'static';
+    disableInfiniteScroll: boolean;
+    constructor(uiService: UIService, entriesGlobal: NodeEntriesGlobalService);
+    onClicked({ event, ...data }: NodeClickEvent<T> & {
+        event: MouseEvent;
+    }): void;
+    onCheckboxChanged(node: T, checked: boolean): void;
+    toggleSelectAll(): void;
+    loadMore(source: 'button' | 'scroll'): boolean;
+    private selectAll;
+    private isAllSelected;
+    private expandSelectionTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeEntriesService<any>>;
+}

package/lib/services/node-helper.service.d.ts

@@ -0,0 +1,56 @@
+import { ApiHelpersService, ConfigService, NetworkService, Node } from 'ngx-edu-sharing-api';
+import { TranslateService } from '@ngx-translate/core';
+import * as Workflow from '../types/workflow';
+import { RepoUrlService } from './repo-url.service';
+import { Params } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class NodeHelperService {
+    protected translate: TranslateService;
+    protected apiHelpersService: ApiHelpersService;
+    protected networkService: NetworkService;
+    protected configService: ConfigService;
+    protected repoUrlService: RepoUrlService;
+    constructor(translate: TranslateService, apiHelpersService: ApiHelpersService, networkService: NetworkService, configService: ConfigService, repoUrlService: RepoUrlService);
+    getCollectionScopeInfo(node: Node): {
+        icon: string;
+        scopeName: string;
+    };
+    /**
+     * Return the license icon of a node
+     */
+    getLicenseIcon(node: Node): Promise<string>;
+    /**
+     * Get a license icon by using the property value string
+     */
+    getLicenseIconByString(string: String, useNoneAsFallback?: boolean): string;
+    /**
+     * Return a translated name of a license name for a node
+     * @param node
+     * @param translate
+     * @returns {string|any|string|any|string|any|string|any|string|any|string}
+     */
+    getLicenseName(node: Node): any;
+    /**
+     * Return a translated name for a license string
+     * @param string
+     * @param translate
+     * @returns {any}
+     */
+    getLicenseNameByString(name: string): any;
+    /**
+     * return the License URL (e.g. for CC_BY licenses) for a license string and version
+     * @param licenseProperty
+     * @param licenseVersion
+     */
+    getLicenseUrlByString(licenseProperty: string, licenseVersion: string): any;
+    getWorkflowStatusById(id: string): Workflow.WorkflowDefinition;
+    getWorkflowStatus(node: Node, useFromConfig?: boolean): Workflow.WorkflowDefinitionStatus;
+    getDefaultWorkflowStatus(useFromConfig?: boolean): Workflow.WorkflowDefinitionStatus;
+    getWorkflows(): Workflow.WorkflowDefinition[];
+    copyDataToNode<T extends Node>(target: T, source: T): void;
+    isNodeCollection(node: Node): boolean;
+    getSourceIconPath(src: string): string;
+    getNodeLink(mode: 'routerLink' | 'queryParams', node: Node): string | Params;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeHelperService>;
+}

package/lib/services/nodes-drag-drop.service.d.ts

@@ -0,0 +1,41 @@
+import { NgZone } from '@angular/core';
+import { CanDrop } from '../types/drag-drop';
+import { NodesDropTargetDirective } from '../directives/drag-nodes/nodes-drop-target.directive';
+import { Node } from 'ngx-edu-sharing-api';
+import { Toast } from './abstract/toast.service';
+import { UIService } from './ui.service';
+import * as i0 from "@angular/core";
+export declare class NodesDragDropService {
+    private ngZone;
+    private toast;
+    private uiService;
+    /** The node(s) currently being dragged. */
+    private draggedNodesSubject;
+    /** The drop target that something is currently dragged above. */
+    private dropTargetSubject;
+    /** Whether the current drop target allows dropping the dragged node(s). */
+    private canDropSubject;
+    /** A target being hovered with the cursor. Does not mean anything is dragged yet. */
+    private hoveredTargetSubject;
+    /** Current drop action based on pressed modifier keys. */
+    private dropActionSubject;
+    /** The current cursor style. */
+    private curserSubject;
+    set draggedNodes(nodes: Node[]);
+    get canDrop(): CanDrop;
+    constructor(ngZone: NgZone, toast: Toast, uiService: UIService);
+    /** Call when the cursor enters a possible drop target. Runs outside ngZone. */
+    onMouseEnter(target: NodesDropTargetDirective): void;
+    /** Call when the cursor leaves a possible drop target. Runs outside ngZone. */
+    onMouseLeave(target: NodesDropTargetDirective): void;
+    onDropped(nodes: Node[]): void;
+    private registerDropTarget;
+    private registerCanDrop;
+    private registerCursor;
+    private registerActiveDropTargetStyle;
+    private registerDropActionSubject;
+    private getDropAction;
+    private getCursor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodesDragDropService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodesDragDropService>;
+}

package/lib/services/options-helper-data.service.d.ts

@@ -0,0 +1,75 @@
+import { DropdownComponent } from '../dropdown/dropdown.component';
+import { ActionbarComponent } from '../actionbar/actionbar.component';
+import { ListEventInterface, NodeEntriesDataType, NodeEntriesDisplayType } from '../node-entries/entries-model';
+import { EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { AuthenticationService, NetworkService, Node, UserService } from 'ngx-edu-sharing-api';
+import { CustomOptions, OptionItem, Scope, Target } from '../types/option-item';
+import { OptionsHelperService } from './abstract/options-helper.service';
+import { KeyboardShortcutsService } from './abstract/keyboard-shortcuts.service';
+import { ActivatedRoute } from '@angular/router';
+import { LocalEventsService } from './local-events.service';
+import * as i0 from "@angular/core";
+type DeleteEvent = {
+    objects: Node[] | any;
+    count: number;
+    error: boolean;
+};
+export interface OptionsHelperComponents {
+    actionbar: ActionbarComponent;
+    dropdown: DropdownComponent;
+    list: ListEventInterface<NodeEntriesDataType>;
+}
+export interface OptionData {
+    scope: Scope;
+    activeObjects?: Node[] | any[];
+    selectedObjects?: Node[] | any[];
+    allObjects?: Node[] | any[];
+    parent?: Node | any;
+    customOptions?: CustomOptions;
+    /**
+     * custom interceptor to modify the default options array
+     */
+    postPrepareOptions?: (options: OptionItem[], objects: Node[]) => void;
+}
+export declare class OptionsHelperDataService implements OnDestroy {
+    private ngZone;
+    private route;
+    private localEvents;
+    private authenticationService;
+    private userService;
+    private networkService;
+    private keyboardShortcutsService;
+    private optionsHelperService;
+    private components;
+    private data;
+    private keyboardShortcutsSubscription;
+    private globalOptions;
+    private destroyed;
+    readonly virtualNodesAdded: EventEmitter<Node[]>;
+    readonly nodesChanged: EventEmitter<void | Node[]>;
+    readonly nodesDeleted: EventEmitter<DeleteEvent>;
+    readonly displayTypeChanged: EventEmitter<NodeEntriesDisplayType>;
+    constructor(ngZone: NgZone, route: ActivatedRoute, localEvents: LocalEventsService, authenticationService: AuthenticationService, userService: UserService, networkService: NetworkService, keyboardShortcutsService: KeyboardShortcutsService, optionsHelperService: OptionsHelperService);
+    /** Performs subscriptions that don't have to be refreshed. */
+    private registerStaticSubscriptions;
+    ngOnDestroy(): void;
+    initComponents(actionbar?: ActionbarComponent, list?: ListEventInterface<NodeEntriesDataType>, dropdown?: DropdownComponent): Promise<void>;
+    getData(): OptionData;
+    setData(data: OptionData): void;
+    refreshComponents(refreshListOptions?: boolean): void;
+    getAvailableOptions(target: Target, objects?: Node[]): OptionItem[];
+    private addVirtualObjects;
+    registerGlobalKeyboardShortcuts(): void;
+    private handleKeyboardEvent;
+    filterOptions(options: OptionItem[], target: Target, objects?: Node[] | any): OptionItem[];
+    /**
+     * shortcut to simply disable all options on the given compoennts
+     * @param actionbar
+     * @param list
+     */
+    clearComponents(actionbar: ActionbarComponent, list?: ListEventInterface<Node>): void;
+    pasteNode(nodes?: Node[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionsHelperDataService, [null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OptionsHelperDataService>;
+}
+export {};

package/lib/services/repo-url.service.d.ts

@@ -0,0 +1,25 @@
+import { Node } from 'ngx-edu-sharing-api';
+import * as i0 from "@angular/core";
+/**
+ * Replaces absolute backend URLs with proxied URLs when in dev environment.
+ *
+ * This is needed for content that requires authentication, so the browser provides the required
+ * session cookie with the request, or when accessing the dev server from another device.
+ */
+export declare class RepoUrlService {
+    private networkService;
+    private configuration;
+    private constructor();
+    /**
+     * Replaces the given URL if the given node belongs to the home repository.
+     */
+    getRepoUrl(url: string, node: Node): Promise<string>;
+    /**
+     * Replaces the given URL.
+     *
+     * The caller needs to make sure that the given URL belongs to the home repository.
+     */
+    withCurrentOrigin(url: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepoUrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RepoUrlService>;
+}

package/lib/services/temporary-storage.service.d.ts

@@ -0,0 +1,35 @@
+import { Node } from 'ngx-edu-sharing-api';
+import * as i0 from "@angular/core";
+/**
+ * Service to store any data temporary (lost after reloading page).
+ *
+ * Note that all components share the same data source. So uses prefixes for your name if
+ * applicable!
+ */
+export declare class TemporaryStorageService {
+    static APPLY_TO_LMS_PARAMETER_NODE: string;
+    static NODE_RENDER_PARAMETER_LIST: string;
+    static NODE_RENDER_PARAMETER_DATA_SOURCE: string;
+    static COLLECTION_ADD_NODES: string;
+    static WORKSPACE_LAST_LOCATION: string;
+    static OPTION_HIDE_MAINNAV: 'option_hide_mainnav';
+    static OPTION_DISABLE_SCROLL_LAYOUT: 'option_disable_scroll_layout';
+    static CUSTOM_NODE_LIST_COMPONENT: string;
+    static CUSTOM_NODE_ENTRIES_COMPONENT: string;
+    private data;
+    constructor();
+    get(name: string, defaultValue?: any): any;
+    set(name: string, value: any): void;
+    /**
+     * Same as get, but will remove the value after fetching it.
+     */
+    pop(name: string, defaultValue?: any): any;
+    remove(name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemporaryStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TemporaryStorageService>;
+}
+export interface ClipboardObject {
+    nodes: Node[];
+    sourceNode: Node;
+    copy: boolean;
+}

package/lib/services/ui.service.d.ts

@@ -0,0 +1,41 @@
+import { ComponentFactoryResolver, ComponentRef, Injector, NgZone, Type, ViewContainerRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OptionItem } from '../types/option-item';
+import * as i0 from "@angular/core";
+export declare class UIService {
+    protected componentFactoryResolver: ComponentFactoryResolver;
+    protected injector: Injector;
+    protected ngZone: NgZone;
+    private isTouchSubject;
+    private metaKeyPressedSubject;
+    private shiftKeyPressedSubject;
+    private ctrlKeyPressedSubject;
+    get shiftKeyPressed(): boolean;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, injector: Injector, ngZone: NgZone);
+    private onKeyDownOrKeyUp;
+    private updateModifierKeys;
+    observeCtrlOrCmdKeyPressedOutsideZone(): Observable<boolean>;
+    isMobile(): boolean;
+    static evaluateMediaQuery(type: string, value: number): boolean;
+    filterValidOptions(options: OptionItem[]): OptionItem[];
+    filterToggleOptions(options: OptionItem[], toggle: boolean): OptionItem[];
+    /**
+     * dynamically inject an angular component into a regular html dom element
+     * @param componentFactoryResolver The resolver service
+     * @param viewContainerRef The viewContainerRef service
+     * @param componentName The name of the angular component (e.g. SpinnerComponent)
+     * @param targetElement The target element of the dom. If the element is null (not found), nothing is done
+     * @param bindings Optional bindings (inputs & outputs) to the given component
+     * @param delay Optional inflating delay in ms(some components may need some time to "init" the layout)
+     * @param replace Whether to replace to previous `innerHTML` of `targetElement`
+     * @param injector (to fetch templates for the component)
+     */
+    injectAngularComponent<T>(viewContainerRef: ViewContainerRef, componentName: Type<T>, targetElement: Element, bindings?: {
+        [key: string]: any;
+    }, { delay, replace }?: {
+        delay?: number;
+        replace?: boolean;
+    }): ComponentRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UIService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UIService>;
+}

package/lib/sort-dropdown/sort-dropdown.component.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '@angular/core';
+import { MatMenu } from '@angular/material/menu';
+import { ListItem, SortEvent } from '../types/list-item';
+import * as i0 from "@angular/core";
+export declare class SortDropdownComponent {
+    menu: MatMenu;
+    columns: ListItem[];
+    sortBy: string;
+    sortAscending: boolean;
+    onSort: EventEmitter<SortEvent>;
+    constructor();
+    setSort(item: ListItem | any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortDropdownComponent, "es-sort-dropdown", never, { "columns": { "alias": "columns"; "required": false; }; "sortBy": { "alias": "sortBy"; "required": false; }; "sortAscending": { "alias": "sortAscending"; "required": false; }; }, { "onSort": "onSort"; }, never, never, false, never>;
+}

package/lib/spinner/spinner.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class SpinnerComponent {
+    readonly dataTest = "loading-spinner";
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "es-spinner", never, {}, {}, never, never, false, never>;
+}

package/lib/translations/fallback-translation-handler.d.ts

@@ -0,0 +1,4 @@
+import { MissingTranslationHandler, MissingTranslationHandlerParams } from '@ngx-translate/core';
+export declare class FallbackTranslationHandler implements MissingTranslationHandler {
+    handle(params: MissingTranslationHandlerParams): any;
+}

package/lib/translations/languages.d.ts

@@ -0,0 +1,4 @@
+import { Locale } from 'ngx-edu-sharing-api';
+export declare const LANGUAGES: {
+    [key: string]: Locale;
+};

package/lib/translations/translation-loader.d.ts

@@ -0,0 +1,51 @@
+import { HttpClient } from '@angular/common/http';
+import { TranslateLoader } from '@ngx-translate/core';
+import { ConfigService } from 'ngx-edu-sharing-api';
+import { Observable } from 'rxjs';
+import { EduSharingUiConfiguration } from '../edu-sharing-ui-configuration';
+export declare const TRANSLATION_LIST: string[];
+type Dictionary = {
+    [key: string]: string | Dictionary;
+};
+export declare class TranslationLoader implements TranslateLoader {
+    private http;
+    private configService;
+    private configuration;
+    private prefix;
+    private suffix;
+    static create(http: HttpClient, configService: ConfigService, configuration: EduSharingUiConfiguration): TranslationLoader;
+    private constructor();
+    private readonly source;
+    /**
+     * Gets the translations from the server
+     */
+    getTranslation(lang: string): Observable<Dictionary>;
+    private getOriginalTranslations;
+    private getSource;
+    /**
+     * Returns an array of Observables that will each fetch a translations json
+     * file.
+     */
+    private fetchTranslations;
+    /**
+     * Takes an array as returned by `fetchTranslations` and converts it to an
+     * Observable that yields a single Dictionary object.
+     */
+    private mergeTranslations;
+    /**
+     * Applies `overrides` to `translations` and returns `translations`.
+     *
+     * Example:
+     *  translations = { foo: { bar: 'bar' } }
+     *  overrides = { 'foo.bar': 'baz' }
+     * results in
+     *  translations = { foo: {bar: 'baz' } }
+     *
+     * @param translations Nested translations object.
+     * @param overrides Flat object with dots (.) in keys interpreted as
+     * separators.
+     */
+    private applyOverrides;
+    private replaceGenderCharacter;
+}
+export {};

package/{src/lib/translations/translation-source.ts → lib/translations/translation-source.d.ts}

@@ -1,9 +1,9 @@
 /** The preferred source for language files. */
-export enum TranslationSource {
+export declare enum TranslationSource {
     /** In dev mode, local files are used and in production, repository files are used (default). */
-    Auto,
+    Auto = 0,
     /** Local files (assets/i18n) are used. */
-    Local,
+    Local = 1,
     /** Repository files are used. */
-    Repository,
+    Repository = 2
 }

package/lib/translations/translations.module.d.ts

@@ -0,0 +1,15 @@
+import { ModuleWithProviders } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+/**
+ * Import this module once in the app module to provide the `TranslateService`.
+ *
+ * Export `TranslateModule` in the shared module to provide directives and pipes.
+ */
+export declare class TranslationsModule {
+    static forRoot(): ModuleWithProviders<TranslationsModule>;
+    constructor(parentModule?: TranslationsModule);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationsModule, [{ optional: true; skipSelf: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TranslationsModule, never, [typeof i1.TranslateModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TranslationsModule>;
+}

package/lib/translations/translations.service.d.ts

@@ -0,0 +1,30 @@
+import { ActivatedRoute } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { ConfigService, SessionStorageService } from 'ngx-edu-sharing-api';
+import { AppService } from '../services/abstract/app.service';
+import * as i0 from "@angular/core";
+export declare class TranslationsService {
+    private config;
+    private route;
+    private storage;
+    private translate;
+    private appService;
+    private language;
+    private languageLoaded;
+    constructor(config: ConfigService, route: ActivatedRoute, storage: SessionStorageService, translate: TranslateService, appService: AppService);
+    /**
+     * Determines and configures the language to use and triggers loading of translations with
+     * ngx-translate.
+     *
+     * Call this once in the app component.
+     */
+    initialize(): Observable<void>;
+    private initializeCordova;
+    waitForInit(): Observable<void>;
+    /** Same as `translate.currentLang`. */
+    getLanguage(): string;
+    getISOLanguage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationsService, [null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationsService>;
+}

package/lib/types/accessibillity.d.ts

@@ -0,0 +1,15 @@
+export declare class AccessibilitySettings {
+    toastMode: 'important' | 'all';
+    toastDuration: ToastDuration;
+    contrastMode: boolean;
+    indicatorIcons: boolean;
+}
+export declare enum ToastDuration {
+    Seconds_3 = 3,
+    Seconds_5 = 5,
+    Seconds_8 = 8,
+    Seconds_15 = 15,
+    Seconds_30 = 30,
+    Seconds_60 = 60,
+    Infinite
+}

package/{src/lib/types/drag-drop.ts → lib/types/drag-drop.d.ts}

@@ -1,7 +1,5 @@
 import { Node } from 'ngx-edu-sharing-api';
-
 export type DropAction = 'move' | 'copy' | 'link';
-
 export interface DragData<T = unknown> {
     draggedNodes: Node[];
     action: DropAction;
@@ -11,7 +9,6 @@ export interface DropTargetState {
     action: DropAction;
     canDrop: CanDrop;
 }
-
 export interface CanDrop {
     /** Whether the target is a valid drop target for the dragged nodes and the given action. */
     accept: boolean;

package/lib/types/keyboard-shortcuts.d.ts

@@ -0,0 +1,10 @@
+export type Modifier = 'Ctrl/Cmd' | 'Shift' | 'Alt';
+export interface KeyboardShortcutCondition {
+    modifiers?: Modifier[];
+    keyCode: string;
+    ignoreWhen?: (event: KeyboardEvent) => boolean;
+}
+export interface KeyboardShortcut extends KeyboardShortcutCondition {
+    callback: () => void;
+}
+export declare function matchesShortcutCondition(event: KeyboardEvent, condition: KeyboardShortcutCondition): boolean;

package/lib/types/list-item.d.ts

@@ -0,0 +1,55 @@
+import { Sort, SortDirection } from '@angular/material/sort';
+import { Observable } from 'rxjs';
+export type ListItemType = 'NODE' | 'NODE_PROPOSAL' | 'COLLECTION' | 'ORG' | 'GROUP' | 'USER';
+/**
+ * A list item info, which is basically a column
+ * Example:
+ this.columns.push(new ListItem(RestConstants.CM_NAME));
+ this.columns.push(new ListItem(RestConstants.CM_ARCHIVED_DATE));
+ */
+export declare class ListItem {
+    type: ListItemType;
+    name: string;
+    config: {
+        showLabel: boolean;
+    };
+    /**
+     * Should this item be shown by default
+     * @type {boolean}
+     */
+    visible: boolean;
+    /**
+     * Label to display, if set, should be preferred instead of automatic i18n
+     */
+    label: string;
+    /**
+     * custom format string for date fields, may be null
+     */
+    format: string;
+    constructor(type: ListItemType, name: string, config?: {
+        showLabel: boolean;
+    });
+    static getCollectionDefaults(): ListItem[];
+}
+export declare class ListItemSort extends ListItem {
+    type: ListItemType;
+    name: string;
+    mode: 'ascending' | 'descending' | null;
+    config: {
+        showLabel: boolean;
+    };
+    constructor(type: ListItemType, name: string, mode?: 'ascending' | 'descending' | null, config?: {
+        showLabel: boolean;
+    });
+}
+export declare class SortEvent extends ListItemSort {
+    ascending: boolean;
+}
+/**
+ * UI element that allows the user to choose sorting.
+ */
+export interface SortPanel {
+    active: string;
+    direction: SortDirection;
+    readonly sortChange: Observable<Sort>;
+}