@smartbit4all/ng-client 2.2.2 → 3.0.0

package/esm2020/lib/smart-form/widgets/smartformwidget/sortable-widget/sortable-widget.component.mjs

@@ -0,0 +1,59 @@
+import { moveItemInArray } from "@angular/cdk/drag-drop";
+import { Component, Input, forwardRef, } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../smart-icon/smart-icon/smart-icon.component";
+import * as i2 from "@angular/cdk/drag-drop";
+import * as i3 from "@angular/common";
+export class SortableWidgetComponent {
+    constructor() {
+        // ControlValueAccessor interface methods
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.isDisabled = false;
+    }
+    ngOnChanges(changes) {
+        if (changes["widgetInstance"] &&
+            !changes["widgetInstance"].isFirstChange()) {
+            this.onChange(this.widgetInstance.valueList);
+        }
+    }
+    onDrop(event) {
+        moveItemInArray(this.widgetInstance.valueList, event.previousIndex, event.currentIndex);
+        this.onChange(this.widgetInstance.valueList);
+    }
+    // ControlValueAccessor methods
+    writeValue(value) {
+        this.widgetInstance.valueList = value || [];
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+}
+SortableWidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SortableWidgetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SortableWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: SortableWidgetComponent, selector: "lib-sortable-widget", inputs: { widgetInstance: "widgetInstance" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => SortableWidgetComponent),
+            multi: true,
+        },
+    ], usesOnChanges: true, ngImport: i0, template: "<div cdkDropList (cdkDropListDropped)=\"onDrop($event)\" class=\"dropList\">\r\n  <div\r\n    cdkDrag\r\n    [cdkDragDisabled]=\"isDisabled\"\r\n    *ngFor=\"let item of widgetInstance.valueList!; let i = index\"\r\n    class=\"draggableItem\"\r\n  >\r\n    <smart-icon\r\n      class=\"cdkDragHandle\"\r\n      cdkDragHandle\r\n      color=\"drag-indicator\"\r\n      icon=\"drag_indicator\"\r\n    ></smart-icon>\r\n    <div class=\"indexCircle\">\r\n      {{ i + 1 }}\r\n    </div>\r\n    <span class=\"valueLabel\"> {{ item }} </span>\r\n  </div>\r\n</div>\r\n", styles: [".dropList{display:flex;flex-direction:column;gap:.25rem}.draggableItem{display:flex;flex-direction:row;gap:.5rem;background-color:#f1f1f1;border-radius:.5rem;padding:.75rem 1rem}.draggableItem .indexCircle{margin:auto 0;padding:.25rem .5rem;border-radius:100%;background-color:#3b3b3b;color:#f1f1f1}.draggableItem .valueLabel{margin:auto 0}.cdkDragHandle{cursor:move}\n"], components: [{ type: i1.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }], directives: [{ type: i2.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { type: i2.CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SortableWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "lib-sortable-widget", providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => SortableWidgetComponent),
+                            multi: true,
+                        },
+                    ], template: "<div cdkDropList (cdkDropListDropped)=\"onDrop($event)\" class=\"dropList\">\r\n  <div\r\n    cdkDrag\r\n    [cdkDragDisabled]=\"isDisabled\"\r\n    *ngFor=\"let item of widgetInstance.valueList!; let i = index\"\r\n    class=\"draggableItem\"\r\n  >\r\n    <smart-icon\r\n      class=\"cdkDragHandle\"\r\n      cdkDragHandle\r\n      color=\"drag-indicator\"\r\n      icon=\"drag_indicator\"\r\n    ></smart-icon>\r\n    <div class=\"indexCircle\">\r\n      {{ i + 1 }}\r\n    </div>\r\n    <span class=\"valueLabel\"> {{ item }} </span>\r\n  </div>\r\n</div>\r\n", styles: [".dropList{display:flex;flex-direction:column;gap:.25rem}.draggableItem{display:flex;flex-direction:row;gap:.5rem;background-color:#f1f1f1;border-radius:.5rem;padding:.75rem 1rem}.draggableItem .indexCircle{margin:auto 0;padding:.25rem .5rem;border-radius:100%;background-color:#3b3b3b;color:#f1f1f1}.draggableItem .valueLabel{margin:auto 0}.cdkDragHandle{cursor:move}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { widgetInstance: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/smart-form/widgets/smartformwidget/trackCaps.directive.mjs

@@ -0,0 +1,31 @@
+import { Directive, EventEmitter, HostListener, Output } from "@angular/core";
+import * as i0 from "@angular/core";
+export class TrackCapsDirective {
+    constructor() {
+        this.capsLock = new EventEmitter();
+    }
+    onKeyDown(event) {
+        const capsOn = event.getModifierState && event.getModifierState("CapsLock");
+        this.capsLock.emit(capsOn);
+    }
+    onKeyUp(event) {
+        const capsOn = event.getModifierState && event.getModifierState("CapsLock");
+        this.capsLock.emit(capsOn);
+    }
+}
+TrackCapsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TrackCapsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+TrackCapsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.4.0", type: TrackCapsDirective, selector: "[capsLock]", outputs: { capsLock: "capsLock" }, host: { listeners: { "window:keydown": "onKeyDown($event)", "window:keyup": "onKeyUp($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TrackCapsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: "[capsLock]" }]
+        }], propDecorators: { capsLock: [{
+                type: Output,
+                args: ["capsLock"]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ["window:keydown", ["$event"]]
+            }], onKeyUp: [{
+                type: HostListener,
+                args: ["window:keyup", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/smart-grid/api/grid-api/api/api.mjs

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

package/esm2020/lib/smart-grid/api/grid-api/api/grid.service.mjs

@@ -0,0 +1,372 @@
+/**
+ * Grid api
+ * The grid api is resposible for the grid components that shows a list of item.
+ *
+ * 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 GridService {
+    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 (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;
+    }
+    expand(uuid, gridId, rowId, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling expand.');
+        }
+        if (gridId === null || gridId === undefined) {
+            throw new Error('Required parameter gridId was null or undefined when calling expand.');
+        }
+        if (rowId === null || rowId === undefined) {
+            throw new Error('Required parameter rowId was null or undefined when calling expand.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            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';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(String(gridId))}/${encodeURIComponent(String(rowId))}/expand`, null, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    load(uuid, gridIdentifier, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling load.');
+        }
+        if (gridIdentifier === null || gridIdentifier === undefined) {
+            throw new Error('Required parameter gridIdentifier was null or undefined when calling load.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            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';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(String(gridIdentifier))}/load`, null, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    select(uuid, gridId, rowId, selected, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling select.');
+        }
+        if (gridId === null || gridId === undefined) {
+            throw new Error('Required parameter gridId was null or undefined when calling select.');
+        }
+        if (rowId === null || rowId === undefined) {
+            throw new Error('Required parameter rowId was null or undefined when calling select.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        if (selected !== undefined && selected !== null) {
+            localVarHeaders = localVarHeaders.set('selected', String(selected));
+        }
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            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';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(String(gridId))}/${encodeURIComponent(String(rowId))}/select`, null, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    selectAll(uuid, gridId, selected, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling selectAll.');
+        }
+        if (gridId === null || gridId === undefined) {
+            throw new Error('Required parameter gridId was null or undefined when calling selectAll.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        if (selected !== undefined && selected !== null) {
+            localVarHeaders = localVarHeaders.set('selected', String(selected));
+        }
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            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';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(String(gridId))}/select`, null, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    setPage(uuid, gridIdentifier, offset, limit, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling setPage.');
+        }
+        if (gridIdentifier === null || gridIdentifier === undefined) {
+            throw new Error('Required parameter gridIdentifier was null or undefined when calling setPage.');
+        }
+        if (offset === null || offset === undefined) {
+            throw new Error('Required parameter offset was null or undefined when calling setPage.');
+        }
+        if (limit === null || limit === undefined) {
+            throw new Error('Required parameter limit was null or undefined when calling setPage.');
+        }
+        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';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(String(gridIdentifier))}/page/${encodeURIComponent(String(offset))}/${encodeURIComponent(String(limit))}`, null, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    update(uuid, gridIdentifier, gridUpdateData, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling update.');
+        }
+        if (gridIdentifier === null || gridIdentifier === undefined) {
+            throw new Error('Required parameter gridIdentifier was null or undefined when calling update.');
+        }
+        if (gridUpdateData === null || gridUpdateData === undefined) {
+            throw new Error('Required parameter gridUpdateData was null or undefined when calling update.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        // to determine the Content-Type header
+        const consumes = ['application/json'];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(String(gridIdentifier))}/update`, gridUpdateData, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+}
+GridService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: GridService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+GridService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: GridService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: GridService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ 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":"grid.service.js","sourceRoot":"","sources":["../../../../../../../../projects/smart-ng-client/src/lib/smart-grid/api/grid-api/api/grid.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Grid api\r\n * The grid api is resposible for the grid components that shows a list of item.\r\n *\r\n * The version of the OpenAPI document: 1.0.0\r\n * Contact: info@it4all.hu\r\n *\r\n * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).\r\n * https://openapi-generator.tech\r\n * Do not edit the class manually.\r\n */\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional } from '@angular/core';\r\nimport {\r\n  HttpClient,\r\n  HttpHeaders,\r\n  HttpParams,\r\n  HttpResponse,\r\n  HttpEvent,\r\n  HttpParameterCodec,\r\n  HttpContext,\r\n} from '@angular/common/http';\r\nimport { CustomHttpParameterCodec } from '../encoder';\r\nimport { Observable } from 'rxjs';\r\n\r\n// @ts-ignore\r\nimport { GridModel } from '../model/gridModel';\r\n// @ts-ignore\r\nimport { GridUpdateData } from '../model/gridUpdateData';\r\n// @ts-ignore\r\nimport { ViewContextChange } from '../../../../view-context/api/model/viewContextChange';\r\n\r\n// @ts-ignore\r\nimport { BASE_PATH, COLLECTION_FORMATS } from '../variables';\r\nimport { Configuration } from '../configuration';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class GridService {\r\n  protected basePath = 'http://localhost';\r\n  public defaultHeaders = new HttpHeaders();\r\n  public configuration = new Configuration();\r\n  public encoder: HttpParameterCodec;\r\n\r\n  constructor(\r\n    protected httpClient: HttpClient,\r\n    @Optional() @Inject(BASE_PATH) basePath: string,\r\n    @Optional() configuration: Configuration\r\n  ) {\r\n    if (configuration) {\r\n      this.configuration = configuration;\r\n    }\r\n    if (typeof this.configuration.basePath !== 'string') {\r\n      if (typeof basePath !== 'string') {\r\n        basePath = this.basePath;\r\n      }\r\n      this.configuration.basePath = basePath;\r\n    }\r\n    this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();\r\n  }\r\n\r\n  // @ts-ignore\r\n  private addToHttpParams(httpParams: HttpParams, value: any, key?: string): HttpParams {\r\n    if (typeof value === 'object' && value instanceof Date === false) {\r\n      httpParams = this.addToHttpParamsRecursive(httpParams, value);\r\n    } else {\r\n      httpParams = this.addToHttpParamsRecursive(httpParams, value, key);\r\n    }\r\n    return httpParams;\r\n  }\r\n\r\n  private addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string): HttpParams {\r\n    if (value == null) {\r\n      return httpParams;\r\n    }\r\n\r\n    if (typeof value === 'object') {\r\n      if (Array.isArray(value)) {\r\n        (value as any[]).forEach(\r\n          (elem) => (httpParams = this.addToHttpParamsRecursive(httpParams, elem, key))\r\n        );\r\n      } else if (value instanceof Date) {\r\n        if (key != null) {\r\n          httpParams = httpParams.append(key, (value as Date).toISOString().substr(0, 10));\r\n        } else {\r\n          throw Error('key may not be null if value is Date');\r\n        }\r\n      } else {\r\n        Object.keys(value).forEach(\r\n          (k) =>\r\n            (httpParams = this.addToHttpParamsRecursive(\r\n              httpParams,\r\n              value[k],\r\n              key != null ? `${key}.${k}` : k\r\n            ))\r\n        );\r\n      }\r\n    } else if (key != null) {\r\n      httpParams = httpParams.append(key, value);\r\n    } else {\r\n      throw Error('key may not be null if value is not object or array');\r\n    }\r\n    return httpParams;\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param uuid\r\n   * @param gridId\r\n   * @param rowId\r\n   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n   * @param reportProgress flag to report request and response progress.\r\n   */\r\n  public expand(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    observe?: 'body',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<object>;\r\n  public expand(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    observe?: 'response',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpResponse<object>>;\r\n  public expand(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    observe?: 'events',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpEvent<object>>;\r\n  public expand(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    observe: any = 'body',\r\n    reportProgress: boolean = false,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<any> {\r\n    if (uuid === null || uuid === undefined) {\r\n      throw new Error('Required parameter uuid was null or undefined when calling expand.');\r\n    }\r\n    if (gridId === null || gridId === undefined) {\r\n      throw new Error('Required parameter gridId was null or undefined when calling expand.');\r\n    }\r\n    if (rowId === null || rowId === undefined) {\r\n      throw new Error('Required parameter rowId was null or undefined when calling expand.');\r\n    }\r\n\r\n    let localVarHeaders = this.defaultHeaders;\r\n\r\n    let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\r\n    if (localVarHttpHeaderAcceptSelected === undefined) {\r\n      // to determine the Accept header\r\n      const httpHeaderAccepts: string[] = ['application/json'];\r\n      localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n    }\r\n    if (localVarHttpHeaderAcceptSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\r\n    }\r\n\r\n    let localVarHttpContext: HttpContext | undefined = options && options.context;\r\n    if (localVarHttpContext === undefined) {\r\n      localVarHttpContext = new HttpContext();\r\n    }\r\n\r\n    let responseType_: 'text' | 'json' | 'blob' = 'json';\r\n    if (localVarHttpHeaderAcceptSelected) {\r\n      if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\r\n        responseType_ = 'text';\r\n      } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\r\n        responseType_ = 'json';\r\n      } else {\r\n        responseType_ = 'blob';\r\n      }\r\n    }\r\n\r\n    return this.httpClient.post<object>(\r\n      `${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(\r\n        String(gridId)\r\n      )}/${encodeURIComponent(String(rowId))}/expand`,\r\n      null,\r\n      {\r\n        context: localVarHttpContext,\r\n        responseType: <any>responseType_,\r\n        withCredentials: this.configuration.withCredentials,\r\n        headers: localVarHeaders,\r\n        observe: observe,\r\n        reportProgress: reportProgress,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param uuid\r\n   * @param gridIdentifier\r\n   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n   * @param reportProgress flag to report request and response progress.\r\n   */\r\n  public load(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    observe?: 'body',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<GridModel>;\r\n  public load(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    observe?: 'response',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpResponse<GridModel>>;\r\n  public load(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    observe?: 'events',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpEvent<GridModel>>;\r\n  public load(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    observe: any = 'body',\r\n    reportProgress: boolean = false,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<any> {\r\n    if (uuid === null || uuid === undefined) {\r\n      throw new Error('Required parameter uuid was null or undefined when calling load.');\r\n    }\r\n    if (gridIdentifier === null || gridIdentifier === undefined) {\r\n      throw new Error('Required parameter gridIdentifier was null or undefined when calling load.');\r\n    }\r\n\r\n    let localVarHeaders = this.defaultHeaders;\r\n\r\n    let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\r\n    if (localVarHttpHeaderAcceptSelected === undefined) {\r\n      // to determine the Accept header\r\n      const httpHeaderAccepts: string[] = ['application/json'];\r\n      localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n    }\r\n    if (localVarHttpHeaderAcceptSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\r\n    }\r\n\r\n    let localVarHttpContext: HttpContext | undefined = options && options.context;\r\n    if (localVarHttpContext === undefined) {\r\n      localVarHttpContext = new HttpContext();\r\n    }\r\n\r\n    let responseType_: 'text' | 'json' | 'blob' = 'json';\r\n    if (localVarHttpHeaderAcceptSelected) {\r\n      if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\r\n        responseType_ = 'text';\r\n      } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\r\n        responseType_ = 'json';\r\n      } else {\r\n        responseType_ = 'blob';\r\n      }\r\n    }\r\n\r\n    return this.httpClient.post<GridModel>(\r\n      `${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(\r\n        String(gridIdentifier)\r\n      )}/load`,\r\n      null,\r\n      {\r\n        context: localVarHttpContext,\r\n        responseType: <any>responseType_,\r\n        withCredentials: this.configuration.withCredentials,\r\n        headers: localVarHeaders,\r\n        observe: observe,\r\n        reportProgress: reportProgress,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param uuid\r\n   * @param gridId\r\n   * @param rowId\r\n   * @param selected\r\n   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n   * @param reportProgress flag to report request and response progress.\r\n   */\r\n  public select(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    selected?: boolean,\r\n    observe?: 'body',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<ViewContextChange>;\r\n  public select(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    selected?: boolean,\r\n    observe?: 'response',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpResponse<ViewContextChange>>;\r\n  public select(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    selected?: boolean,\r\n    observe?: 'events',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpEvent<ViewContextChange>>;\r\n  public select(\r\n    uuid: string,\r\n    gridId: string,\r\n    rowId: string,\r\n    selected?: boolean,\r\n    observe: any = 'body',\r\n    reportProgress: boolean = false,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<any> {\r\n    if (uuid === null || uuid === undefined) {\r\n      throw new Error('Required parameter uuid was null or undefined when calling select.');\r\n    }\r\n    if (gridId === null || gridId === undefined) {\r\n      throw new Error('Required parameter gridId was null or undefined when calling select.');\r\n    }\r\n    if (rowId === null || rowId === undefined) {\r\n      throw new Error('Required parameter rowId was null or undefined when calling select.');\r\n    }\r\n\r\n    let localVarHeaders = this.defaultHeaders;\r\n    if (selected !== undefined && selected !== null) {\r\n      localVarHeaders = localVarHeaders.set('selected', String(selected));\r\n    }\r\n\r\n    let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\r\n    if (localVarHttpHeaderAcceptSelected === undefined) {\r\n      // to determine the Accept header\r\n      const httpHeaderAccepts: string[] = ['application/json'];\r\n      localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n    }\r\n    if (localVarHttpHeaderAcceptSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\r\n    }\r\n\r\n    let localVarHttpContext: HttpContext | undefined = options && options.context;\r\n    if (localVarHttpContext === undefined) {\r\n      localVarHttpContext = new HttpContext();\r\n    }\r\n\r\n    let responseType_: 'text' | 'json' | 'blob' = 'json';\r\n    if (localVarHttpHeaderAcceptSelected) {\r\n      if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\r\n        responseType_ = 'text';\r\n      } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\r\n        responseType_ = 'json';\r\n      } else {\r\n        responseType_ = 'blob';\r\n      }\r\n    }\r\n\r\n    return this.httpClient.post<ViewContextChange>(\r\n      `${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(\r\n        String(gridId)\r\n      )}/${encodeURIComponent(String(rowId))}/select`,\r\n      null,\r\n      {\r\n        context: localVarHttpContext,\r\n        responseType: <any>responseType_,\r\n        withCredentials: this.configuration.withCredentials,\r\n        headers: localVarHeaders,\r\n        observe: observe,\r\n        reportProgress: reportProgress,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param uuid\r\n   * @param gridId\r\n   * @param selected\r\n   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n   * @param reportProgress flag to report request and response progress.\r\n   */\r\n  public selectAll(\r\n    uuid: string,\r\n    gridId: string,\r\n    selected?: boolean,\r\n    observe?: 'body',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<ViewContextChange>;\r\n  public selectAll(\r\n    uuid: string,\r\n    gridId: string,\r\n    selected?: boolean,\r\n    observe?: 'response',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpResponse<ViewContextChange>>;\r\n  public selectAll(\r\n    uuid: string,\r\n    gridId: string,\r\n    selected?: boolean,\r\n    observe?: 'events',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpEvent<ViewContextChange>>;\r\n  public selectAll(\r\n    uuid: string,\r\n    gridId: string,\r\n    selected?: boolean,\r\n    observe: any = 'body',\r\n    reportProgress: boolean = false,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<any> {\r\n    if (uuid === null || uuid === undefined) {\r\n      throw new Error('Required parameter uuid was null or undefined when calling selectAll.');\r\n    }\r\n    if (gridId === null || gridId === undefined) {\r\n      throw new Error('Required parameter gridId was null or undefined when calling selectAll.');\r\n    }\r\n\r\n    let localVarHeaders = this.defaultHeaders;\r\n    if (selected !== undefined && selected !== null) {\r\n      localVarHeaders = localVarHeaders.set('selected', String(selected));\r\n    }\r\n\r\n    let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\r\n    if (localVarHttpHeaderAcceptSelected === undefined) {\r\n      // to determine the Accept header\r\n      const httpHeaderAccepts: string[] = ['application/json'];\r\n      localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n    }\r\n    if (localVarHttpHeaderAcceptSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\r\n    }\r\n\r\n    let localVarHttpContext: HttpContext | undefined = options && options.context;\r\n    if (localVarHttpContext === undefined) {\r\n      localVarHttpContext = new HttpContext();\r\n    }\r\n\r\n    let responseType_: 'text' | 'json' | 'blob' = 'json';\r\n    if (localVarHttpHeaderAcceptSelected) {\r\n      if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\r\n        responseType_ = 'text';\r\n      } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\r\n        responseType_ = 'json';\r\n      } else {\r\n        responseType_ = 'blob';\r\n      }\r\n    }\r\n\r\n    return this.httpClient.post<ViewContextChange>(\r\n      `${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(\r\n        String(gridId)\r\n      )}/select`,\r\n      null,\r\n      {\r\n        context: localVarHttpContext,\r\n        responseType: <any>responseType_,\r\n        withCredentials: this.configuration.withCredentials,\r\n        headers: localVarHeaders,\r\n        observe: observe,\r\n        reportProgress: reportProgress,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param uuid\r\n   * @param gridIdentifier\r\n   * @param offset\r\n   * @param limit\r\n   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n   * @param reportProgress flag to report request and response progress.\r\n   */\r\n  public setPage(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    offset: string,\r\n    limit: string,\r\n    observe?: 'body',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: undefined; context?: HttpContext }\r\n  ): Observable<any>;\r\n  public setPage(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    offset: string,\r\n    limit: string,\r\n    observe?: 'response',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: undefined; context?: HttpContext }\r\n  ): Observable<HttpResponse<any>>;\r\n  public setPage(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    offset: string,\r\n    limit: string,\r\n    observe?: 'events',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: undefined; context?: HttpContext }\r\n  ): Observable<HttpEvent<any>>;\r\n  public setPage(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    offset: string,\r\n    limit: string,\r\n    observe: any = 'body',\r\n    reportProgress: boolean = false,\r\n    options?: { httpHeaderAccept?: undefined; context?: HttpContext }\r\n  ): Observable<any> {\r\n    if (uuid === null || uuid === undefined) {\r\n      throw new Error('Required parameter uuid was null or undefined when calling setPage.');\r\n    }\r\n    if (gridIdentifier === null || gridIdentifier === undefined) {\r\n      throw new Error(\r\n        'Required parameter gridIdentifier was null or undefined when calling setPage.'\r\n      );\r\n    }\r\n    if (offset === null || offset === undefined) {\r\n      throw new Error('Required parameter offset was null or undefined when calling setPage.');\r\n    }\r\n    if (limit === null || limit === undefined) {\r\n      throw new Error('Required parameter limit was null or undefined when calling setPage.');\r\n    }\r\n\r\n    let localVarHeaders = this.defaultHeaders;\r\n\r\n    let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\r\n    if (localVarHttpHeaderAcceptSelected === undefined) {\r\n      // to determine the Accept header\r\n      const httpHeaderAccepts: string[] = [];\r\n      localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n    }\r\n    if (localVarHttpHeaderAcceptSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\r\n    }\r\n\r\n    let localVarHttpContext: HttpContext | undefined = options && options.context;\r\n    if (localVarHttpContext === undefined) {\r\n      localVarHttpContext = new HttpContext();\r\n    }\r\n\r\n    let responseType_: 'text' | 'json' | 'blob' = 'json';\r\n    if (localVarHttpHeaderAcceptSelected) {\r\n      if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\r\n        responseType_ = 'text';\r\n      } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\r\n        responseType_ = 'json';\r\n      } else {\r\n        responseType_ = 'blob';\r\n      }\r\n    }\r\n\r\n    return this.httpClient.post<any>(\r\n      `${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(\r\n        String(gridIdentifier)\r\n      )}/page/${encodeURIComponent(String(offset))}/${encodeURIComponent(String(limit))}`,\r\n      null,\r\n      {\r\n        context: localVarHttpContext,\r\n        responseType: <any>responseType_,\r\n        withCredentials: this.configuration.withCredentials,\r\n        headers: localVarHeaders,\r\n        observe: observe,\r\n        reportProgress: reportProgress,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param uuid\r\n   * @param gridIdentifier\r\n   * @param gridUpdateData\r\n   * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n   * @param reportProgress flag to report request and response progress.\r\n   */\r\n  public update(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    gridUpdateData: GridUpdateData,\r\n    observe?: 'body',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<GridModel>;\r\n  public update(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    gridUpdateData: GridUpdateData,\r\n    observe?: 'response',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpResponse<GridModel>>;\r\n  public update(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    gridUpdateData: GridUpdateData,\r\n    observe?: 'events',\r\n    reportProgress?: boolean,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<HttpEvent<GridModel>>;\r\n  public update(\r\n    uuid: string,\r\n    gridIdentifier: string,\r\n    gridUpdateData: GridUpdateData,\r\n    observe: any = 'body',\r\n    reportProgress: boolean = false,\r\n    options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext }\r\n  ): Observable<any> {\r\n    if (uuid === null || uuid === undefined) {\r\n      throw new Error('Required parameter uuid was null or undefined when calling update.');\r\n    }\r\n    if (gridIdentifier === null || gridIdentifier === undefined) {\r\n      throw new Error(\r\n        'Required parameter gridIdentifier was null or undefined when calling update.'\r\n      );\r\n    }\r\n    if (gridUpdateData === null || gridUpdateData === undefined) {\r\n      throw new Error(\r\n        'Required parameter gridUpdateData was null or undefined when calling update.'\r\n      );\r\n    }\r\n\r\n    let localVarHeaders = this.defaultHeaders;\r\n\r\n    let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\r\n    if (localVarHttpHeaderAcceptSelected === undefined) {\r\n      // to determine the Accept header\r\n      const httpHeaderAccepts: string[] = ['application/json'];\r\n      localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n    }\r\n    if (localVarHttpHeaderAcceptSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\r\n    }\r\n\r\n    let localVarHttpContext: HttpContext | undefined = options && options.context;\r\n    if (localVarHttpContext === undefined) {\r\n      localVarHttpContext = new HttpContext();\r\n    }\r\n\r\n    // to determine the Content-Type header\r\n    const consumes: string[] = ['application/json'];\r\n    const httpContentTypeSelected: string | undefined =\r\n      this.configuration.selectHeaderContentType(consumes);\r\n    if (httpContentTypeSelected !== undefined) {\r\n      localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\r\n    }\r\n\r\n    let responseType_: 'text' | 'json' | 'blob' = 'json';\r\n    if (localVarHttpHeaderAcceptSelected) {\r\n      if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\r\n        responseType_ = 'text';\r\n      } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\r\n        responseType_ = 'json';\r\n      } else {\r\n        responseType_ = 'blob';\r\n      }\r\n    }\r\n\r\n    return this.httpClient.post<GridModel>(\r\n      `${this.configuration.basePath}/grid/${encodeURIComponent(String(uuid))}/${encodeURIComponent(\r\n        String(gridIdentifier)\r\n      )}/update`,\r\n      gridUpdateData,\r\n      {\r\n        context: localVarHttpContext,\r\n        responseType: <any>responseType_,\r\n        withCredentials: this.configuration.withCredentials,\r\n        headers: localVarHeaders,\r\n        observe: observe,\r\n        reportProgress: reportProgress,\r\n      }\r\n    );\r\n  }\r\n}\r\n"]}