@geosanja/geosanja-frontend-api 4.0.2 → 4.0.4

package/api/default.service.d.ts

@@ -20,6 +20,16 @@ export declare class DefaultService {
      * @return true: consumes contains 'multipart/form-data', false: otherwise
      */
     private canConsumeForm;
+    /**
+     * Delete usuário da aplicação
+     *
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    deleteUsuario(body: UsuarioDTO, observe?: 'body', reportProgress?: boolean): Observable<boolean>;
+    deleteUsuario(body: UsuarioDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<boolean>>;
+    deleteUsuario(body: UsuarioDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<boolean>>;
     /**
      * Download de camadas e grupo de camadas do GeoServer.
      *
@@ -152,6 +162,16 @@ export declare class DefaultService {
     proxy(url: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;
     proxy(url: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;
     proxy(url: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;
+    /**
+     * Salvar usuário na aplicação
+     *
+     * @param body
+     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+     * @param reportProgress flag to report request and response progress.
+     */
+    setUsuario(body: UsuarioDTO, observe?: 'body', reportProgress?: boolean): Observable<boolean>;
+    setUsuario(body: UsuarioDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<boolean>>;
+    setUsuario(body: UsuarioDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<boolean>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DefaultService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DefaultService>;
 }

package/esm2022/api/default.service.mjs

@@ -45,6 +45,35 @@ export class DefaultService {
         }
         return false;
     }
+    deleteUsuario(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling deleteUsuario.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            'application/json'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('delete', `${this.basePath}/admin/usuario`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
     downloadCamada(layerId, format, observe = 'body', reportProgress = false) {
         if (layerId === null || layerId === undefined) {
             throw new Error('Required parameter layerId was null or undefined when calling downloadCamada.');
@@ -428,6 +457,35 @@ export class DefaultService {
             reportProgress: reportProgress
         });
     }
+    setUsuario(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling setUsuario.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            'application/json'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('post', `${this.basePath}/admin/usuario`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultService, providedIn: 'root' });
 }
@@ -444,4 +502,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }] }, { type: i2.Configuration, decorators: [{
                     type: Optional
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default.service.js","sourceRoot":"","sources":["../../../api/default.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n *//* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent }                           from '@angular/common/http';\nimport { CustomHttpUrlEncodingCodec }                        from '../encoder';\n\nimport { Observable }                                        from 'rxjs';\n\nimport { CamadaPropriedadeDTO } from '../model/camadaPropriedadeDTO';\nimport { EditAttributesDTO } from '../model/editAttributesDTO';\nimport { GrupoCamadaDTO } from '../model/grupoCamadaDTO';\nimport { LocalizarUnidadeGeoDTO } from '../model/localizarUnidadeGeoDTO';\nimport { PerfilDTO } from '../model/perfilDTO';\nimport { ResultadoUnidadeGeoDTO } from '../model/resultadoUnidadeGeoDTO';\nimport { UsuarioDTO } from '../model/usuarioDTO';\n\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefaultService {\n\n    protected basePath = '/';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\n        if (basePath) {\n            this.basePath = basePath;\n        }\n        if (configuration) {\n            this.configuration = configuration;\n            this.basePath = basePath || configuration.basePath || this.basePath;\n        }\n    }\n\n    /**\n     * @param consumes string[] mime-types\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\n     */\n    private canConsumeForm(consumes: string[]): boolean {\n        const form = 'multipart/form-data';\n        for (const consume of consumes) {\n            if (form === consume) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n\n    /**\n     * Download de camadas e grupo de camadas do GeoServer.\n     * \n     * @param layerId \n     * @param format \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public downloadCamada(layerId: string, format: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public downloadCamada(layerId: string, format: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (layerId === null || layerId === undefined) {\n            throw new Error('Required parameter layerId was null or undefined when calling downloadCamada.');\n        }\n\n        if (format === null || format === undefined) {\n            throw new Error('Required parameter format was null or undefined when calling downloadCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (layerId !== undefined && layerId !== null) {\n            queryParameters = queryParameters.set('layerId', <any>layerId);\n        }\n        if (format !== undefined && format !== null) {\n            queryParameters = queryParameters.set('format', <any>format);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/download/camada`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Edição dos atributos de camada.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public editAttributes(body?: EditAttributesDTO, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<string>('post',`${this.basePath}/edit/attributes`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Serviço para exportar o mapa e legendas para PDF.\n     * \n     * @param pdfHeader \n     * @param pdfFooter \n     * @param pdfLegends \n     * @param pdfMap \n     * @param pdfFormat \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'multipart/form-data'\n        ];\n\n        const canConsumeForm = this.canConsumeForm(consumes);\n\n        let formParams: { append(param: string, value: any): void; };\n        let useForm = false;\n        let convertFormParamsToString = false;\n        // use FormData to transmit files using content-type \"multipart/form-data\"\n        // see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data\n        useForm = canConsumeForm;\n        if (useForm) {\n            formParams = new FormData();\n        } else {\n            formParams = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        }\n\n        if (pdfHeader !== undefined) {\n            formParams = formParams.append('pdfHeader', <any>pdfHeader) as any || formParams;\n        }\n        if (pdfFooter !== undefined) {\n            formParams = formParams.append('pdfFooter', <any>pdfFooter) as any || formParams;\n        }\n        if (pdfLegends !== undefined) {\n            formParams = formParams.append('pdfLegends', <any>pdfLegends) as any || formParams;\n        }\n        if (pdfMap !== undefined) {\n            formParams = formParams.append('pdfMap', <any>pdfMap) as any || formParams;\n        }\n        if (pdfFormat !== undefined) {\n            formParams = formParams.append('pdfFormat', <any>pdfFormat) as any || formParams;\n        }\n\n        return this.httpClient.request('post',`${this.basePath}/export/pdf`,\n            {\n                body: convertFormParamsToString ? formParams.toString() : formParams,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de camadas.\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getCamadas(observe?: 'body', reportProgress?: boolean): Observable<Array<GrupoCamadaDTO>>;\n    public getCamadas(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<GrupoCamadaDTO>>('get',`${this.basePath}/camadas`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários do esjc\n     * \n     * @param cpf \n     * @param nome \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (cpf !== undefined && cpf !== null) {\n            queryParameters = queryParameters.set('cpf', <any>cpf);\n        }\n        if (nome !== undefined && nome !== null) {\n            queryParameters = queryParameters.set('nome', <any>nome);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/esjc/usuarios`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar informações de camadas e grupos de camadas por apontamento.\n     * \n     * @param srs \n     * @param version \n     * @param bbox \n     * @param height \n     * @param width \n     * @param layers \n     * @param queryLayers \n     * @param infoFormat \n     * @param x \n     * @param y \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (srs === null || srs === undefined) {\n            throw new Error('Required parameter srs was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (version === null || version === undefined) {\n            throw new Error('Required parameter version was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (bbox === null || bbox === undefined) {\n            throw new Error('Required parameter bbox was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (height === null || height === undefined) {\n            throw new Error('Required parameter height was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (width === null || width === undefined) {\n            throw new Error('Required parameter width was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (layers === null || layers === undefined) {\n            throw new Error('Required parameter layers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (queryLayers === null || queryLayers === undefined) {\n            throw new Error('Required parameter queryLayers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (infoFormat === null || infoFormat === undefined) {\n            throw new Error('Required parameter infoFormat was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (x === null || x === undefined) {\n            throw new Error('Required parameter x was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (y === null || y === undefined) {\n            throw new Error('Required parameter y was null or undefined when calling getFeatureInfo.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (srs !== undefined && srs !== null) {\n            queryParameters = queryParameters.set('srs', <any>srs);\n        }\n        if (version !== undefined && version !== null) {\n            queryParameters = queryParameters.set('version', <any>version);\n        }\n        if (bbox !== undefined && bbox !== null) {\n            queryParameters = queryParameters.set('bbox', <any>bbox);\n        }\n        if (height !== undefined && height !== null) {\n            queryParameters = queryParameters.set('height', <any>height);\n        }\n        if (width !== undefined && width !== null) {\n            queryParameters = queryParameters.set('width', <any>width);\n        }\n        if (layers !== undefined && layers !== null) {\n            queryParameters = queryParameters.set('layers', <any>layers);\n        }\n        if (queryLayers !== undefined && queryLayers !== null) {\n            queryParameters = queryParameters.set('query_layers', <any>queryLayers);\n        }\n        if (infoFormat !== undefined && infoFormat !== null) {\n            queryParameters = queryParameters.set('info_format', <any>infoFormat);\n        }\n        if (x !== undefined && x !== null) {\n            queryParameters = queryParameters.set('x', <any>x);\n        }\n        if (y !== undefined && y !== null) {\n            queryParameters = queryParameters.set('y', <any>y);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<string>('get',`${this.basePath}/featureinfo`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Busca icone\n     * \n     * @param filename \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getIcon(filename: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public getIcon(filename: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public getIcon(filename: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public getIcon(filename: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (filename === null || filename === undefined) {\n            throw new Error('Required parameter filename was null or undefined when calling getIcon.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'image/svg+xml'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/icon/${encodeURIComponent(String(filename))}`,\n            {\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de perfis\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPerfis(observe?: 'body', reportProgress?: boolean): Observable<Array<PerfilDTO>>;\n    public getPerfis(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<PerfilDTO>>>;\n    public getPerfis(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<PerfilDTO>>>;\n    public getPerfis(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<PerfilDTO>>('get',`${this.basePath}/admin/perfis`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de proprieades das camadas e suas configurações.\n     * \n     * @param id \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPropriedadesCamada(id: string, observe?: 'body', reportProgress?: boolean): Observable<Array<CamadaPropriedadeDTO>>;\n    public getPropriedadesCamada(id: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getPropriedadesCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (id !== undefined && id !== null) {\n            queryParameters = queryParameters.set('id', <any>id);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<CamadaPropriedadeDTO>>('get',`${this.basePath}/camada/propriedades`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários da aplicação\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getUsuarios(observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getUsuarios(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getUsuarios(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getUsuarios(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/usuarios`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Localização por unidade geográfica.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'body', reportProgress?: boolean): Observable<Array<ResultadoUnidadeGeoDTO>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling localizarUnidadeGeo.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<Array<ResultadoUnidadeGeoDTO>>('post',`${this.basePath}/localizar`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Proxy para requisições GET ao GeoServer.\n     * \n     * @param url \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public proxy(url: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public proxy(url: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public proxy(url: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public proxy(url: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (url === null || url === undefined) {\n            throw new Error('Required parameter url was null or undefined when calling proxy.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (url !== undefined && url !== null) {\n            queryParameters = queryParameters.set('url', <any>url);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/proxy`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default.service.js","sourceRoot":"","sources":["../../../api/default.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n *//* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent }                           from '@angular/common/http';\nimport { CustomHttpUrlEncodingCodec }                        from '../encoder';\n\nimport { Observable }                                        from 'rxjs';\n\nimport { CamadaPropriedadeDTO } from '../model/camadaPropriedadeDTO';\nimport { EditAttributesDTO } from '../model/editAttributesDTO';\nimport { GrupoCamadaDTO } from '../model/grupoCamadaDTO';\nimport { LocalizarUnidadeGeoDTO } from '../model/localizarUnidadeGeoDTO';\nimport { PerfilDTO } from '../model/perfilDTO';\nimport { ResultadoUnidadeGeoDTO } from '../model/resultadoUnidadeGeoDTO';\nimport { UsuarioDTO } from '../model/usuarioDTO';\n\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefaultService {\n\n    protected basePath = '/';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\n        if (basePath) {\n            this.basePath = basePath;\n        }\n        if (configuration) {\n            this.configuration = configuration;\n            this.basePath = basePath || configuration.basePath || this.basePath;\n        }\n    }\n\n    /**\n     * @param consumes string[] mime-types\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\n     */\n    private canConsumeForm(consumes: string[]): boolean {\n        const form = 'multipart/form-data';\n        for (const consume of consumes) {\n            if (form === consume) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n\n    /**\n     * Delete usuário da aplicação\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public deleteUsuario(body: UsuarioDTO, observe?: 'body', reportProgress?: boolean): Observable<boolean>;\n    public deleteUsuario(body: UsuarioDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<boolean>>;\n    public deleteUsuario(body: UsuarioDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<boolean>>;\n    public deleteUsuario(body: UsuarioDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling deleteUsuario.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<boolean>('delete',`${this.basePath}/admin/usuario`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Download de camadas e grupo de camadas do GeoServer.\n     * \n     * @param layerId \n     * @param format \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public downloadCamada(layerId: string, format: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public downloadCamada(layerId: string, format: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (layerId === null || layerId === undefined) {\n            throw new Error('Required parameter layerId was null or undefined when calling downloadCamada.');\n        }\n\n        if (format === null || format === undefined) {\n            throw new Error('Required parameter format was null or undefined when calling downloadCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (layerId !== undefined && layerId !== null) {\n            queryParameters = queryParameters.set('layerId', <any>layerId);\n        }\n        if (format !== undefined && format !== null) {\n            queryParameters = queryParameters.set('format', <any>format);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/download/camada`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Edição dos atributos de camada.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public editAttributes(body?: EditAttributesDTO, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<string>('post',`${this.basePath}/edit/attributes`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Serviço para exportar o mapa e legendas para PDF.\n     * \n     * @param pdfHeader \n     * @param pdfFooter \n     * @param pdfLegends \n     * @param pdfMap \n     * @param pdfFormat \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'multipart/form-data'\n        ];\n\n        const canConsumeForm = this.canConsumeForm(consumes);\n\n        let formParams: { append(param: string, value: any): void; };\n        let useForm = false;\n        let convertFormParamsToString = false;\n        // use FormData to transmit files using content-type \"multipart/form-data\"\n        // see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data\n        useForm = canConsumeForm;\n        if (useForm) {\n            formParams = new FormData();\n        } else {\n            formParams = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        }\n\n        if (pdfHeader !== undefined) {\n            formParams = formParams.append('pdfHeader', <any>pdfHeader) as any || formParams;\n        }\n        if (pdfFooter !== undefined) {\n            formParams = formParams.append('pdfFooter', <any>pdfFooter) as any || formParams;\n        }\n        if (pdfLegends !== undefined) {\n            formParams = formParams.append('pdfLegends', <any>pdfLegends) as any || formParams;\n        }\n        if (pdfMap !== undefined) {\n            formParams = formParams.append('pdfMap', <any>pdfMap) as any || formParams;\n        }\n        if (pdfFormat !== undefined) {\n            formParams = formParams.append('pdfFormat', <any>pdfFormat) as any || formParams;\n        }\n\n        return this.httpClient.request('post',`${this.basePath}/export/pdf`,\n            {\n                body: convertFormParamsToString ? formParams.toString() : formParams,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de camadas.\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getCamadas(observe?: 'body', reportProgress?: boolean): Observable<Array<GrupoCamadaDTO>>;\n    public getCamadas(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<GrupoCamadaDTO>>('get',`${this.basePath}/camadas`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários do esjc\n     * \n     * @param cpf \n     * @param nome \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (cpf !== undefined && cpf !== null) {\n            queryParameters = queryParameters.set('cpf', <any>cpf);\n        }\n        if (nome !== undefined && nome !== null) {\n            queryParameters = queryParameters.set('nome', <any>nome);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/esjc/usuarios`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar informações de camadas e grupos de camadas por apontamento.\n     * \n     * @param srs \n     * @param version \n     * @param bbox \n     * @param height \n     * @param width \n     * @param layers \n     * @param queryLayers \n     * @param infoFormat \n     * @param x \n     * @param y \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (srs === null || srs === undefined) {\n            throw new Error('Required parameter srs was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (version === null || version === undefined) {\n            throw new Error('Required parameter version was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (bbox === null || bbox === undefined) {\n            throw new Error('Required parameter bbox was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (height === null || height === undefined) {\n            throw new Error('Required parameter height was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (width === null || width === undefined) {\n            throw new Error('Required parameter width was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (layers === null || layers === undefined) {\n            throw new Error('Required parameter layers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (queryLayers === null || queryLayers === undefined) {\n            throw new Error('Required parameter queryLayers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (infoFormat === null || infoFormat === undefined) {\n            throw new Error('Required parameter infoFormat was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (x === null || x === undefined) {\n            throw new Error('Required parameter x was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (y === null || y === undefined) {\n            throw new Error('Required parameter y was null or undefined when calling getFeatureInfo.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (srs !== undefined && srs !== null) {\n            queryParameters = queryParameters.set('srs', <any>srs);\n        }\n        if (version !== undefined && version !== null) {\n            queryParameters = queryParameters.set('version', <any>version);\n        }\n        if (bbox !== undefined && bbox !== null) {\n            queryParameters = queryParameters.set('bbox', <any>bbox);\n        }\n        if (height !== undefined && height !== null) {\n            queryParameters = queryParameters.set('height', <any>height);\n        }\n        if (width !== undefined && width !== null) {\n            queryParameters = queryParameters.set('width', <any>width);\n        }\n        if (layers !== undefined && layers !== null) {\n            queryParameters = queryParameters.set('layers', <any>layers);\n        }\n        if (queryLayers !== undefined && queryLayers !== null) {\n            queryParameters = queryParameters.set('query_layers', <any>queryLayers);\n        }\n        if (infoFormat !== undefined && infoFormat !== null) {\n            queryParameters = queryParameters.set('info_format', <any>infoFormat);\n        }\n        if (x !== undefined && x !== null) {\n            queryParameters = queryParameters.set('x', <any>x);\n        }\n        if (y !== undefined && y !== null) {\n            queryParameters = queryParameters.set('y', <any>y);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<string>('get',`${this.basePath}/featureinfo`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Busca icone\n     * \n     * @param filename \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getIcon(filename: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public getIcon(filename: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public getIcon(filename: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public getIcon(filename: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (filename === null || filename === undefined) {\n            throw new Error('Required parameter filename was null or undefined when calling getIcon.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'image/svg+xml'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/icon/${encodeURIComponent(String(filename))}`,\n            {\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de perfis\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPerfis(observe?: 'body', reportProgress?: boolean): Observable<Array<PerfilDTO>>;\n    public getPerfis(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<PerfilDTO>>>;\n    public getPerfis(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<PerfilDTO>>>;\n    public getPerfis(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<PerfilDTO>>('get',`${this.basePath}/admin/perfis`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de proprieades das camadas e suas configurações.\n     * \n     * @param id \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPropriedadesCamada(id: string, observe?: 'body', reportProgress?: boolean): Observable<Array<CamadaPropriedadeDTO>>;\n    public getPropriedadesCamada(id: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getPropriedadesCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (id !== undefined && id !== null) {\n            queryParameters = queryParameters.set('id', <any>id);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<CamadaPropriedadeDTO>>('get',`${this.basePath}/camada/propriedades`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários da aplicação\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getUsuarios(observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getUsuarios(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getUsuarios(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getUsuarios(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/usuarios`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Localização por unidade geográfica.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'body', reportProgress?: boolean): Observable<Array<ResultadoUnidadeGeoDTO>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling localizarUnidadeGeo.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<Array<ResultadoUnidadeGeoDTO>>('post',`${this.basePath}/localizar`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Proxy para requisições GET ao GeoServer.\n     * \n     * @param url \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public proxy(url: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public proxy(url: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public proxy(url: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public proxy(url: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (url === null || url === undefined) {\n            throw new Error('Required parameter url was null or undefined when calling proxy.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (url !== undefined && url !== null) {\n            queryParameters = queryParameters.set('url', <any>url);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/proxy`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Salvar usuário na aplicação\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public setUsuario(body: UsuarioDTO, observe?: 'body', reportProgress?: boolean): Observable<boolean>;\n    public setUsuario(body: UsuarioDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<boolean>>;\n    public setUsuario(body: UsuarioDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<boolean>>;\n    public setUsuario(body: UsuarioDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling setUsuario.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<boolean>('post',`${this.basePath}/admin/usuario`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}

package/esm2022/model/usuarioDTO.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXN1YXJpb0RUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL3VzdWFyaW9EVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VvU2FuamEgQVBJXG4gKiBBUEkgcGFyYSBBcGxpY2HDp8OjbyBHZW9TYW5qYVxuICpcbiAqIE9wZW5BUEkgc3BlYyB2ZXJzaW9uOiAxLjIuOFxuICogQ29udGFjdDogY2xhdWRpby5ib2dvc3NpYW5AZ21haWwuY29tXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxuICogaHR0cHM6Ly9naXRodWIuY29tL3N3YWdnZXItYXBpL3N3YWdnZXItY29kZWdlbi5naXRcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgUGVyZmlsRFRPIH0gZnJvbSAnLi9wZXJmaWxEVE8nO1xuXG5leHBvcnQgaW50ZXJmYWNlIFVzdWFyaW9EVE8geyBcbiAgICBpZDogbnVtYmVyO1xuICAgIGNwZjogbnVtYmVyO1xuICAgIG5vbWU6IHN0cmluZztcbiAgICBlbWFpbD86IHN0cmluZztcbiAgICB0ZWxlZm9uZTogbnVtYmVyO1xuICAgIHBlcmZpcz86IEFycmF5PFBlcmZpbERUTz47XG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXN1YXJpb0RUTy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL21vZGVsL3VzdWFyaW9EVE8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VvU2FuamEgQVBJXG4gKiBBUEkgcGFyYSBBcGxpY2HDp8OjbyBHZW9TYW5qYVxuICpcbiAqIE9wZW5BUEkgc3BlYyB2ZXJzaW9uOiAxLjIuOFxuICogQ29udGFjdDogY2xhdWRpby5ib2dvc3NpYW5AZ21haWwuY29tXG4gKlxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxuICogaHR0cHM6Ly9naXRodWIuY29tL3N3YWdnZXItYXBpL3N3YWdnZXItY29kZWdlbi5naXRcbiAqIERvIG5vdCBlZGl0IHRoZSBjbGFzcyBtYW51YWxseS5cbiAqL1xuaW1wb3J0IHsgUGVyZmlsRFRPIH0gZnJvbSAnLi9wZXJmaWxEVE8nO1xuXG5leHBvcnQgaW50ZXJmYWNlIFVzdWFyaW9EVE8geyBcbiAgICBpZDogbnVtYmVyO1xuICAgIGNwZjogbnVtYmVyO1xuICAgIG5vbWU6IHN0cmluZztcbiAgICBlbWFpbD86IHN0cmluZztcbiAgICB0ZWxlZm9uZT86IG51bWJlcjtcbiAgICBwZXJmaXM/OiBBcnJheTxQZXJmaWxEVE8+O1xufSJdfQ==

package/fesm2022/geosanja-geosanja-frontend-api.mjs

@@ -131,6 +131,35 @@ class DefaultService {
         }
         return false;
     }
+    deleteUsuario(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling deleteUsuario.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            'application/json'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('delete', `${this.basePath}/admin/usuario`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
     downloadCamada(layerId, format, observe = 'body', reportProgress = false) {
         if (layerId === null || layerId === undefined) {
             throw new Error('Required parameter layerId was null or undefined when calling downloadCamada.');
@@ -514,6 +543,35 @@ class DefaultService {
             reportProgress: reportProgress
         });
     }
+    setUsuario(body, observe = 'body', reportProgress = false) {
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling setUsuario.');
+        }
+        let headers = this.defaultHeaders;
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            'application/json'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('post', `${this.basePath}/admin/usuario`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultService, providedIn: 'root' });
 }

package/fesm2022/geosanja-geosanja-frontend-api.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"geosanja-geosanja-frontend-api.mjs","sources":["../../encoder.ts","../../variables.ts","../../configuration.ts","../../api/default.service.ts","../../api/api.ts","../../model/camadaCustomAttributeDTO.ts","../../model/camadaPropriedadeValorPadraoDTO.ts","../../model/camadaToolDTO.ts","../../model/editAttributesDTOAttributes.ts","../../model/exportPDFDTO.ts","../../model/localizarUnidadeGeoDTOParametros.ts","../../model/perfilDTO.ts","../../model/resultadoUnidadeGeoDTO.ts","../../api.module.ts","../../geosanja-geosanja-frontend-api.ts"],"sourcesContent":["    import { HttpUrlEncodingCodec } from '@angular/common/http';\n\n/**\n* CustomHttpUrlEncodingCodec\n* Fix plus sign (+) not encoding, so sent as blank space\n* See: https://github.com/angular/angular/issues/11058#issuecomment-247367318\n*/\nexport class CustomHttpUrlEncodingCodec extends HttpUrlEncodingCodec {\n    override encodeKey(k: string): string {\n        k = super.encodeKey(k);\n        return k.replace(/\\+/gi, '%2B');\n    }\n    override encodeValue(v: string): string {\n        v = super.encodeValue(v);\n        return v.replace(/\\+/gi, '%2B');\n    }\n}\n\n","import { InjectionToken } from '@angular/core';\n\nexport const BASE_PATH = new InjectionToken<string>('basePath');\nexport const COLLECTION_FORMATS = {\n    'csv': ',',\n    'tsv': '   ',\n    'ssv': ' ',\n    'pipes': '|'\n}\n","export interface ConfigurationParameters {\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n}\n\nexport class Configuration {\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n\n    constructor(configurationParameters: ConfigurationParameters = {}) {\n        this.apiKeys = configurationParameters.apiKeys;\n        this.username = configurationParameters.username;\n        this.password = configurationParameters.password;\n        this.accessToken = configurationParameters.accessToken;\n        this.basePath = configurationParameters.basePath;\n        this.withCredentials = configurationParameters.withCredentials;\n    }\n\n    /**\n     * Select the correct content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param contentTypes - the array of content types that are available for selection\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderContentType (contentTypes: string[]): string | undefined {\n        if (contentTypes.length == 0) {\n            return undefined;\n        }\n\n        let type = contentTypes.find(x => this.isJsonMime(x));\n        if (type === undefined) {\n            return contentTypes[0];\n        }\n        return type;\n    }\n\n    /**\n     * Select the correct accept content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param accepts - the array of content types that are available for selection.\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderAccept(accepts: string[]): string | undefined {\n        if (accepts.length == 0) {\n            return undefined;\n        }\n\n        let type = accepts.find(x => this.isJsonMime(x));\n        if (type === undefined) {\n            return accepts[0];\n        }\n        return type;\n    }\n\n    /**\n     * Check if the given MIME is a JSON MIME.\n     * JSON MIME examples:\n     *   application/json\n     *   application/json; charset=UTF8\n     *   APPLICATION/JSON\n     *   application/vnd.company+json\n     * @param mime - MIME (Multipurpose Internet Mail Extensions)\n     * @return True if the given MIME is JSON, false otherwise.\n     */\n    public isJsonMime(mime: string): boolean {\n        const jsonMime: RegExp = new RegExp('^(application\\/json|[^;/ \\t]+\\/[^;/ \\t]+[+]json)[ \\t]*(;.*)?$', 'i');\n        return mime != null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');\n    }\n}\n","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n *//* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent }                           from '@angular/common/http';\nimport { CustomHttpUrlEncodingCodec }                        from '../encoder';\n\nimport { Observable }                                        from 'rxjs';\n\nimport { CamadaPropriedadeDTO } from '../model/camadaPropriedadeDTO';\nimport { EditAttributesDTO } from '../model/editAttributesDTO';\nimport { GrupoCamadaDTO } from '../model/grupoCamadaDTO';\nimport { LocalizarUnidadeGeoDTO } from '../model/localizarUnidadeGeoDTO';\nimport { PerfilDTO } from '../model/perfilDTO';\nimport { ResultadoUnidadeGeoDTO } from '../model/resultadoUnidadeGeoDTO';\nimport { UsuarioDTO } from '../model/usuarioDTO';\n\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefaultService {\n\n    protected basePath = '/';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\n        if (basePath) {\n            this.basePath = basePath;\n        }\n        if (configuration) {\n            this.configuration = configuration;\n            this.basePath = basePath || configuration.basePath || this.basePath;\n        }\n    }\n\n    /**\n     * @param consumes string[] mime-types\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\n     */\n    private canConsumeForm(consumes: string[]): boolean {\n        const form = 'multipart/form-data';\n        for (const consume of consumes) {\n            if (form === consume) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n\n    /**\n     * Download de camadas e grupo de camadas do GeoServer.\n     * \n     * @param layerId \n     * @param format \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public downloadCamada(layerId: string, format: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public downloadCamada(layerId: string, format: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (layerId === null || layerId === undefined) {\n            throw new Error('Required parameter layerId was null or undefined when calling downloadCamada.');\n        }\n\n        if (format === null || format === undefined) {\n            throw new Error('Required parameter format was null or undefined when calling downloadCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (layerId !== undefined && layerId !== null) {\n            queryParameters = queryParameters.set('layerId', <any>layerId);\n        }\n        if (format !== undefined && format !== null) {\n            queryParameters = queryParameters.set('format', <any>format);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/download/camada`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Edição dos atributos de camada.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public editAttributes(body?: EditAttributesDTO, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<string>('post',`${this.basePath}/edit/attributes`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Serviço para exportar o mapa e legendas para PDF.\n     * \n     * @param pdfHeader \n     * @param pdfFooter \n     * @param pdfLegends \n     * @param pdfMap \n     * @param pdfFormat \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'multipart/form-data'\n        ];\n\n        const canConsumeForm = this.canConsumeForm(consumes);\n\n        let formParams: { append(param: string, value: any): void; };\n        let useForm = false;\n        let convertFormParamsToString = false;\n        // use FormData to transmit files using content-type \"multipart/form-data\"\n        // see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data\n        useForm = canConsumeForm;\n        if (useForm) {\n            formParams = new FormData();\n        } else {\n            formParams = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        }\n\n        if (pdfHeader !== undefined) {\n            formParams = formParams.append('pdfHeader', <any>pdfHeader) as any || formParams;\n        }\n        if (pdfFooter !== undefined) {\n            formParams = formParams.append('pdfFooter', <any>pdfFooter) as any || formParams;\n        }\n        if (pdfLegends !== undefined) {\n            formParams = formParams.append('pdfLegends', <any>pdfLegends) as any || formParams;\n        }\n        if (pdfMap !== undefined) {\n            formParams = formParams.append('pdfMap', <any>pdfMap) as any || formParams;\n        }\n        if (pdfFormat !== undefined) {\n            formParams = formParams.append('pdfFormat', <any>pdfFormat) as any || formParams;\n        }\n\n        return this.httpClient.request('post',`${this.basePath}/export/pdf`,\n            {\n                body: convertFormParamsToString ? formParams.toString() : formParams,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de camadas.\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getCamadas(observe?: 'body', reportProgress?: boolean): Observable<Array<GrupoCamadaDTO>>;\n    public getCamadas(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<GrupoCamadaDTO>>('get',`${this.basePath}/camadas`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários do esjc\n     * \n     * @param cpf \n     * @param nome \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (cpf !== undefined && cpf !== null) {\n            queryParameters = queryParameters.set('cpf', <any>cpf);\n        }\n        if (nome !== undefined && nome !== null) {\n            queryParameters = queryParameters.set('nome', <any>nome);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/esjc/usuarios`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar informações de camadas e grupos de camadas por apontamento.\n     * \n     * @param srs \n     * @param version \n     * @param bbox \n     * @param height \n     * @param width \n     * @param layers \n     * @param queryLayers \n     * @param infoFormat \n     * @param x \n     * @param y \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (srs === null || srs === undefined) {\n            throw new Error('Required parameter srs was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (version === null || version === undefined) {\n            throw new Error('Required parameter version was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (bbox === null || bbox === undefined) {\n            throw new Error('Required parameter bbox was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (height === null || height === undefined) {\n            throw new Error('Required parameter height was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (width === null || width === undefined) {\n            throw new Error('Required parameter width was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (layers === null || layers === undefined) {\n            throw new Error('Required parameter layers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (queryLayers === null || queryLayers === undefined) {\n            throw new Error('Required parameter queryLayers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (infoFormat === null || infoFormat === undefined) {\n            throw new Error('Required parameter infoFormat was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (x === null || x === undefined) {\n            throw new Error('Required parameter x was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (y === null || y === undefined) {\n            throw new Error('Required parameter y was null or undefined when calling getFeatureInfo.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (srs !== undefined && srs !== null) {\n            queryParameters = queryParameters.set('srs', <any>srs);\n        }\n        if (version !== undefined && version !== null) {\n            queryParameters = queryParameters.set('version', <any>version);\n        }\n        if (bbox !== undefined && bbox !== null) {\n            queryParameters = queryParameters.set('bbox', <any>bbox);\n        }\n        if (height !== undefined && height !== null) {\n            queryParameters = queryParameters.set('height', <any>height);\n        }\n        if (width !== undefined && width !== null) {\n            queryParameters = queryParameters.set('width', <any>width);\n        }\n        if (layers !== undefined && layers !== null) {\n            queryParameters = queryParameters.set('layers', <any>layers);\n        }\n        if (queryLayers !== undefined && queryLayers !== null) {\n            queryParameters = queryParameters.set('query_layers', <any>queryLayers);\n        }\n        if (infoFormat !== undefined && infoFormat !== null) {\n            queryParameters = queryParameters.set('info_format', <any>infoFormat);\n        }\n        if (x !== undefined && x !== null) {\n            queryParameters = queryParameters.set('x', <any>x);\n        }\n        if (y !== undefined && y !== null) {\n            queryParameters = queryParameters.set('y', <any>y);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<string>('get',`${this.basePath}/featureinfo`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Busca icone\n     * \n     * @param filename \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getIcon(filename: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public getIcon(filename: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public getIcon(filename: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public getIcon(filename: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (filename === null || filename === undefined) {\n            throw new Error('Required parameter filename was null or undefined when calling getIcon.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'image/svg+xml'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/icon/${encodeURIComponent(String(filename))}`,\n            {\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de perfis\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPerfis(observe?: 'body', reportProgress?: boolean): Observable<Array<PerfilDTO>>;\n    public getPerfis(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<PerfilDTO>>>;\n    public getPerfis(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<PerfilDTO>>>;\n    public getPerfis(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<PerfilDTO>>('get',`${this.basePath}/admin/perfis`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de proprieades das camadas e suas configurações.\n     * \n     * @param id \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPropriedadesCamada(id: string, observe?: 'body', reportProgress?: boolean): Observable<Array<CamadaPropriedadeDTO>>;\n    public getPropriedadesCamada(id: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getPropriedadesCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (id !== undefined && id !== null) {\n            queryParameters = queryParameters.set('id', <any>id);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<CamadaPropriedadeDTO>>('get',`${this.basePath}/camada/propriedades`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários da aplicação\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getUsuarios(observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getUsuarios(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getUsuarios(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getUsuarios(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/usuarios`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Localização por unidade geográfica.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'body', reportProgress?: boolean): Observable<Array<ResultadoUnidadeGeoDTO>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling localizarUnidadeGeo.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<Array<ResultadoUnidadeGeoDTO>>('post',`${this.basePath}/localizar`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Proxy para requisições GET ao GeoServer.\n     * \n     * @param url \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public proxy(url: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public proxy(url: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public proxy(url: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public proxy(url: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (url === null || url === undefined) {\n            throw new Error('Required parameter url was null or undefined when calling proxy.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (url !== undefined && url !== null) {\n            queryParameters = queryParameters.set('url', <any>url);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/proxy`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n","export * from './default.service';\nimport { DefaultService } from './default.service';\nexport const APIS = [DefaultService];\n","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface CamadaCustomAttributeDTO { \n    id?: number;\n    attribute?: string;\n    valor?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface CamadaPropriedadeValorPadraoDTO { \n    id?: number;\n    geoserverId?: string;\n    campo?: string;\n    valor?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface CamadaToolDTO { \n    id?: number;\n    toolId?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface EditAttributesDTOAttributes { \n    key?: string;\n    value?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface ExportPDFDTO { \n    pdfHeader?: string;\n    pdfFooter?: string;\n    pdfLegends?: string;\n    pdfMap: Blob;\n    pdfFormat: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface LocalizarUnidadeGeoDTOParametros { \n    name?: string;\n    value?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface PerfilDTO { \n    id: number;\n    nome?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface ResultadoUnidadeGeoDTO { \n    camadaId?: number;\n    data?: any;\n}","import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';\nimport { Configuration } from './configuration';\nimport { HttpClient } from '@angular/common/http';\n\n\nimport { DefaultService } from './api/default.service';\n\n@NgModule({\n  imports:      [],\n  declarations: [],\n  exports:      [],\n  providers: [\n    DefaultService ]\n})\nexport class ApiModule {\n    public static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<ApiModule> {\n        return {\n            ngModule: ApiModule,\n            providers: [ { provide: Configuration, useFactory: configurationFactory } ]\n        };\n    }\n\n    constructor( @Optional() @SkipSelf() parentModule: ApiModule,\n                 @Optional() http: HttpClient) {\n        if (parentModule) {\n            throw new Error('ApiModule is already loaded. Import in your base AppModule only.');\n        }\n        if (!http) {\n            throw new Error('You need to import the HttpClientModule in your AppModule! \\n' +\n            'See also https://github.com/angular/angular/issues/20575');\n        }\n    }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["i2.Configuration"],"mappings":"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"}
+{"version":3,"file":"geosanja-geosanja-frontend-api.mjs","sources":["../../encoder.ts","../../variables.ts","../../configuration.ts","../../api/default.service.ts","../../api/api.ts","../../model/camadaCustomAttributeDTO.ts","../../model/camadaPropriedadeValorPadraoDTO.ts","../../model/camadaToolDTO.ts","../../model/editAttributesDTOAttributes.ts","../../model/exportPDFDTO.ts","../../model/localizarUnidadeGeoDTOParametros.ts","../../model/perfilDTO.ts","../../model/resultadoUnidadeGeoDTO.ts","../../api.module.ts","../../geosanja-geosanja-frontend-api.ts"],"sourcesContent":["    import { HttpUrlEncodingCodec } from '@angular/common/http';\n\n/**\n* CustomHttpUrlEncodingCodec\n* Fix plus sign (+) not encoding, so sent as blank space\n* See: https://github.com/angular/angular/issues/11058#issuecomment-247367318\n*/\nexport class CustomHttpUrlEncodingCodec extends HttpUrlEncodingCodec {\n    override encodeKey(k: string): string {\n        k = super.encodeKey(k);\n        return k.replace(/\\+/gi, '%2B');\n    }\n    override encodeValue(v: string): string {\n        v = super.encodeValue(v);\n        return v.replace(/\\+/gi, '%2B');\n    }\n}\n\n","import { InjectionToken } from '@angular/core';\n\nexport const BASE_PATH = new InjectionToken<string>('basePath');\nexport const COLLECTION_FORMATS = {\n    'csv': ',',\n    'tsv': '   ',\n    'ssv': ' ',\n    'pipes': '|'\n}\n","export interface ConfigurationParameters {\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n}\n\nexport class Configuration {\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n\n    constructor(configurationParameters: ConfigurationParameters = {}) {\n        this.apiKeys = configurationParameters.apiKeys;\n        this.username = configurationParameters.username;\n        this.password = configurationParameters.password;\n        this.accessToken = configurationParameters.accessToken;\n        this.basePath = configurationParameters.basePath;\n        this.withCredentials = configurationParameters.withCredentials;\n    }\n\n    /**\n     * Select the correct content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param contentTypes - the array of content types that are available for selection\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderContentType (contentTypes: string[]): string | undefined {\n        if (contentTypes.length == 0) {\n            return undefined;\n        }\n\n        let type = contentTypes.find(x => this.isJsonMime(x));\n        if (type === undefined) {\n            return contentTypes[0];\n        }\n        return type;\n    }\n\n    /**\n     * Select the correct accept content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param accepts - the array of content types that are available for selection.\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderAccept(accepts: string[]): string | undefined {\n        if (accepts.length == 0) {\n            return undefined;\n        }\n\n        let type = accepts.find(x => this.isJsonMime(x));\n        if (type === undefined) {\n            return accepts[0];\n        }\n        return type;\n    }\n\n    /**\n     * Check if the given MIME is a JSON MIME.\n     * JSON MIME examples:\n     *   application/json\n     *   application/json; charset=UTF8\n     *   APPLICATION/JSON\n     *   application/vnd.company+json\n     * @param mime - MIME (Multipurpose Internet Mail Extensions)\n     * @return True if the given MIME is JSON, false otherwise.\n     */\n    public isJsonMime(mime: string): boolean {\n        const jsonMime: RegExp = new RegExp('^(application\\/json|[^;/ \\t]+\\/[^;/ \\t]+[+]json)[ \\t]*(;.*)?$', 'i');\n        return mime != null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');\n    }\n}\n","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n *//* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent }                           from '@angular/common/http';\nimport { CustomHttpUrlEncodingCodec }                        from '../encoder';\n\nimport { Observable }                                        from 'rxjs';\n\nimport { CamadaPropriedadeDTO } from '../model/camadaPropriedadeDTO';\nimport { EditAttributesDTO } from '../model/editAttributesDTO';\nimport { GrupoCamadaDTO } from '../model/grupoCamadaDTO';\nimport { LocalizarUnidadeGeoDTO } from '../model/localizarUnidadeGeoDTO';\nimport { PerfilDTO } from '../model/perfilDTO';\nimport { ResultadoUnidadeGeoDTO } from '../model/resultadoUnidadeGeoDTO';\nimport { UsuarioDTO } from '../model/usuarioDTO';\n\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefaultService {\n\n    protected basePath = '/';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\n        if (basePath) {\n            this.basePath = basePath;\n        }\n        if (configuration) {\n            this.configuration = configuration;\n            this.basePath = basePath || configuration.basePath || this.basePath;\n        }\n    }\n\n    /**\n     * @param consumes string[] mime-types\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\n     */\n    private canConsumeForm(consumes: string[]): boolean {\n        const form = 'multipart/form-data';\n        for (const consume of consumes) {\n            if (form === consume) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n\n    /**\n     * Delete usuário da aplicação\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public deleteUsuario(body: UsuarioDTO, observe?: 'body', reportProgress?: boolean): Observable<boolean>;\n    public deleteUsuario(body: UsuarioDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<boolean>>;\n    public deleteUsuario(body: UsuarioDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<boolean>>;\n    public deleteUsuario(body: UsuarioDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling deleteUsuario.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<boolean>('delete',`${this.basePath}/admin/usuario`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Download de camadas e grupo de camadas do GeoServer.\n     * \n     * @param layerId \n     * @param format \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public downloadCamada(layerId: string, format: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public downloadCamada(layerId: string, format: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public downloadCamada(layerId: string, format: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (layerId === null || layerId === undefined) {\n            throw new Error('Required parameter layerId was null or undefined when calling downloadCamada.');\n        }\n\n        if (format === null || format === undefined) {\n            throw new Error('Required parameter format was null or undefined when calling downloadCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (layerId !== undefined && layerId !== null) {\n            queryParameters = queryParameters.set('layerId', <any>layerId);\n        }\n        if (format !== undefined && format !== null) {\n            queryParameters = queryParameters.set('format', <any>format);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/download/camada`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Edição dos atributos de camada.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public editAttributes(body?: EditAttributesDTO, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public editAttributes(body?: EditAttributesDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<string>('post',`${this.basePath}/edit/attributes`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Serviço para exportar o mapa e legendas para PDF.\n     * \n     * @param pdfHeader \n     * @param pdfFooter \n     * @param pdfLegends \n     * @param pdfMap \n     * @param pdfFormat \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public exportPDFForm(pdfHeader?: string, pdfFooter?: string, pdfLegends?: string, pdfMap?: Blob, pdfFormat?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n\n\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'multipart/form-data'\n        ];\n\n        const canConsumeForm = this.canConsumeForm(consumes);\n\n        let formParams: { append(param: string, value: any): void; };\n        let useForm = false;\n        let convertFormParamsToString = false;\n        // use FormData to transmit files using content-type \"multipart/form-data\"\n        // see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data\n        useForm = canConsumeForm;\n        if (useForm) {\n            formParams = new FormData();\n        } else {\n            formParams = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        }\n\n        if (pdfHeader !== undefined) {\n            formParams = formParams.append('pdfHeader', <any>pdfHeader) as any || formParams;\n        }\n        if (pdfFooter !== undefined) {\n            formParams = formParams.append('pdfFooter', <any>pdfFooter) as any || formParams;\n        }\n        if (pdfLegends !== undefined) {\n            formParams = formParams.append('pdfLegends', <any>pdfLegends) as any || formParams;\n        }\n        if (pdfMap !== undefined) {\n            formParams = formParams.append('pdfMap', <any>pdfMap) as any || formParams;\n        }\n        if (pdfFormat !== undefined) {\n            formParams = formParams.append('pdfFormat', <any>pdfFormat) as any || formParams;\n        }\n\n        return this.httpClient.request('post',`${this.basePath}/export/pdf`,\n            {\n                body: convertFormParamsToString ? formParams.toString() : formParams,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de camadas.\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getCamadas(observe?: 'body', reportProgress?: boolean): Observable<Array<GrupoCamadaDTO>>;\n    public getCamadas(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<GrupoCamadaDTO>>>;\n    public getCamadas(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<GrupoCamadaDTO>>('get',`${this.basePath}/camadas`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários do esjc\n     * \n     * @param cpf \n     * @param nome \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getESJCUsuarios(cpf?: number, nome?: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (cpf !== undefined && cpf !== null) {\n            queryParameters = queryParameters.set('cpf', <any>cpf);\n        }\n        if (nome !== undefined && nome !== null) {\n            queryParameters = queryParameters.set('nome', <any>nome);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/esjc/usuarios`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar informações de camadas e grupos de camadas por apontamento.\n     * \n     * @param srs \n     * @param version \n     * @param bbox \n     * @param height \n     * @param width \n     * @param layers \n     * @param queryLayers \n     * @param infoFormat \n     * @param x \n     * @param y \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'body', reportProgress?: boolean): Observable<string>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<string>>;\n    public getFeatureInfo(srs: string, version: string, bbox: string, height: string, width: string, layers: string, queryLayers: string, infoFormat: string, x: string, y: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (srs === null || srs === undefined) {\n            throw new Error('Required parameter srs was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (version === null || version === undefined) {\n            throw new Error('Required parameter version was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (bbox === null || bbox === undefined) {\n            throw new Error('Required parameter bbox was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (height === null || height === undefined) {\n            throw new Error('Required parameter height was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (width === null || width === undefined) {\n            throw new Error('Required parameter width was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (layers === null || layers === undefined) {\n            throw new Error('Required parameter layers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (queryLayers === null || queryLayers === undefined) {\n            throw new Error('Required parameter queryLayers was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (infoFormat === null || infoFormat === undefined) {\n            throw new Error('Required parameter infoFormat was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (x === null || x === undefined) {\n            throw new Error('Required parameter x was null or undefined when calling getFeatureInfo.');\n        }\n\n        if (y === null || y === undefined) {\n            throw new Error('Required parameter y was null or undefined when calling getFeatureInfo.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (srs !== undefined && srs !== null) {\n            queryParameters = queryParameters.set('srs', <any>srs);\n        }\n        if (version !== undefined && version !== null) {\n            queryParameters = queryParameters.set('version', <any>version);\n        }\n        if (bbox !== undefined && bbox !== null) {\n            queryParameters = queryParameters.set('bbox', <any>bbox);\n        }\n        if (height !== undefined && height !== null) {\n            queryParameters = queryParameters.set('height', <any>height);\n        }\n        if (width !== undefined && width !== null) {\n            queryParameters = queryParameters.set('width', <any>width);\n        }\n        if (layers !== undefined && layers !== null) {\n            queryParameters = queryParameters.set('layers', <any>layers);\n        }\n        if (queryLayers !== undefined && queryLayers !== null) {\n            queryParameters = queryParameters.set('query_layers', <any>queryLayers);\n        }\n        if (infoFormat !== undefined && infoFormat !== null) {\n            queryParameters = queryParameters.set('info_format', <any>infoFormat);\n        }\n        if (x !== undefined && x !== null) {\n            queryParameters = queryParameters.set('x', <any>x);\n        }\n        if (y !== undefined && y !== null) {\n            queryParameters = queryParameters.set('y', <any>y);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<string>('get',`${this.basePath}/featureinfo`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Busca icone\n     * \n     * @param filename \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getIcon(filename: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public getIcon(filename: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public getIcon(filename: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public getIcon(filename: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (filename === null || filename === undefined) {\n            throw new Error('Required parameter filename was null or undefined when calling getIcon.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'image/svg+xml'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/icon/${encodeURIComponent(String(filename))}`,\n            {\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de perfis\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPerfis(observe?: 'body', reportProgress?: boolean): Observable<Array<PerfilDTO>>;\n    public getPerfis(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<PerfilDTO>>>;\n    public getPerfis(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<PerfilDTO>>>;\n    public getPerfis(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<PerfilDTO>>('get',`${this.basePath}/admin/perfis`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de proprieades das camadas e suas configurações.\n     * \n     * @param id \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getPropriedadesCamada(id: string, observe?: 'body', reportProgress?: boolean): Observable<Array<CamadaPropriedadeDTO>>;\n    public getPropriedadesCamada(id: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<CamadaPropriedadeDTO>>>;\n    public getPropriedadesCamada(id: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (id === null || id === undefined) {\n            throw new Error('Required parameter id was null or undefined when calling getPropriedadesCamada.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (id !== undefined && id !== null) {\n            queryParameters = queryParameters.set('id', <any>id);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<CamadaPropriedadeDTO>>('get',`${this.basePath}/camada/propriedades`,\n            {\n                params: queryParameters,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Buscar lista de usuários da aplicação\n     * \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getUsuarios(observe?: 'body', reportProgress?: boolean): Observable<Array<UsuarioDTO>>;\n    public getUsuarios(observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<UsuarioDTO>>>;\n    public getUsuarios(observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<UsuarioDTO>>>;\n    public getUsuarios(observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request<Array<UsuarioDTO>>('get',`${this.basePath}/admin/usuarios`,\n            {\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Localização por unidade geográfica.\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'body', reportProgress?: boolean): Observable<Array<ResultadoUnidadeGeoDTO>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Array<ResultadoUnidadeGeoDTO>>>;\n    public localizarUnidadeGeo(body: LocalizarUnidadeGeoDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling localizarUnidadeGeo.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<Array<ResultadoUnidadeGeoDTO>>('post',`${this.basePath}/localizar`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Proxy para requisições GET ao GeoServer.\n     * \n     * @param url \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public proxy(url: string, observe?: 'body', reportProgress?: boolean): Observable<Blob>;\n    public proxy(url: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<Blob>>;\n    public proxy(url: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<Blob>>;\n    public proxy(url: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (url === null || url === undefined) {\n            throw new Error('Required parameter url was null or undefined when calling proxy.');\n        }\n\n        let queryParameters = new HttpParams({encoder: new CustomHttpUrlEncodingCodec()});\n        if (url !== undefined && url !== null) {\n            queryParameters = queryParameters.set('url', <any>url);\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/octet-stream'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n        ];\n\n        return this.httpClient.request('get',`${this.basePath}/proxy`,\n            {\n                params: queryParameters,\n                responseType: \"blob\",\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Salvar usuário na aplicação\n     * \n     * @param body \n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public setUsuario(body: UsuarioDTO, observe?: 'body', reportProgress?: boolean): Observable<boolean>;\n    public setUsuario(body: UsuarioDTO, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<boolean>>;\n    public setUsuario(body: UsuarioDTO, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<boolean>>;\n    public setUsuario(body: UsuarioDTO, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\n\n        if (body === null || body === undefined) {\n            throw new Error('Required parameter body was null or undefined when calling setUsuario.');\n        }\n\n        let headers = this.defaultHeaders;\n\n        // to determine the Accept header\n        let httpHeaderAccepts: string[] = [\n            'application/json'\n        ];\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        if (httpHeaderAcceptSelected != undefined) {\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\n        }\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected != undefined) {\n            headers = headers.set('Content-Type', httpContentTypeSelected);\n        }\n\n        return this.httpClient.request<boolean>('post',`${this.basePath}/admin/usuario`,\n            {\n                body: body,\n                withCredentials: this.configuration.withCredentials,\n                headers: headers,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n","export * from './default.service';\nimport { DefaultService } from './default.service';\nexport const APIS = [DefaultService];\n","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface CamadaCustomAttributeDTO { \n    id?: number;\n    attribute?: string;\n    valor?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface CamadaPropriedadeValorPadraoDTO { \n    id?: number;\n    geoserverId?: string;\n    campo?: string;\n    valor?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface CamadaToolDTO { \n    id?: number;\n    toolId?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface EditAttributesDTOAttributes { \n    key?: string;\n    value?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface ExportPDFDTO { \n    pdfHeader?: string;\n    pdfFooter?: string;\n    pdfLegends?: string;\n    pdfMap: Blob;\n    pdfFormat: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface LocalizarUnidadeGeoDTOParametros { \n    name?: string;\n    value?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface PerfilDTO { \n    id: number;\n    nome?: string;\n}","/**\n * GeoSanja API\n * API para Aplicação GeoSanja\n *\n * OpenAPI spec version: 1.2.8\n * Contact: claudio.bogossian@gmail.com\n *\n * NOTE: This class is auto generated by the swagger code generator program.\n * https://github.com/swagger-api/swagger-codegen.git\n * Do not edit the class manually.\n */\n\nexport interface ResultadoUnidadeGeoDTO { \n    camadaId?: number;\n    data?: any;\n}","import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';\nimport { Configuration } from './configuration';\nimport { HttpClient } from '@angular/common/http';\n\n\nimport { DefaultService } from './api/default.service';\n\n@NgModule({\n  imports:      [],\n  declarations: [],\n  exports:      [],\n  providers: [\n    DefaultService ]\n})\nexport class ApiModule {\n    public static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<ApiModule> {\n        return {\n            ngModule: ApiModule,\n            providers: [ { provide: Configuration, useFactory: configurationFactory } ]\n        };\n    }\n\n    constructor( @Optional() @SkipSelf() parentModule: ApiModule,\n                 @Optional() http: HttpClient) {\n        if (parentModule) {\n            throw new Error('ApiModule is already loaded. Import in your base AppModule only.');\n        }\n        if (!http) {\n            throw new Error('You need to import the HttpClientModule in your AppModule! \\n' +\n            'See also https://github.com/angular/angular/issues/20575');\n        }\n    }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["i2.Configuration"],"mappings":"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"}

package/model/usuarioDTO.d.ts

@@ -15,6 +15,6 @@ export interface UsuarioDTO {
     cpf: number;
     nome: string;
     email?: string;
-    telefone: number;
+    telefone?: number;
     perfis?: Array<PerfilDTO>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geosanja/geosanja-frontend-api",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "swagger client for @geosanja/geosanja-frontend-api",
   "author": "Swagger Codegen Contributors",
   "keywords": [