@netgrif/components-core 6.0.1

package/lib/authorization/group/group-guard.service.d.ts

@@ -0,0 +1,19 @@
+import { ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { UserService } from '../../user/services/user.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { View } from '../../../commons/schema';
+import { NextGroupService } from '../../groups/services/next-group.service';
+export declare class GroupGuardService implements CanActivate {
+    protected _redirectService: RedirectService;
+    protected _userService: UserService;
+    protected _nextGroupService: NextGroupService;
+    protected _configService: ConfigurationService;
+    protected _log: LoggerService;
+    private readonly _loginUrl;
+    constructor(_redirectService: RedirectService, _userService: UserService, _nextGroupService: NextGroupService, _configService: ConfigurationService, _log: LoggerService);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    canAccessView(view: View, url: string): boolean;
+}

package/lib/authorization/permission/permission.service.d.ts

@@ -0,0 +1,22 @@
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { Task } from '../../resources/interface/task';
+import { UserService } from '../../user/services/user.service';
+import { Case } from '../../resources/interface/case';
+import { PetriNetReferenceWithPermissions } from '../../process/petri-net-reference-with-permissions';
+import { Permissions, UserPermissions } from '../../process/permissions';
+export declare class PermissionService {
+    protected userComparator: UserComparatorService;
+    protected _userService: UserService;
+    constructor(userComparator: UserComparatorService, _userService: UserService);
+    hasTaskPermission(task: Task | undefined, permission: string): boolean;
+    hasCasePermission(case_: Case | undefined, permission: string): boolean;
+    resolvePermissions(rolePermValue: boolean | undefined, userPermValue: boolean | undefined): boolean;
+    hasNetPermission(action: string, net: PetriNetReferenceWithPermissions): boolean;
+    canAssign(task: Task | undefined): boolean;
+    canCancel(task: Task | undefined): boolean;
+    canReassign(task: Task | undefined): boolean;
+    canFinish(task: Task | undefined): boolean;
+    canCollapse(task: Task | undefined): boolean;
+    checkRolePerms(roles: Permissions, permission: string): boolean | undefined;
+    checkUserPerms(users: UserPermissions, permission: any): boolean | undefined;
+}

package/lib/authorization/public-api.d.ts

@@ -0,0 +1,4 @@
+export * from './authority/authority-guard.service';
+export * from './role/role-guard.service';
+export * from './group/group-guard.service';
+export * from './permission/permission.service';

package/lib/authorization/role/role-guard.service.d.ts

@@ -0,0 +1,29 @@
+import { ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { UserService } from '../../user/services/user.service';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { Access, RoleAccess, View } from '../../../commons/schema';
+import { LoggerService } from '../../logger/services/logger.service';
+import { Observable } from 'rxjs';
+interface RoleConstraint {
+    processIdentifier: string;
+    roleIdentifier?: string;
+    roleName?: string;
+}
+export declare class RoleGuardService implements CanActivate {
+    protected _redirectService: RedirectService;
+    protected _userService: UserService;
+    protected _configService: ConfigurationService;
+    protected _log: LoggerService;
+    private readonly _loginUrl;
+    constructor(_redirectService: RedirectService, _userService: UserService, _configService: ConfigurationService, _log: LoggerService);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    canAccessView(view: View, url: string): boolean;
+    protected parseRoleConstraints(roleConstrains: Access['role'], viewUrl: string): Array<RoleConstraint>;
+    /**
+     * @deprecated in 5.0.0
+     */
+    protected parseStringRoleConstraints(roleConstrains: string | Array<string>): Array<RoleConstraint>;
+    protected parseObjectRoleConstrains(roleConstrains: RoleAccess | Array<RoleAccess>): Array<RoleConstraint>;
+}
+export {};

package/lib/changed-fields/public-api.d.ts

@@ -0,0 +1 @@
+export * from './services/changed-fields.service';

package/lib/changed-fields/services/changed-fields.service.d.ts

@@ -0,0 +1,12 @@
+import { OnDestroy } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { ChangedFields } from '../../data-fields/models/changed-fields';
+import { ChangedFieldsMap } from '../../event/services/interfaces/changed-fields-map';
+export declare class ChangedFieldsService implements OnDestroy {
+    protected _changedFields$: Subject<ChangedFieldsMap>;
+    ngOnDestroy(): void;
+    constructor();
+    get changedFields$(): Observable<ChangedFieldsMap>;
+    emitChangedFields(changedFields: ChangedFieldsMap): void;
+    parseChangedFieldsByCaseAndTaskIds(caseId: string, taskIds: Array<string>, changedFieldsMap: ChangedFieldsMap): Array<ChangedFields>;
+}

package/lib/configuration/configuration.service.d.ts

@@ -0,0 +1,69 @@
+import { NetgrifApplicationEngine, Services, View } from '../../commons/schema';
+import { Observable } from 'rxjs';
+export declare abstract class ConfigurationService {
+    protected configuration: NetgrifApplicationEngine;
+    private readonly _dataFieldConfiguration;
+    protected constructor(configuration: NetgrifApplicationEngine);
+    getAsync(): Observable<NetgrifApplicationEngine>;
+    /**
+     * @returns a deep copy of the entire configuration object
+     */
+    get(): NetgrifApplicationEngine;
+    /**
+     * Get view configuration from nae.json for view at given config path.
+     * @param viewConfigPath configuration path to the requested view. No leading backslash.
+     * @return requested configuration if it exists. `undefined` otherwise.
+     */
+    getViewByPath(viewConfigPath: string): View | undefined;
+    /**
+     * Get view configuration from nae.json for view at given url.
+     * @param url to the requested view. Necessary backslash.
+     * @return requested configuration if it exists. `undefined` otherwise.
+     */
+    getViewByUrl(url: string): View | undefined;
+    private getChildren;
+    /**
+     * Get all URLs/paths of views with specified layout.
+     * @param layout Search views with this layout
+     * @returns Paths with prefixed '/' of all views with specified layout, empty array otherwise.
+     */
+    getPathsByView(layout: string): Array<string>;
+    /**
+     * @param pathSegments the keys specifying the path trough the configuration that should be accessed
+     * @returns a deep copy of a specified subsection of the configuration object, or `undefined` if such subsection doesn't exist.
+     * Calling this method with an empty array as argument is equivalent to calling the [get()]{@link ConfigurationService#get} method.
+     */
+    getConfigurationSubtree(pathSegments: Array<string>): any | undefined;
+    /**
+     * @returns the appropriate template configuration for data fields, or `undefined` if such configuration is not present.
+     */
+    getDatafieldConfiguration(): Services['dataFields'] | undefined;
+    /**
+     * Resolves the URL addresses of backend endpoints based on the provided configuration.
+     *
+     * If the URLs begin with either `http://`, or `https://` the provided URL will be used.
+     *
+     * If not, then the URLs are considered to be relative to the location of the frontend application and it's URL will be used
+     * as the base path. `/api` is appended automatically.
+     */
+    protected resolveEndpointURLs(): void;
+    /**
+     * Resolves a single URL address.
+     *
+     * If the URL begins with either `http://`, or `https://` the provided URL will be used.
+     *
+     * If not, then the URL is considered to be relative to the location of the frontend application and it's URL will be used
+     * as the base path. `/api` is appended automatically.
+     *
+     * @param configURL value from the configuration file
+     * @returns the resolved URL
+     */
+    protected resolveURL(configURL: string): string;
+    /**
+     * @returns the services configuration, or `undefined` if such configuration is not present.
+     */
+    getServicesConfiguration(): Services | undefined;
+    private getView;
+    private createConfigurationCopy;
+    private deepCopy;
+}

package/lib/configuration/public-api.d.ts

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

package/lib/covalent/covalent.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CovalentModule {
+}

package/lib/currency/currency.module.d.ts

@@ -0,0 +1,3 @@
+export declare class CurrencyModule {
+    constructor();
+}

package/lib/dashboard/cards/count-card/abstract-count-card.d.ts

@@ -0,0 +1,19 @@
+import { Injector, OnDestroy, OnInit } from '@angular/core';
+import { CountCard } from '../model/count-card';
+import { CountService } from '../../../resources/abstract-endpoint/count-service';
+import { Filter } from '../../../filter/models/filter';
+import { Subscription } from 'rxjs';
+export declare abstract class AbstractCountCard implements OnInit, OnDestroy {
+    protected _injector: Injector;
+    card: CountCard;
+    protected _countService: CountService;
+    protected _filter: Filter;
+    loading: boolean;
+    count: number;
+    protected subCount: Subscription;
+    constructor(_injector: Injector);
+    ngOnInit(): void;
+    private resolveResourceService;
+    private resolveFilter;
+    ngOnDestroy(): void;
+}

package/lib/dashboard/cards/custom-card/abstract-custom-card.d.ts

@@ -0,0 +1,39 @@
+import { Injector, OnDestroy, OnInit } from '@angular/core';
+import { Filter } from '../../../filter/models/filter';
+import { CustomCard } from '../model/custom-dashboard-model/custom-card';
+import { DashboardResourceService } from '../../../resources/engine-endpoint/dashboard-resource.service';
+import { TranslateService } from '@ngx-translate/core';
+import { LoadingEmitter } from '../../../utility/loading-emitter';
+import { DashboardSingleData } from '../model/custom-dashboard-model/dashboard-single-data';
+import { DashboardMultiData } from '../model/custom-dashboard-model/dashboard-multi-data';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { AggregationResult } from '../model/custom-dashboard-model/aggregation-result';
+export declare abstract class AbstractCustomCard implements OnInit, OnDestroy {
+    protected _injector: Injector;
+    protected resourceService: DashboardResourceService;
+    protected translateService: TranslateService;
+    protected loggerService: LoggerService;
+    card: CustomCard;
+    protected _filter: Filter;
+    loading: LoadingEmitter;
+    count: number;
+    value: number;
+    single: Array<DashboardSingleData>;
+    multi: Array<DashboardMultiData>;
+    showLegend: boolean;
+    showLabels: boolean;
+    animations: boolean;
+    xAxis: boolean;
+    yAxis: boolean;
+    showYAxisLabel: boolean;
+    showXAxisLabel: boolean;
+    gradient: boolean;
+    colorScheme: {
+        domain: string[];
+    };
+    protected constructor(_injector: Injector, resourceService: DashboardResourceService, translateService: TranslateService, loggerService: LoggerService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getResourceTypeAsString(): string;
+    abstract convertData(json: AggregationResult): void;
+}

package/lib/dashboard/cards/iframe-card/abstract-iframe-card.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import { IframeCard } from '../model/iframe-card';
+export declare abstract class AbstractIframeCard implements OnInit {
+    protected _sanitizer: DomSanitizer;
+    card: IframeCard;
+    sanitizedURL: SafeResourceUrl;
+    constructor(_sanitizer: DomSanitizer);
+    ngOnInit(): void;
+}

package/lib/dashboard/cards/model/card-grid-element.d.ts

@@ -0,0 +1,4 @@
+import { GridElementWithItem } from '../../../utility/grid-layout/model/grid-element-with-item';
+import { DashboardCard } from './dashboard-card';
+export interface CardGridElement extends GridElementWithItem<DashboardCard> {
+}

package/lib/dashboard/cards/model/count-card.d.ts

@@ -0,0 +1,11 @@
+import { DashboardCard } from './dashboard-card';
+import { DashboardCardTypes } from './dashboard-card-types';
+import { CaseSearchRequestBody } from '../../../filter/models/case-search-request-body';
+import { TaskSearchRequestBody } from '../../../filter/models/task-search-request-body';
+import { FilterType } from '../../../filter/models/filter-type';
+export interface CountCard extends DashboardCard {
+    type: DashboardCardTypes.COUNT;
+    title: string;
+    resourceType: FilterType;
+    filter: CaseSearchRequestBody | TaskSearchRequestBody;
+}

package/lib/dashboard/cards/model/custom-dashboard-model/aggregation-query.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents aggregation query for elasticsearch aggregations
+ * See the documentation: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html
+ */
+export interface AggregationQuery {
+    aggs: {
+        [k: string]: any;
+    };
+}

package/lib/dashboard/cards/model/custom-dashboard-model/aggregation-result.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Represents aggregation query for elasticsearch aggregations
+ * See the documentation: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html
+ */
+export interface AggregationResult {
+    aggregations: {
+        result?: {
+            buckets?: Array<BucketContent>;
+        };
+        types_count?: {
+            value: number;
+        };
+    };
+}
+export interface BucketContent {
+    key?: string;
+    doc_count?: number;
+}

package/lib/dashboard/cards/model/custom-dashboard-model/custom-card.d.ts

@@ -0,0 +1,14 @@
+import { DashboardCard } from '../dashboard-card';
+import { CaseSearchRequestBody } from '../../../../filter/models/case-search-request-body';
+import { TaskSearchRequestBody } from '../../../../filter/models/task-search-request-body';
+import { FilterType } from '../../../../filter/models/filter-type';
+import { AggregationQuery } from './aggregation-query';
+export interface CustomCard extends DashboardCard {
+    title: string;
+    query: AggregationQuery;
+    units: string;
+    xAxisLabel: string;
+    yAxisLabel: string;
+    resourceType: FilterType;
+    filter: CaseSearchRequestBody | TaskSearchRequestBody;
+}

package/lib/dashboard/cards/model/custom-dashboard-model/dashboard-event-content.d.ts

@@ -0,0 +1,5 @@
+export interface DashboardEventContent {
+    name: string;
+    label: string;
+    value: number | string;
+}

package/lib/dashboard/cards/model/custom-dashboard-model/dashboard-multi-data.d.ts

@@ -0,0 +1,6 @@
+import { DashboardSingleData } from './dashboard-single-data';
+export declare class DashboardMultiData {
+    name: string;
+    series: Array<DashboardSingleData>;
+    constructor(name: string, series: Array<DashboardSingleData>);
+}

package/lib/dashboard/cards/model/custom-dashboard-model/dashboard-single-data.d.ts

@@ -0,0 +1,5 @@
+export declare class DashboardSingleData {
+    name: string;
+    value: number;
+    constructor(name: string, value: number);
+}

package/lib/dashboard/cards/model/dashboard-card-types.d.ts

@@ -0,0 +1,11 @@
+export declare enum DashboardCardTypes {
+    BLANK = "blank",
+    COUNT = "count",
+    GRAPH = "graph",
+    IFRAME = "iframe",
+    PIE = "pie",
+    LINE = "line",
+    LINEARGAUGE = "lineargauge",
+    BAR = "bar",
+    DEFAULT = "default"
+}

package/lib/dashboard/cards/model/dashboard-card.d.ts

@@ -0,0 +1,7 @@
+import { DashboardCardTypes } from './dashboard-card-types';
+import { GridElement } from '../../../utility/grid-layout/model/grid-element';
+import { ComponentPortal } from '@angular/cdk/portal';
+export interface DashboardCard extends GridElement {
+    type: DashboardCardTypes;
+    portalComponent: ComponentPortal<any>;
+}

package/lib/dashboard/cards/model/graph-card.d.ts

@@ -0,0 +1,5 @@
+import { DashboardCard } from './dashboard-card';
+import { DashboardCardTypes } from './dashboard-card-types';
+export interface GraphCard extends DashboardCard {
+    type: DashboardCardTypes.GRAPH;
+}

package/lib/dashboard/cards/model/iframe-card.d.ts

@@ -0,0 +1,6 @@
+import { DashboardCard } from './dashboard-card';
+import { DashboardCardTypes } from './dashboard-card-types';
+export interface IframeCard extends DashboardCard {
+    type: DashboardCardTypes.IFRAME;
+    url: string;
+}

package/lib/dashboard/dashboard-content/abstract-dashboard-content.d.ts

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { DashboardParams } from './dashboard-params';
+import { DashboardCardTypes } from '../cards/model/dashboard-card-types';
+import { CardGridElement } from '../cards/model/card-grid-element';
+import { LoggerService } from '../../logger/services/logger.service';
+import { ComponentPortal } from '@angular/cdk/portal';
+export declare abstract class AbstractDashboardContent implements OnInit {
+    protected _log: LoggerService;
+    params: DashboardParams;
+    portalComponent: ComponentPortal<any>;
+    readonly cardTypes: typeof DashboardCardTypes;
+    gridElements: Array<CardGridElement>;
+    protected constructor(_log: LoggerService);
+    ngOnInit(): void;
+}

package/lib/dashboard/dashboard-content/dashboard-params.d.ts

@@ -0,0 +1,8 @@
+import { CountCard } from '../cards/model/count-card';
+import { GraphCard } from '../cards/model/graph-card';
+import { IframeCard } from '../cards/model/iframe-card';
+import { CustomCard } from '../cards/model/custom-dashboard-model/custom-card';
+export interface DashboardParams {
+    columns: number;
+    cards: Array<CountCard | GraphCard | IframeCard | CustomCard>;
+}

package/lib/dashboard/public-api.d.ts

@@ -0,0 +1,16 @@
+export * from './dashboard-content/dashboard-params';
+export * from './cards/model/custom-dashboard-model/aggregation-query';
+export * from './cards/model/custom-dashboard-model/aggregation-result';
+export * from './cards/model/dashboard-card';
+export * from './cards/model/count-card';
+export * from './cards/model/graph-card';
+export * from './cards/model/iframe-card';
+export * from './cards/model/custom-dashboard-model/custom-card';
+export * from './cards/model/custom-dashboard-model/dashboard-multi-data';
+export * from './cards/model/custom-dashboard-model/dashboard-single-data';
+export * from './cards/model/custom-dashboard-model/dashboard-event-content';
+export * from './cards/model/dashboard-card-types';
+export * from './cards/count-card/abstract-count-card';
+export * from './cards/iframe-card/abstract-iframe-card';
+export * from './cards/custom-card/abstract-custom-card';
+export * from './dashboard-content/abstract-dashboard-content';

package/lib/data-fields/boolean-field/abstract-boolean-field.component.d.ts

@@ -0,0 +1,11 @@
+import { BooleanField } from './models/boolean-field';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+import { TranslateService } from '@ngx-translate/core';
+export declare abstract class AbstractBooleanFieldComponent extends AbstractDataFieldComponent {
+    protected _translate: TranslateService;
+    dataField: BooleanField;
+    protected constructor(_translate: TranslateService, informAboutInvalidData: boolean | null);
+    getErrorMessage(): any;
+    createValueLabel(): string;
+    private resolveErrorMessage;
+}

package/lib/data-fields/boolean-field/models/boolean-field.d.ts

@@ -0,0 +1,15 @@
+import { Behavior } from '../../models/behavior';
+import { ValidatorFn } from '@angular/forms';
+import { Layout } from '../../models/layout';
+import { Validation } from '../../models/validation';
+import { Component } from '../../models/component';
+import { DataField } from '../../models/abstract-data-field';
+export declare enum BooleanFieldValidation {
+    REQUIRED_TRUE = "requiredTrue",
+    REQUIRED = "required"
+}
+export declare class BooleanField extends DataField<boolean> {
+    constructor(stringId: string, title: string, value: boolean, behavior: Behavior, placeholder?: string, description?: string, layout?: Layout, validations?: Array<Validation>, component?: Component, parentTaskId?: string);
+    protected resolveValidations(): Array<ValidatorFn>;
+    private requiredTrue;
+}

package/lib/data-fields/button-field/abstract-button-field.component.d.ts

@@ -0,0 +1,25 @@
+import { ButtonField } from './models/button-field';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+import { TranslateService } from '@ngx-translate/core';
+import { DialogService } from '../../dialog/services/dialog.service';
+export declare abstract class AbstractButtonFieldComponent extends AbstractDataFieldComponent {
+    protected _translate: TranslateService;
+    protected _dialogService: DialogService;
+    dataField: ButtonField;
+    protected constructor(_translate: TranslateService, _dialogService: DialogService, informAboutInvalidData: boolean | null);
+    getErrorMessage(): any;
+    /**
+     * This function resolve type of component for HTML
+     * @returns type of component in string
+     */
+    resolveComponentType(): string;
+    /**
+     * Function checks if button is icon type
+     * @returns true if component type is 'fab', 'minifab' or 'icon'
+     */
+    isIconTypeButton(): boolean;
+    /**
+     * This function depends on type of component, if had dialogText provided in component, then its open a dialog with that text
+     */
+    resolveValue(): void;
+}

package/lib/data-fields/button-field/models/button-field.d.ts

@@ -0,0 +1,22 @@
+import { DataField } from '../../models/abstract-data-field';
+import { Behavior } from '../../models/behavior';
+import { Layout } from '../../models/layout';
+import { Component } from '../../models/component';
+import { Validation } from '../../models/validation';
+export declare enum ButtonFieldView {
+    STANDARD = "standard",
+    RAISED = "raised",
+    STROKED = "stroked",
+    FLAT = "flat",
+    ICON = "icon",
+    FAB = "fab",
+    MINIFAB = "minifab"
+}
+export declare enum ButtonFieldValidation {
+    REQUIRED = "required"
+}
+export declare class ButtonField extends DataField<number> {
+    private _view;
+    constructor(stringId: string, title: string, behavior: Behavior, value?: number, placeholder?: string, description?: string, layout?: Layout, _view?: ButtonFieldView, validations?: Array<Validation>, component?: Component, parentTaskId?: string);
+    get view(): ButtonFieldView;
+}

package/lib/data-fields/data-field-template/abstract-data-field-template.component.d.ts

@@ -0,0 +1,65 @@
+import { ElementRef, OnInit, TemplateRef } from '@angular/core';
+import { WrappedBoolean } from './models/wrapped-boolean';
+import { DataField } from '../models/abstract-data-field';
+import { PaperViewService } from '../../navigation/quick-panel/components/paper-view.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+/**
+ * Provides a responsive layout to data fields where their appearance can change based on the width of space they have available.
+ *
+ * If the width of the available space is less than the `layoutChangeWidthBreakpoint` then the provided `dataFieldTemplate` is displayed at
+ * 100% width. If the width is greater or equal to the breakpoint the datafield template occupies the right half and the left half contains
+ * it's title.
+ *
+ * If the datafield's layout is set to `TemplateAppearance.MATERIAL` the field always occupies 100% of the available space
+ * regardless of it's width.
+ *
+ * See {@link DataField} and {@link TemplateAppearance} for more information.
+ */
+export declare abstract class AbstractDataFieldTemplateComponent implements OnInit {
+    protected _paperView: PaperViewService;
+    protected _config: ConfigurationService;
+    /**
+     * Content of the datafield that should be displayed in the template
+     */
+    dataFieldTemplate: TemplateRef<any>;
+    /**
+     * If the available space has a width smaller that this breakpoint the datafield will fill 100% of the available space.
+     *
+     * The breakpoint is only taken into consideration if `TemplateAppearance.NETGRIF` is set on the data field.
+     *
+     * See [DataField.layout]{@link DataField#layout} for more information.
+     */
+    layoutChangeWidthBreakpoint: number;
+    /**
+     * Field offset defined by task
+     */
+    offset: number;
+    container: ElementRef;
+    protected _dataField: DataField<any>;
+    protected _isConfiguredNetgrifTemplate: boolean;
+    protected _isNetgrifTemplate: boolean;
+    /**
+     * @ignore
+     * The value determines whether the layout should be "small" or not. Data field fills 100% of the width in "small" layout.
+     */
+    protected _showLargeLayout: WrappedBoolean;
+    protected constructor(_paperView: PaperViewService, _config: ConfigurationService);
+    ngOnInit(): void;
+    get showLargeLayout(): WrappedBoolean;
+    /**
+     * Datafield model object that should be displayed in the template
+     */
+    set dataField(dataField: DataField<any>);
+    get dataField(): DataField<any>;
+    /**
+     * Function that is called when the Component changes dimension and
+     * determines whether the "small" or "large" layout should be displayed.
+     * @param event - event containing the new width of this Component
+     */
+    evaluateTemplateCondition(): boolean;
+    /**
+     * @returns `false` if the data field uses the `TemplateAppearance.MATERIAL` and `true` otherwise.
+     */
+    protected evaluateTemplate(): boolean;
+    isPaperView(): boolean;
+}

package/lib/data-fields/data-field-template/models/wrapped-boolean.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This class wraps a `boolean` variable into an object, so it can be passed by reference rather than by value to other objects.
+ */
+export declare class WrappedBoolean {
+    value: boolean;
+}

package/lib/data-fields/data-fields.module.d.ts

@@ -0,0 +1,2 @@
+export declare class DataFieldsModule {
+}

package/lib/data-fields/date-field/abstract-date-field.component.d.ts

@@ -0,0 +1,9 @@
+import { DateField } from './models/date-field';
+import { AbstractTimeInstanceFieldComponent } from '../time-instance-abstract-field/abstract-time-instance-field.component';
+import { TranslateService } from '@ngx-translate/core';
+export declare abstract class AbstractDateFieldComponent extends AbstractTimeInstanceFieldComponent {
+    protected _translate: TranslateService;
+    dataField: DateField;
+    protected constructor(_translate: TranslateService, informAboutInvalidData: boolean | null);
+    getErrorMessage(): any;
+}

package/lib/data-fields/date-field/models/custom-date-adapter.d.ts

@@ -0,0 +1,4 @@
+import { MomentDateAdapter } from '@angular/material-moment-adapter';
+export declare class CustomDateAdapter extends MomentDateAdapter {
+    getFirstDayOfWeek(): number;
+}

package/lib/data-fields/date-field/models/date-field.d.ts

@@ -0,0 +1,10 @@
+import { Behavior } from '../../models/behavior';
+import { Moment } from 'moment';
+import { AbstractTimeInstanceField } from '../../time-instance-abstract-field/models/abstract-time-instance-field';
+import { Layout } from '../../models/layout';
+import { Validation } from '../../models/validation';
+import { Component } from '../../models/component';
+export declare class DateField extends AbstractTimeInstanceField {
+    constructor(stringId: string, title: string, value: Moment, behavior: Behavior, placeholder?: string, description?: string, layout?: Layout, validations?: Array<Validation>, component?: Component, parentTaskId?: string);
+    protected valueEquality(a: Moment, b: Moment): boolean;
+}

package/lib/data-fields/date-time-field/abstract-date-time-field.component.d.ts

@@ -0,0 +1,9 @@
+import { DateTimeField } from './models/date-time-field';
+import { AbstractTimeInstanceFieldComponent } from '../time-instance-abstract-field/abstract-time-instance-field.component';
+import { TranslateService } from '@ngx-translate/core';
+export declare abstract class AbstractDateTimeFieldComponent extends AbstractTimeInstanceFieldComponent {
+    protected _translate: TranslateService;
+    dataField: DateTimeField;
+    protected constructor(_translate: TranslateService, informAboutInvalidData: boolean | null);
+    getErrorMessage(): any;
+}

package/lib/data-fields/date-time-field/models/date-time-field.d.ts

@@ -0,0 +1,10 @@
+import { Behavior } from '../../models/behavior';
+import { Moment } from 'moment';
+import { AbstractTimeInstanceField } from '../../time-instance-abstract-field/models/abstract-time-instance-field';
+import { Layout } from '../../models/layout';
+import { Validation } from '../../models/validation';
+import { Component } from '../../models/component';
+export declare class DateTimeField extends AbstractTimeInstanceField {
+    constructor(stringId: string, title: string, value: Moment, behavior: Behavior, placeholder?: string, description?: string, layout?: Layout, validations?: Array<Validation>, component?: Component, parentTaskId?: string);
+    protected valueEquality(a: Moment, b: Moment): boolean;
+}