@energycap/energycap-billcapture-sdk-angular 1.0.2-internal-20240104-2210

package/esm2020/api/sample.service.mjs

@@ -0,0 +1,233 @@
+/**
+ * BillCapture.API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+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";
+const RequestMethod = {
+    Get: 'get',
+    Post: 'post',
+    Put: 'put',
+    Delete: 'delete',
+    Options: 'options',
+    Head: 'head',
+    Patch: 'patch'
+};
+export class SampleService {
+    constructor(http, basePath, configuration) {
+        this.http = http;
+        this.basePath = 'https://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     *
+     * Extends object by coping non-existing properties.
+     * @param objA object to be extended
+     * @param objB source object
+     */
+    extendObj(objA, objB) {
+        for (let key in objB) {
+            if (objB.hasOwnProperty(key)) {
+                objA[key] = objB[key];
+            }
+        }
+        return objA;
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (let consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Sample controller endpoint that gets a client
+     *
+     * @param clientId The client identifier
+     */
+    apiPublicSampleClientIdGet(clientId, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.apiPublicSampleClientIdGetWithHttpInfo(clientId, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Sample controller endpoint that gets clients
+     *
+     * @param filter A filter  <table id=\"api-filter\"><tr><th>Name</th><th>Description</th><th>Type</th><th>Operators</th></tr><tr><td>clientName</td><td>Client Name</td><td>Any Text</td><td>equals, not equals, one of, like, not like, not one of</td></tr><tr><td>clientID</td><td>Client Id</td><td>Whole Number</td><td>equals</td></tr></table>
+     * @param orderBy An order by  <table id=\"api-filter\"><tr><th>Name</th><th>Description</th><th>Sort Operators</th></tr><tr><td>clientName</td><td>Client Name</td><td>ASC, DESC</td></tr></table>
+     * @param pageSize The number of elements to return in a page
+     * @param pageNumber The current page number
+     */
+    apiPublicSampleGet(filter, orderBy, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.apiPublicSampleGetWithHttpInfo(filter, orderBy, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Sample controller endpoint that gets a client
+     *
+     * @param clientId The client identifier
+     */
+    apiPublicSampleClientIdGetWithHttpInfo(clientId, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/public/Sample/${clientId}'
+            .replace('${' + 'clientId' + '}', String(clientId));
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        // verify required parameter 'clientId' is not null or undefined
+        if (clientId === null || clientId === undefined) {
+            throw new Error('Required parameter clientId was null or undefined when calling apiPublicSampleClientIdGet.');
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        if (this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]) {
+            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+    /**
+     * Sample controller endpoint that gets clients
+     *
+     * @param filter A filter  <table id=\"api-filter\"><tr><th>Name</th><th>Description</th><th>Type</th><th>Operators</th></tr><tr><td>clientName</td><td>Client Name</td><td>Any Text</td><td>equals, not equals, one of, like, not like, not one of</td></tr><tr><td>clientID</td><td>Client Id</td><td>Whole Number</td><td>equals</td></tr></table>
+     * @param orderBy An order by  <table id=\"api-filter\"><tr><th>Name</th><th>Description</th><th>Sort Operators</th></tr><tr><td>clientName</td><td>Client Name</td><td>ASC, DESC</td></tr></table>
+     * @param pageSize The number of elements to return in a page
+     * @param pageNumber The current page number
+     */
+    apiPublicSampleGetWithHttpInfo(filter, orderBy, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/public/Sample';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        if (filter !== undefined) {
+            queryParameters = queryParameters.set('filter', filter);
+        }
+        if (orderBy !== undefined) {
+            queryParameters = queryParameters.set('orderBy', orderBy);
+        }
+        if (pageSize !== undefined) {
+            queryParameters = queryParameters.set('pageSize', pageSize);
+        }
+        if (pageNumber !== undefined) {
+            queryParameters = queryParameters.set('pageNumber', pageNumber);
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        if (this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]) {
+            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+}
+SampleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SampleService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+SampleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SampleService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SampleService, decorators: [{
+            type: Injectable
+        }], 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":"sample.service.js","sourceRoot":"","sources":["../../../api/sample.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * BillCapture.API\r\n * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)\r\n *\r\n * OpenAPI spec version: 1.0\r\n * \r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n */\r\n\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams }               from '@angular/common/http';\r\nimport { HttpResponse }                                      from '@angular/common/http';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\nimport { map }                                               from 'rxjs/operators';\r\n\r\nimport { GetClientsResponse } from '../model/getClientsResponse';\r\n\r\nimport { BASE_PATH }                                         from '../variables';\r\nimport { COLLECTION_FORMATS }                                from '../variables';\r\n\r\nimport { Configuration }                                     from '../configuration';\r\n\r\nconst RequestMethod = {\r\n    Get: 'get',\r\n    Post: 'post',\r\n    Put: 'put',\r\n    Delete: 'delete',\r\n    Options: 'options',\r\n    Head: 'head',\r\n    Patch: 'patch'\r\n};\r\n\r\n\r\n@Injectable()\r\nexport class SampleService {\r\n\r\n    protected basePath = 'https://localhost';\r\n    public defaultHeaders: HttpHeaders = new HttpHeaders();\r\n    public configuration: Configuration = new Configuration();\r\n\r\n    constructor(protected http: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n\t\t\tthis.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * \r\n     * Extends object by coping non-existing properties.\r\n     * @param objA object to be extended\r\n     * @param objB source object\r\n     */\r\n    private extendObj<T1,T2>(objA: T1, objB: T2) {\r\n        for(let key in objB){\r\n            if(objB.hasOwnProperty(key)){\r\n                (objA as any)[key] = (objB as any)[key];\r\n            }\r\n        }\r\n        return <T1&T2>objA;\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (let consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Sample controller endpoint that gets a client\r\n     * \r\n     * @param clientId The client identifier\r\n     */\r\n    public apiPublicSampleClientIdGet(clientId: number, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<GetClientsResponse> {\r\n        return this.apiPublicSampleClientIdGetWithHttpInfo(clientId, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<GetClientsResponse>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n    /**\r\n     * Sample controller endpoint that gets clients\r\n     * \r\n     * @param filter A filter  &lt;table id&#x3D;\\&quot;api-filter\\&quot;&gt;&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Description&lt;/th&gt;&lt;th&gt;Type&lt;/th&gt;&lt;th&gt;Operators&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientName&lt;/td&gt;&lt;td&gt;Client Name&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals, not equals, one of, like, not like, not one of&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientID&lt;/td&gt;&lt;td&gt;Client Id&lt;/td&gt;&lt;td&gt;Whole Number&lt;/td&gt;&lt;td&gt;equals&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;\r\n     * @param orderBy An order by  &lt;table id&#x3D;\\&quot;api-filter\\&quot;&gt;&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Description&lt;/th&gt;&lt;th&gt;Sort Operators&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientName&lt;/td&gt;&lt;td&gt;Client Name&lt;/td&gt;&lt;td&gt;ASC, DESC&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;\r\n     * @param pageSize The number of elements to return in a page\r\n     * @param pageNumber The current page number\r\n     */\r\n    public apiPublicSampleGet(filter?: string, orderBy?: string, pageSize?: number, pageNumber?: number, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<Array<GetClientsResponse>> {\r\n        return this.apiPublicSampleGetWithHttpInfo(filter, orderBy, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<Array<GetClientsResponse>>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n\r\n    /**\r\n     * Sample controller endpoint that gets a client\r\n     * \r\n     * @param clientId The client identifier\r\n     */\r\n    public apiPublicSampleClientIdGetWithHttpInfo(clientId: number, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<GetClientsResponse>> {\r\n        const path = this.basePath + '/api/public/Sample/${clientId}'\r\n                    .replace('${' + 'clientId' + '}', String(clientId));\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n        // verify required parameter 'clientId' is not null or undefined\r\n        if (clientId === null || clientId === undefined) {\r\n            throw new Error('Required parameter clientId was null or undefined when calling apiPublicSampleClientIdGet.');\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n\r\n        if (this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]) {\r\n            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<GetClientsResponse>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n    /**\r\n     * Sample controller endpoint that gets clients\r\n     * \r\n     * @param filter A filter  &lt;table id&#x3D;\\&quot;api-filter\\&quot;&gt;&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Description&lt;/th&gt;&lt;th&gt;Type&lt;/th&gt;&lt;th&gt;Operators&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientName&lt;/td&gt;&lt;td&gt;Client Name&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals, not equals, one of, like, not like, not one of&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientID&lt;/td&gt;&lt;td&gt;Client Id&lt;/td&gt;&lt;td&gt;Whole Number&lt;/td&gt;&lt;td&gt;equals&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;\r\n     * @param orderBy An order by  &lt;table id&#x3D;\\&quot;api-filter\\&quot;&gt;&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Description&lt;/th&gt;&lt;th&gt;Sort Operators&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientName&lt;/td&gt;&lt;td&gt;Client Name&lt;/td&gt;&lt;td&gt;ASC, DESC&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;\r\n     * @param pageSize The number of elements to return in a page\r\n     * @param pageNumber The current page number\r\n     */\r\n    public apiPublicSampleGetWithHttpInfo(filter?: string, orderBy?: string, pageSize?: number, pageNumber?: number, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<Array<GetClientsResponse>>> {\r\n        const path = this.basePath + '/api/public/Sample';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n        if (filter !== undefined) {\r\n            queryParameters = queryParameters.set('filter', <any>filter);\r\n        }\r\n\r\n        if (orderBy !== undefined) {\r\n            queryParameters = queryParameters.set('orderBy', <any>orderBy);\r\n        }\r\n\r\n        if (pageSize !== undefined) {\r\n            queryParameters = queryParameters.set('pageSize', <any>pageSize);\r\n        }\r\n\r\n        if (pageNumber !== undefined) {\r\n            queryParameters = queryParameters.set('pageNumber', <any>pageNumber);\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n\r\n        if (this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]) {\r\n            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<Array<GetClientsResponse>>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n}\r\n"]}

package/esm2020/api/upload.service.mjs

@@ -0,0 +1,160 @@
+/**
+ * BillCapture.API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+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";
+const RequestMethod = {
+    Get: 'get',
+    Post: 'post',
+    Put: 'put',
+    Delete: 'delete',
+    Options: 'options',
+    Head: 'head',
+    Patch: 'patch'
+};
+export class UploadService {
+    constructor(http, basePath, configuration) {
+        this.http = http;
+        this.basePath = 'https://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     *
+     * Extends object by coping non-existing properties.
+     * @param objA object to be extended
+     * @param objB source object
+     */
+    extendObj(objA, objB) {
+        for (let key in objB) {
+            if (objB.hasOwnProperty(key)) {
+                objA[key] = objB[key];
+            }
+        }
+        return objA;
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (let consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get file uploads
+     *
+     * @param filter API filters. <br />  Valid values for the Upload Category filter are: 'Maintenance', 'Historical', 'Setup Enrollments', and 'Live'. <br />  TODO (ECAP-20445): 'utilityManagementSystemUserID' filter is not implemented yet.  <table id=\"api-filter\"><tr><th>Name</th><th>Description</th><th>Type</th><th>Operators</th></tr><tr><td>clientFileName</td><td>Client File Name</td><td>Any Text</td><td>equals, not equals, one of, like, not like, not one of</td></tr><tr><td>uploadDate</td><td>Client File Upload Date</td><td>Date & Time</td><td>equals, not equals, less than, between, greater than, less than equal, greater than equal, not between</td></tr><tr><td>uploadCategory</td><td>Upload Category</td><td>Any Text</td><td>equals</td></tr><tr><td>clientName</td><td>Client Name</td><td>Any Text</td><td>equals, not equals, one of, like, not like, not one of</td></tr><tr><td>utilityManagementSystemUserID</td><td>Utility Management System User ID</td><td>Whole Number</td><td>equals</td></tr></table>
+     * @param pageSize The number of elements to return in a page
+     * @param pageNumber The current page number
+     */
+    apiPublicUploadGet(filter, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.apiPublicUploadGetWithHttpInfo(filter, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     * Get file uploads
+     *
+     * @param filter API filters. <br />  Valid values for the Upload Category filter are: 'Maintenance', 'Historical', 'Setup Enrollments', and 'Live'. <br />  TODO (ECAP-20445): 'utilityManagementSystemUserID' filter is not implemented yet.  <table id=\"api-filter\"><tr><th>Name</th><th>Description</th><th>Type</th><th>Operators</th></tr><tr><td>clientFileName</td><td>Client File Name</td><td>Any Text</td><td>equals, not equals, one of, like, not like, not one of</td></tr><tr><td>uploadDate</td><td>Client File Upload Date</td><td>Date & Time</td><td>equals, not equals, less than, between, greater than, less than equal, greater than equal, not between</td></tr><tr><td>uploadCategory</td><td>Upload Category</td><td>Any Text</td><td>equals</td></tr><tr><td>clientName</td><td>Client Name</td><td>Any Text</td><td>equals, not equals, one of, like, not like, not one of</td></tr><tr><td>utilityManagementSystemUserID</td><td>Utility Management System User ID</td><td>Whole Number</td><td>equals</td></tr></table>
+     * @param pageSize The number of elements to return in a page
+     * @param pageNumber The current page number
+     */
+    apiPublicUploadGetWithHttpInfo(filter, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/public/Upload';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        if (filter !== undefined) {
+            queryParameters = queryParameters.set('filter', filter);
+        }
+        if (pageSize !== undefined) {
+            queryParameters = queryParameters.set('pageSize', pageSize);
+        }
+        if (pageNumber !== undefined) {
+            queryParameters = queryParameters.set('pageNumber', pageNumber);
+        }
+        // to determine the Accept header
+        let produces = [
+            'application/json'
+        ];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        if (this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]) {
+            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+}
+UploadService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UploadService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+UploadService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UploadService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UploadService, decorators: [{
+            type: Injectable
+        }], 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":"upload.service.js","sourceRoot":"","sources":["../../../api/upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * BillCapture.API\r\n * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)\r\n *\r\n * OpenAPI spec version: 1.0\r\n * \r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n */\r\n\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams }               from '@angular/common/http';\r\nimport { HttpResponse }                                      from '@angular/common/http';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\nimport { map }                                               from 'rxjs/operators';\r\n\r\nimport { UploadResponseDTO } from '../model/uploadResponseDTO';\r\n\r\nimport { BASE_PATH }                                         from '../variables';\r\nimport { COLLECTION_FORMATS }                                from '../variables';\r\n\r\nimport { Configuration }                                     from '../configuration';\r\n\r\nconst RequestMethod = {\r\n    Get: 'get',\r\n    Post: 'post',\r\n    Put: 'put',\r\n    Delete: 'delete',\r\n    Options: 'options',\r\n    Head: 'head',\r\n    Patch: 'patch'\r\n};\r\n\r\n\r\n@Injectable()\r\nexport class UploadService {\r\n\r\n    protected basePath = 'https://localhost';\r\n    public defaultHeaders: HttpHeaders = new HttpHeaders();\r\n    public configuration: Configuration = new Configuration();\r\n\r\n    constructor(protected http: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n\t\t\tthis.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * \r\n     * Extends object by coping non-existing properties.\r\n     * @param objA object to be extended\r\n     * @param objB source object\r\n     */\r\n    private extendObj<T1,T2>(objA: T1, objB: T2) {\r\n        for(let key in objB){\r\n            if(objB.hasOwnProperty(key)){\r\n                (objA as any)[key] = (objB as any)[key];\r\n            }\r\n        }\r\n        return <T1&T2>objA;\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (let consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Get file uploads\r\n     * \r\n     * @param filter API filters. &lt;br /&gt;  Valid values for the Upload Category filter are: &#39;Maintenance&#39;, &#39;Historical&#39;, &#39;Setup Enrollments&#39;, and &#39;Live&#39;. &lt;br /&gt;  TODO (ECAP-20445): &#39;utilityManagementSystemUserID&#39; filter is not implemented yet.  &lt;table id&#x3D;\\&quot;api-filter\\&quot;&gt;&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Description&lt;/th&gt;&lt;th&gt;Type&lt;/th&gt;&lt;th&gt;Operators&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientFileName&lt;/td&gt;&lt;td&gt;Client File Name&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals, not equals, one of, like, not like, not one of&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;uploadDate&lt;/td&gt;&lt;td&gt;Client File Upload Date&lt;/td&gt;&lt;td&gt;Date &amp;amp; Time&lt;/td&gt;&lt;td&gt;equals, not equals, less than, between, greater than, less than equal, greater than equal, not between&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;uploadCategory&lt;/td&gt;&lt;td&gt;Upload Category&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientName&lt;/td&gt;&lt;td&gt;Client Name&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals, not equals, one of, like, not like, not one of&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;utilityManagementSystemUserID&lt;/td&gt;&lt;td&gt;Utility Management System User ID&lt;/td&gt;&lt;td&gt;Whole Number&lt;/td&gt;&lt;td&gt;equals&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;\r\n     * @param pageSize The number of elements to return in a page\r\n     * @param pageNumber The current page number\r\n     */\r\n    public apiPublicUploadGet(filter?: string, pageSize?: number, pageNumber?: number, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<Array<UploadResponseDTO>> {\r\n        return this.apiPublicUploadGetWithHttpInfo(filter, pageSize, pageNumber, extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<Array<UploadResponseDTO>>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n\r\n    /**\r\n     * Get file uploads\r\n     * \r\n     * @param filter API filters. &lt;br /&gt;  Valid values for the Upload Category filter are: &#39;Maintenance&#39;, &#39;Historical&#39;, &#39;Setup Enrollments&#39;, and &#39;Live&#39;. &lt;br /&gt;  TODO (ECAP-20445): &#39;utilityManagementSystemUserID&#39; filter is not implemented yet.  &lt;table id&#x3D;\\&quot;api-filter\\&quot;&gt;&lt;tr&gt;&lt;th&gt;Name&lt;/th&gt;&lt;th&gt;Description&lt;/th&gt;&lt;th&gt;Type&lt;/th&gt;&lt;th&gt;Operators&lt;/th&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientFileName&lt;/td&gt;&lt;td&gt;Client File Name&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals, not equals, one of, like, not like, not one of&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;uploadDate&lt;/td&gt;&lt;td&gt;Client File Upload Date&lt;/td&gt;&lt;td&gt;Date &amp;amp; Time&lt;/td&gt;&lt;td&gt;equals, not equals, less than, between, greater than, less than equal, greater than equal, not between&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;uploadCategory&lt;/td&gt;&lt;td&gt;Upload Category&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;clientName&lt;/td&gt;&lt;td&gt;Client Name&lt;/td&gt;&lt;td&gt;Any Text&lt;/td&gt;&lt;td&gt;equals, not equals, one of, like, not like, not one of&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;utilityManagementSystemUserID&lt;/td&gt;&lt;td&gt;Utility Management System User ID&lt;/td&gt;&lt;td&gt;Whole Number&lt;/td&gt;&lt;td&gt;equals&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;\r\n     * @param pageSize The number of elements to return in a page\r\n     * @param pageNumber The current page number\r\n     */\r\n    public apiPublicUploadGetWithHttpInfo(filter?: string, pageSize?: number, pageNumber?: number, extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<Array<UploadResponseDTO>>> {\r\n        const path = this.basePath + '/api/public/Upload';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n        if (filter !== undefined) {\r\n            queryParameters = queryParameters.set('filter', <any>filter);\r\n        }\r\n\r\n        if (pageSize !== undefined) {\r\n            queryParameters = queryParameters.set('pageSize', <any>pageSize);\r\n        }\r\n\r\n        if (pageNumber !== undefined) {\r\n            queryParameters = queryParameters.set('pageNumber', <any>pageNumber);\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n            'application/json'\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n\r\n        if (this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]) {\r\n            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<Array<UploadResponseDTO>>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n}\r\n"]}

package/esm2020/api/version.service.mjs

@@ -0,0 +1,143 @@
+/**
+ * BillCapture.API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+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";
+const RequestMethod = {
+    Get: 'get',
+    Post: 'post',
+    Put: 'put',
+    Delete: 'delete',
+    Options: 'options',
+    Head: 'head',
+    Patch: 'patch'
+};
+export class VersionService {
+    constructor(http, basePath, configuration) {
+        this.http = http;
+        this.basePath = 'https://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     *
+     * Extends object by coping non-existing properties.
+     * @param objA object to be extended
+     * @param objB source object
+     */
+    extendObj(objA, objB) {
+        for (let key in objB) {
+            if (objB.hasOwnProperty(key)) {
+                objA[key] = objB[key];
+            }
+        }
+        return objA;
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (let consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     *
+     */
+    getVersion(extraHttpRequestParams, extraHttpRequestHeaders) {
+        return this.getVersionWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders)
+            .pipe(map((response) => {
+            if (response.status === 204) {
+                return undefined;
+            }
+            else {
+                return response.body;
+            }
+        }));
+    }
+    /**
+     *
+     *
+     */
+    getVersionWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders) {
+        const path = this.basePath + '/api/public/Version';
+        let queryParameters;
+        if (extraHttpRequestParams) {
+            if (typeof extraHttpRequestParams.search === 'string') {
+                queryParameters = new HttpParams({ fromString: extraHttpRequestParams.search });
+            }
+            else {
+                queryParameters = new HttpParams({ fromObject: extraHttpRequestParams.search });
+            }
+        }
+        else {
+            queryParameters = new HttpParams();
+        }
+        let headers = new HttpHeaders();
+        this.defaultHeaders.keys().forEach(key => {
+            headers = headers.set(key, this.defaultHeaders.getAll(key));
+        });
+        if (extraHttpRequestHeaders) {
+            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {
+                headers = headers.set(key, value);
+            });
+        }
+        // to determine the Accept header
+        let produces = [];
+        if (this.configuration.apiKeys["Authorization"]) {
+            headers = headers.set('Authorization', this.configuration.apiKeys["Authorization"]);
+        }
+        if (this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]) {
+            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys["ECI-PUBLIC-DASHBOARD-KEY"]);
+        }
+        const consumes = [];
+        let requestOptions = {
+            headers: headers,
+            params: queryParameters,
+            withCredentials: this.configuration.withCredentials,
+            observe: 'response'
+        };
+        return this.http.request(RequestMethod.Get, path, requestOptions);
+    }
+}
+VersionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: VersionService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+VersionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: VersionService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: VersionService, decorators: [{
+            type: Injectable
+        }], 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":"version.service.js","sourceRoot":"","sources":["../../../api/version.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * BillCapture.API\r\n * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)\r\n *\r\n * OpenAPI spec version: 1.0\r\n * \r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n */\r\n\r\n/* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams }               from '@angular/common/http';\r\nimport { HttpResponse }                                      from '@angular/common/http';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\nimport { map }                                               from 'rxjs/operators';\r\n\r\n\r\nimport { BASE_PATH }                                         from '../variables';\r\nimport { COLLECTION_FORMATS }                                from '../variables';\r\n\r\nimport { Configuration }                                     from '../configuration';\r\n\r\nconst RequestMethod = {\r\n    Get: 'get',\r\n    Post: 'post',\r\n    Put: 'put',\r\n    Delete: 'delete',\r\n    Options: 'options',\r\n    Head: 'head',\r\n    Patch: 'patch'\r\n};\r\n\r\n\r\n@Injectable()\r\nexport class VersionService {\r\n\r\n    protected basePath = 'https://localhost';\r\n    public defaultHeaders: HttpHeaders = new HttpHeaders();\r\n    public configuration: Configuration = new Configuration();\r\n\r\n    constructor(protected http: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n\t\t\tthis.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * \r\n     * Extends object by coping non-existing properties.\r\n     * @param objA object to be extended\r\n     * @param objB source object\r\n     */\r\n    private extendObj<T1,T2>(objA: T1, objB: T2) {\r\n        for(let key in objB){\r\n            if(objB.hasOwnProperty(key)){\r\n                (objA as any)[key] = (objB as any)[key];\r\n            }\r\n        }\r\n        return <T1&T2>objA;\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (let consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * \r\n     * \r\n     */\r\n    public getVersion(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<any> {\r\n        return this.getVersionWithHttpInfo(extraHttpRequestParams, extraHttpRequestHeaders)\r\n            .pipe(\r\n                map((response: HttpResponse<any>) => {\r\n                    if (response.status === 204) {\r\n                        return undefined;\r\n                    } else {\r\n                        return response.body;\r\n                    }\r\n                })\r\n            )\r\n    }\r\n\r\n\r\n    /**\r\n     * \r\n     * \r\n     */\r\n    public getVersionWithHttpInfo(extraHttpRequestParams?: {search: string | {[param: string]: string | string[] } }, extraHttpRequestHeaders?: {[header: string]: string | string[]}): Observable<HttpResponse<any>> {\r\n        const path = this.basePath + '/api/public/Version';\r\n\r\n        let queryParameters: HttpParams;\r\n        \r\n        if (extraHttpRequestParams) {\r\n            if (typeof extraHttpRequestParams.search === 'string') { \r\n                queryParameters = new HttpParams({fromString: extraHttpRequestParams.search});\r\n            } else {\r\n                queryParameters = new HttpParams({fromObject: extraHttpRequestParams.search});\r\n            }\r\n        } else {\r\n            queryParameters = new HttpParams();\r\n        }\r\n\r\n        let headers = new HttpHeaders();\r\n        this.defaultHeaders.keys().forEach(key => {\r\n            headers = headers.set(key, this.defaultHeaders.getAll(key));\r\n        });\r\n\r\n        if (extraHttpRequestHeaders) {\r\n            Object.entries(extraHttpRequestHeaders).forEach(([key, value]) => {\r\n                headers = headers.set(key, value);\r\n            });\r\n        }\r\n\r\n\r\n        // to determine the Accept header\r\n        let produces: string[] = [\r\n        ];\r\n\r\n        if (this.configuration.apiKeys[\"Authorization\"]) {\r\n            headers = headers.set('Authorization', this.configuration.apiKeys[\"Authorization\"]);\r\n        }\r\n\r\n        if (this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]) {\r\n            headers = headers.set('ECI-PUBLIC-DASHBOARD-KEY', this.configuration.apiKeys[\"ECI-PUBLIC-DASHBOARD-KEY\"]);\r\n        }\r\n        \r\n\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        let requestOptions = {\r\n            headers: headers,\r\n            params: queryParameters,\r\n            withCredentials:this.configuration.withCredentials,\r\n            observe: 'response' as 'response'\r\n        };\r\n        return this.http.request<any>(RequestMethod.Get, path, requestOptions);\r\n    }\r\n\r\n}\r\n"]}