@netgrif/components-core 6.0.1

package/lib/panel/task-panel/abstract-task-panel.component.d.ts

@@ -0,0 +1,109 @@
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit, Type } from '@angular/core';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskPanelData } from '../task-panel-list/task-panel-data/task-panel-data';
+import { Observable, Subscription } from 'rxjs';
+import { TaskViewService } from '../../view/task-view/service/task-view.service';
+import { HeaderColumn } from '../../header/models/header-column';
+import { PaperViewService } from '../../navigation/quick-panel/components/paper-view.service';
+import { TaskEventService } from '../../task-content/services/task-event.service';
+import { AssignTaskService } from '../../task/services/assign-task.service';
+import { DelegateTaskService } from '../../task/services/delegate-task.service';
+import { CancelTaskService } from '../../task/services/cancel-task.service';
+import { FinishTaskService } from '../../task/services/finish-task.service';
+import { TaskRequestStateService } from '../../task/services/task-request-state.service';
+import { TaskDataService } from '../../task/services/task-data.service';
+import { AssignPolicyService } from '../../task/services/assign-policy.service';
+import { SubjectTaskOperations } from '../../task/models/subject-task-operations';
+import { CallChainService } from '../../utility/call-chain/call-chain.service';
+import { TaskEventNotification } from '../../task-content/model/task-event-notification';
+import { DisableButtonFuntions } from './models/disable-functions';
+import { PanelWithImmediateData } from '../abstract/panel-with-immediate-data';
+import { TranslateService } from '@ngx-translate/core';
+import { FeaturedValue } from '../abstract/featured-value';
+import { CurrencyPipe } from '@angular/common';
+import { PermissionService } from '../../authorization/permission/permission.service';
+import { ChangedFieldsService } from '../../changed-fields/services/changed-fields.service';
+export declare abstract class AbstractTaskPanelComponent extends PanelWithImmediateData implements OnInit, AfterViewInit, OnDestroy {
+    protected _taskContentService: TaskContentService;
+    protected _log: LoggerService;
+    protected _taskViewService: TaskViewService;
+    protected _paperView: PaperViewService;
+    protected _taskEventService: TaskEventService;
+    protected _assignTaskService: AssignTaskService;
+    protected _delegateTaskService: DelegateTaskService;
+    protected _cancelTaskService: CancelTaskService;
+    protected _finishTaskService: FinishTaskService;
+    protected _taskState: TaskRequestStateService;
+    protected _taskDataService: TaskDataService;
+    protected _assignPolicyService: AssignPolicyService;
+    protected _callChain: CallChainService;
+    protected _taskOperations: SubjectTaskOperations;
+    protected _disableFunctions: DisableButtonFuntions;
+    protected _translate: TranslateService;
+    protected _currencyPipe: CurrencyPipe;
+    protected _changedFieldsService: ChangedFieldsService;
+    protected _permissionService: PermissionService;
+    /**
+     * @ignore
+     * Set by an @Input() on a setter function, that also resolves featured fields.
+     */
+    protected _taskPanelData: TaskPanelData;
+    protected _forceLoadDataOnOpen: boolean;
+    panelContentComponent: Type<any>;
+    selectedHeaders$: Observable<Array<HeaderColumn>>;
+    first: boolean;
+    last: boolean;
+    responsiveBody: boolean;
+    set forceLoadDataOnOpen(force: boolean);
+    textEllipsis: boolean;
+    /**
+     * Emits notifications about task events
+     */
+    taskEvent: EventEmitter<TaskEventNotification>;
+    panelRefOutput: EventEmitter<MatExpansionPanel>;
+    portal: ComponentPortal<any>;
+    panelRef: MatExpansionPanel;
+    protected _sub: Subscription;
+    protected _subTaskEvent: Subscription;
+    protected _subTaskData: Subscription;
+    protected _subOperationOpen: Subscription;
+    protected _subOperationClose: Subscription;
+    protected _subOperationReload: Subscription;
+    protected _subOperationForceReload: Subscription;
+    protected _subPanelUpdate: Subscription;
+    protected _taskDisableButtonFunctions: DisableButtonFuntions;
+    protected constructor(_taskContentService: TaskContentService, _log: LoggerService, _taskViewService: TaskViewService, _paperView: PaperViewService, _taskEventService: TaskEventService, _assignTaskService: AssignTaskService, _delegateTaskService: DelegateTaskService, _cancelTaskService: CancelTaskService, _finishTaskService: FinishTaskService, _taskState: TaskRequestStateService, _taskDataService: TaskDataService, _assignPolicyService: AssignPolicyService, _callChain: CallChainService, _taskOperations: SubjectTaskOperations, _disableFunctions: DisableButtonFuntions, _translate: TranslateService, _currencyPipe: CurrencyPipe, _changedFieldsService: ChangedFieldsService, _permissionService: PermissionService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    protected abstract createContentPortal(): void;
+    set taskPanelData(data: TaskPanelData);
+    get taskPanelData(): TaskPanelData;
+    get isLoading(): boolean;
+    stopLoading(): void;
+    preventPanelOpen($event: MouseEvent): boolean;
+    isPaperView(): boolean;
+    setPanelRef(panelRef: MatExpansionPanel): void;
+    assign(): void;
+    delegate(): void;
+    cancel(): void;
+    finish(): void;
+    collapse(): void;
+    expand(): void;
+    canAssign(): boolean;
+    canReassign(): boolean;
+    canCancel(): boolean;
+    canFinish(): boolean;
+    canCollapse(): boolean;
+    canDo(action: any): boolean;
+    getAssignTitle(): string;
+    getCancelTitle(): string;
+    getDelegateTitle(): string;
+    getFinishTitle(): string;
+    canDisable(type: string): boolean;
+    protected getFeaturedMetaValue(selectedHeader: HeaderColumn): FeaturedValue;
+    protected getFeaturedImmediateValue(selectedHeader: HeaderColumn): FeaturedValue;
+    ngOnDestroy(): void;
+}

package/lib/panel/task-panel/models/disable-functions.d.ts

@@ -0,0 +1,10 @@
+import { Task } from '../../../resources/interface/task';
+import { InjectionToken } from '@angular/core';
+export declare const NAE_TASK_PANEL_DISABLE_BUTTON_FUNCTIONS: InjectionToken<DisableButtonFuntions>;
+export interface DisableButtonFuntions {
+    finish?: (t: Task) => boolean;
+    assign?: (t: Task) => boolean;
+    delegate?: (t: Task) => boolean;
+    reassign?: (t: Task) => boolean;
+    cancel?: (t: Task) => boolean;
+}

package/lib/panel/task-panel-list/abstract-task-list.component.d.ts

@@ -0,0 +1,46 @@
+import { AfterViewInit, EventEmitter, OnDestroy } from '@angular/core';
+import { TaskPanelData } from './task-panel-data/task-panel-data';
+import { Observable } from 'rxjs';
+import { HeaderColumn } from '../../header/models/header-column';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { TaskViewService } from '../../view/task-view/service/task-view.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TaskEventNotification } from '../../task-content/model/task-event-notification';
+import { TabbedVirtualScrollComponent } from '../abstract/tabbed-virtual-scroll.component';
+import { InjectedTabData } from '../../tabs/interfaces';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { ActivatedRoute } from '@angular/router';
+export declare abstract class AbstractTaskListComponent extends TabbedVirtualScrollComponent implements AfterViewInit, OnDestroy {
+    protected _taskViewService: TaskViewService;
+    protected _log: LoggerService;
+    protected route?: ActivatedRoute;
+    protected _allowMultiOpen: boolean;
+    protected taskPanelRefs: Map<string, MatExpansionPanel>;
+    tasks$: Observable<Array<TaskPanelData>>;
+    loading$: Observable<boolean>;
+    selectedHeaders$: Observable<Array<HeaderColumn>>;
+    responsiveBody: boolean;
+    forceLoadDataOnOpen: boolean;
+    textEllipsis: boolean;
+    set allowMultiOpen(bool: boolean);
+    get allowMultiOpen(): boolean;
+    /**
+     * Emits notifications about task events
+     */
+    taskEvent: EventEmitter<TaskEventNotification>;
+    viewport: CdkVirtualScrollViewport;
+    private redirectTaskId;
+    private unsubscribe$;
+    protected constructor(_taskViewService: TaskViewService, _log: LoggerService, injectedTabData: InjectedTabData, route?: ActivatedRoute);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    trackBy(idx: number, item: TaskPanelData): any;
+    loadNextPage(): void;
+    /**
+     * Emits an event into this component's @Output attribute
+     * @param event the event that will be emitted
+     */
+    emitTaskEvent(event: TaskEventNotification): void;
+    addToPanelRefs(task: TaskPanelData, panelRef: MatExpansionPanel): void;
+    onRedirect(): void;
+}

package/lib/panel/task-panel-list/task-panel-data/task-panel-data.d.ts

@@ -0,0 +1,8 @@
+import { Task } from '../../../resources/interface/task';
+import { Subject } from 'rxjs';
+import { ChangedFields } from '../../../data-fields/models/changed-fields';
+export interface TaskPanelData {
+    task: Task;
+    changedFields: Subject<ChangedFields>;
+    initiallyExpanded: boolean;
+}

package/lib/panel/workflow-panel/abstract-workflow-panel.component.d.ts

@@ -0,0 +1,57 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { PanelWithHeaderBinding } from '../abstract/panel-with-header-binding';
+import { HeaderColumn } from '../../header/models/header-column';
+import { Observable } from 'rxjs';
+import { LoggerService } from '../../logger/services/logger.service';
+import { TextField } from '../../data-fields/text-field/models/text-field';
+import { DateTimeField } from '../../data-fields/date-time-field/models/date-time-field';
+import { Behavior } from '../../data-fields/models/behavior';
+import { Net } from '../../process/net';
+import { TranslateService } from '@ngx-translate/core';
+import { WorkflowViewService } from '../../view/workflow-view/workflow-view.service';
+import { FeaturedValue } from '../abstract/featured-value';
+export interface WorkflowPanelContent {
+    netIdentifier: TextField;
+    title: TextField;
+    version: TextField;
+    author: TextField;
+    uploaded: DateTimeField;
+}
+export declare abstract class AbstractWorkflowPanelComponent extends PanelWithHeaderBinding implements OnInit, OnDestroy {
+    protected _log: LoggerService;
+    protected _translate: TranslateService;
+    protected _workflowService: WorkflowViewService;
+    workflow: Net;
+    selectedHeaders$: Observable<Array<HeaderColumn>>;
+    responsiveBody: boolean;
+    showDeleteMenu: boolean;
+    panelRef: MatExpansionPanel;
+    panelContent: WorkflowPanelContent;
+    private _subscription;
+    private readonly TRANSLATION_NET;
+    private readonly TRANSLATION_TITLE;
+    private readonly TRANSLATION_VERSION;
+    private readonly TRANSLATION_AUTHOR;
+    private readonly TRANSLATION_UPLOAD;
+    protected dataFieldsBehaviour: Behavior;
+    protected constructor(_log: LoggerService, _translate: TranslateService, _workflowService: WorkflowViewService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    show(event: MouseEvent): boolean;
+    collapse(): void;
+    setPanelRef(panelRef: MatExpansionPanel): void;
+    /**
+     * Handles the logic that should be executed when the "delete workflow" button is clicked.
+     *
+     * Calls the appropriate method in the {@link WorkflowViewService}.
+     */
+    deleteWorkflow(): void;
+    /**
+     * Populate data fields group for every petri net model
+     */
+    protected createPanelContent(): WorkflowPanelContent;
+    protected resolveFeaturedFieldsValues(): void;
+    protected getFeaturedMetaValue(selectedHeader: HeaderColumn): FeaturedValue;
+    protected getFeaturedImmediateValue(selectedHeader: HeaderColumn): FeaturedValue;
+}

package/lib/process/net.d.ts

@@ -0,0 +1,95 @@
+import { PetriNetReference } from '../resources/interface/petri-net-reference';
+import { Author } from '../resources/interface/author';
+import { ImmediateData } from '../resources/interface/immediate-data';
+import Transition from './transition';
+import Transaction from './transaction';
+import NetRole from './netRole';
+import { Permissions } from './permissions';
+import { PetriNetReferenceWithPermissions } from './petri-net-reference-with-permissions';
+/**
+ * @ignore
+ */
+export declare class Net implements PetriNetReferenceWithPermissions {
+    /**
+     * @ignore
+     */
+    private _stringId;
+    /**
+     * @ignore
+     */
+    private _title;
+    /**
+     * @ignore
+     */
+    private _identifier;
+    /**
+     * @ignore
+     */
+    private _version;
+    /**
+     * @ignore
+     */
+    private _initials;
+    /**
+     * @ignore
+     */
+    private _defaultCaseName;
+    /**
+     * @ignore
+     */
+    private _createdDate;
+    /**
+     * @ignore
+     */
+    private _author;
+    /**
+     * @ignore
+     */
+    private _immediateData;
+    /**
+     * @ignore
+     */
+    private _transitions;
+    /**
+     * @ignore
+     */
+    private _transactions;
+    /**
+     * @ignore
+     */
+    private _roles;
+    /**
+     * @ignore
+     */
+    private _permissions;
+    /**
+     * @ignore
+     */
+    constructor(net: PetriNetReference);
+    get stringId(): string;
+    set stringId(value: string);
+    get title(): string;
+    set title(value: string);
+    get identifier(): string;
+    set identifier(value: string);
+    get version(): string;
+    set version(value: string);
+    get initials(): string;
+    set initials(value: string);
+    get defaultCaseName(): string;
+    set defaultCaseName(value: string);
+    get createdDate(): Array<number>;
+    set createdDate(value: Array<number>);
+    get author(): Author;
+    set author(value: Author);
+    get immediateData(): Array<ImmediateData>;
+    set immediateData(value: Array<ImmediateData>);
+    get transitions(): Array<Transition>;
+    set transitions(value: Array<Transition>);
+    get transactions(): Array<Transaction>;
+    set transactions(value: Array<Transaction>);
+    get roles(): Array<NetRole>;
+    set roles(value: Array<NetRole>);
+    get permissions(): Permissions;
+    set permissions(value: Permissions);
+}

package/lib/process/netRole.d.ts

@@ -0,0 +1,4 @@
+export default interface NetRole {
+    stringId: string;
+    name: string;
+}

package/lib/process/permissions.d.ts

@@ -0,0 +1,30 @@
+export interface Permissions {
+    [k: string]: Permission;
+}
+export interface UserPermissions {
+    [k: string]: Permission;
+}
+export interface UserRefs {
+    [k: string]: Permission;
+}
+export interface Permission {
+    create?: boolean;
+    delete?: boolean;
+    view?: boolean;
+    assign?: boolean;
+    assigned?: boolean;
+    cancel?: boolean;
+    finish?: boolean;
+    delegate?: boolean;
+    set?: boolean;
+}
+export declare enum PermissionType {
+    CREATE = "create",
+    DELETE = "delete",
+    VIEW = "view",
+    ASSIGN = "assign",
+    CANCEL = "cancel",
+    FINISH = "finish",
+    DELEGATE = "delegate",
+    SET = "set"
+}

package/lib/process/petri-net-reference-with-permissions.d.ts

@@ -0,0 +1,7 @@
+import { PetriNetReference } from '../resources/interface/petri-net-reference';
+import { Permissions } from './permissions';
+import NetRole from './netRole';
+export interface PetriNetReferenceWithPermissions extends PetriNetReference {
+    roles: Array<NetRole>;
+    permissions: Permissions;
+}

package/lib/process/process.service.d.ts

@@ -0,0 +1,94 @@
+import { OnDestroy } from '@angular/core';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { Net } from './net';
+import { PetriNetResourceService } from '../resources/engine-endpoint/petri-net-resource.service';
+import { LoggerService } from '../logger/services/logger.service';
+import Transition from './transition';
+import Transaction from './transaction';
+import RolesAndPermissions from './rolesAndPermissions';
+import { PetriNetReference } from '../resources/interface/petri-net-reference';
+import { PetriNetReferenceWithPermissions } from './petri-net-reference-with-permissions';
+export interface NetCache {
+    [k: string]: Net;
+}
+/**
+ * Process service is responsible for loading and caching processes needed for any functionality of an app.
+ */
+export declare class ProcessService implements OnDestroy {
+    private _petriNetResource;
+    private _log;
+    protected readonly _nets: NetCache;
+    protected _netsSubject: Subject<NetCache>;
+    protected _netUpdate: Subject<Net>;
+    protected _requestCache: Map<string, ReplaySubject<Net>>;
+    protected _referenceRequestCache: Map<string, ReplaySubject<PetriNetReferenceWithPermissions>>;
+    constructor(_petriNetResource: PetriNetResourceService, _log: LoggerService);
+    ngOnDestroy(): void;
+    /**
+     * Get process nets according to provided identifiers.
+     * If any of the requested processes is not cached it will be loaded from the server and saved for later.
+     * @param identifiers Array of identifiers of requested processes. See {@link Net}
+     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made
+     * (unless another is already pending)
+     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.
+     * If any of the processes failed to load it is skipped from the result.
+     */
+    getNets(identifiers: Array<string>, forceLoad?: boolean): Observable<Array<Net>>;
+    /**
+     * Get process net by identifier.
+     * @param identifier Identifier of the requested process. See {@link Net}
+     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made
+     * (unless another is already pending)
+     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.
+     */
+    getNet(identifier: string, forceLoad?: boolean): Observable<Net>;
+    /**
+     * Get process net referencess according to provided identifiers.
+     *
+     * `PetriNetReferences` are not cached.
+     * Each call will result in a new backend request unless a request for the same net is already pending.
+     * @param identifiers Array of identifiers of requested processes. See {@link Net}
+     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.
+     * If any of the processes failed to load it is skipped from the result.
+     */
+    getNetReferences(identifiers: Array<string>): Observable<Array<PetriNetReferenceWithPermissions>>;
+    /**
+     * Get process net reference by identifier.
+     *
+     * `PetriNetReferences` are not cached.
+     * Each call will result in a new backend request unless a request for the same net is already pending.
+     * @param identifier Identifier of the requested process. See {@link Net}
+     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.
+     */
+    getNetReference(identifier: string): Observable<PetriNetReferenceWithPermissions>;
+    /**
+     * Remove cached process by identifier. If the process is not found nothing happens.
+     * @param identifier Process identifier
+     */
+    removeNet(identifier: string): void;
+    /**
+     * Update cached process object. If the process is not found nothing happens. Process object is replaced.
+     * @param net Updated process object.
+     */
+    updateNet(net: Net): void;
+    /**
+     * Stream of change of the process cache.
+     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.
+     * @returns Observable of whole updated cache.
+     */
+    get nets$(): Observable<NetCache>;
+    /**
+     * Stream of change in the process cache.
+     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.
+     * @returns Observable of updated or newly loaded process net.
+     */
+    get netUpdate$(): Observable<Net>;
+    areNetsLoaded(identifiers: Array<string>): boolean;
+    isNetLoaded(identifier: string): boolean;
+    protected loadNet(id: string): Observable<Net>;
+    protected loadNetReference(id: string): Observable<PetriNetReference>;
+    protected loadTransitions(id: string): Observable<Array<Transition>>;
+    protected loadTransactions(id: string): Observable<Array<Transaction>>;
+    protected loadRoles(id: string): Observable<RolesAndPermissions>;
+    protected publishUpdate(net?: Net): void;
+}

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

@@ -0,0 +1,7 @@
+export * from './process.service';
+export * from './net';
+export * from './transition';
+export * from './transaction';
+export * from './netRole';
+export * from './public-process.service';
+export * from './petri-net-reference-with-permissions';

package/lib/process/public-process.service.d.ts

@@ -0,0 +1,8 @@
+import { ProcessService } from './process.service';
+import { PublicPetriNetResourceService } from '../resources/engine-endpoint/public/public-petri-net-resource.service';
+import { LoggerService } from '../logger/services/logger.service';
+export declare class PublicProcessService extends ProcessService {
+    private _publicPetriNetResource;
+    private _logger;
+    constructor(_publicPetriNetResource: PublicPetriNetResourceService, _logger: LoggerService);
+}

package/lib/process/rolesAndPermissions.d.ts

@@ -0,0 +1,6 @@
+import NetRole from './netRole';
+import { Permissions } from './permissions';
+export default interface RolesAndPermissions {
+    processRoles: Array<NetRole>;
+    permissions: Permissions;
+}

package/lib/process/transaction.d.ts

@@ -0,0 +1,5 @@
+import Transition from './transition';
+export default interface Transaction {
+    transitions: Array<Transition>;
+    title: string;
+}

package/lib/process/transition.d.ts

@@ -0,0 +1,7 @@
+import { ImmediateData } from '../resources/interface/immediate-data';
+export default interface Transition {
+    stringId: string;
+    title: string;
+    petriNetId: string;
+    immediateData: Array<ImmediateData>;
+}

package/lib/public/factories/get-net-and-create-case.d.ts

@@ -0,0 +1,6 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { ProcessService } from '../../process/process.service';
+import { CaseResourceService } from '../../resources/engine-endpoint/case-resource.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+export declare const getNetAndCreateCase: (router: Router, route: ActivatedRoute, process: ProcessService, caseResourceService: CaseResourceService, snackBarService: SnackBarService, translate: TranslateService) => void;

package/lib/public/factories/public-factory-resolver.d.ts

@@ -0,0 +1,6 @@
+import { Router } from '@angular/router';
+import { UserService } from '../../user/services/user.service';
+import { SessionService } from '../../authentication/session/services/session.service';
+import { AuthenticationService } from '../../authentication/services/authentication/authentication.service';
+import { PublicUrlResolverService } from '../services/public-url-resolver.service';
+export declare const publicFactoryResolver: (userService: UserService, sessionService: SessionService, authService: AuthenticationService, router: Router, publicResolverService: PublicUrlResolverService, privateService: any, publicService: any) => any;

package/lib/public/factories/public-search-factory.d.ts

@@ -0,0 +1,9 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { ProcessService } from '../../process/process.service';
+import { CaseResourceService } from '../../resources/engine-endpoint/case-resource.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { TranslateService } from '@ngx-translate/core';
+export declare const publicBaseFilterFactory: (router: Router, route: ActivatedRoute, process: ProcessService, caseResourceService: CaseResourceService, snackBarService: SnackBarService, translate: TranslateService) => {
+    filter: SimpleFilter;
+};

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

@@ -0,0 +1,4 @@
+export * from './factories/public-factory-resolver';
+export * from './factories/get-net-and-create-case';
+export * from './factories/public-search-factory';
+export * from './services/public-url-resolver.service';

package/lib/public/services/public-url-resolver.service.d.ts

@@ -0,0 +1,6 @@
+export declare class PublicUrlResolverService {
+    protected _url: string;
+    constructor();
+    set url(url: string);
+    get url(): string;
+}

package/lib/resources/abstract-endpoint/abstract-resource.service.d.ts

@@ -0,0 +1,38 @@
+import { ResourceProvider } from '../resource-provider.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { Page } from '../interface/page';
+/**
+ * The class that contains behavior common to all resource services.
+ *
+ * Mostly endpoint URL resolution and utility functions for response parsing.
+ */
+export declare abstract class AbstractResourceService {
+    protected _resourceProvider: ResourceProvider;
+    protected _configService: ConfigurationService;
+    private readonly _SERVER_URL;
+    /**
+     * @param resourceName the identifier of the desired endpoint from configuration, found in
+     * {@link SetAuthAndResourcesAddress}.[resources]{@link Resources}.
+     * @param _resourceProvider `ResourceProvider` instance
+     * @param _configService `ConfigurationService` instance
+     */
+    protected constructor(resourceName: string, _resourceProvider: ResourceProvider, _configService: ConfigurationService);
+    protected get SERVER_URL(): string;
+    /**
+     * Get URL form nae.json - resources
+     * @param name - ID property
+     */
+    protected getResourceAddress(name: string): string;
+    /**
+     * Parses a response `r` into a {@link Page} instance
+     * @param r - response object
+     * @param propertiesParams - plural form of the resource name, that is used to extract the data. Eg. "cases".
+     */
+    protected getResourcePage<T>(r: any, propertiesParams: string): Page<T>;
+    /**
+     * Extracts data from the response `r` into an object with better usability.
+     * @param r - response object
+     * @param propertiesParams - plural form of the resource name, that is used to extract the data. Eg. "cases".
+     */
+    protected changeType<T>(r: any, propertiesParams: string): T;
+}

package/lib/resources/abstract-endpoint/count-service.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+import { Count } from '../interface/count';
+import { Filter } from '../../filter/models/filter';
+export interface CountService {
+    count: (body: Filter) => Observable<Count>;
+}