@smartbit4all/ng-client 1.0.0

package/lib/session/dev-tool/smart-dev-tool.interceptor.d.ts

@@ -0,0 +1,18 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { SmartDevToolService } from "./smart-dev-tool.service";
+import * as i0 from "@angular/core";
+export declare class SmartDevToolInterceptor implements HttpInterceptor {
+    private service;
+    constructor(service: SmartDevToolService);
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartDevToolInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartDevToolInterceptor>;
+}
+export declare class SmartDevToolErrorInterceptor implements HttpInterceptor {
+    private service;
+    constructor(service: SmartDevToolService);
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartDevToolErrorInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartDevToolErrorInterceptor>;
+}

package/lib/session/dev-tool/smart-dev-tool.service.d.ts

@@ -0,0 +1,55 @@
+import { DatePipe } from "@angular/common";
+import { HttpErrorResponse, HttpRequest, HttpResponse } from "@angular/common/http";
+import { PipeTransform } from "@angular/core";
+import { Subject } from "rxjs";
+import { SmartCookieService } from "../cookie-service/smart-cookie.service";
+import * as i0 from "@angular/core";
+export declare class SmartDevToolService {
+    private cookieService;
+    descriptor?: SmartDevToolDescriptor;
+    smartDevToolName: string;
+    isSmartDevToolActiveName: string;
+    isActive: boolean;
+    smartDevToolHoursName: string;
+    smartDevToolMaxName: string;
+    hoursToSave: number;
+    maxNumOfSavedCalls: number;
+    descriptorChanged: Subject<void>;
+    newErrorsCount: number;
+    newErrorsCountChanged: Subject<void>;
+    constructor(cookieService: SmartCookieService);
+    private setUpLocalStorage;
+    writeResponse(request: HttpRequest<any>, response: HttpResponse<any> | HttpErrorResponse, requestDate: Date, responseDate: Date): void;
+    clearErrors(): void;
+    createObject(keys: string[], mapWithValues: any, useGetItem: boolean): any;
+    sanitizeByTime(): void;
+    sanitizeByLength(): void;
+    save(): void;
+    clear(): void;
+    getPureString(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartDevToolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartDevToolService>;
+}
+export interface SmartDevToolDescriptor {
+    apiCalls: SmartDevToolApiCallDescriptor[];
+}
+export interface SmartDevToolApiCallDescriptor {
+    url: string | null;
+    responseBody: any;
+    responseHeader: any;
+    responseStatus: number;
+    responseStatusText: string;
+    responseDate: Date;
+    requestHeader: any;
+    requestBody: any;
+    requestDate: Date;
+    requestMethod: string;
+    localStorage: any;
+    sessionStorage: any;
+    cookies: any;
+}
+export declare class SmartDevToolDatePipe extends DatePipe implements PipeTransform {
+    transform(value: any, format?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartDevToolDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SmartDevToolDatePipe, "smartDevToolDatePipe">;
+}

package/lib/session/projects.d.ts

@@ -0,0 +1,8 @@
+export * from "./smart-session.service";
+export * from "./api/index";
+export * from "./smart-session.module";
+export * from "./dev-tool/smart-dev-tool-floating-button/smart-dev-tool-floating-button.component";
+export * from "./dev-tool/smart-dev-tool.service";
+export * from "./smart-session-handler.service";
+export * from "./smart-timer/smart-session-timer.component";
+export * from "./smart-timer/smart-session-timer.service";

package/lib/session/smart-error-catching.interceptor.d.ts

@@ -0,0 +1,13 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { SessionError, SmartSessionService } from "./projects";
+import * as i0 from "@angular/core";
+export declare class SmartErrorCatchingInterceptor implements HttpInterceptor {
+    private session;
+    sessionErrorCodes: SessionError[];
+    constructor(session: SmartSessionService);
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    resolveError(sessionError: SessionError): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartErrorCatchingInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartErrorCatchingInterceptor>;
+}

package/lib/session/smart-header-maintainer.interceptor.d.ts

@@ -0,0 +1,11 @@
+import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { SmartSessionService } from "./smart-session.service";
+import * as i0 from "@angular/core";
+export declare class SmartHeaderMaintainerInterceptor implements HttpInterceptor {
+    private session;
+    constructor(session: SmartSessionService);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartHeaderMaintainerInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartHeaderMaintainerInterceptor>;
+}

package/lib/session/smart-session-handler.service.d.ts

@@ -0,0 +1,11 @@
+export interface SmartSessionHandlerService {
+    handleSessionError(sessionError: SessionError): Promise<void>;
+}
+export interface SessionError {
+    code: string;
+    behaviour: SessionErrorBehaviour;
+}
+export declare enum SessionErrorBehaviour {
+    REFRESH = 0,
+    RESTART = 1
+}

package/lib/session/smart-session.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dev-tool/smart-dev-tool-dialog/smart-dev-tool-dialog.component";
+import * as i2 from "./dev-tool/smart-dev-tool-floating-button/smart-dev-tool-floating-button.component";
+import * as i3 from "./dev-tool/smart-dev-tool.service";
+import * as i4 from "./smart-timer/smart-session-timer.component";
+import * as i5 from "@angular/platform-browser";
+import * as i6 from "@angular/material/core";
+import * as i7 from "@angular/material/expansion";
+import * as i8 from "@angular/material/button";
+import * as i9 from "@smartbit4all/icon";
+export declare class SmartSessionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartSessionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SmartSessionModule, [typeof i1.SmartDevToolDialogComponent, typeof i2.SmartDevToolFloatingButtonComponent, typeof i3.SmartDevToolDatePipe, typeof i4.SmartSessionTimerComponent], [typeof i5.BrowserModule, typeof i6.MatCommonModule, typeof i7.MatExpansionModule, typeof i8.MatButtonModule, typeof i9.SmartIconModule], [typeof i2.SmartDevToolFloatingButtonComponent, typeof i4.SmartSessionTimerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SmartSessionModule>;
+}

package/lib/session/smart-session.service.d.ts

@@ -0,0 +1,50 @@
+import { Subject } from "rxjs";
+import { AuthenticationProviderData, SessionInfoData, SessionService } from "./api";
+import { SmartCookieService } from "./cookie-service/smart-cookie.service";
+import { SessionError, SmartSessionHandlerService } from "./smart-session-handler.service";
+import * as i0 from "@angular/core";
+export interface HeaderParam {
+    headerName: string;
+    value: string;
+}
+export declare class SmartSessionService {
+    private apiService;
+    private cookieService;
+    private basePath?;
+    private token?;
+    private _sessionInfoData?;
+    get sessionInfoData(): SessionInfoData | undefined;
+    private set sessionInfoData(value);
+    private providers?;
+    private cookieName?;
+    isAuthenticated: boolean;
+    authenticationStateChanged: Subject<boolean>;
+    headerParams: Array<HeaderParam>;
+    headersUpdated: Subject<void>;
+    private localStorageLocaleName;
+    localeChanged: Subject<void>;
+    sessionExpiracyChanged: Subject<void>;
+    private sessionHandlerService?;
+    constructor(apiService: SessionService, cookieService: SmartCookieService);
+    setSessionHandlerService(smartSessionHandlerService: SmartSessionHandlerService): void;
+    handleSessionError(sessionError: SessionError): Promise<void>;
+    addHeaderParam(headerParam: HeaderParam): void;
+    private setUpTokenForSessionService;
+    setUrl(url: string): void;
+    getBasePath(): string;
+    setCookieName(name: string): void;
+    private saveTokenToLocalStorage;
+    private setAuthenticationStatus;
+    private checkStatements;
+    initialize(): Promise<void>;
+    private startSession;
+    getSession(): Promise<SessionInfoData>;
+    refreshSession(): Promise<SessionInfoData>;
+    getAuthenticationProviders(): Promise<Array<AuthenticationProviderData>>;
+    getIsAuthenticated(): Promise<boolean>;
+    clearAndStartNewSession(): Promise<void>;
+    getLocale(): string;
+    changeLocale(locale: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartSessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartSessionService>;
+}

package/lib/session/smart-timer/smart-session-timer.component.d.ts

@@ -0,0 +1,14 @@
+import { OnDestroy, OnInit } from "@angular/core";
+import { SmartSessionTimerService } from "./smart-session-timer.service";
+import * as i0 from "@angular/core";
+export declare class SmartSessionTimerComponent implements OnInit, OnDestroy {
+    private service;
+    private _destroy$;
+    timeInSeconds?: number;
+    constructor(service: SmartSessionTimerService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    formatTime(seconds: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartSessionTimerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmartSessionTimerComponent, "smart-session-timer", never, {}, {}, never, never>;
+}

package/lib/session/smart-timer/smart-session-timer.service.d.ts

@@ -0,0 +1,21 @@
+import { OnDestroy } from "@angular/core";
+import { Subject } from "rxjs";
+import { SmartSessionService } from "../smart-session.service";
+import * as i0 from "@angular/core";
+export declare class SmartSessionTimerService implements OnDestroy {
+    private session;
+    private _destroy$;
+    totalTimeInMinutes: number;
+    timeLeftInSeconds?: number;
+    readonly sessionExpiration: string;
+    timeChanged: Subject<void>;
+    onTimerExpired: Subject<void>;
+    timer: any;
+    constructor(session: SmartSessionService);
+    ngOnDestroy(): void;
+    startTimer(): void;
+    restart(): void;
+    timeout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartSessionTimerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartSessionTimerService>;
+}

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

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./session/smart-session.module";
+import * as i2 from "./view-context/smart-view-context.module";
+export declare class SmartNgClientModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartNgClientModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SmartNgClientModule, never, [typeof i1.SmartSessionModule, typeof i2.SmartViewContextModule], [typeof i1.SmartSessionModule, typeof i2.SmartViewContextModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SmartNgClientModule>;
+}

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

@@ -0,0 +1,10 @@
+import { SmartSessionService } from "./session/smart-session.service";
+import { SmartViewContextService } from "./view-context/smart-view-context.service";
+import * as i0 from "@angular/core";
+export declare class SmartNgClientService {
+    private session;
+    private viewContext;
+    constructor(session: SmartSessionService, viewContext: SmartViewContextService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartNgClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartNgClientService>;
+}

package/lib/view-context/api/api/api.d.ts

@@ -0,0 +1,3 @@
+export * from './view.service';
+import { ViewService } from './view.service';
+export declare const APIS: (typeof ViewService)[];

package/lib/view-context/api/api/view.service.d.ts

@@ -0,0 +1,147 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { MessageResult } from '../model/messageResult';
+import { ViewConstraint } from '../model/viewConstraint';
+import { ViewContextData } from '../model/viewContextData';
+import { ViewContextUpdate } from '../model/viewContextUpdate';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+export declare class ViewService {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Creates a new ViewContext
+     * @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.
+     */
+    createViewContext(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<ViewContextData>;
+    createViewContext(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<ViewContextData>>;
+    createViewContext(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<ViewContextData>>;
+    /**
+     * @param uuid
+     * @param item
+     * @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.
+     */
+    downloadItem(uuid: string, item: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/octet-stream';
+        context?: HttpContext;
+    }): Observable<Blob>;
+    downloadItem(uuid: string, item: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/octet-stream';
+        context?: HttpContext;
+    }): Observable<HttpResponse<Blob>>;
+    downloadItem(uuid: string, item: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/octet-stream';
+        context?: HttpContext;
+    }): Observable<HttpEvent<Blob>>;
+    /**
+     * Returns the view constraint object belongs to the given view
+     * @param uuid View\&#39;s unique identifier.
+     * @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.
+     */
+    getViewConstraint(uuid: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<ViewConstraint>;
+    getViewConstraint(uuid: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<ViewConstraint>>;
+    getViewConstraint(uuid: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<ViewConstraint>>;
+    /**
+     * Returns the existing session info
+     * @param uuid ViewContext\&#39;s unique identifier.
+     * @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.
+     */
+    getViewContext(uuid: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<ViewContextData>;
+    getViewContext(uuid: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<ViewContextData>>;
+    getViewContext(uuid: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<ViewContextData>>;
+    /**
+     *
+     * @param viewUuid View UUID.
+     * @param messageUuid Message UUID.
+     * @param messageResult
+     * @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.
+     */
+    message(viewUuid: string, messageUuid: string, messageResult: MessageResult, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+    }): Observable<any>;
+    message(viewUuid: string, messageUuid: string, messageResult: MessageResult, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+    }): Observable<HttpResponse<any>>;
+    message(viewUuid: string, messageUuid: string, messageResult: MessageResult, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * @param channel Smartlink\&#39;s channel.
+     * @param uuid Smartlink\&#39;s unique identifier
+     * @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.
+     */
+    showPublishedView(channel: string, uuid: string, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+    }): Observable<any>;
+    showPublishedView(channel: string, uuid: string, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+    }): Observable<HttpResponse<any>>;
+    showPublishedView(channel: string, uuid: string, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: undefined;
+        context?: HttpContext;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Updates an existing ViewContext
+     * @param viewContextUpdate
+     * @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.
+     */
+    updateViewContext(viewContextUpdate: ViewContextUpdate, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<ViewContextData>;
+    updateViewContext(viewContextUpdate: ViewContextUpdate, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<ViewContextData>>;
+    updateViewContext(viewContextUpdate: ViewContextUpdate, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<ViewContextData>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewService>;
+}

package/lib/view-context/api/api.module.d.ts

@@ -0,0 +1,11 @@
+import { ModuleWithProviders } from "@angular/core";
+import { Configuration } from "./configuration";
+import { HttpClient } from "@angular/common/http";
+import * as i0 from "@angular/core";
+export declare class ViewContextApiModule {
+    static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<ViewContextApiModule>;
+    constructor(parentModule: ViewContextApiModule, http: HttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewContextApiModule, [{ optional: true; skipSelf: true; }, { optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ViewContextApiModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ViewContextApiModule>;
+}

package/lib/view-context/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/view-context/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/view-context/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api/api';
+export * from './model/models';
+export * from './variables';
+export * from './configuration';
+export * from './api.module';
+export * from './param';

package/lib/view-context/api/model/closeResult.d.ts

@@ -0,0 +1,17 @@
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare type CloseResult = 'approved' | 'pending' | 'rejected';
+export declare const CloseResult: {
+    Approved: CloseResult;
+    Pending: CloseResult;
+    Rejected: CloseResult;
+};

package/lib/view-context/api/model/componentConstraint.d.ts

@@ -0,0 +1,25 @@
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { ValueSetData } from '../../value-api';
+/**
+ * The component constraint is responsible for the constraints belong to a given component (textfield, combobox etc.) on the view. The UI must identify the component by the dataName that is a path of the data name separated by dot like dataSheet.field.
+ */
+export interface ComponentConstraint {
+    /**
+     * The data name to identify the related component or componenets. If it is a path the format is the following - dataSheet.field.
+     */
+    dataName?: string;
+    visible?: boolean;
+    mandatory?: boolean;
+    enabled?: boolean;
+    valueSet?: ValueSetData;
+}

package/lib/view-context/api/model/messageData.d.ts

@@ -0,0 +1,27 @@
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { MessageOption } from './messageOption';
+import { MessageType } from './messageType';
+export interface MessageData {
+    /**
+     * Unique identifier of the Message.
+     */
+    uuid: string;
+    /**
+     * UUID of the View, showing this message. May be null.
+     */
+    viewUuid?: string;
+    type: MessageType;
+    header?: string;
+    text?: string;
+    options?: Array<MessageOption>;
+}

package/lib/view-context/api/model/messageOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { MessageOptionType } from './messageOptionType';
+export interface MessageOption {
+    code: string;
+    label: string;
+    icon?: string;
+    type?: MessageOptionType;
+}

package/lib/view-context/api/model/messageOptionType.d.ts

@@ -0,0 +1,17 @@
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare type MessageOptionType = 'confirm' | 'reject' | 'cancel';
+export declare const MessageOptionType: {
+    Confirm: MessageOptionType;
+    Reject: MessageOptionType;
+    Cancel: MessageOptionType;
+};