@smartbit4all/ng-client 1.2.1 → 2.0.0

package/lib/smart-client/smart-component-api-client.d.ts

@@ -1,7 +1,7 @@
 import { Injector } from '@angular/core';
 import { SmartForm, SmartformComponent } from '@smartbit4all/form';
 import { GridOptions, SmartGrid, SmartGridComponent } from '@smartbit4all/grid';
-import { SmarttreeGenericService } from '@smartbit4all/tree';
+import { SmarttreeGenericService } from '../smart-tree/projects';
 import { Subject } from 'rxjs';
 import { ComponentModel, SmartTranslateService, SmartViewContextService, UiAction, UiActionAdditionalParams, UiActionDescriptorService, UiActionModel, UiActionRequest, UiActionService, UiActionSpecificDemandResponse, UseUiAction } from '../view-context/projects';
 import { SmartAuthenticationServiceInterface } from './smart-authentication.service';

package/lib/smart-ng-client.module.d.ts

@@ -6,8 +6,9 @@ import * as i4 from "./session/smart-session.module";
 import * as i5 from "./view-context/smart-view-context.module";
 import * as i6 from "@smartbit4all/form";
 import * as i7 from "@smartbit4all/expandable-section";
+import * as i8 from "./smart-tree/smarttree.module";
 export declare class SmartNgClientModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<SmartNgClientModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SmartNgClientModule, [typeof i1.SmartFileUploaderComponent], [typeof i2.BrowserModule, typeof i3.MatCommonModule, typeof i4.SmartSessionModule, typeof i5.SmartViewContextModule, typeof i6.SmartformModule, typeof i7.SmartExpandableSectionModule], [typeof i4.SmartSessionModule, typeof i5.SmartViewContextModule, typeof i1.SmartFileUploaderComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SmartNgClientModule, [typeof i1.SmartFileUploaderComponent], [typeof i2.BrowserModule, typeof i3.MatCommonModule, typeof i4.SmartSessionModule, typeof i5.SmartViewContextModule, typeof i6.SmartformModule, typeof i7.SmartExpandableSectionModule], [typeof i4.SmartSessionModule, typeof i5.SmartViewContextModule, typeof i1.SmartFileUploaderComponent, typeof i8.SmarttreeModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<SmartNgClientModule>;
 }

package/lib/smart-tree/projects.d.ts

@@ -0,0 +1,5 @@
+export * from './smarttree.service';
+export * from './smarttree.component';
+export * from './smarttree.module';
+export * from './smarttree.model';
+export * from './smarttree-generic.service';

package/lib/smart-tree/smarttree-generic.service.d.ts

@@ -0,0 +1,50 @@
+import { Injector } from '@angular/core';
+import { SmartViewContextService, UiAction, UiActionAdditionalParams, UiActionDescriptor, UiActionRequest, UiActionSpecificDemandResponse, UseUiAction } from '../view-context/projects';
+import { SmartTreeNode } from './smarttree.model';
+import { SmarttreeService } from './smarttree.service';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface SmarttreeConfiguration {
+    treeid: string;
+    viewContextName: string;
+    pageName: string;
+}
+export declare class SmarttreeGenericService extends SmarttreeService<SmartTreeNode[]> implements UseUiAction {
+    protected pageName: string;
+    protected treeId: string;
+    submit: Subject<void>;
+    reSubscribeToChange: Subject<void>;
+    uiActionDescriptors: Map<string, UiActionDescriptor>;
+    selectedNode?: SmartTreeNode;
+    viewContextName: string;
+    protected viewContext: SmartViewContextService;
+    private service;
+    private uiActionDescriptorService;
+    private uiActionService;
+    constructor(inject: Injector, pageName: string, treeId: string);
+    constructUiActionModels(uiActions: UiAction[]): void;
+    configureTree(configuration: SmarttreeConfiguration): void;
+    initialize(): Promise<void>;
+    downloadTree(): Promise<SmartTreeNode[]>;
+    downloadChildren(parentNode: SmartTreeNode): Promise<SmartTreeNode[]>;
+    onTreeNodeOpen(treeNode: SmartTreeNode): Promise<void>;
+    onTreeNodeClick(treeNode: SmartTreeNode): void;
+    selectFolder(folderUri: string, treeNode?: SmartTreeNode): Promise<void>;
+    updateTreeOnTheFly(): Promise<void>;
+    syncTree(): Promise<void>;
+    deepSearchTreeNode(identifier: string, nodes: SmartTreeNode[]): SmartTreeNode | undefined;
+    findSelected(nodes: SmartTreeNode[]): void;
+    createButtonsForTreeNodes(nodes: SmartTreeNode[]): SmartTreeNode[];
+    doAction(args: any[]): Promise<void>;
+    protected getAllNodes(nodes: SmartTreeNode[]): SmartTreeNode[];
+    protected cacheActionDesciptors(nodes: SmartTreeNode[]): Promise<void>;
+    getLabelByAction(action: UiAction): string;
+    getAdditionalParams(uiAction: UiAction): UiActionAdditionalParams;
+    getModel(): {};
+    performUiActionRequest(uiActionRequest: UiActionRequest): Promise<any>;
+    performNodeUiActionRequest(uiActionRequest: UiActionRequest): Promise<any>;
+    performMainUiActionRequest(uiActionRequest: UiActionRequest): Promise<any>;
+    handleSpecificDemandsAsynchronously(uiAction: UiAction, uiActionRequest: UiActionRequest): Promise<UiActionSpecificDemandResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmarttreeGenericService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmarttreeGenericService>;
+}

package/lib/smart-tree/smarttree.component.d.ts

@@ -0,0 +1,42 @@
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { ChangeDetectorRef, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { SmartTreeModel, SmartTreeNode, SmartTreeNodeButton, SmartTreeNodeButtonType } from './smarttree.model';
+import { TreeStyle } from './smarttree.node.model';
+import { SmarttreeService } from './smarttree.service';
+import { UiActionModel } from '../view-context/projects';
+import * as i0 from "@angular/core";
+export declare class SmartTreeComponent implements OnInit, OnDestroy {
+    private cdr;
+    private _destroy$;
+    trigger: QueryList<MatMenuTrigger>;
+    tree: any;
+    treeControl: NestedTreeControl<SmartTreeNode, SmartTreeNode>;
+    dataSource: MatTreeNestedDataSource<SmartTreeNode>;
+    tempActiveNode?: SmartTreeNode;
+    treeData?: SmartTreeModel;
+    treeStyle?: TreeStyle;
+    treeService: SmarttreeService<any>;
+    smartTreeNodeButtonType: typeof SmartTreeNodeButtonType;
+    errorMessage?: string;
+    uiActionModels: UiActionModel[];
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getIfExpanded(node: SmartTreeNode): boolean;
+    expandTreeNodes(): void;
+    expandTreeNodesDeeply(nodes: SmartTreeNode[]): void;
+    onNodeClick(event: any, node: SmartTreeNode): void;
+    onOpenNode(event: any, node: SmartTreeNode): void;
+    hasChild: (_: number, node: SmartTreeNode) => boolean;
+    getNodeStyle(node: SmartTreeNode): {};
+    getNodePadding(node: SmartTreeNode): {};
+    customButtonClicked(event: any, button: SmartTreeNodeButton, close?: boolean): void;
+    getClassesForTreeNode(node: SmartTreeNode): string[];
+    getInnerClassesForTreeNode(node: SmartTreeNode): string[];
+    getClassesForTreeNodeChildren(node: SmartTreeNode): string[];
+    getCustomClass(cssClass: string, plusProperty: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmartTreeComponent, "smart-tree", never, { "treeStyle": "treeStyle"; "treeService": "treeService"; }, {}, never, never>;
+}

package/lib/smart-tree/smarttree.model.d.ts

@@ -0,0 +1,41 @@
+import { UiAction } from '../view-context/projects';
+export interface SmartTreeModel {
+    identifier?: string;
+    rootNodes: Array<SmartTreeNode>;
+    selectedNodeIdentifier?: string;
+    navigationUrlsByNodeType?: Array<SmartTreeNodeType>;
+}
+export interface SmartTreeNode {
+    icon?: string;
+    caption: string;
+    classes?: Array<string>;
+    hasChildren: boolean;
+    childrenNodes: Array<SmartTreeNode>;
+    expanded: boolean;
+    selected: boolean;
+    childrenNodesLoaded: boolean;
+    level: number;
+    shortDescription?: string;
+    identifier?: string;
+    objectUri?: string;
+    nodeType: string;
+    button?: SmartTreeNodeButton;
+    actions?: Array<UiAction>;
+}
+export interface SmartTreeNodeButton {
+    icon?: string;
+    label?: string;
+    type: SmartTreeNodeButtonType;
+    menuItemButtons?: SmartTreeNodeButton[];
+    callback?: (...args: any[]) => any;
+    args?: any[];
+}
+export declare enum SmartTreeNodeButtonType {
+    MENU = "MENU",
+    ICON = "ICON",
+    NORMAL = "NORMAL"
+}
+export interface SmartTreeNodeType {
+    nodeType: string;
+    navigationUrl: any[];
+}

package/lib/smart-tree/smarttree.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./smarttree.component";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "@angular/material/core";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/tree";
+import * as i7 from "@angular/material/menu";
+import * as i8 from "@smartbit4all/icon";
+export declare class SmarttreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmarttreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SmarttreeModule, [typeof i1.SmartTreeComponent], [typeof i2.BrowserModule, typeof i3.MatCommonModule, typeof i4.MatButtonModule, typeof i5.MatIconModule, typeof i6.MatTreeModule, typeof i7.MatMenuModule, typeof i8.SmartIconModule], [typeof i1.SmartTreeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SmarttreeModule>;
+}

package/lib/smart-tree/smarttree.node.model.d.ts

@@ -0,0 +1,13 @@
+export interface TreeStyle {
+    arrowPosition?: TreeArrowPosition;
+    levelBackgroundColor?: string[];
+    color?: string;
+    activeStyle?: {
+        color: string;
+        backgroundColor: string;
+    };
+}
+export declare enum TreeArrowPosition {
+    START = 0,
+    END = 1
+}

package/lib/smart-tree/smarttree.service.d.ts

@@ -0,0 +1,24 @@
+import { Subject } from 'rxjs';
+import { SmartTreeModel, SmartTreeNode } from './smarttree.model';
+import { SmarttreeServiceDescriptor } from './smarttree.service.interface';
+import { UiActionModel } from '../view-context/projects';
+import * as i0 from "@angular/core";
+export declare class SmarttreeService<T> implements SmarttreeServiceDescriptor<T> {
+    errorMessage: string;
+    treeFromBackend: T | undefined;
+    smartTreeModel: SmartTreeModel | undefined;
+    smartTreeModelChanged: Subject<SmartTreeModel>;
+    protected _uiActionModels: UiActionModel[] | undefined;
+    uiActionModelsChanged: Subject<void>;
+    get uiActionModels(): UiActionModel[] | undefined;
+    set uiActionModels(uiActionModels: UiActionModel[] | undefined);
+    constructor();
+    initialize(): Promise<void>;
+    downloadTree(): Promise<T>;
+    downloadChildren(parentNode: SmartTreeNode): Promise<T>;
+    onTreeNodeClick(treeNode: SmartTreeNode): void;
+    onTreeNodeOpen(treeNode: SmartTreeNode): void;
+    syncTree(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmarttreeService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmarttreeService<any>>;
+}

package/lib/smart-tree/smarttree.service.interface.d.ts

@@ -0,0 +1,43 @@
+import { Subject } from 'rxjs';
+import { SmartTreeModel, SmartTreeNode } from './smarttree.model';
+import { UiActionModel } from '../view-context/projects';
+/**
+ * T - TreeNodeList
+ * N - TreeNode
+ */
+export interface SmarttreeServiceDescriptor<T> {
+    errorMessage: string;
+    treeFromBackend: T | undefined;
+    smartTreeModel: SmartTreeModel | undefined;
+    smartTreeModelChanged: Subject<SmartTreeModel>;
+    uiActionModelsChanged: Subject<void>;
+    get uiActionModels(): UiActionModel[] | undefined;
+    set uiActionModels(uiActions: UiActionModel[] | undefined);
+    /**
+     * Initializes the SmartTree.
+     */
+    initialize(): Promise<void>;
+    /**
+     * BFF API call, downloads the tree from the backend and returns it.
+     */
+    downloadTree(): Promise<T>;
+    /**
+     * BFF API call, downloads the children of a parentNode and returns it.
+     * @param parentNode
+     */
+    downloadChildren(parentNode: SmartTreeNode): Promise<T>;
+    /**
+     * Handles the on click event for the treeNode.
+     * @param treeNode
+     */
+    onTreeNodeClick(treeNode: SmartTreeNode): void;
+    /**
+     * handles the open click event for the treeNode.
+     * @param treeNode
+     */
+    onTreeNodeOpen(treeNode: SmartTreeNode): void;
+    /**
+     * Synchronise the tree and emits a smartTreeModelChanged event.
+     */
+    syncTree(): void;
+}

package/lib/smart-tree/tree-api/api/tree.service.d.ts

@@ -0,0 +1,177 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { UiAction, UiActionRequest } from '../view-context/projects';
+import { Configuration } from '../configuration';
+import { SmartTreeNode } from '../../smarttree.model';
+import * as i0 from "@angular/core";
+export declare class TreeService {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Collapses the given treenode. The viewcontext will hold the appropriate instruction  for the ui. Returns the collapsed SmartTreeNode.
+     * @param viewUuid
+     * @param treeId
+     * @param nodeId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    collapseNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<SmartTreeNode>;
+    collapseNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<SmartTreeNode>>;
+    collapseNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<SmartTreeNode>>;
+    /**
+     * Expands the given treenode. The viewcontext will hold the appropriate instruction  for the ui, if any. Returns the expanded SmartTreeNode.
+     * @param viewUuid
+     * @param treeId
+     * @param nodeId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    expandNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<SmartTreeNode>;
+    expandNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<SmartTreeNode>>;
+    expandNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<SmartTreeNode>>;
+    /**
+     * Query the child nodes of the tree\&#39;s node given in the parameter
+     * @param viewUuid
+     * @param treeId
+     * @param nodeId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    getChildrenNodes(viewUuid: string, treeId: string, nodeId: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<Array<SmartTreeNode>>;
+    getChildrenNodes(viewUuid: string, treeId: string, nodeId: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<Array<SmartTreeNode>>>;
+    getChildrenNodes(viewUuid: string, treeId: string, nodeId: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<Array<SmartTreeNode>>>;
+    /**
+     * Query all tree nodes.
+     * @param viewUuid
+     * @param treeId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    getMainActions(viewUuid: string, treeId: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<Array<UiAction>>;
+    getMainActions(viewUuid: string, treeId: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<Array<UiAction>>>;
+    getMainActions(viewUuid: string, treeId: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<Array<UiAction>>>;
+    /**
+     * Query all tree nodes.
+     * @param viewUuid
+     * @param treeId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    getRootNodes(viewUuid: string, treeId: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<Array<SmartTreeNode>>;
+    getRootNodes(viewUuid: string, treeId: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<Array<SmartTreeNode>>>;
+    getRootNodes(viewUuid: string, treeId: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<Array<SmartTreeNode>>>;
+    /**
+     * Performs an action on the given treenode. The viewcontext will hold the appropriate instruction  for the ui. Returns the SmartTreeNode which the action was performed on.
+     * @param viewUuid
+     * @param treeId
+     * @param nodeId
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    performAction(viewUuid: string, treeId: string, nodeId: string, body: UiActionRequest, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<Array<SmartTreeNode>>;
+    performAction(viewUuid: string, treeId: string, nodeId: string, body: UiActionRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<Array<SmartTreeNode>>>;
+    performAction(viewUuid: string, treeId: string, nodeId: string, body: UiActionRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<Array<SmartTreeNode>>>;
+    /**
+     * Performs an action on the given treenode. The viewcontext will hold the appropriate instruction  for the ui. Returns the SmartTreeNode which the action was performed on.
+     * @param viewUuid
+     * @param treeId
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    performMainAction(viewUuid: string, treeId: string, body: UiActionRequest, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<Array<SmartTreeNode>>;
+    performMainAction(viewUuid: string, treeId: string, body: UiActionRequest, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<Array<SmartTreeNode>>>;
+    performMainAction(viewUuid: string, treeId: string, body: UiActionRequest, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<Array<SmartTreeNode>>>;
+    /**
+     * Collapses the given treenode. The viewcontext will hold the appropriate instruction  for the ui. Returns the collapsed SmartTreeNode.
+     * @param viewUuid
+     * @param treeId
+     * @param nodeId
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    selectNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<SmartTreeNode>;
+    selectNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<SmartTreeNode>>;
+    selectNode(viewUuid: string, treeId: string, nodeId: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<SmartTreeNode>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeService>;
+}

package/lib/smart-tree/tree-api/configuration.d.ts

@@ -0,0 +1,104 @@
+import { HttpParameterCodec } from '@angular/common/http';
+import { Param } from './param';
+export interface ConfigurationParameters {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {
+        [key: string]: string;
+    };
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Override the default method for encoding path parameters in various
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam?: (param: Param) => string;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials?: {
+        [key: string]: string | (() => string | undefined);
+    };
+}
+export declare class Configuration {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {
+        [key: string]: string;
+    };
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Encoding of various path parameter
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam: (param: Param) => string;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials: {
+        [key: string]: string | (() => string | undefined);
+    };
+    constructor(configurationParameters?: ConfigurationParameters);
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderContentType(contentTypes: string[]): string | undefined;
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderAccept(accepts: string[]): string | undefined;
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime: string): boolean;
+    lookupCredential(key: string): string | undefined;
+    private defaultEncodeParam;
+}

package/lib/smart-tree/tree-api/encoder.d.ts

@@ -0,0 +1,11 @@
+import { HttpParameterCodec } from '@angular/common/http';
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export declare class CustomHttpParameterCodec implements HttpParameterCodec {
+    encodeKey(k: string): string;
+    encodeValue(v: string): string;
+    decodeKey(k: string): string;
+    decodeValue(v: string): string;
+}

package/lib/smart-tree/tree-api/param.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Standard parameter styles defined by OpenAPI spec
+ */
+export declare type StandardParamStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+/**
+ * The OpenAPI standard {@link StandardParamStyle}s may be extended by custom styles by the user.
+ */
+export declare type ParamStyle = StandardParamStyle | string;
+/**
+ * Standard parameter locations defined by OpenAPI spec
+ */
+export declare type ParamLocation = 'query' | 'header' | 'path' | 'cookie';
+/**
+ * Standard types as defined in <a href="https://swagger.io/specification/#data-types">OpenAPI Specification: Data Types</a>
+ */
+export declare type StandardDataType = "integer" | "number" | "boolean" | "string" | "object" | "array";
+/**
+ * Standard {@link DataType}s plus your own types/classes.
+ */
+export declare type DataType = StandardDataType | string;
+/**
+ * Standard formats as defined in <a href="https://swagger.io/specification/#data-types">OpenAPI Specification: Data Types</a>
+ */
+export declare type StandardDataFormat = "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password";
+export declare type DataFormat = StandardDataFormat | string;
+/**
+ * The parameter to encode.
+ */
+export interface Param {
+    name: string;
+    value: unknown;
+    in: ParamLocation;
+    style: ParamStyle;
+    explode: boolean;
+    dataType: DataType;
+    dataFormat: DataFormat | undefined;
+}

package/lib/smart-tree/tree-api/variables.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+export declare const BASE_PATH: InjectionToken<string>;
+export declare const COLLECTION_FORMATS: {
+    csv: string;
+    tsv: string;
+    ssv: string;
+    pipes: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartbit4all/ng-client",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "peerDependencies": {
     "@angular/common": "^13.2.0",
     "@angular/core": "^13.2.0",

package/projects.d.ts

@@ -4,3 +4,4 @@ export * from './lib/smart-client/smart-file-uploader/smart-file-uploader.compon
 export * from './lib/view-context/projects';
 export * from './lib/session/projects';
 export * from './lib/smart-client/projects';
+export * from './lib/smart-tree/projects';