@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/smart-client/smart-file-uploader/smart-file-uploader.component.mjs

@@ -0,0 +1,79 @@
+import { Component, Inject, Input } from '@angular/core';
+import { COMPONENT_LIBRARY, ComponentLibrary, } from '../../view-context/projects';
+import * as i0 from "@angular/core";
+import * as i1 from "../../view-context/projects";
+import * as i2 from "@angular/common";
+import * as i3 from "../../smart-form/smartfileuploader/smartfileuploader.component";
+import * as i4 from "primeng/fileupload";
+import * as i5 from "primeng/api";
+export class SmartFileUploaderComponent {
+    constructor(uiActionService, uiActionDescriptorService, compLib) {
+        this.uiActionService = uiActionService;
+        this.uiActionDescriptorService = uiActionDescriptorService;
+        this.compLib = compLib;
+        this.componentLibrary = ComponentLibrary;
+        this.uploadedFiles = [];
+    }
+    ngOnChanges(changes) {
+        this.config = changes['config'].currentValue;
+        if (this.config) {
+            this.setUp();
+        }
+    }
+    async setUp() {
+        if (!this.config?.smartComponent?.uiActionModels?.length) {
+            return;
+        }
+        this.uiActionModel = this.config?.smartComponent.uiActionModels.find((uiActionModel) => uiActionModel.uiAction.code === this.config?.uiActionCode);
+        if (!this.uiActionModel) {
+            throw new Error(`UiAction with code ${this.config?.uiActionCode} could not found`);
+        }
+        const descriptor = await this.uiActionDescriptorService.getActionDescriptor(this.uiActionModel.uiAction);
+        this.i18n = {
+            addFile: descriptor.upload?.title ?? 'dokumentum hozzáadása',
+            browseOrDrag: descriptor.upload?.description ?? 'tallózás vagy behúzás',
+            formats: descriptor.upload?.formats ?? '',
+            maxSize: descriptor.upload?.maxSize ?? '',
+            upload: descriptor.upload?.uploadButtonTitle,
+        };
+    }
+    executeUpload(files) {
+        this.uiActionModel.uiAction.params = {
+            ...this.uiActionModel.uiAction.params,
+            _files: files,
+            isMultiple: this.config?.isMultiple,
+            param: 'INPUT',
+        };
+        this.uiActionService.execute(this.uiActionModel.uiAction, this.uiActionModel);
+    }
+    onSelect(event) {
+        this.uploadedFiles = [];
+        for (let file of event.files) {
+            this.uploadedFiles.push(file);
+        }
+    }
+    onRemove(event) {
+        this.uploadedFiles = [];
+    }
+    uploadFiles(event) {
+        this.uiActionModel.uiAction.params = {
+            ...this.uiActionModel.uiAction.params,
+            _files: this.uploadedFiles,
+            isMultiple: this.config?.isMultiple,
+            param: 'INPUT',
+        };
+        this.uiActionService.execute(this.uiActionModel.uiAction, this.uiActionModel);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartFileUploaderComponent, deps: [{ token: i1.UiActionService }, { token: i1.UiActionDescriptorService }, { token: COMPONENT_LIBRARY }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.11", type: SmartFileUploaderComponent, selector: "smart-file-uploader4sc", inputs: { config: "config" }, usesOnChanges: true, ngImport: i0, template: "@if (compLib === componentLibrary.PRIMENG) {\n  <p-fileUpload\n    name=\"files[]\"\n    url=\"\"\n    (onSend)=\"uploadFiles($event)\"\n    (onSelect)=\"onSelect($event)\"\n    (onRemove)=\"onRemove($event)\"\n    [multiple]=\"true\"\n    [accept]=\"config?.fileFormats?.join(',')\"\n    [maxFileSize]=\"config?.maxSizeMb\"\n    uploadLabel=\"Felt\u00F6lt\u00E9s\"\n    cancelLabel=\"M\u00E9gsem\"\n    chooseLabel=\"V\u00E1laszt\u00E1s\"\n  >\n    <ng-template pTemplate=\"content\"> </ng-template>\n  </p-fileUpload>\n} @else {\n  <smartfileuploader\n    *ngIf=\"i18n\"\n    [i18n]=\"i18n\"\n    [fileFormats]=\"config?.fileFormats\"\n    [isMultiple]=\"config?.isMultiple\"\n    [maxSizeMb]=\"config?.maxSizeMb\"\n    [uploadCallback]=\"executeUpload.bind(this)\"\n  ></smartfileuploader>\n}\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.SmartfileuploaderComponent, selector: "smartfileuploader", inputs: ["uploadCallback", "fileFormats", "maxSizeMb", "i18n", "useIconButton", "isMultiple", "autoUpload", "isDisabled"] }, { kind: "component", type: i4.FileUpload, selector: "p-fileUpload", inputs: ["name", "url", "method", "multiple", "accept", "disabled", "auto", "withCredentials", "maxFileSize", "invalidFileSizeMessageSummary", "invalidFileSizeMessageDetail", "invalidFileTypeMessageSummary", "invalidFileTypeMessageDetail", "invalidFileLimitMessageDetail", "invalidFileLimitMessageSummary", "style", "styleClass", "previewWidth", "chooseLabel", "uploadLabel", "cancelLabel", "chooseIcon", "uploadIcon", "cancelIcon", "showUploadButton", "showCancelButton", "mode", "headers", "customUpload", "fileLimit", "uploadStyleClass", "cancelStyleClass", "removeStyleClass", "chooseStyleClass", "files"], outputs: ["onBeforeUpload", "onSend", "onUpload", "onError", "onClear", "onRemove", "onSelect", "onProgress", "uploadHandler", "onImageError", "onRemoveUploadedFile"] }, { kind: "directive", type: i5.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartFileUploaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-file-uploader4sc', template: "@if (compLib === componentLibrary.PRIMENG) {\n  <p-fileUpload\n    name=\"files[]\"\n    url=\"\"\n    (onSend)=\"uploadFiles($event)\"\n    (onSelect)=\"onSelect($event)\"\n    (onRemove)=\"onRemove($event)\"\n    [multiple]=\"true\"\n    [accept]=\"config?.fileFormats?.join(',')\"\n    [maxFileSize]=\"config?.maxSizeMb\"\n    uploadLabel=\"Felt\u00F6lt\u00E9s\"\n    cancelLabel=\"M\u00E9gsem\"\n    chooseLabel=\"V\u00E1laszt\u00E1s\"\n  >\n    <ng-template pTemplate=\"content\"> </ng-template>\n  </p-fileUpload>\n} @else {\n  <smartfileuploader\n    *ngIf=\"i18n\"\n    [i18n]=\"i18n\"\n    [fileFormats]=\"config?.fileFormats\"\n    [isMultiple]=\"config?.isMultiple\"\n    [maxSizeMb]=\"config?.maxSizeMb\"\n    [uploadCallback]=\"executeUpload.bind(this)\"\n  ></smartfileuploader>\n}\n" }]
+        }], ctorParameters: () => [{ type: i1.UiActionService }, { type: i1.UiActionDescriptorService }, { type: i1.ComponentLibrary, decorators: [{
+                    type: Inject,
+                    args: [COMPONENT_LIBRARY]
+                }] }], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-file-uploader.component.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/smart-client/smart-file-uploader/smart-file-uploader.component.ts","../../../../../../projects/smart-ng-client/src/lib/smart-client/smart-file-uploader/smart-file-uploader.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, Input, OnChanges, SimpleChanges } from '@angular/core';\nimport {\n  COMPONENT_LIBRARY,\n  ComponentLibrary,\n  UiActionDescriptorService,\n  UiActionModel,\n  UiActionService,\n} from '../../view-context/projects';\nimport { SmartComponentFileUploader } from '../smart-component-api-client';\nimport { SmartFileUploaderI18n } from '../../smart-form/smartfileuploader/smartfileuploader.model';\n\n@Component({\n  selector: 'smart-file-uploader4sc',\n  templateUrl: './smart-file-uploader.component.html',\n  styleUrls: ['./smart-file-uploader.component.css'],\n})\nexport class SmartFileUploaderComponent implements OnChanges {\n  @Input() config?: SmartComponentFileUploader;\n  componentLibrary = ComponentLibrary;\n  i18n?: SmartFileUploaderI18n;\n  private uiActionModel?: UiActionModel;\n  uploadedFiles: any[] = [];\n  fileFormats?: string;\n  constructor(\n    private uiActionService: UiActionService,\n    private uiActionDescriptorService: UiActionDescriptorService,\n    @Inject(COMPONENT_LIBRARY) public compLib: ComponentLibrary\n  ) {}\n\n  ngOnChanges(changes: SimpleChanges): void {\n    this.config = changes['config'].currentValue;\n    if (this.config) {\n      this.setUp();\n    }\n  }\n\n  async setUp(): Promise<void> {\n    if (!this.config?.smartComponent?.uiActionModels?.length) {\n      return;\n    }\n    this.uiActionModel = this.config?.smartComponent.uiActionModels.find(\n      (uiActionModel: UiActionModel) => uiActionModel.uiAction.code === this.config?.uiActionCode\n    );\n\n    if (!this.uiActionModel) {\n      throw new Error(`UiAction with code ${this.config?.uiActionCode} could not found`);\n    }\n\n    const descriptor = await this.uiActionDescriptorService.getActionDescriptor(\n      this.uiActionModel.uiAction\n    );\n\n    this.i18n = {\n      addFile: descriptor.upload?.title ?? 'dokumentum hozzáadása',\n      browseOrDrag: descriptor.upload?.description ?? 'tallózás vagy behúzás',\n      formats: descriptor.upload?.formats ?? '',\n      maxSize: descriptor.upload?.maxSize ?? '',\n      upload: descriptor.upload?.uploadButtonTitle,\n    };\n  }\n\n  executeUpload(files: any[]): void {\n    this.uiActionModel!.uiAction.params = {\n      ...this.uiActionModel!.uiAction.params,\n      _files: files,\n      isMultiple: this.config?.isMultiple,\n      param: 'INPUT',\n    };\n\n    this.uiActionService.execute(this.uiActionModel!.uiAction, this.uiActionModel!);\n  }\n\n  onSelect(event: any) {\n    this.uploadedFiles = [];\n    for (let file of event.files) {\n      this.uploadedFiles.push(file);\n    }\n  }\n\n  onRemove(event: any): void {\n    this.uploadedFiles = [];\n  }\n\n  uploadFiles(event: any): void {\n    this.uiActionModel!.uiAction.params = {\n      ...this.uiActionModel!.uiAction.params,\n      _files: this.uploadedFiles,\n      isMultiple: this.config?.isMultiple,\n      param: 'INPUT',\n    };\n\n    this.uiActionService.execute(this.uiActionModel!.uiAction, this.uiActionModel!);\n  }\n}\n","@if (compLib === componentLibrary.PRIMENG) {\n  <p-fileUpload\n    name=\"files[]\"\n    url=\"\"\n    (onSend)=\"uploadFiles($event)\"\n    (onSelect)=\"onSelect($event)\"\n    (onRemove)=\"onRemove($event)\"\n    [multiple]=\"true\"\n    [accept]=\"config?.fileFormats?.join(',')\"\n    [maxFileSize]=\"config?.maxSizeMb\"\n    uploadLabel=\"Feltöltés\"\n    cancelLabel=\"Mégsem\"\n    chooseLabel=\"Választás\"\n  >\n    <ng-template pTemplate=\"content\"> </ng-template>\n  </p-fileUpload>\n} @else {\n  <smartfileuploader\n    *ngIf=\"i18n\"\n    [i18n]=\"i18n\"\n    [fileFormats]=\"config?.fileFormats\"\n    [isMultiple]=\"config?.isMultiple\"\n    [maxSizeMb]=\"config?.maxSizeMb\"\n    [uploadCallback]=\"executeUpload.bind(this)\"\n  ></smartfileuploader>\n}\n"]}

