@paperless/angular 0.1.0-alpha.23 → 0.1.0-alpha.230

package/lib/animations/index.d.ts

@@ -0,0 +1 @@
+export * from './slide';

package/lib/animations/slide.d.ts

@@ -0,0 +1,2 @@
+export declare const SLIDE_IN_BOTTOM_OUT_TOP: import("@angular/animations").AnimationTriggerMetadata;
+export declare const SLIDE_IN_TOP_OUT_BOTTOM: import("@angular/animations").AnimationTriggerMetadata;

package/lib/base/index.d.ts

@@ -1 +1,2 @@
+export * from './upload.component';
 export * from './value-accessor';

package/lib/base/upload.component.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare abstract class BaseUploadComponent {
+    fileId?: string;
+    uploaded: boolean;
+    set loading(value: boolean);
+    get loading(): boolean;
+    fileChange: EventEmitter<any>;
+    uploaderInput?: ElementRef;
+    file?: File;
+    private _loading;
+    onChange($event: Event): void;
+    onLoad(file: File, result: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseUploadComponent, "ng-component", never, { "fileId": "fileId"; "uploaded": "uploaded"; "loading": "loading"; }, { "fileChange": "fileChange"; }, never, never, false>;
+}

package/lib/base/value-accessor.d.ts

@@ -1,17 +1,17 @@
 import { ElementRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import * as i0 from "@angular/core";
-export declare class ValueAccessor implements ControlValueAccessor {
+export declare class BaseValueAccessor implements ControlValueAccessor {
     protected el: ElementRef;
-    private onChange;
-    private onTouched;
+    protected onChange: (value: any) => void;
+    protected onTouched: () => void;
     protected lastValue: any;
     constructor(el: ElementRef);
     writeValue(value: any): void;
     handleChangeEvent(value: any): void;
-    _handleBlurEvent(): void;
     registerOnChange(fn: (value: any) => void): void;
     registerOnTouched(fn: () => void): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ValueAccessor, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ValueAccessor, never, never, {}, {}, never>;
+    private _handleBlurEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseValueAccessor, never, never, {}, {}, never, never, false>;
 }

package/lib/directives/index.d.ts

@@ -1,3 +1,5 @@
-export * from './pagination.directive';
-import { PaginationDirective } from './pagination.directive';
-export declare const CUSTOM_DIRECTIVES: (typeof PaginationDirective)[];
+export * from './p-page-size-select.directive';
+export * from './p-pagination.directive';
+export * from './p-select.directive';
+import { SelectDirective } from './p-select.directive';
+export declare const DIRECTIVES: (typeof SelectDirective)[];

package/lib/directives/p-page-size-select.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef } from '@angular/core';
+import { BaseValueAccessor } from '../base';
+import * as i0 from "@angular/core";
+export declare class PageSizeSelectDirective extends BaseValueAccessor {
+    constructor(el: ElementRef);
+    writeValue(value: any): void;
+    registerOnChange(fn: (_: number | null) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageSizeSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageSizeSelectDirective, "p-page-size-select", never, {}, {}, never, never, false>;
+}

package/lib/directives/{pagination.directive.d.ts → p-pagination.directive.d.ts}

@@ -1,10 +1,10 @@
 import { ElementRef } from '@angular/core';
-import { ValueAccessor } from '../base';
+import { BaseValueAccessor } from '../base';
 import * as i0 from "@angular/core";
-export declare class PaginationDirective extends ValueAccessor {
+export declare class PaginationDirective extends BaseValueAccessor {
     constructor(el: ElementRef);
     writeValue(value: any): void;
     registerOnChange(fn: (_: number | null) => void): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PaginationDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationDirective, "p-pagination", never, {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationDirective, "p-pagination", never, {}, {}, never, never, false>;
 }

package/lib/directives/p-select.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef } from '@angular/core';
+import { BaseValueAccessor } from '../base';
+import * as i0 from "@angular/core";
+export declare class SelectDirective extends BaseValueAccessor {
+    constructor(el: ElementRef);
+    writeValue(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectDirective, "p-select", never, {}, {}, never, never, false>;
+}

package/lib/modules/index.d.ts

@@ -0,0 +1,4 @@
+import { TableModule } from './table';
+export * from './table';
+export * from './toast';
+export declare const MODULES: (typeof TableModule)[];

package/lib/modules/table/base/form.component.d.ts

@@ -0,0 +1,15 @@
+import { AbstractControl, FormArray, FormControl, FormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare abstract class FormBaseComponent {
+    markedDirty: boolean;
+    scrollToFirstError(): void;
+    markControlDirty(control: FormControl | FormGroup | FormArray | AbstractControl): void;
+    markAllDirty(formGroup: FormGroup): void;
+    getControlError(control: FormControl | AbstractControl | FormArray | FormGroup): string | undefined;
+    hasControlError(control: FormControl | AbstractControl | FormGroup | FormArray, showChildErrors?: boolean): string | false | undefined;
+    firstControlError(control: FormControl | AbstractControl | FormGroup | FormArray, showChildErrors?: boolean): string | undefined;
+    resetControl(control: FormControl | FormGroup | FormArray | AbstractControl): void;
+    resetForm(formGroup: FormGroup): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormBaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormBaseComponent, "ng-component", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './form.component';
+export * from './table.component';

package/lib/modules/table/base/table.component.d.ts

@@ -0,0 +1,49 @@
+import { OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { QuickFilter } from '@paperless/core';
+import { FormBaseComponent } from './form.component';
+import * as i0 from "@angular/core";
+export interface TableOptions {
+    pageSize: number;
+    page: number;
+    quickFilter: any | string;
+    query: string;
+    filters: any[];
+    selectedRows: any[];
+}
+export declare abstract class BaseTableComponent extends FormBaseComponent implements OnInit {
+    protected quickFilters: any[];
+    pageSizeDefault: number;
+    tableOptions?: FormControl<TableOptions>;
+    private _defaultTableValues;
+    defaultTableValues: Partial<TableOptions>;
+    get pageSize(): number;
+    get page(): number;
+    get quickFilter(): QuickFilter;
+    set quickFilter(quickFilter: QuickFilter);
+    get query(): string;
+    set query(query: string);
+    get filters(): any[];
+    set filters(filters: any[]);
+    get selectedRows(): any[];
+    set selectedRows(selectedRows: any[]);
+    get parsedDefaultTableValues(): {
+        pageSize: number;
+        page: number;
+        quickFilter: any;
+        query: string;
+        filters: any[];
+        selectedRows: any[];
+    };
+    get tableValues(): Partial<TableOptions>;
+    set tableValues(values: Partial<TableOptions>);
+    constructor();
+    ngOnInit(): void;
+    resetTable(emitEvent?: boolean, forceRefresh?: null): void;
+    protected _refresh(): void;
+    private _resetPageOrRefresh;
+    private _setTableValues;
+    private _getChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTableComponent, "ng-component", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/components/index.d.ts

@@ -0,0 +1,7 @@
+export * from './table-cell/table-cell.component';
+export * from './table-column/table-column.component';
+export * from './table/table.component';
+import { TableCell } from './table-cell/table-cell.component';
+import { TableColumn } from './table-column/table-column.component';
+import { Table } from './table/table.component';
+export declare const TABLE_COMPONENTS: (typeof TableCell | typeof TableColumn | typeof Table)[];

package/lib/modules/table/components/table/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultSize = 12;
+export declare const defaultSizeOptions: number[];

package/lib/modules/table/components/table/table.component.d.ts

@@ -0,0 +1,209 @@
+import { EventEmitter, OnChanges, OnInit, QueryList, SimpleChanges, TemplateRef } from '@angular/core';
+import { QuickFilter, RowClickEvent } from '@paperless/core';
+import { TableColumn } from '../table-column/table-column.component';
+import * as i0 from "@angular/core";
+export declare class Table implements OnInit, OnChanges {
+    /**
+     * The items to be fed to the table
+     */
+    items: string;
+    /**
+     * Wether data is loading
+     */
+    loading: boolean;
+    /**
+     * The amount of loading rows to show
+     */
+    amountOfLoadingRows: number;
+    /**
+     * Wether to enable selection
+     */
+    enableRowSelection: boolean;
+    /**
+     * Wether to enable row clicking
+     */
+    enableRowClick: boolean;
+    /**
+     * The current selection of items
+     */
+    selectedRows: any[];
+    /**
+     * Event whenever the current selection changes
+     */
+    selectedRowsChange: EventEmitter<any>;
+    /**
+     * The key to determine if a row is selected
+     */
+    selectionKey: string | undefined;
+    /**
+     * A key to determine if a row can be selected
+     */
+    canSelectKey: string | undefined;
+    /**
+     * Event whenever a row is clicked
+     */
+    rowClick: EventEmitter<RowClickEvent>;
+    /**
+     * Event whenever a row is selected
+     */
+    rowSelected: EventEmitter<any>;
+    /**
+     * Event whenever a row is deselected
+     */
+    rowDeselected: EventEmitter<any>;
+    /** START HEADER */
+    /**
+     * Quick filters to show
+     */
+    quickFilters: QuickFilter[];
+    /**
+     * Active quick filter identifier
+     */
+    activeQuickFilterIdentifier: string | undefined;
+    /**
+     * Wether to show the search input
+     */
+    enableSearch: boolean;
+    /**
+     * The query to show in the search bar
+     */
+    query: string | undefined;
+    /**
+     * Wether to show the filter button
+     */
+    enableFilter: boolean;
+    /**
+     * The amount of filters being selected
+     */
+    selectedFiltersAmount: number | undefined;
+    /**
+     * The template for the filter button text
+     */
+    filterButtonTemplate: any;
+    /**
+     * Wether to show the edit button
+     */
+    enableEdit: boolean;
+    /**
+     * The template for the edit button text
+     */
+    editButtonTemplate: any;
+    /**
+     * Event when one of the quick filters is clicked
+     */
+    quickFilter: EventEmitter<QuickFilter>;
+    /**
+     * Event when the query changes
+     */
+    queryChange: EventEmitter<string>;
+    /**
+     * Event when the filter button is clicked
+     */
+    filter: EventEmitter<null>;
+    /**
+     * Event when the edit button is clicked
+     */
+    edit: EventEmitter<null>;
+    /** START FOOTER */
+    /**
+     * Wether to enable page size select
+     */
+    enablePageSize: boolean;
+    /**
+     * Wether to enable pagination
+     */
+    enablePagination: boolean;
+    /**
+     * Wether to enable export
+     */
+    enableExport: boolean;
+    /**
+     * The current page
+     */
+    page: number;
+    /**
+     * The total amount of items
+     */
+    total: number;
+    /**
+     * Event whenever the page changes
+     */
+    pageChange: EventEmitter<number>;
+    /**
+     * The amount of items per page
+     */
+    pageSize: number;
+    /**
+     * The options for the page size
+     */
+    pageSizeOptions: number[];
+    /**
+     * Event whenever the page changes
+     */
+    pageSizeChange: EventEmitter<number>;
+    /**
+     * Event whenever the page changes
+     */
+    export: EventEmitter<number>;
+    /**
+     * Wether to hide when there is only 1 page available
+     */
+    hideOnSinglePage: boolean;
+    emptyStateType: 'no_filter' | 'filtered';
+    emptyStateHeader: string;
+    emptyStateContent: string;
+    emptyStateAction: string;
+    emptyStateFilteredHeader: string;
+    emptyStateFilteredContent: string;
+    /**
+     * Event whenever the empty state is clicked
+     */
+    emptyStateActionClick: EventEmitter<null>;
+    columns: any[];
+    parsedItems: any[];
+    loadingRows: unknown[];
+    private _ctrlDown;
+    private _columnDefinitions;
+    set columnDefinitions(v: QueryList<TableColumn>);
+    get columnDefinitions(): QueryList<TableColumn>;
+    filterModalTemplate: TemplateRef<any> | undefined;
+    private _filterModalShow;
+    set filterModalShow(value: boolean);
+    get filterModalShow(): boolean;
+    filterModalHeaderText: string;
+    filterModalSaveText: string;
+    filterModalCancelText: string;
+    filterModalShown: EventEmitter<boolean>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    keyDown({ key }: {
+        key: string;
+    }): void;
+    keyUp({ key }: {
+        key: string;
+    }): void;
+    visibilityChange(): void;
+    onQueryChange({ detail }: CustomEvent<string>): void;
+    onQuickFilter({ detail }: CustomEvent<any>): void;
+    onPageSizeChange({ detail }: CustomEvent<number>): void;
+    onPageChange({ detail }: CustomEvent<number>): void;
+    filterModalSave(): void;
+    private _parseItems;
+    private _generateColumns;
+    _checkboxDisabled(item: any): boolean | "" | undefined;
+    _selectAllChange($event: any): void;
+    _checkboxChange(target: any, index: number): void;
+    private _getCheckedValue;
+    private _getSelectionValue;
+    _selectionContains(row: any, index: number, returnIndex?: boolean): any;
+    _selectionContainsAll(): boolean;
+    _selectionIndeterminate(): boolean;
+    _rowClick($event: {
+        target: any;
+    }, index: number): void;
+    private _findRow;
+    private _findRowAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Table, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Table, "p-table-ngx", never, { "items": "items"; "loading": "loading"; "amountOfLoadingRows": "amountOfLoadingRows"; "enableRowSelection": "enableRowSelection"; "enableRowClick": "enableRowClick"; "selectedRows": "selectedRows"; "selectionKey": "selectionKey"; "canSelectKey": "canSelectKey"; "quickFilters": "quickFilters"; "activeQuickFilterIdentifier": "activeQuickFilterIdentifier"; "enableSearch": "enableSearch"; "query": "query"; "enableFilter": "enableFilter"; "selectedFiltersAmount": "selectedFiltersAmount"; "filterButtonTemplate": "filterButtonTemplate"; "enableEdit": "enableEdit"; "editButtonTemplate": "editButtonTemplate"; "enablePageSize": "enablePageSize"; "enablePagination": "enablePagination"; "enableExport": "enableExport"; "page": "page"; "total": "total"; "pageSize": "pageSize"; "pageSizeOptions": "pageSizeOptions"; "hideOnSinglePage": "hideOnSinglePage"; "emptyStateType": "emptyStateType"; "emptyStateHeader": "emptyStateHeader"; "emptyStateContent": "emptyStateContent"; "emptyStateAction": "emptyStateAction"; "emptyStateFilteredHeader": "emptyStateFilteredHeader"; "emptyStateFilteredContent": "emptyStateFilteredContent"; "filterModalHeaderText": "filterModalHeaderText"; "filterModalSaveText": "filterModalSaveText"; "filterModalCancelText": "filterModalCancelText"; }, { "selectedRowsChange": "selectedRowsChange"; "rowClick": "rowClick"; "rowSelected": "rowSelected"; "rowDeselected": "rowDeselected"; "quickFilter": "quickFilter"; "queryChange": "queryChange"; "filter": "filter"; "edit": "edit"; "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; "export": "export"; "emptyStateActionClick": "emptyStateActionClick"; "filterModalShown": "filterModalShown"; }, ["filterModalTemplate", "columnDefinitions"], never, false>;
+}

package/lib/modules/table/components/table-cell/table-cell.component.d.ts

@@ -0,0 +1,45 @@
+import { TemplateRef } from '@angular/core';
+import { TableDefinitionData } from '@paperless/core';
+import * as i0 from "@angular/core";
+export declare class TableCell {
+    /**
+     * The variant of the column
+     */
+    variant: 'default' | 'loading' | 'header';
+    /**
+     * The index of the column
+     */
+    index: number;
+    /**
+     * The index of the row
+     */
+    rowIndex: number;
+    /**
+     * The definition of the table column
+     */
+    definition?: any;
+    /**
+     * The item in question
+     */
+    item: any;
+    /**
+     * The value of the column
+     */
+    value: any;
+    /**
+     * The checkbox templateRef
+     */
+    checkbox: TemplateRef<any> | undefined;
+    /**
+     * The template ref for the content
+     */
+    template: TemplateRef<any> | undefined;
+    get class(): any;
+    get data(): TableDefinitionData | {
+        value: string;
+    };
+    getColumnClasses(): any;
+    private _getSizes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCell, "p-table-cell-ngx", never, { "variant": "variant"; "index": "index"; "rowIndex": "rowIndex"; "definition": "definition"; "item": "item"; "value": "value"; "checkbox": "checkbox"; "template": "template"; }, {}, never, never, false>;
+}

package/lib/modules/table/components/table-column/table-column.component.d.ts

@@ -0,0 +1,17 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, TemplateRef } from '@angular/core';
+import { Components } from '@paperless/core';
+import * as i0 from "@angular/core";
+export declare interface PTableColumn extends Components.PTableColumn {
+    /**
+     * Event to let the table know it has to re render
+     */
+    tableDefinitionChanged: EventEmitter<CustomEvent<boolean>>;
+}
+export declare class TableColumn {
+    protected z: NgZone;
+    protected el: HTMLElement;
+    template: TemplateRef<any> | undefined;
+    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumn, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumn, "p-table-column", never, { "align": "align"; "name": "name"; "path": "path"; "sizes": "sizes"; "type": "type"; "useSlot": "useSlot"; }, {}, ["template"], ["*"], false>;
+}

package/lib/modules/table/directives/index.d.ts

@@ -0,0 +1,11 @@
+export * from './p-table-filter-modal.directive';
+export * from './p-table-footer.directive';
+export * from './p-table-header.directive';
+export * from './p-table-ngx.directive';
+export * from './p-table.directive';
+import { TableFilterModalDirective } from './p-table-filter-modal.directive';
+import { TableFooterDirective } from './p-table-footer.directive';
+import { TableHeaderDirective } from './p-table-header.directive';
+import { TableNgxDirective } from './p-table-ngx.directive';
+import { TableDirective } from './p-table.directive';
+export declare const TABLE_DIRECTIVES: (typeof TableFilterModalDirective | typeof TableFooterDirective | typeof TableHeaderDirective | typeof TableNgxDirective | typeof TableDirective)[];

package/lib/modules/table/directives/p-table-filter-modal.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TableFilterModalDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFilterModalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFilterModalDirective, "p-table-filter-modal", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/directives/p-table-footer.directive.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import { BaseValueAccessor } from '../../../base';
+import * as i0 from "@angular/core";
+export declare class TableFooterDirective extends BaseValueAccessor {
+    protected lastValue: any;
+    constructor(el: ElementRef);
+    writeValue(value: any): void;
+    handleChange(value: number, type: 'page' | 'pageSize'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableFooterDirective, "p-table-footer", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/directives/p-table-header.directive.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef } from '@angular/core';
+import { QuickFilter } from '@paperless/core';
+import { BaseValueAccessor } from '../../../base';
+import * as i0 from "@angular/core";
+export interface TableHeaderDirectiveValue {
+    query?: string;
+    quickFilter?: QuickFilter;
+}
+export declare class TableHeaderDirective extends BaseValueAccessor {
+    protected lastValue: TableHeaderDirectiveValue;
+    constructor(el: ElementRef);
+    writeValue(value: TableHeaderDirectiveValue): void;
+    handleChange(value: string | QuickFilter, type: 'query' | 'quickFilter'): void;
+    private _setActiveQuickFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeaderDirective, "p-table-header", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/directives/p-table-ngx.directive.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef } from '@angular/core';
+import { QuickFilter } from '@paperless/core';
+import { BaseValueAccessor } from '../../../base';
+import { Table } from '../components/table/table.component';
+import * as i0 from "@angular/core";
+export interface TableDirectiveValue {
+    query?: string;
+    quickFilter?: QuickFilter;
+    filters?: any[];
+    page?: number;
+    pageSize?: number;
+    selectedRows?: any[];
+}
+export declare class TableNgxDirective extends BaseValueAccessor {
+    private _base;
+    protected lastValue: TableDirectiveValue;
+    constructor(el: ElementRef, _base: Table);
+    writeValue(value: TableDirectiveValue): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    handleChange(value: number | string | QuickFilter, type: 'page' | 'pageSize' | 'query' | 'quickFilter' | 'selectedRows'): void;
+    private _setActiveQuickFilter;
+    private _checkEmptyStateType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableNgxDirective, [null, { host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableNgxDirective, "p-table-ngx", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/directives/p-table.directive.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import { QuickFilter } from '@paperless/core';
+import { BaseValueAccessor } from '../../../base';
+import * as i0 from "@angular/core";
+export interface NGXTableDirectiveValue {
+    query?: string;
+    quickFilter?: QuickFilter;
+    page?: number;
+    pageSize?: number;
+    selectedRows?: any[];
+}
+export declare class TableDirective extends BaseValueAccessor {
+    protected lastValue: NGXTableDirectiveValue;
+    constructor(el: ElementRef);
+    writeValue(value: NGXTableDirectiveValue): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    handleChange(value: number | string | QuickFilter, type: 'page' | 'pageSize' | 'query' | 'quickFilter' | 'selectedRows'): void;
+    private _setActiveQuickFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDirective, "p-table", never, {}, {}, never, never, false>;
+}

package/lib/modules/table/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './components';
+export * from './directives';
+export * from './table.module';

package/lib/modules/table/table.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/table/table.component";
+import * as i2 from "./components/table-cell/table-cell.component";
+import * as i3 from "./components/table-column/table-column.component";
+import * as i4 from "./directives/p-table-footer.directive";
+import * as i5 from "./directives/p-table-header.directive";
+import * as i6 from "./directives/p-table.directive";
+import * as i7 from "./directives/p-table-ngx.directive";
+import * as i8 from "./directives/p-table-filter-modal.directive";
+import * as i9 from "@angular/common";
+import * as i10 from "../../stencil.module";
+export declare class TableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof i1.Table, typeof i2.TableCell, typeof i3.TableColumn, typeof i4.TableFooterDirective, typeof i5.TableHeaderDirective, typeof i6.TableDirective, typeof i7.TableNgxDirective, typeof i8.TableFilterModalDirective], [typeof i9.CommonModule, typeof i10.StencilModule], [typeof i1.Table, typeof i2.TableCell, typeof i3.TableColumn, typeof i4.TableFooterDirective, typeof i5.TableHeaderDirective, typeof i6.TableDirective, typeof i7.TableNgxDirective, typeof i8.TableFilterModalDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}

package/lib/modules/toast/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from './toast-container/toast-container.component';
+import { ToastContainer } from './toast-container/toast-container.component';
+export declare const TOAST_COMPONENTS: (typeof ToastContainer)[];

package/lib/modules/toast/components/toast-container/toast-container.component.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, NgZone } from '@angular/core';
+import { Components } from '@paperless/core';
+import { ToastService } from '../../services/toast.service';
+import * as i0 from "@angular/core";
+export declare interface PToastContainer extends Components.PToastContainer {
+    placement: 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+}
+export declare class ToastContainer {
+    protected z: NgZone;
+    private _toastService;
+    toasts$: import("rxjs").Observable<import("@paperless/angular").ToastData[]>;
+    protected el: HTMLElement;
+    constructor(r: ElementRef, z: NgZone, _toastService: ToastService);
+    dismiss(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastContainer, "p-toast-container", never, { "placement": "placement"; }, {}, never, never, false>;
+}

package/lib/modules/toast/directives/index.d.ts

@@ -0,0 +1,3 @@
+export * from './toast.directive';
+import { ToastDirective } from './toast.directive';
+export declare const TOAST_DIRECTIVES: (typeof ToastDirective)[];

package/lib/modules/toast/directives/toast.directive.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@angular/core';
+import { ToastActionFunction } from '../types';
+import * as i0 from "@angular/core";
+export declare class ToastDirective {
+    delay: number | 'infinite';
+    index: number;
+    dismissOnAction: boolean;
+    actionFunc?: ToastActionFunction;
+    actionData: any;
+    dismiss: EventEmitter<number>;
+    ngOnInit(): void;
+    onAction(): void;
+    doDismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToastDirective, "p-toast", never, { "delay": "delay"; "index": "index"; "dismissOnAction": "dismissOnAction"; "actionFunc": "actionFunc"; "actionData": "actionData"; }, { "dismiss": "dismiss"; }, never, never, false>;
+}

package/lib/modules/toast/index.d.ts

@@ -0,0 +1,5 @@
+export * from './components';
+export * from './directives';
+export * from './services';
+export * from './toast.module';
+export * from './types';