@sankhyalabs/sankhyablocks 0.0.0-feat-dev-kb-4158.0

package/dist/collection/components/snk-application/snk-application.js

@@ -0,0 +1,2000 @@
+import { h } from "@stencil/core";
+import { DataType, ErrorTracking, DependencyType, ApplicationContext, ElementIDUtils, OnboardingUtils } from "@sankhyalabs/core";
+import { DataFetcher } from "../../lib/http/data-fetcher/DataFetcher";
+import { ApplicationUtils } from "@sankhyalabs/ezui/dist/collection/utils";
+import { SnkErrorHandler } from "./errorhandler/snk-error-handler";
+import { PesquisaFetcher } from "../../lib/http/data-fetcher/fetchers/pesquisa-fetcher";
+import { agGridLicense } from '../../lib/licenses/sankhyalicense.module';
+import { TotalsFetcher } from "../../lib/http/data-fetcher/fetchers/totals-fetcher";
+import { ConfigStorage } from "../../lib/configs/ConfigStorage";
+import DataUnitFetcher from "../../lib/http/data-fetcher/fetchers/dataunit-fetcher";
+import UrlUtils from "../../lib/utils/urlutils";
+import Workspace from "../../lib/workspace/workspace";
+import AppletCaller from "../../lib/applet-caller/applet-caller";
+import ParametersFetcher from "../../lib/http/data-fetcher/fetchers/parameters-fecher";
+import MGEAuthorization from '../../lib/auth/mgeauthorization.module';
+import GridConfigFetcher from "../../lib/http/data-fetcher/fetchers/grid-config-fetcher";
+import AuthFetcher, { AutorizationType } from "../../lib/http/data-fetcher/fetchers/auth-fetcher";
+import { SnkMessageBuilder } from "../../lib/message/SnkMessageBuilder";
+/**
+ * É possível customizar as mensagens dos blocos de construção através de um pequeno modulo na estrutura da aplicação:
+ * - Criar um arquivo no seguinte caminho: /messages/appmessages.msg.js.
+ * Para conhecer os detalhes do módulo, vide os arquivos neste projeto "/src/lib/message/resources/*.msg.ts"
+ */
+export class SnkApplication {
+  constructor() {
+    this._authPromises = [];
+    this._duCache = new Map();
+    this._duPromises = new Map();
+    this._requestListener = new RequestListenerLoadingBar();
+    this.messagesBuilder = undefined;
+    this.configName = undefined;
+  }
+  get parameters() {
+    if (!this._parameters) {
+      this._parameters = new ParametersFetcher();
+    }
+    return this._parameters;
+  }
+  get resourceID() {
+    if (!this._resourceID) {
+      this._resourceID = this.urlParams.get("workspaceResourceID") ||
+        this.urlParams.get("resourceID") ||
+        Workspace.resourceID ||
+        "unknown.resource.id";
+    }
+    return this._resourceID;
+  }
+  get auth() {
+    if (this._auth) {
+      return Promise.resolve(this._auth);
+    }
+    else {
+      return new Promise((resolve, reject) => {
+        const waitingAuth = this._authPromises.length > 0;
+        this._authPromises.push(new PendingPromise(resolve, reject));
+        if (!waitingAuth) {
+          this.authFetcher.getData(this.resourceID).then((authList) => {
+            this._auth = authList;
+            while (this._authPromises.length > 0) {
+              this._authPromises.pop().resolve(this._auth);
+            }
+          }).catch(error => {
+            while (this._authPromises.length > 0) {
+              this._authPromises.pop().reject(error);
+            }
+          });
+        }
+      });
+    }
+  }
+  /**
+   * Obtém `true` caso o usuário logado seja o SUP.
+   */
+  async isUserSup() {
+    return new Promise((resolve, reject) => {
+      this.auth.then((authorization) => {
+        this.getAuthList(authorization).then((auths) => {
+          resolve(auths.isSup);
+        }).catch(error => reject(error));
+      });
+    });
+  }
+  initOnboarding(onboardingKey) {
+    OnboardingUtils.getInstance().init(onboardingKey, window.envContext);
+    return Promise.resolve();
+  }
+  /**
+   * Obtém `true` caso o usuário logado tem permissão pra determinada ação.
+   */
+  async hasAccess(access) {
+    return new Promise((resolve, reject) => {
+      this.auth.then((authorization) => {
+        this.getAuthList(authorization).then((auths) => {
+          resolve(auths.isSup || auths.actions[access]);
+        }).catch(error => reject(error));
+      });
+    });
+  }
+  /**
+   * Obtém todos os acessos do usuário logado.
+   */
+  async getAllAccess() {
+    return new Promise((resolve, reject) => {
+      this.auth.then((authorization) => {
+        this.getAuthList(authorization).then((auths) => {
+          const allAccess = {};
+          allAccess['isSup'] = auths.isSup;
+          Object.entries(AutorizationType).forEach((data) => {
+            allAccess[data[0]] = auths.actions[data[1]] || false;
+          });
+          resolve(allAccess);
+        }).catch(error => reject(error));
+      });
+    });
+  }
+  /**
+   * Obtém o valor de um parâmetro do tipo string.
+   */
+  async getStringParam(name) {
+    return this.parameters.asString(name);
+  }
+  /**
+   * Obtém o valor de um parâmetro do tipo Inteiro.
+   */
+  async getIntParam(name) {
+    return this.parameters.asInteger(name);
+  }
+  /**
+   * Obtém o valor de um parâmetro do tipo Decimal.
+   */
+  async getFloatParam(name) {
+    return this.parameters.asFloat(name);
+  }
+  /**
+   * Obtém o valor de um parâmetro do tipo booleano.
+   */
+  async getBooleanParam(name) {
+    return this.parameters.asBoolean(name);
+  }
+  /**
+   * Obtém o valor de um parâmetro do tipo data.
+   */
+  async getDateParam(name) {
+    return this.parameters.asDate(name);
+  }
+  /**
+   * Exibe o conteúdo passado em um Popup.
+   */
+  async showPopUp(content, size = "full", useHeader = true) {
+    this.clearContent(this._popUp);
+    this._popUp.appendChild(content);
+    this._popUp.opened = true;
+    this._popUp.heightMode = size;
+    this._popUp.useHeader = useHeader;
+    if (content.tagName === 'EZ-MODAL-CONTAINER') {
+      this._popUp.useHeader = false;
+    }
+  }
+  /**
+   * Exibe o conteúdo passado em um Modal.
+   */
+  async showModal(content) {
+    this.clearContent(this._rightModal);
+    this._rightModal.appendChild(content);
+    this._rightModal.opened = true;
+  }
+  /**
+   * Fecha o Modal e limpa o conteúdo.
+   */
+  async closeModal() {
+    this.clearContent(this._rightModal);
+    this._rightModal.opened = false;
+  }
+  /**
+   * Fecha o Popup e limpa o conteúdo.
+   */
+  async closePopUp() {
+    this.clearContent(this._popUp);
+    this._popUp.opened = false;
+    this._popUp.useHeader = true;
+    this._popUp.heightMode = "full";
+  }
+  /**
+   * Verifica se a licença do cliente tem determinado opcional (produto)
+   */
+  async temOpcional(opcional) {
+    const opts = opcional.split(",");
+    return new Promise((resolve, reject) => {
+      this.getAttributeFromHTMLWrapper("opc0009")
+        .then(value => {
+        if (value === "1") {
+          resolve(true);
+        }
+        else {
+          Promise.all(opts.map(opt => this.getAttributeFromHTMLWrapper("opc" + opt)))
+            .then(result => {
+            resolve(result.includes("1"));
+          })
+            .catch(error => {
+            reject(error);
+          });
+        }
+      })
+        .catch(error => {
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Obtém a configuração de um recurso por service broker
+   */
+  async getConfig(key) {
+    let payload = {
+      "serviceName": "SystemUtilsSP.getConf",
+      "requestBody": {
+        "config": {
+          "chave": key,
+          "tipo": "T"
+        }
+      }
+    };
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callServiceBroker("SystemUtilsSP.getConf", JSON.stringify(payload))
+        .then(result => { var _a; return resolve((_a = result.config) === null || _a === void 0 ? void 0 : _a.data); })
+        .catch(error => reject(error));
+    });
+  }
+  /**
+   * Salva a configuração de determinado recurso.
+   */
+  async saveConfig(key, data) {
+    let payload = {
+      "serviceName": "SystemUtilsSP.saveConf",
+      "requestBody": {
+        "config": {
+          "chave": key,
+          "tipo": "T",
+          data
+        }
+      }
+    };
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callServiceBroker("SystemUtilsSP.saveConf", JSON.stringify(payload))
+        .then(result => resolve(result))
+        .catch(error => reject(error));
+    });
+  }
+  /**
+   * Acessa informações de contexto "empurrados" na abertura da tela.
+   */
+  async getAttributeFromHTMLWrapper(attribName) {
+    return Promise.resolve(window[attribName]);
+  }
+  /**
+   * Abre determinada tela, repassando pkObject.
+   */
+  async openApp(resourceId, pkObject) {
+    Workspace.openAppActivity(resourceId, pkObject);
+  }
+  /**
+   * Realiza a chamada do WebConnection para realizar a exportação de arquivo.
+   * @param keyPort - Chave da porta que será requisitada.
+   * @param methodName - Nome do tipo de exportação de arquivo que será realizado.
+   * @param params - Parâmetros necessários para realizar a exportação do arquivo.
+   */
+  async webConnection(keyPort, methodName, params) {
+    this.getStringParam(keyPort).then((port) => {
+      AppletCaller.webConnectionCaller(port, methodName, params);
+    });
+  }
+  getDuPromissesStack(dataUnitName) {
+    let stack;
+    if (dataUnitName) {
+      stack = this._duPromises.get(dataUnitName);
+      if (!stack) {
+        stack = [];
+        this._duPromises.set(dataUnitName, stack);
+      }
+    }
+    return stack || [];
+  }
+  /**
+   * Cria o DataUnit a partir do nome da entidade. É possível armazená-lo no cache
+   * passando o dataUnitName, assim, se mais de uma chamada for feita, o mesmo DataUnit será usado.
+   */
+  async createDataunit(entityName, dataUnitName, parentDataUnit, configName) {
+    return new Promise((resolve, reject) => {
+      const duPromisses = this.getDuPromissesStack(dataUnitName);
+      const waitingDu = duPromisses.length > 0;
+      duPromisses.push(new PendingPromise(resolve, reject));
+      if (!waitingDu) {
+        const dataUnit = this.dataUnitFetcher.getDataUnit(entityName, this.resourceID, parentDataUnit, configName);
+        dataUnit.loadMetadata().then(() => {
+          if (dataUnitName) {
+            this.updateDataunitCache(undefined, dataUnitName, dataUnit);
+          }
+          while (duPromisses.length > 0) {
+            duPromisses.pop().resolve(dataUnit);
+          }
+        }).catch(reason => {
+          while (duPromisses.length > 0) {
+            duPromisses.pop().reject(reason);
+          }
+        });
+      }
+    });
+  }
+  /**
+   * Atualiza o cache de dataunits da aplicação.
+   * @param oldName - Nome do dataunit que está em cache.
+   * @param dataUnitName - Nome do dataunit que será armazenado em cache.
+   * @param dataUnit - Instancia do Dataunit para ser armazenado em cache.
+   */
+  async updateDataunitCache(oldName, dataUnitName, dataUnit) {
+    if (oldName) {
+      this._duCache.delete(oldName);
+    }
+    this._duCache.set(dataUnitName, dataUnit);
+  }
+  /**
+   * Obtem um DataUnit do cache ou cria um caso ainda não tenha sido criado.
+   */
+  async getDataUnit(entityName, dataUnitName, parentDataUnit, configName) {
+    return new Promise((resolve, reject) => {
+      const dataUnit = this._duCache.get(dataUnitName);
+      if (dataUnit) {
+        resolve(dataUnit);
+      }
+      else {
+        this.createDataunit(entityName, dataUnitName, parentDataUnit, configName).then(dataUnit => {
+          resolve(dataUnit);
+        }).catch(reason => reject(reason));
+      }
+    });
+  }
+  /**
+   * Registra um client event para o DataFetcher da aplicação.
+   *
+   * @param eventID - Nome do evento para a aplicação se registrar.
+   * @param handler - Função de callback que será chamada quando o client event ocorrer.
+   */
+  async addClientEvent(eventID, handler) {
+    return new Promise((resolve) => {
+      DataFetcher.addClientEvent(eventID, handler);
+      resolve();
+    });
+  }
+  /**
+   * Remove um client event para o DataFetcher da aplicação.
+   *
+   * @param eventID - Nome do evento a ser removido.
+   */
+  async removeClientEvent(eventID) {
+    return new Promise((resolve) => {
+      DataFetcher.removeClientEvent(eventID);
+      resolve();
+    });
+  }
+  /**
+   * Verfica se um client event está registrado no DataFetcher da aplicação.
+   *
+   * @param eventID - Nome do evento a ser verificado.
+   */
+  async hasClientEvent(eventID) {
+    return new Promise((resolve) => {
+      resolve(DataFetcher.hasClientEvent(eventID));
+    });
+  }
+  /**
+   * Realiza a chamada ao Service Broker conforme o nome do serviço.
+   *
+   * @param serviceName - Nome do serviço
+   * @param payload - Dados que serão processados na ação
+   * @param options - Parâmetros de URL
+   */
+  async callServiceBroker(serviceName, payload, options) {
+    return DataFetcher.get().callServiceBroker(serviceName, payload, options);
+  }
+  /**
+   * Obtém o resourceID da tela em questão.
+   */
+  async getResourceID() {
+    return Promise.resolve(this.resourceID);
+  }
+  /**
+   * Obtém o UserId da tela em questão.
+   */
+  async getUserID() {
+    return Promise.resolve(window["UID"]);
+  }
+  /**
+   * Exibe o diálogo de alerta de acordo com os parâmetros passados.
+   */
+  async alert(title, message, icon, options) {
+    return ApplicationUtils.alert(title, message, icon, options);
+  }
+  /**
+   * Exibe o diálogo de erro de acordo com os parâmetros passados.
+   */
+  async error(title, message, icon, options) {
+    return ApplicationUtils.error(title, message, icon, options);
+  }
+  /**
+   * Exibe o diálogo de sucesso de acordo com os parâmetros passados.
+   */
+  async success(title, message, icon, options) {
+    return ApplicationUtils.success(title, message, icon, options);
+  }
+  /**
+   * Exibe um diálogo de mensagem comum
+   */
+  async message(title, message, icon, options) {
+    return ApplicationUtils.message(title, message, icon, options);
+  }
+  /**
+   * Exibe um diálogo de confirmação
+   */
+  async confirm(title, message, icon, dialogType, options) {
+    return ApplicationUtils.confirm(title, message, icon, dialogType, options);
+  }
+  /**
+   * Exibe uma informação efêmera (de segundo plano).
+   */
+  async info(message, options) {
+    return ApplicationUtils.info(message, options);
+  }
+  /**
+   * Obtém a configuração de grade.
+  */
+  async loadGridConfig(name) {
+    return this.gridConfigFetcher.getConfig(name, this.resourceID);
+  }
+  /**
+   * Obtém os totalizadores da grade.
+   */
+  async loadTotals(name, resourceID, filters) {
+    return this.totalsFetcher.fetchTotals(name, resourceID, filters);
+  }
+  async getAuthList(_auth) {
+    return await (new MGEAuthorization()).parseFromJSON(_auth);
+  }
+  get urlParams() {
+    if (!this._urlParams) {
+      this._urlParams = UrlUtils.getQueryParams(location.search);
+    }
+    return this._urlParams;
+  }
+  get dataUnitFetcher() {
+    if (!this._dataUnitFetcher) {
+      this._dataUnitFetcher = new DataUnitFetcher();
+    }
+    return this._dataUnitFetcher;
+  }
+  get gridConfigFetcher() {
+    if (!this._gridConfigFetcher) {
+      this._gridConfigFetcher = new GridConfigFetcher();
+    }
+    return this._gridConfigFetcher;
+  }
+  get totalsFetcher() {
+    if (!this._totalsFetcher) {
+      this._totalsFetcher = new TotalsFetcher();
+    }
+    return this._totalsFetcher;
+  }
+  get pesquisaFetcher() {
+    if (!this._pesquisaFetcher) {
+      this._pesquisaFetcher = new PesquisaFetcher();
+    }
+    return this._pesquisaFetcher;
+  }
+  get authFetcher() {
+    if (!this._authFetcher) {
+      this._authFetcher = new AuthFetcher();
+    }
+    return this._authFetcher;
+  }
+  /**
+   * Obtém as opções em componentes de pesquisa
+   * Ex.: snk-config-options
+   */
+  async executeSearch(searchArgument, fieldName, dataUnit) {
+    const descriptor = dataUnit === null || dataUnit === void 0 ? void 0 : dataUnit.getField(fieldName);
+    if (!descriptor) {
+      //TODO: Implementar mensagem de erro
+    }
+    else {
+      const { mode, argument } = searchArgument;
+      const { ENTITYNAME, CODEFIELD, DESCRIPTIONFIELD, ROOTENTITY, DESCRIPTIONENTITY } = descriptor.properties;
+      const dependencies = descriptor.dependencies;
+      let criteria;
+      const searchOptions = {
+        rootEntity: ROOTENTITY,
+        descriptionFieldName: DESCRIPTIONFIELD,
+        codeFieldName: CODEFIELD,
+        showInactives: false,
+        dataUnitId: dataUnit.dataUnitId
+      };
+      dependencies === null || dependencies === void 0 ? void 0 : dependencies.filter(dep => dep.masterFields).forEach(dependency => {
+        var _a;
+        if (dependency.type === DependencyType.SEARCHING) {
+          if (((_a = dependency.masterFields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            criteria = {
+              expression: dependency.expression,
+              params: dependency.masterFields.map(fieldName => {
+                const masterDescriptor = dataUnit.getField(fieldName);
+                const dataType = (masterDescriptor === null || masterDescriptor === void 0 ? void 0 : masterDescriptor.dataType) || DataType.TEXT;
+                const value = dataUnit.getFieldValue(fieldName);
+                if (value == undefined) {
+                  this.alert("Erro ao pesquisar", `É necessario informar o campo ${masterDescriptor.label} para executar a pesquisa.`);
+                  throw new Error(`É necessario informar o campo ${masterDescriptor.label} para executar a pesquisa.`);
+                }
+                return { name: fieldName, value, dataType };
+              })
+            };
+          }
+        }
+      });
+      return this.executePreparedSearch(mode, argument, { entity: ENTITYNAME, entityDescription: DESCRIPTIONENTITY, criteria, searchOptions });
+    }
+  }
+  /**
+   * Obtém as opções em componentes de pesquisa
+   * Ex.: snk-config-options
+   */
+  async executePreparedSearch(mode, argument, options) {
+    const { entity, entityDescription, criteria, searchOptions } = options;
+    if (mode === "ADVANCED") {
+      return new Promise(accept => {
+        const pesquisaContent = document.createElement("snk-pesquisa");
+        pesquisaContent[ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME] = `entity_${entity}`;
+        pesquisaContent.argument = argument;
+        pesquisaContent.searchLoader = (text) => this.pesquisaFetcher.loadAdvancedSearch(entity, text, criteria, searchOptions);
+        pesquisaContent.selectItem = (option) => {
+          accept(option);
+          this.clearPopUpTitle();
+          this.closePopUp();
+        };
+        this.setPopUpTitle(entityDescription);
+        this.showPopUp(pesquisaContent);
+      });
+    }
+    else {
+      return this.pesquisaFetcher.loadSearchOptions(entity, argument, criteria, searchOptions);
+    }
+  }
+  /**
+   * Obtém `true` caso a tela esteja em modo de debug.
+   */
+  async isDebugMode() {
+    return new Promise(accept => {
+      accept(window['isDebugMode']);
+    });
+  }
+  /**
+   * Obtém o nome das telas da aplicação
+   */
+  async getAppLabel() {
+    return Workspace.getAppLabel(this._resourceID);
+  }
+  /**
+   * Adiciona um listener no fetcher de Pesquisa
+  */
+  addSearchListener(entityName, dataUnit, listener) {
+    return new Promise(resolve => {
+      const removeListener = this.pesquisaFetcher.addSearchListener(entityName, dataUnit.dataUnitId, listener);
+      resolve(removeListener);
+    });
+  }
+  /**
+    Realiza o import de um JavaScript que está disponivel dentro da pasta /public da aplicação.
+    @param relativePath: Define o caminho relativo para o arquivo JavaScript a ser importado.
+   */
+  importScript(relativePath) {
+    return new Promise((resolve) => {
+      this.getApplicationPath().then((appPath) => {
+        let paths = [];
+        if (!Array.isArray(relativePath)) {
+          paths = [relativePath];
+        }
+        paths.forEach(path => {
+          const script = document.createElement('script');
+          script.src = `${appPath}/${path}`;
+          script.async = true;
+          document.body.appendChild(script);
+        });
+        resolve();
+      });
+    });
+  }
+  /**
+    Retorna o path relativo da aplicação.
+   */
+  getApplicationPath() {
+    return new Promise((resolve) => {
+      if (window['applicationenv'] !== "dev") {
+        resolve(`/${window["MGE_MODULE_NAME"]}/labsApps/${window["APPLICATION_NAME"]}/build`);
+      }
+      resolve('');
+    });
+  }
+  /**
+   * Com base em um campo realiza um "select distinct" respeitando os
+   * filtros atuais do dataUnit e um critério de filtro para a própria
+   * coluna.
+   */
+  executeSelectDistinct(dataUnit, fieldName, argument) {
+    return this.dataUnitFetcher.loadSelectDistinct(dataUnit, fieldName, argument);
+  }
+  /**
+   * Retorna a instancia do DataFetcher utilizado pelo application
+   * @returns DataFetcher do application
+   */
+  getDataFetcher() {
+    return Promise.resolve(DataFetcher.get());
+  }
+  clearContent(container) {
+    if (container) {
+      Array.from(container.children).forEach(child => {
+        container.removeChild(child);
+      });
+    }
+  }
+  clearPopUpTitle() {
+    this._popUp.ezTitle = "";
+  }
+  setPopUpTitle(title) {
+    this._popUp.ezTitle = title;
+  }
+  componentWillLoad() {
+    this._errorHandler = new SnkErrorHandler(this);
+    this.messagesBuilder = new SnkMessageBuilder();
+    ApplicationContext.setContextValue("__EZUI__UPLOAD__ADD__URL__", `${UrlUtils.getUrlBase()}/mge/upload/file`);
+    ApplicationContext.setContextValue("__EZUI__SEARCH__OPTION__LOADER__", (searchArgument, fieldName, dataUnit) => {
+      return this.executeSearch(searchArgument, fieldName, dataUnit);
+    });
+    ApplicationContext.setContextValue("__EZUI__GRID_LICENSE__", agGridLicense);
+    ErrorTracking.init();
+    ConfigStorage.get();
+  }
+  connectedCallback() {
+    ApplicationContext.setContextValue("__SNK__APPLICATION__", this);
+    DataFetcher.addRequestListener(this._requestListener);
+  }
+  disconnectedCallback() {
+    DataFetcher.removeRequestListener(this._requestListener);
+  }
+  componentDidLoad() {
+    this.applicationLoading.emit(true);
+    window.requestAnimationFrame(() => {
+      this.applicationLoaded.emit(true);
+    });
+    ElementIDUtils.addIDInfo(this._element, `resource_${this._resourceID}`);
+  }
+  render() {
+    return (h("div", null, h("ez-loading-bar", { ref: (ref) => this._requestListener.loadingBar = ref }), h("ez-popup", { opened: false, ref: (ref) => this._popUp = ref, onEzClosePopup: () => this.closePopUp() }), h("ez-modal", { opened: false, ref: (ref) => this._rightModal = ref, "modal-size": "small", closeOutsideClick: true, closeEsc: true })));
+  }
+  static get is() { return "snk-application"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["snk-application.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["snk-application.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "messagesBuilder": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "SnkMessageBuilder",
+          "resolved": "SnkMessageBuilder",
+          "references": {
+            "SnkMessageBuilder": {
+              "location": "import",
+              "path": "../../lib/message/SnkMessageBuilder"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        }
+      },
+      "configName": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Usado para salvar as configura\u00E7\u00F5es dos blocos de constru\u00E7\u00E3o."
+        },
+        "attribute": "config-name",
+        "reflect": false
+      }
+    };
+  }
+  static get events() {
+    return [{
+        "method": "applicationLoaded",
+        "name": "applicationLoaded",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitido quando a aplica\u00E7\u00E3o for carregada."
+        },
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        }
+      }, {
+        "method": "applicationLoading",
+        "name": "applicationLoading",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitido ao iniciar a carga do componente."
+        },
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        }
+      }];
+  }
+  static get methods() {
+    return {
+      "isUserSup": {
+        "complexType": {
+          "signature": "() => Promise<boolean>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m `true` caso o usu\u00E1rio logado seja o SUP.",
+          "tags": []
+        }
+      },
+      "initOnboarding": {
+        "complexType": {
+          "signature": "(onboardingKey: string) => Promise<void>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "",
+          "tags": []
+        }
+      },
+      "hasAccess": {
+        "complexType": {
+          "signature": "(access: AutorizationType) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "AutorizationType": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/fetchers/auth-fetcher"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m `true` caso o usu\u00E1rio logado tem permiss\u00E3o pra determinada a\u00E7\u00E3o.",
+          "tags": []
+        }
+      },
+      "getAllAccess": {
+        "complexType": {
+          "signature": "() => Promise<any>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<any>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m todos os acessos do usu\u00E1rio logado.",
+          "tags": []
+        }
+      },
+      "getStringParam": {
+        "complexType": {
+          "signature": "(name: string) => Promise<string>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<string>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o valor de um par\u00E2metro do tipo string.",
+          "tags": []
+        }
+      },
+      "getIntParam": {
+        "complexType": {
+          "signature": "(name: string) => Promise<number>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<number>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o valor de um par\u00E2metro do tipo Inteiro.",
+          "tags": []
+        }
+      },
+      "getFloatParam": {
+        "complexType": {
+          "signature": "(name: string) => Promise<number>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<number>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o valor de um par\u00E2metro do tipo Decimal.",
+          "tags": []
+        }
+      },
+      "getBooleanParam": {
+        "complexType": {
+          "signature": "(name: string) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o valor de um par\u00E2metro do tipo booleano.",
+          "tags": []
+        }
+      },
+      "getDateParam": {
+        "complexType": {
+          "signature": "(name: string) => Promise<Date>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "Date": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<Date>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o valor de um par\u00E2metro do tipo data.",
+          "tags": []
+        }
+      },
+      "showPopUp": {
+        "complexType": {
+          "signature": "(content: HTMLElement, size?: \"auto\" | \"full\", useHeader?: boolean) => Promise<void>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "HTMLElement": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Exibe o conte\u00FAdo passado em um Popup.",
+          "tags": []
+        }
+      },
+      "showModal": {
+        "complexType": {
+          "signature": "(content: HTMLElement) => Promise<void>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "HTMLElement": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Exibe o conte\u00FAdo passado em um Modal.",
+          "tags": []
+        }
+      },
+      "closeModal": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Fecha o Modal e limpa o conte\u00FAdo.",
+          "tags": []
+        }
+      },
+      "closePopUp": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Fecha o Popup e limpa o conte\u00FAdo.",
+          "tags": []
+        }
+      },
+      "temOpcional": {
+        "complexType": {
+          "signature": "(opcional: string) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Verifica se a licen\u00E7a do cliente tem determinado opcional (produto)",
+          "tags": []
+        }
+      },
+      "getConfig": {
+        "complexType": {
+          "signature": "(key: string) => Promise<any>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<any>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m a configura\u00E7\u00E3o de um recurso por service broker",
+          "tags": []
+        }
+      },
+      "saveConfig": {
+        "complexType": {
+          "signature": "(key: string, data: Object) => Promise<any>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "Object": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<any>"
+        },
+        "docs": {
+          "text": "Salva a configura\u00E7\u00E3o de determinado recurso.",
+          "tags": []
+        }
+      },
+      "getAttributeFromHTMLWrapper": {
+        "complexType": {
+          "signature": "(attribName: string) => Promise<string>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<string>"
+        },
+        "docs": {
+          "text": "Acessa informa\u00E7\u00F5es de contexto \"empurrados\" na abertura da tela.",
+          "tags": []
+        }
+      },
+      "openApp": {
+        "complexType": {
+          "signature": "(resourceId: string, pkObject: Object) => Promise<void>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "Object": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Abre determinada tela, repassando pkObject.",
+          "tags": []
+        }
+      },
+      "webConnection": {
+        "complexType": {
+          "signature": "(keyPort: string, methodName: string, params: IAppletCallerParams) => Promise<void>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "keyPort - Chave da porta que ser\u00E1 requisitada."
+                }],
+              "text": "- Chave da porta que ser\u00E1 requisitada."
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "methodName - Nome do tipo de exporta\u00E7\u00E3o de arquivo que ser\u00E1 realizado."
+                }],
+              "text": "- Nome do tipo de exporta\u00E7\u00E3o de arquivo que ser\u00E1 realizado."
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "params - Par\u00E2metros necess\u00E1rios para realizar a exporta\u00E7\u00E3o do arquivo."
+                }],
+              "text": "- Par\u00E2metros necess\u00E1rios para realizar a exporta\u00E7\u00E3o do arquivo."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "IAppletCallerParams": {
+              "location": "import",
+              "path": "../../lib/applet-caller/applet-caller"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Realiza a chamada do WebConnection para realizar a exporta\u00E7\u00E3o de arquivo.",
+          "tags": [{
+              "name": "param",
+              "text": "keyPort - Chave da porta que ser\u00E1 requisitada."
+            }, {
+              "name": "param",
+              "text": "methodName - Nome do tipo de exporta\u00E7\u00E3o de arquivo que ser\u00E1 realizado."
+            }, {
+              "name": "param",
+              "text": "params - Par\u00E2metros necess\u00E1rios para realizar a exporta\u00E7\u00E3o do arquivo."
+            }]
+        }
+      },
+      "createDataunit": {
+        "complexType": {
+          "signature": "(entityName: string, dataUnitName?: string, parentDataUnit?: DataUnit, configName?: string) => Promise<DataUnit>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          },
+          "return": "Promise<DataUnit>"
+        },
+        "docs": {
+          "text": "Cria o DataUnit a partir do nome da entidade. \u00C9 poss\u00EDvel armazen\u00E1-lo no cache\npassando o dataUnitName, assim, se mais de uma chamada for feita, o mesmo DataUnit ser\u00E1 usado.",
+          "tags": []
+        }
+      },
+      "updateDataunitCache": {
+        "complexType": {
+          "signature": "(oldName: string, dataUnitName: string, dataUnit: DataUnit) => Promise<void>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "oldName - Nome do dataunit que est\u00E1 em cache."
+                }],
+              "text": "- Nome do dataunit que est\u00E1 em cache."
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "dataUnitName - Nome do dataunit que ser\u00E1 armazenado em cache."
+                }],
+              "text": "- Nome do dataunit que ser\u00E1 armazenado em cache."
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "dataUnit - Instancia do Dataunit para ser armazenado em cache."
+                }],
+              "text": "- Instancia do Dataunit para ser armazenado em cache."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Atualiza o cache de dataunits da aplica\u00E7\u00E3o.",
+          "tags": [{
+              "name": "param",
+              "text": "oldName - Nome do dataunit que est\u00E1 em cache."
+            }, {
+              "name": "param",
+              "text": "dataUnitName - Nome do dataunit que ser\u00E1 armazenado em cache."
+            }, {
+              "name": "param",
+              "text": "dataUnit - Instancia do Dataunit para ser armazenado em cache."
+            }]
+        }
+      },
+      "getDataUnit": {
+        "complexType": {
+          "signature": "(entityName: string, dataUnitName: string, parentDataUnit?: DataUnit, configName?: string) => Promise<DataUnit>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          },
+          "return": "Promise<DataUnit>"
+        },
+        "docs": {
+          "text": "Obtem um DataUnit do cache ou cria um caso ainda n\u00E3o tenha sido criado.",
+          "tags": []
+        }
+      },
+      "addClientEvent": {
+        "complexType": {
+          "signature": "(eventID: String, handler: (clientEvent: IClientEventResponse, dataFetcherReacaller: IDataFetcherRecaller) => void) => Promise<void>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "eventID - Nome do evento para a aplica\u00E7\u00E3o se registrar."
+                }],
+              "text": "- Nome do evento para a aplica\u00E7\u00E3o se registrar."
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "handler - Fun\u00E7\u00E3o de callback que ser\u00E1 chamada quando o client event ocorrer."
+                }],
+              "text": "- Fun\u00E7\u00E3o de callback que ser\u00E1 chamada quando o client event ocorrer."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "String": {
+              "location": "global"
+            },
+            "IClientEventResponse": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/interfaces/IClientEventResponse"
+            },
+            "IDataFetcherRecaller": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/recaller/IDataFetcherRecaller"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Registra um client event para o DataFetcher da aplica\u00E7\u00E3o.",
+          "tags": [{
+              "name": "param",
+              "text": "eventID - Nome do evento para a aplica\u00E7\u00E3o se registrar."
+            }, {
+              "name": "param",
+              "text": "handler - Fun\u00E7\u00E3o de callback que ser\u00E1 chamada quando o client event ocorrer."
+            }]
+        }
+      },
+      "removeClientEvent": {
+        "complexType": {
+          "signature": "(eventID: String) => Promise<void>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "eventID - Nome do evento a ser removido."
+                }],
+              "text": "- Nome do evento a ser removido."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "String": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Remove um client event para o DataFetcher da aplica\u00E7\u00E3o.",
+          "tags": [{
+              "name": "param",
+              "text": "eventID - Nome do evento a ser removido."
+            }]
+        }
+      },
+      "hasClientEvent": {
+        "complexType": {
+          "signature": "(eventID: String) => Promise<boolean>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "eventID - Nome do evento a ser verificado."
+                }],
+              "text": "- Nome do evento a ser verificado."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "String": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Verfica se um client event est\u00E1 registrado no DataFetcher da aplica\u00E7\u00E3o.",
+          "tags": [{
+              "name": "param",
+              "text": "eventID - Nome do evento a ser verificado."
+            }]
+        }
+      },
+      "callServiceBroker": {
+        "complexType": {
+          "signature": "(serviceName: string, payload: string | Object, options?: Options) => Promise<any>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "serviceName - Nome do servi\u00E7o"
+                }],
+              "text": "- Nome do servi\u00E7o"
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "payload - Dados que ser\u00E3o processados na a\u00E7\u00E3o"
+                }],
+              "text": "- Dados que ser\u00E3o processados na a\u00E7\u00E3o"
+            }, {
+              "tags": [{
+                  "name": "param",
+                  "text": "options - Par\u00E2metros de URL"
+                }],
+              "text": "- Par\u00E2metros de URL"
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "Object": {
+              "location": "global"
+            },
+            "Options": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/DataFetcher"
+            }
+          },
+          "return": "Promise<any>"
+        },
+        "docs": {
+          "text": "Realiza a chamada ao Service Broker conforme o nome do servi\u00E7o.",
+          "tags": [{
+              "name": "param",
+              "text": "serviceName - Nome do servi\u00E7o"
+            }, {
+              "name": "param",
+              "text": "payload - Dados que ser\u00E3o processados na a\u00E7\u00E3o"
+            }, {
+              "name": "param",
+              "text": "options - Par\u00E2metros de URL"
+            }]
+        }
+      },
+      "getResourceID": {
+        "complexType": {
+          "signature": "() => Promise<string>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<string>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o resourceID da tela em quest\u00E3o.",
+          "tags": []
+        }
+      },
+      "getUserID": {
+        "complexType": {
+          "signature": "() => Promise<string>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<string>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o UserId da tela em quest\u00E3o.",
+          "tags": []
+        }
+      },
+      "alert": {
+        "complexType": {
+          "signature": "(title: string, message: string, icon?: string, options?: MessageOptions) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "MessageOptions": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Exibe o di\u00E1logo de alerta de acordo com os par\u00E2metros passados.",
+          "tags": []
+        }
+      },
+      "error": {
+        "complexType": {
+          "signature": "(title: string, message: string, icon?: string, options?: MessageOptions) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "MessageOptions": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Exibe o di\u00E1logo de erro de acordo com os par\u00E2metros passados.",
+          "tags": []
+        }
+      },
+      "success": {
+        "complexType": {
+          "signature": "(title: string, message: string, icon?: string, options?: MessageOptions) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "MessageOptions": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Exibe o di\u00E1logo de sucesso de acordo com os par\u00E2metros passados.",
+          "tags": []
+        }
+      },
+      "message": {
+        "complexType": {
+          "signature": "(title: string, message: string, icon?: string, options?: MessageOptions) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "MessageOptions": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Exibe um di\u00E1logo de mensagem comum",
+          "tags": []
+        }
+      },
+      "confirm": {
+        "complexType": {
+          "signature": "(title: string, message: string, icon?: string, dialogType?: DialogType, options?: MessageOptions) => Promise<boolean>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DialogType": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            },
+            "MessageOptions": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Exibe um di\u00E1logo de confirma\u00E7\u00E3o",
+          "tags": []
+        }
+      },
+      "info": {
+        "complexType": {
+          "signature": "(message: string, options?: MessageOptions) => Promise<void>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "MessageOptions": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/collection/utils"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Exibe uma informa\u00E7\u00E3o ef\u00EAmera (de segundo plano).",
+          "tags": []
+        }
+      },
+      "loadGridConfig": {
+        "complexType": {
+          "signature": "(name: string) => Promise<IGridConfig>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "IGridConfig": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/types/components/ez-grid/controller/EzGridController"
+            }
+          },
+          "return": "Promise<IGridConfig>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m a configura\u00E7\u00E3o de grade.",
+          "tags": []
+        }
+      },
+      "loadTotals": {
+        "complexType": {
+          "signature": "(name: string, resourceID: string, filters: Array<Filter>) => Promise<Map<string, number>>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "Map": {
+              "location": "global"
+            },
+            "Array": {
+              "location": "global"
+            },
+            "Filter": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          },
+          "return": "Promise<Map<string, number>>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m os totalizadores da grade.",
+          "tags": []
+        }
+      },
+      "executeSearch": {
+        "complexType": {
+          "signature": "(searchArgument: ISearchArgument, fieldName: string, dataUnit: DataUnit) => Promise<Array<IOption> | IOption>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "IOption": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/types/components/ez-combo-box/ez-combo-box"
+            },
+            "ISearchArgument": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/types/components/ez-combo-box/ez-combo-box"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            },
+            "Array": {
+              "location": "global"
+            },
+            "SearchCriteria": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/fetchers/pesquisa-fetcher"
+            }
+          },
+          "return": "Promise<IOption | IOption[]>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m as op\u00E7\u00F5es em componentes de pesquisa\nEx.: snk-config-options",
+          "tags": []
+        }
+      },
+      "executePreparedSearch": {
+        "complexType": {
+          "signature": "(mode: string, argument: string, options: any) => Promise<Array<IOption> | IOption>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "IOption": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/types/components/ez-combo-box/ez-combo-box"
+            },
+            "Array": {
+              "location": "global"
+            },
+            "HTMLSnkPesquisaElement": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<IOption | IOption[]>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m as op\u00E7\u00F5es em componentes de pesquisa\nEx.: snk-config-options",
+          "tags": []
+        }
+      },
+      "isDebugMode": {
+        "complexType": {
+          "signature": "() => Promise<boolean>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m `true` caso a tela esteja em modo de debug.",
+          "tags": []
+        }
+      },
+      "getAppLabel": {
+        "complexType": {
+          "signature": "() => Promise<string>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<string>"
+        },
+        "docs": {
+          "text": "Obt\u00E9m o nome das telas da aplica\u00E7\u00E3o",
+          "tags": []
+        }
+      },
+      "addSearchListener": {
+        "complexType": {
+          "signature": "(entityName: string, dataUnit: DataUnit, listener: ISearchListener) => Promise<IRemoveSearchListener>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "IRemoveSearchListener": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/fetchers/pesquisa-fetcher"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            },
+            "ISearchListener": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/fetchers/pesquisa-fetcher"
+            }
+          },
+          "return": "Promise<IRemoveSearchListener>"
+        },
+        "docs": {
+          "text": "Adiciona um listener no fetcher de Pesquisa",
+          "tags": []
+        }
+      },
+      "importScript": {
+        "complexType": {
+          "signature": "(relativePath: string | Array<string>) => Promise<void>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "relativePath : Define o caminho relativo para o arquivo JavaScript a ser importado."
+                }],
+              "text": ": Define o caminho relativo para o arquivo JavaScript a ser importado."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "Array": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Realiza o import de um JavaScript que est\u00E1 disponivel dentro da pasta /public da aplica\u00E7\u00E3o.",
+          "tags": [{
+              "name": "param",
+              "text": "relativePath : Define o caminho relativo para o arquivo JavaScript a ser importado."
+            }]
+        }
+      },
+      "getApplicationPath": {
+        "complexType": {
+          "signature": "() => Promise<string>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<string>"
+        },
+        "docs": {
+          "text": "Retorna o path relativo da aplica\u00E7\u00E3o.",
+          "tags": []
+        }
+      },
+      "executeSelectDistinct": {
+        "complexType": {
+          "signature": "(dataUnit: DataUnit, fieldName: string, argument: string) => Promise<Array<any>>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }, {
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            },
+            "Array": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<any[]>"
+        },
+        "docs": {
+          "text": "Com base em um campo realiza um \"select distinct\" respeitando os \nfiltros atuais do dataUnit e um crit\u00E9rio de filtro para a pr\u00F3pria \ncoluna.",
+          "tags": []
+        }
+      },
+      "getDataFetcher": {
+        "complexType": {
+          "signature": "() => Promise<DataFetcher>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DataFetcher": {
+              "location": "import",
+              "path": "../../lib/http/data-fetcher/DataFetcher"
+            }
+          },
+          "return": "Promise<DataFetcher>"
+        },
+        "docs": {
+          "text": "Retorna a instancia do DataFetcher utilizado pelo application",
+          "tags": [{
+              "name": "returns",
+              "text": "DataFetcher do application"
+            }]
+        }
+      }
+    };
+  }
+  static get elementRef() { return "_element"; }
+}
+class RequestListenerLoadingBar {
+  constructor() {
+    this._debounceTime = 1000;
+    this._ignoredNameTypes = ["totals"];
+    this._countRequest = 0;
+  }
+  onRequestStart(param) {
+    if (this.isIgnoreLoadingOnRequest(param)) {
+      return;
+    }
+    this._countRequest++;
+    this.loadingBar.show();
+    if (this._timerLoading) {
+      clearTimeout(this._timerLoading);
+    }
+  }
+  ;
+  onRequestEnd(param) {
+    if (this.isIgnoreLoadingOnRequest(param)) {
+      return;
+    }
+    this._countRequest--;
+    this._timerLoading = setTimeout(() => {
+      if (this._countRequest <= 0) {
+        this.loadingBar.hide();
+      }
+    }, this._debounceTime);
+  }
+  ;
+  isIgnoreLoadingOnRequest(param) {
+    var _a;
+    if (((_a = param === null || param === void 0 ? void 0 : param.requestBody) === null || _a === void 0 ? void 0 : _a.length) == 1) {
+      const { name } = param.requestBody[0].variables;
+      if (name) {
+        const nameParts = name.split(":");
+        const nameType = nameParts[0];
+        return this._ignoredNameTypes.indexOf(nameType) >= 0;
+      }
+    }
+    return false;
+  }
+  ;
+}
+class PendingPromise {
+  constructor(resolve, reject) {
+    this.resolve = resolve;
+    this.reject = reject;
+  }
+}