package/esm2022/lib/smart-client/smart.component.mjs

@@ -0,0 +1,88 @@
+import { Component, Inject, ViewChildren, } from '@angular/core';
+import { SmartComponentLayoutComponent } from '../smart-component-layout/projects';
+import { SmartFilterEditorContentComponent } from '../smart-filter-editor/project';
+import { SmartformComponent } from '../smart-form/projects';
+import { SmartGridComponent } from '../smart-grid/projects';
+import { SmartMapComponent } from '../smart-map/smart-map.component';
+import { SmartTreeComponent } from '../smart-tree/projects';
+import { UiActionToolbarComponent } from '../view-context/projects';
+import { SmartComponentApiClient } from './smart-component-api-client';
+import { SmartDiagramComponent } from '../smart-diagram/projects';
+import * as i0 from "@angular/core";
+export class SmartComponent extends SmartComponentApiClient {
+    constructor(inject, pageName, _componentName, element, renderer) {
+        super(inject, pageName, _componentName, element, renderer);
+    }
+    ngOnInit() {
+        this._ngOnInit();
+    }
+    ngOnDestroy() {
+        this._ngOnDestroy();
+    }
+    ngAfterViewInit() {
+        this._ngAfterViewInit();
+    }
+    getSmartFormsQL() {
+        return this.smartFormsQL;
+    }
+    getSmartGridsQL() {
+        return this.smartGridsQL;
+    }
+    getSmartTreesQL() {
+        return this.smartTreesQL;
+    }
+    getSmartComponentLayoutsQL() {
+        return this.smartComponentLayoutsQL;
+    }
+    getSmartFilterEditorContentComponentsQL() {
+        return this.smartFilterEditorContentComponentsQL;
+    }
+    getSmartUiActionToolbarsQL() {
+        return this.smartUiActionToolbarsQL;
+    }
+    getSmartMapQL() {
+        return this.smartMapQL;
+    }
+    getSmartDiagramQL() {
+        return this.smartDiagramQL;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartComponent, deps: [{ token: i0.Injector }, { token: 'pageName' }, { token: 'componentName' }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", type: SmartComponent, selector: "ng-component", viewQueries: [{ propertyName: "smartFormsQL", predicate: SmartformComponent, descendants: true }, { propertyName: "smartGridsQL", predicate: SmartGridComponent, descendants: true }, { propertyName: "smartTreesQL", predicate: SmartTreeComponent, descendants: true }, { propertyName: "smartComponentLayoutsQL", predicate: SmartComponentLayoutComponent, descendants: true }, { propertyName: "smartFilterEditorContentComponentsQL", predicate: SmartFilterEditorContentComponent, descendants: true }, { propertyName: "smartUiActionToolbarsQL", predicate: UiActionToolbarComponent, descendants: true }, { propertyName: "smartMapQL", predicate: SmartMapComponent, descendants: true }, { propertyName: "smartDiagramQL", predicate: SmartDiagramComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['pageName']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['componentName']
+                }] }, { type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { smartFormsQL: [{
+                type: ViewChildren,
+                args: [SmartformComponent]
+            }], smartGridsQL: [{
+                type: ViewChildren,
+                args: [SmartGridComponent]
+            }], smartTreesQL: [{
+                type: ViewChildren,
+                args: [SmartTreeComponent]
+            }], smartComponentLayoutsQL: [{
+                type: ViewChildren,
+                args: [SmartComponentLayoutComponent]
+            }], smartFilterEditorContentComponentsQL: [{
+                type: ViewChildren,
+                args: [SmartFilterEditorContentComponent]
+            }], smartUiActionToolbarsQL: [{
+                type: ViewChildren,
+                args: [UiActionToolbarComponent]
+            }], smartMapQL: [{
+                type: ViewChildren,
+                args: [SmartMapComponent]
+            }], smartDiagramQL: [{
+                type: ViewChildren,
+                args: [SmartDiagramComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/smart-client/smart.service.mjs

@@ -0,0 +1,71 @@
+import { Inject, Injectable, ViewChildren, } from '@angular/core';
+import { SmartComponentApiClient } from './smart-component-api-client';
+import { SmartformComponent } from '../smart-form/projects';
+import { SmartGridComponent } from '../smart-grid/projects';
+import { SmartTreeComponent } from '../smart-tree/projects';
+import { SmartComponentLayoutComponent } from '../smart-component-layout/projects';
+import { SmartFilterEditorContentComponent, } from '../smart-filter-editor/project';
+import { UiActionToolbarComponent } from '../view-context/projects';
+import * as i0 from "@angular/core";
+export class SmartService extends SmartComponentApiClient {
+    constructor(inject, pageName) {
+        super(inject, pageName);
+    }
+    ngOnInit() {
+        this._ngOnInit();
+    }
+    ngOnDestroy() {
+        this._ngOnDestroy();
+    }
+    ngAfterViewInit() {
+        this._ngAfterViewInit();
+    }
+    getSmartFormsQL() {
+        return this.smartFormsQL;
+    }
+    getSmartGridsQL() {
+        return this.smartGridsQL;
+    }
+    getSmartTreesQL() {
+        return this.smartTreesQL;
+    }
+    getSmartComponentLayoutsQL() {
+        return this.smartComponentLayoutsQL;
+    }
+    getSmartFilterEditorContentComponentsQL() {
+        return this.smartFilterEditorContentComponentsQL;
+    }
+    getSmartUiActionToolbarsQL() {
+        return this.smartUiActionToolbarsQL;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartService, deps: [{ token: i0.Injector }, { token: 'pageName' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['pageName']
+                }] }], propDecorators: { smartFormsQL: [{
+                type: ViewChildren,
+                args: [SmartformComponent]
+            }], smartGridsQL: [{
+                type: ViewChildren,
+                args: [SmartGridComponent]
+            }], smartTreesQL: [{
+                type: ViewChildren,
+                args: [SmartTreeComponent]
+            }], smartComponentLayoutsQL: [{
+                type: ViewChildren,
+                args: [SmartComponentLayoutComponent]
+            }], smartFilterEditorContentComponentsQL: [{
+                type: ViewChildren,
+                args: [SmartFilterEditorContentComponent]
+            }], smartUiActionToolbarsQL: [{
+                type: ViewChildren,
+                args: [UiActionToolbarComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/smart-component-layout/api/api/api.mjs

@@ -0,0 +1,4 @@
+export * from './default.service';
+import { DefaultService } from './default.service';
+export const APIS = [DefaultService];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtbmctY2xpZW50L3NyYy9saWIvc21hcnQtY29tcG9uZW50LWxheW91dC9hcGkvYXBpL2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGVmYXVsdC5zZXJ2aWNlJztcbmltcG9ydCB7IERlZmF1bHRTZXJ2aWNlIH0gZnJvbSAnLi9kZWZhdWx0LnNlcnZpY2UnO1xuZXhwb3J0IGNvbnN0IEFQSVMgPSBbRGVmYXVsdFNlcnZpY2VdO1xuIl19

package/esm2022/lib/smart-component-layout/api/api/default.service.mjs

@@ -0,0 +1,133 @@
+/**
+ * Form layout definition
+ * Contains form layout definition objects.
+ *
+ * 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.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders, HttpContext } from '@angular/common/http';
+import { CustomHttpParameterCodec } from '../encoder';
+// @ts-ignore
+import { BASE_PATH } from '../variables';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../configuration";
+export class DefaultService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = 'http://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (configuration) {
+            this.configuration = configuration;
+        }
+        if (typeof this.configuration.basePath !== 'string') {
+            if (Array.isArray(basePath) && basePath.length > 0) {
+                basePath = basePath[0];
+            }
+            if (typeof basePath !== 'string') {
+                basePath = this.basePath;
+            }
+            this.configuration.basePath = basePath;
+        }
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+    }
+    // @ts-ignore
+    addToHttpParams(httpParams, value, key) {
+        if (typeof value === "object" && value instanceof Date === false) {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value);
+        }
+        else {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value, key);
+        }
+        return httpParams;
+    }
+    addToHttpParamsRecursive(httpParams, value, key) {
+        if (value == null) {
+            return httpParams;
+        }
+        if (typeof value === "object") {
+            if (Array.isArray(value)) {
+                value.forEach(elem => httpParams = this.addToHttpParamsRecursive(httpParams, elem, key));
+            }
+            else if (value instanceof Date) {
+                if (key != null) {
+                    httpParams = httpParams.append(key, value.toISOString().substr(0, 10));
+                }
+                else {
+                    throw Error("key may not be null if value is Date");
+                }
+            }
+            else {
+                Object.keys(value).forEach(k => httpParams = this.addToHttpParamsRecursive(httpParams, value[k], key != null ? `${key}.${k}` : k));
+            }
+        }
+        else if (key != null) {
+            httpParams = httpParams.append(key, value);
+        }
+        else {
+            throw Error("key may not be null if value is not object or array");
+        }
+        return httpParams;
+    }
+    nopePost(observe = 'body', reportProgress = false, options) {
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/nope`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: DefaultService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: DefaultService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: DefaultService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_PATH]
+                }] }, { type: i2.Configuration, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default.service.js","sourceRoot":"","sources":["../../../../../../../projects/smart-ng-client/src/lib/smart-component-layout/api/api/default.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Form layout definition\n * Contains form layout definition objects.\n *\n * The version of the OpenAPI document: 1.0.0\n * Contact: info@it4all.hu\n *\n * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).\n * https://openapi-generator.tech\n * Do not edit the class manually.\n */\n/* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext \n        }       from '@angular/common/http';\nimport { CustomHttpParameterCodec }                          from '../encoder';\nimport { Observable }                                        from 'rxjs';\n\n\n// @ts-ignore\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefaultService {\n\n    protected basePath = 'http://localhost';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n    public encoder: HttpParameterCodec;\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string|string[], @Optional() configuration: Configuration) {\n        if (configuration) {\n            this.configuration = configuration;\n        }\n        if (typeof this.configuration.basePath !== 'string') {\n            if (Array.isArray(basePath) && basePath.length > 0) {\n                basePath = basePath[0];\n            }\n\n            if (typeof basePath !== 'string') {\n                basePath = this.basePath;\n            }\n            this.configuration.basePath = basePath;\n        }\n        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();\n    }\n\n\n    // @ts-ignore\n    private addToHttpParams(httpParams: HttpParams, value: any, key?: string): HttpParams {\n        if (typeof value === \"object\" && value instanceof Date === false) {\n            httpParams = this.addToHttpParamsRecursive(httpParams, value);\n        } else {\n            httpParams = this.addToHttpParamsRecursive(httpParams, value, key);\n        }\n        return httpParams;\n    }\n\n    private addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string): HttpParams {\n        if (value == null) {\n            return httpParams;\n        }\n\n        if (typeof value === \"object\") {\n            if (Array.isArray(value)) {\n                (value as any[]).forEach( elem => httpParams = this.addToHttpParamsRecursive(httpParams, elem, key));\n            } else if (value instanceof Date) {\n                if (key != null) {\n                    httpParams = httpParams.append(key, (value as Date).toISOString().substr(0, 10));\n                } else {\n                   throw Error(\"key may not be null if value is Date\");\n                }\n            } else {\n                Object.keys(value).forEach( k => httpParams = this.addToHttpParamsRecursive(\n                    httpParams, value[k], key != null ? `${key}.${k}` : k));\n            }\n        } else if (key != null) {\n            httpParams = httpParams.append(key, value);\n        } else {\n            throw Error(\"key may not be null if value is not object or array\");\n        }\n        return httpParams;\n    }\n\n    /**\n     * Placeholder for generation\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public nopePost(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext}): Observable<any>;\n    public nopePost(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext}): Observable<HttpResponse<any>>;\n    public nopePost(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: undefined, context?: HttpContext}): Observable<HttpEvent<any>>;\n    public nopePost(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: undefined, context?: HttpContext}): Observable<any> {\n\n        let localVarHeaders = this.defaultHeaders;\n\n        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\n        if (localVarHttpHeaderAcceptSelected === undefined) {\n            // to determine the Accept header\n            const httpHeaderAccepts: string[] = [\n            ];\n            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        }\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        let localVarHttpContext: HttpContext | undefined = options && options.context;\n        if (localVarHttpContext === undefined) {\n            localVarHttpContext = new HttpContext();\n        }\n\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        let localVarPath = `/nope`;\n        return this.httpClient.request<any>('post', `${this.configuration.basePath}${localVarPath}`,\n            {\n                context: localVarHttpContext,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}

package/esm2022/lib/smart-component-layout/api/api.module.mjs

@@ -0,0 +1,40 @@
+import { NgModule, SkipSelf, Optional } from '@angular/core';
+import { Configuration } from './configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiModule {
+    static forRoot(configurationFactory) {
+        return {
+            ngModule: ApiModule,
+            providers: [{ provide: Configuration, useFactory: configurationFactory }]
+        };
+    }
+    constructor(parentModule, http) {
+        if (parentModule) {
+            throw new Error('ApiModule is already loaded. Import in your base AppModule only.');
+        }
+        if (!http) {
+            throw new Error('You need to import the HttpClientModule in your AppModule! \n' +
+                'See also https://github.com/angular/angular/issues/20575');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ApiModule, deps: [{ token: ApiModule, optional: true, skipSelf: true }, { token: i1.HttpClient, optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.11", ngImport: i0, type: ApiModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ApiModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ApiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [],
+                    exports: [],
+                    providers: []
+                }]
+        }], ctorParameters: () => [{ type: ApiModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.HttpClient, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/smart-component-layout/api/configuration.mjs

@@ -0,0 +1,91 @@
+export class Configuration {
+    constructor(configurationParameters = {}) {
+        this.apiKeys = configurationParameters.apiKeys;
+        this.username = configurationParameters.username;
+        this.password = configurationParameters.password;
+        this.accessToken = configurationParameters.accessToken;
+        this.basePath = configurationParameters.basePath;
+        this.withCredentials = configurationParameters.withCredentials;
+        this.encoder = configurationParameters.encoder;
+        if (configurationParameters.encodeParam) {
+            this.encodeParam = configurationParameters.encodeParam;
+        }
+        else {
+            this.encodeParam = param => this.defaultEncodeParam(param);
+        }
+        if (configurationParameters.credentials) {
+            this.credentials = configurationParameters.credentials;
+        }
+        else {
+            this.credentials = {};
+        }
+    }
+    /**
+     * 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) {
+        if (contentTypes.length === 0) {
+            return undefined;
+        }
+        const type = contentTypes.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return contentTypes[0];
+        }
+        return type;
+    }
+    /**
+     * 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) {
+        if (accepts.length === 0) {
+            return undefined;
+        }
+        const type = accepts.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return accepts[0];
+        }
+        return type;
+    }
+    /**
+     * 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) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+    lookupCredential(key) {
+        const value = this.credentials[key];
+        return typeof value === 'function'
+            ? value()
+            : value;
+    }
+    defaultEncodeParam(param) {
+        // This implementation exists as fallback for missing configuration
+        // and for backwards compatibility to older typescript-angular generator versions.
+        // It only works for the 'simple' parameter style.
+        // Date-handling only works for the 'date-time' format.
+        // All other styles and Date-formats are probably handled incorrectly.
+        //
+        // But: if that's all you need (i.e.: the most common use-case): no need for customization!
+        const value = param.dataFormat === 'date-time' && param.value instanceof Date
+            ? param.value.toISOString()
+            : param.value;
+        return encodeURIComponent(String(value));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/smart-component-layout/api/configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParameterCodec } from '@angular/common/http';\nimport { Param } from './param';\n\nexport interface ConfigurationParameters {\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n    /**\n     * Takes care of encoding query- and form-parameters.\n     */\n    encoder?: HttpParameterCodec;\n    /**\n     * Override the default method for encoding path parameters in various\n     * <a href=\"https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values\">styles</a>.\n     * <p>\n     * See {@link README.md} for more details\n     * </p>\n     */\n    encodeParam?: (param: Param) => string;\n    /**\n     * The keys are the names in the securitySchemes section of the OpenAPI\n     * document. They should map to the value used for authentication\n     * minus any standard prefixes such as 'Basic' or 'Bearer'.\n     */\n    credentials?: {[ key: string ]: string | (() => string | undefined)};\n}\n\nexport class Configuration {\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n    /**\n     * Takes care of encoding query- and form-parameters.\n     */\n    encoder?: HttpParameterCodec;\n    /**\n     * Encoding of various path parameter\n     * <a href=\"https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values\">styles</a>.\n     * <p>\n     * See {@link README.md} for more details\n     * </p>\n     */\n    encodeParam: (param: Param) => string;\n    /**\n     * The keys are the names in the securitySchemes section of the OpenAPI\n     * document. They should map to the value used for authentication\n     * minus any standard prefixes such as 'Basic' or 'Bearer'.\n     */\n    credentials: {[ key: string ]: string | (() => string | undefined)};\n\n    constructor(configurationParameters: ConfigurationParameters = {}) {\n        this.apiKeys = configurationParameters.apiKeys;\n        this.username = configurationParameters.username;\n        this.password = configurationParameters.password;\n        this.accessToken = configurationParameters.accessToken;\n        this.basePath = configurationParameters.basePath;\n        this.withCredentials = configurationParameters.withCredentials;\n        this.encoder = configurationParameters.encoder;\n        if (configurationParameters.encodeParam) {\n            this.encodeParam = configurationParameters.encodeParam;\n        }\n        else {\n            this.encodeParam = param => this.defaultEncodeParam(param);\n        }\n        if (configurationParameters.credentials) {\n            this.credentials = configurationParameters.credentials;\n        }\n        else {\n            this.credentials = {};\n        }\n    }\n\n    /**\n     * Select the correct content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param contentTypes - the array of content types that are available for selection\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderContentType (contentTypes: string[]): string | undefined {\n        if (contentTypes.length === 0) {\n            return undefined;\n        }\n\n        const type = contentTypes.find((x: string) => this.isJsonMime(x));\n        if (type === undefined) {\n            return contentTypes[0];\n        }\n        return type;\n    }\n\n    /**\n     * Select the correct accept content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param accepts - the array of content types that are available for selection.\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderAccept(accepts: string[]): string | undefined {\n        if (accepts.length === 0) {\n            return undefined;\n        }\n\n        const type = accepts.find((x: string) => this.isJsonMime(x));\n        if (type === undefined) {\n            return accepts[0];\n        }\n        return type;\n    }\n\n    /**\n     * Check if the given MIME is a JSON MIME.\n     * JSON MIME examples:\n     *   application/json\n     *   application/json; charset=UTF8\n     *   APPLICATION/JSON\n     *   application/vnd.company+json\n     * @param mime - MIME (Multipurpose Internet Mail Extensions)\n     * @return True if the given MIME is JSON, false otherwise.\n     */\n    public isJsonMime(mime: string): boolean {\n        const jsonMime: RegExp = new RegExp('^(application\\/json|[^;/ \\t]+\\/[^;/ \\t]+[+]json)[ \\t]*(;.*)?$', 'i');\n        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');\n    }\n\n    public lookupCredential(key: string): string | undefined {\n        const value = this.credentials[key];\n        return typeof value === 'function'\n            ? value()\n            : value;\n    }\n\n    private defaultEncodeParam(param: Param): string {\n        // This implementation exists as fallback for missing configuration\n        // and for backwards compatibility to older typescript-angular generator versions.\n        // It only works for the 'simple' parameter style.\n        // Date-handling only works for the 'date-time' format.\n        // All other styles and Date-formats are probably handled incorrectly.\n        //\n        // But: if that's all you need (i.e.: the most common use-case): no need for customization!\n\n        const value = param.dataFormat === 'date-time' && param.value instanceof Date\n            ? (param.value as Date).toISOString()\n            : param.value;\n\n        return encodeURIComponent(String(value));\n    }\n}\n"]}

package/esm2022/lib/smart-component-layout/api/encoder.mjs

@@ -0,0 +1,19 @@
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export class CustomHttpParameterCodec {
+    encodeKey(k) {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v) {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k) {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v) {
+        return decodeURIComponent(v);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LW5nLWNsaWVudC9zcmMvbGliL3NtYXJ0LWNvbXBvbmVudC1sYXlvdXQvYXBpL2VuY29kZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLHdCQUF3QjtJQUNqQyxTQUFTLENBQUMsQ0FBUztRQUNmLE9BQU8sa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUNELFdBQVcsQ0FBQyxDQUFTO1FBQ2pCLE9BQU8sa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUNELFNBQVMsQ0FBQyxDQUFTO1FBQ2YsT0FBTyxrQkFBa0IsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsV0FBVyxDQUFDLENBQVM7UUFDakIsT0FBTyxrQkFBa0IsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwUGFyYW1ldGVyQ29kZWMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5cbi8qKlxuICogQ3VzdG9tIEh0dHBQYXJhbWV0ZXJDb2RlY1xuICogV29ya2Fyb3VuZCBmb3IgaHR0cHM6Ly9naXRodWIuY29tL2FuZ3VsYXIvYW5ndWxhci9pc3N1ZXMvMTgyNjFcbiAqL1xuZXhwb3J0IGNsYXNzIEN1c3RvbUh0dHBQYXJhbWV0ZXJDb2RlYyBpbXBsZW1lbnRzIEh0dHBQYXJhbWV0ZXJDb2RlYyB7XG4gICAgZW5jb2RlS2V5KGs6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBlbmNvZGVVUklDb21wb25lbnQoayk7XG4gICAgfVxuICAgIGVuY29kZVZhbHVlKHY6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBlbmNvZGVVUklDb21wb25lbnQodik7XG4gICAgfVxuICAgIGRlY29kZUtleShrOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gZGVjb2RlVVJJQ29tcG9uZW50KGspO1xuICAgIH1cbiAgICBkZWNvZGVWYWx1ZSh2OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gZGVjb2RlVVJJQ29tcG9uZW50KHYpO1xuICAgIH1cbn1cbiJdfQ==