@po-ui/ng-sync 19.26.0 → 20.0.0

package/index.d.ts

@@ -1,5 +1,1055 @@
+import { Observable } from 'rxjs';
+import { PoStorageService } from '@po-ui/ng-storage';
+import { HttpClient, HttpResponse, HttpErrorResponse } from '@angular/common/http';
+import * as i0 from '@angular/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * @description
+ *
+ * Classe responsável por adaptar dados de APIs que não seguem
+ * o padrão de [API do PO UI](https://po-ui.io/guides/api).
+ *
+ * Essa classe deve ser estendida por uma classe que implemente cada um de seus métodos, adaptando os parâmetros de
+ * acordo com a API do *backend* existente que se deseja comunicar.
  */
-/// <amd-module name="@po-ui/ng-sync" />
-export * from './public-api';
+declare abstract class PoDataTransform {
+    protected data: any;
+    /**
+     * @docsPrivate
+     *
+     * Método responsável por receber e armazenar os dados retornados pela API para manipulação na classe `PoDataTransform`.
+     *
+     * @param {any} data Dados retornados pela API.
+     */
+    transform(data: any): void;
+    /**
+     * Retorna o nome da propriedade responsável por informar a data da última sincronização.
+     *
+     * @returns {string} Nome do campo que contém a data da última sincronização.
+     */
+    abstract getDateFieldName(): string;
+    /**
+     * Retorna o nome da propriedade responsável por informar a lista de registros vindos da API.
+     *
+     * @returns {string} Nome da propriedade que contém a lista de registros.
+     */
+    abstract getItemsFieldName(): string;
+    /**
+     * Retorna o nome da propriedade responsável por informar o número da página de registros que a API
+     * recebe como parâmetro.
+     *
+     * @returns {string} Nome da propriedade responsável por informar o número da página de registros.
+     */
+    abstract getPageParamName(): string;
+    /**
+     * Retorna o nome da propriedade responsável pela quantidade de registros que serão exibidos por página
+     * que a API recebe como parâmetro.
+     *
+     * @returns {string} Nome da propriedade responsável pela quantidade de registros por página.
+     */
+    abstract getPageSizeParamName(): string;
+    /**
+     * Retorna um valor `boolean`, responsável por informar se há uma nova página de registros disponível.
+     *
+     * @returns {boolean} Informa se existe próxima página de registros.
+     */
+    abstract hasNext(): boolean;
+}
+
+/**
+ * @docsPrivate
+ *
+ * Define as operações realizadas no sync.
+ */
+declare enum PoEventSourcingOperation {
+    Delete = "DELETE",
+    Http = "HTTP",
+    Insert = "INSERT",
+    Update = "UPDATE"
+}
+
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Define as informações de um evento para um determinado registro.
+ */
+interface PoEventSourcingSummaryItem {
+    /** Identificador customizado do registro. */
+    customRequestId: string;
+    /** Especifica a operação que deverá ser realizada na API. */
+    operation: PoEventSourcingOperation;
+    /** Objeto *json* com os dados do registro. */
+    record: object;
+}
+
+/**
+ * @docsPrivate
+ *
+ * @usedBy PoHttpClientService
+ *
+ * @description
+ *
+ * Define o cabeçalho da requisição HTTP.
+ */
+interface PoHttpHeaderOption {
+    /** Nome do cabeçalho. */
+    name: string;
+    /** Valor do cabeçalho. */
+    value: string;
+}
+
+/**
+ * @usedBy PoHttpClientService, PoHttpCommandResponse, PoSyncService
+ *
+ * @description
+ *
+ * Define o método de requisição HTTP.
+ */
+declare enum PoHttpRequestType {
+    /** Método `delete` do protocolo HTTP. */
+    DELETE = "DELETE",
+    /** Método `get` do protocolo HTTP. */
+    GET = "GET",
+    /** Método `head` do protocolo HTTP. */
+    HEAD = "HEAD",
+    /** Método `options` do protocolo HTTP. */
+    OPTIONS = "OPTIONS",
+    /** Método `patch` do protocolo HTTP. */
+    PATCH = "PATCH",
+    /** Método `post` do protocolo HTTP. */
+    POST = "POST",
+    /** Método `put` do protocolo HTTP. */
+    PUT = "PUT"
+}
+
+/**
+ * @usedBy PoSyncService
+ *
+ * @description
+ *
+ * Interface para definição de uma requisição HTTP.
+ */
+interface PoHttpRequestData {
+    /** URL que será utilizada na requisição. */
+    url: string;
+    /** Cabeçalho da requisição. */
+    headers?: Array<PoHttpHeaderOption>;
+    /** Método HTTP que será utilizado. */
+    method: PoHttpRequestType;
+    /** Corpo da requisição. */
+    body?: any;
+    /** Nome da propriedade que conterá o arquivo enviado para o servidor */
+    formField?: string;
+    bodyType?: string;
+    mimeType?: string;
+    fileName?: string;
+}
+
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço para execução de requisições HTTP.
+ */
+declare class PoHttpClientService {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Constrói uma requisição HTTP personalizada.
+     *
+     * @param {PoHttpRequestData} poHttpOperationData Parâmetros para a construção
+     * da requisição.
+     */
+    createRequest(poHttpOperationData: PoHttpRequestData): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `delete`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    delete(url: string, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `get`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    get(url: string, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `head`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    head(url: string, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `options`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    options(url: string, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `patch`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {any} body Corpo da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    patch(url: string, body?: any, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `post`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {any} body Corpo da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    post(url: string, body?: any, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    /**
+     * Constrói uma requisição com o método `put`.
+     *
+     * @param {string} url URL da requisição.
+     * @param {any} body Corpo da requisição.
+     * @param {Array<PoHeaderOption>} httpHeaders Cabeçalhos da requisição.
+     */
+    put(url: string, body?: any, httpHeaders?: Array<PoHttpHeaderOption>): Observable<HttpResponse<object>>;
+    private createHttpHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoHttpClientService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoHttpClientService>;
+}
+
+/**
+ * @usedBy PoSyncService
+ *
+ * @description
+ *
+ * Interface que irá mapear as configurações dos campos do `PoSyncSchema`.
+ */
+interface PoSyncFieldOptions {
+    /** Propriedade que informa o nome do campo. */
+    readonly name: string;
+    /** Propriedade que informa se o campo será apenas para armazenamento local
+     * ou se deve ser enviado para o servidor.
+     */
+    readonly local?: boolean;
+}
+
+/**
+ * @usedBy PoSyncService
+ *
+ * @description
+ *
+ * Interface que irá mapear as informações dos recursos, principalmente sua origem e as informações que serão retornadas.
+ */
+interface PoSyncSchema {
+    /** Nome da propriedade que informa a data de criação do registro. */
+    readonly createdAtField?: string;
+    /** Nome da propriedade que informa a data de deleção. */
+    readonly deletedAtField?: string;
+    /** Nome da propriedade que informa se o registro foi excluído. */
+    readonly deletedField: string;
+    /** Endereço do endpoint para excluir registros. */
+    readonly deleteUrlApi?: string;
+    /** Endereço do endpoint que proverá apenas dados alterados no servidor. */
+    readonly diffUrlApi: string;
+    /** Campos que serão retornados pela API. */
+    readonly fields: Array<string | PoSyncFieldOptions>;
+    /** Endereço do endpoint que utiliza o método GET que proverá os dados. */
+    readonly getUrlApi: string;
+    /** Nome da propriedade referente ao identificador único para os itens do *schema*. */
+    readonly idField: string;
+    /** Identifição para representar o *schema*. */
+    readonly name: string;
+    /** Quantidade de itens por página que será enviado pela API. */
+    readonly pageSize: number;
+    /** Endereço do endpoint que utiliza o método PUT para atualizar registros. */
+    readonly patchUrlApi?: string;
+    /** Endereço do endpoint que utiliza o método POST para incluir os registros. */
+    readonly postUrlApi?: string;
+    /** Nome da propriedade que informa a data de atualização do registro. */
+    readonly updatedAtField?: string;
+    lastSync?: string;
+}
+
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço que disponibiliza métodos que permite operar sobre as definições dos *schemas*.
+ */
+declare class PoSchemaDefinitionService {
+    private poStorage;
+    constructor(poStorage: PoStorageService);
+    /**
+     * Destrói a chave do *storage* que contém as definições dos *schemas*.
+     *
+     * > Para que não venham ocorrer erros em ações que dependam das definições dos *schemas*,
+     * recomenda-se utilizar o método `prepare()` em seguida.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando a chave referente as definições dos *schemas* for destruída.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Busca um *schema* a partir do nome informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @returns {Promise<PoSyncSchema>} Promessa que é resolvida quando o *schema* for retornado.
+     */
+    get(schemaName: string): Promise<PoSyncSchema>;
+    /**
+     * Retorna uma promessa com a lista dos *schemas* definidos.
+     *
+     * @returns {Promise<Array<PoSyncSchema>>} Promessa que é resolvida quando a lista dos *schemas* definidos for retornada.
+     */
+    getAll(): Promise<Array<PoSyncSchema>>;
+    /**
+     * Salva uma lista de *schemas*.
+     *
+     * @param {Array<PoSyncSchema>} schemas Lista de schemas que serão salvos.
+     * @returns {Promise<Array<PoSyncSchema>>} Promessa que é resolvida quando a lista de *schemas* for salva.
+     */
+    saveAll(schemas: Array<PoSyncSchema>): Promise<Array<PoSyncSchema>>;
+    /**
+     * Atualiza um *schema* a partir do *schema name*.
+     *
+     * @param {PoSyncSchema} updatedSchema **Schema* que será atualizado.
+     */
+    update(updatedSchema: PoSyncSchema): Promise<PoSyncSchema[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoSchemaDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoSchemaDefinitionService>;
+}
+
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço que realiza as operações nos `schemas`.
+ */
+declare class PoSchemaService {
+    private poSchemaDefinitionService;
+    private poStorage;
+    constructor(poSchemaDefinitionService: PoSchemaDefinitionService, poStorage: PoStorageService);
+    /**
+     * Retorna o id a partir de uma chave de um *schema*.
+     *
+     * @param {string} schemaKey Chave do *schema* em que será realizada a busca do id.
+     */
+    private static getIdByRecordKey;
+    /**
+     * Retorna a chave do *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     * @param {boolean} isLocalKey Indica se é uma chave local.
+     */
+    private static getRecordKey;
+    /**
+     * Verifica se o dado informado é uma chave de um *schema*.
+     *
+     * @param {string} data Dado que será verificado se é uma chave de um *schema*.
+     * @param {string} schemaName Nome do *schema*.
+     */
+    private static isSchemaKey;
+    /**
+     * Cria um novo registro para o *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* em que será criado o registro.
+     * @param {object} newRecord Registro que será criado.
+     */
+    create(schema: PoSyncSchema, newRecord: object): Promise<object>;
+    /**
+     * Destrói as chaves do *storage* que contém os registros dos *schemas*.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando as chaves referentes aos *schemas* forem destruídas.
+     */
+    destroySchemasRecords(): Promise<void>;
+    /**
+     * Retorna o registro referente ao *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     */
+    get(schemaName: string, recordId: any): Promise<object>;
+    /**
+     * Retorna todos os registros referente ao *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     */
+    getAll(schemaName: string): Promise<Array<object>>;
+    /**
+     * Aguarda a liberação do recurso limitado, posteriormente o envolve em um comportamento
+     * de bloqueio e desbloqueio.
+     *
+     * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.
+     */
+    limitedCallWrap(limitedResource: Function): Promise<any>;
+    /**
+     * Remove um registro de um *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     */
+    remove(schemaName: string, recordId: any): Promise<any>;
+    /**
+     * Atualiza um registro de um *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* referente ao registro que será alterado.
+     * @param {object} record Registro que será atualizado.
+     * @param {any} recordId Id do registro que deseja ser alterado. Deve ser utilizado em casos em que o id foi alterado.
+     */
+    update(schema: PoSyncSchema, record: object, recordId?: any): Promise<object>;
+    /**
+     * Atualiza todos os registros de um *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* referente aos registros que serão alterados.
+     * @param {Array<object>} records Lista de registros que serão alterados.
+     */
+    updateAll(schema: PoSyncSchema, records: Array<object>): Promise<void>;
+    private getRecord;
+    private save;
+    private saveLocalFields;
+    private updateRecordId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoSchemaService>;
+}
+
+/**
+ * @usedBy PoSyncConfig, PoNetworkStatus
+ *
+ * @description
+ *
+ * Tipos de rede existentes no dispositivo.
+ */
+declare enum PoNetworkType {
+    /** Define o tipo de rede como desconhecido (`unknown`). */
+    unknown = 0,
+    /** Define o tipo de rede como `Ethernet`. */
+    ethernet = 1,
+    /** Define o tipo de rede como `WiFi`. */
+    wifi = 2,
+    /** Define o tipo de rede como `2G`. */
+    _2g = 3,
+    /** Define o tipo de rede como `3G`. */
+    _3g = 4,
+    /** Define o tipo de rede como `4G`. */
+    _4g = 5,
+    /**
+     * Define o tipo de rede como `cellular`. Isso acontece na utilização dos navegadores
+     * dentro do dispositvo móvel, com exceção do *web view*.
+     */
+    cellular = 6,
+    /** Define o tipo de rede como `none`. */
+    none = 7
+}
+
+/**
+ * @usedBy PoSyncService
+ *
+ * @description
+ *
+ * Interface para a definição das configurações do sincronismo.
+ */
+interface PoSyncConfig {
+    /**
+     * Classe usada para a trasformação dos dados nas requisições.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Adaptando a resposta da API para o padrão do PO UI](/guides/sync-fundamentals).
+     */
+    dataTransform?: PoDataTransform;
+    /**
+     * Tempo em segundos do sicronismo periódico.
+     * Caso não seja definido, o sincronismo periódico estará desabilitado.
+     */
+    period?: number;
+    /** Tipos de conexões permitidas para o sincronismo. */
+    type: PoNetworkType | Array<PoNetworkType>;
+}
+
+/**
+ * @description
+ *
+ * Classe que define a resposta de erro para um item da fila de eventos que não foi enviado ao servidor por
+ * alguma inconsistência.
+ *
+ * > Pode ser utilizada em casos onde um item da fila é enviado ao servidor com inconsistência nos dados, por exemplo
+ * uma operação de *delete* ou *update* sem o `id` do objeto.
+ */
+declare class PoEventSourcingErrorResponse {
+    /** Mensagem de erro. */
+    message: string;
+    /** Operação que havia sido requisitada. */
+    operation: PoEventSourcingOperation;
+    constructor({ message, operation }: {
+        message: any;
+        operation: any;
+    });
+}
+
+/**
+ * @usedBy PoSyncService
+ *
+ * @description
+ *
+ * Define a resposta dos eventos enviados ao servidor.
+ */
+interface PoSyncResponse {
+    /** Identificador do evento na fila. */
+    id: number;
+    /** Identificador customizado do registro. */
+    customRequestId?: string;
+    /** Dados da requisição. */
+    request: PoHttpRequestData;
+    /** Resposta retornada após a tentativa de envio para o servidor. */
+    response: HttpResponse<object> | HttpErrorResponse | PoEventSourcingErrorResponse;
+}
+
+declare class PoEventSourcingService {
+    private poSchemaDefinition;
+    private poSchemaService;
+    private poStorage;
+    private poHttpClient;
+    static readonly event_sourcing_name: string;
+    private static readonly VALID_HTTP_STATUS_CODES;
+    config: PoSyncConfig;
+    stoppedQueueEventSourcing: boolean;
+    private emitter;
+    private eventSub;
+    private responseSubject;
+    private schemasSyncConfig;
+    constructor(poSchemaDefinition: PoSchemaDefinitionService, poSchemaService: PoSchemaService, poStorage: PoStorageService, poHttpClient: PoHttpClientService);
+    private static getUrl;
+    create(schemaName: string, newItem: any, customRequestId?: string): Promise<any>;
+    createBatchEvents(schemaName: string, eventList: Array<PoEventSourcingSummaryItem>): Promise<void>;
+    /**
+     * Destrói a chave do *storage* que contém a fila de dados que estão esperando para serem enviados ao
+     * servidor *(EventSourcing)*.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando a chave referente a fila de *EventSourcing* for destruída.
+     */
+    destroyEventSourcingQueue(): Promise<void>;
+    httpCommand(httpOperationData: PoHttpRequestData, customRequestId?: string): Promise<number>;
+    responsesSubject(): Observable<PoSyncResponse>;
+    onSaveData(): Observable<null>;
+    remove(schemaName: string, itemToDelete: any, customRequestId?: string): Promise<any>;
+    removeEventSourcingItem(idEventSourcingItem: any): Promise<any>;
+    syncGet(): Promise<any>;
+    syncSend(): Promise<any>;
+    update(schemaName: string, itemUpdated: any, customRequestId?: string): Promise<any>;
+    private serializeBody;
+    private buildUrlParams;
+    private checkRecordIdExists;
+    private concatPageItems;
+    private createEventSourcingItem;
+    private createEventSourcingList;
+    private createSchemaSyncConfig;
+    private deleteOperation;
+    private diffServerItems;
+    private getBodyAndDate;
+    private getServerDiffRecords;
+    private httpOperation;
+    private insertEventSourcingQueue;
+    private insertOperation;
+    private isValidStatus;
+    private notifyEventCreation;
+    private paginateSchemaData;
+    private removeEventSourcingValidItem;
+    private selectOperation;
+    private sendResponseSubject;
+    private sendServerItem;
+    private createPoHttpRequestData;
+    private createFormData;
+    private updateOperation;
+    private updatePendingEventSourcing;
+    private updateRecords;
+    private updateRecordByServerRecord;
+    private updateStorageBySchema;
+    private updateStorageSchemas;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoEventSourcingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoEventSourcingService>;
+}
+
+/**
+ * @usedBy PoQueryBuilder
+ *
+ * @description
+ *
+ * Interface que representa a estrutura de resposta de uma coleção de itens.
+ *
+ */
+interface PoResponseApi {
+    /** Lista de itens retornados. */
+    items: Array<object>;
+    /** Indica se existe uma próxima página com mais registros para aquela coleção de itens. */
+    hasNext: boolean;
+}
+
+/**
+ * @description
+ *
+ * Classe utilitária para construir consultas sobre os registros de um *schema*.
+ *
+ * A utilização dos métodos desta classe é feita a partir do retorno do método `PoEntity.find()`. Por exemplo,
+ * para utilizar o método `PoQueryBuilder.page()`, é necessário:
+ *
+ * ``` typescript
+ * PoSyncService.getModel('schema name').find().page(2).exec();
+ * ```
+ *
+ * O `PoQueryBuilder` foi projetado para que os seus métodos sejam
+ * chamados em cascata e ao final desse encadeamento invocar o método
+ * `PoQueryBuilder.exec()` para que a busca seja concluída. Por exemplo:
+ *
+ * ``` typescript
+ * PoSyncService
+ *   .getModel('schema name')
+ *   .find()
+ *   .page(2)
+ *   .pageSize(5)
+ *   .sort()
+ *   .exec();
+ * ```
+ */
+declare class PoQueryBuilder {
+    private poSchemaService;
+    private schema;
+    private fields;
+    private filters;
+    private _limit;
+    private _page;
+    private _pageSize;
+    private _sort;
+    constructor(poSchemaService: PoSchemaService, schema: PoSyncSchema);
+    /**
+     * Ao final da chamada dos métodos do `PoQueryBuilder` utilizados, este método deve ser chamado para que a busca seja concluída.
+     *
+     * @return {Promise<PoResponseApi | object>} Registros do *schema* na qual foi aplicado a consulta.
+     */
+    exec(): Promise<PoResponseApi | object>;
+    /**
+     * Aplica filtros sobre os registros, baseados nos campos e valores definidos como filtro. Por exemplo:
+     *
+     * ```
+     * PoQueryBuilder.filter({ name: 'Marie', age: 24 });
+     * ```
+     * Retorna todos os registros que contenham a propriedade `name` igual a Marie e `age` igual a 24.
+     *
+     * @param {object} filter Objeto que contém os campos e valores a serem filtrados no *schema*.
+     *
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    filter(filter?: object): PoQueryBuilder;
+    /**
+     * Limita o número de registros que serão retornados.
+     *
+     * @param {number} limit Número de registros retornados.
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    limit(limit: number): PoQueryBuilder;
+    /**
+     * Especifica a página de registros que se deseja retornar.
+     *
+     * @param {number} page Número da página.
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    page(page: number): PoQueryBuilder;
+    /**
+     * Define quantos elementos serão retornados por página.
+     *
+     * @param {number} pageSize Número de registros por página.
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    pageSize(pageSize: number): PoQueryBuilder;
+    /**
+     * Utilizado para definir quais campos do *schema* serão retornados na consulta.
+     *
+     * @param {string} fields Campos que serão retornados nos registros. Este campos devem estar dentro de
+     * uma *string* separados por espaço podendo usar o caractere `-` para excluir campos.
+     * Por exemplo, a definição abaixo:
+     *
+     * ```
+     * PoQueryBuilder.select('name age address');
+     * ```
+     * Irá retornar apenas os campos `name`, `age` e `address`. Para não retornar um campo ou mais basta fazer:
+     *
+     * ```
+     * PoQueryBuilder.select('-name -age');
+     * ```
+     *
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    select(fields: string): PoQueryBuilder;
+    /**
+     * Ordena os registros por um campo.
+     *
+     * @param {string} field Campo a ser ordenado. Para ordenar de forma decrescente basta colocar o caractere `-`
+     * na frente do campo. Por exemplo:
+     * ```
+     * PoQueryBuilder.sort('-name');
+     * ```
+     *
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    sort(field: string): PoQueryBuilder;
+    /**
+     * Essa função serve como alias para o `PoQueryBuilder.filter()`. É utilizada somente para dar maior legibilidade ao código.
+     *
+     * @param {object} filter Objeto que contém os campos e valores a serem filtrados no *schema*.
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um novo método do `PoQueryBuilder`.
+     */
+    where(filter: object): PoQueryBuilder;
+    private applyFields;
+    private applyFilters;
+    private groupFields;
+    private paginate;
+    private order;
+    private removeDuplicate;
+    private removeFieldsData;
+    private removeRestrictedFields;
+}
+
+/**
+ * @description
+ *
+ * Uma instância `PoEntity` representa um *schema* e ela contém métodos que possibilitam manipular seus registros,
+ * como por exemplo: buscar, criar e remover.
+ *
+ * Esta instância pode ser obtida a partir do retorno do método `PoSyncService.getModel('schema name')`.
+ */
+declare class PoEntity {
+    private eventSourcing;
+    private schema;
+    private poSchemaService;
+    constructor(eventSourcing: PoEventSourcingService, schema: PoSyncSchema, poSchemaService: PoSchemaService);
+    /**
+     * Busca os registros do *schema*, podendo filtrar o resultado a partir do filtro passado e retornando apenas
+     * os campos definidos.
+     *
+     * Para que esta busca seja concluída é necessário utilizar o método `PoQueryBuilder.exec()`.
+     * Veja mais em: [PoQueryBuilder](/documentation/po-query-builder).
+     *
+     * @param {object} filter Objeto que contém os campos e valores a serem filtrados no *schema*.
+     * @param {string} fields Campos que serão retornados nos registros. Este campos devem estar dentro de
+     * uma *string* separados por espaço podendo usar o caractere `-` para excluir campos.
+     * Por exemplo, a definição abaixo:
+     *
+     * ```
+     * PoQueryBuilder.select('name age address');
+     * ```
+     * Irá retornar apenas os campos `name`, `age` e `address`. E para não mostrar um campo ou mais basta fazer:
+     *
+     * ```
+     * PoQueryBuilder.select('-name -age');
+     * ```
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um método do `PoQueryBuilder`.
+     */
+    find(filter?: object, fields?: string): PoQueryBuilder;
+    /**
+     * Busca um registro pelo seu *id*.
+     *
+     * Para que esta busca seja concluída é necessário utilizar o método `PoQueryBuilder.exec()`.
+     * Veja mais em: [PoQueryBuilder](/documentation/po-query-builder).
+     *
+     * @param {any} id Identificador do registro.
+     * @param {string} fields Campos que serão retornados nos registros. Este campos devem estar dentro de
+     * uma *string* separados por espaço podendo usar o caractere `-` para excluir campos.
+     * Por exemplo, a definição abaixo:
+     *
+     * ```
+     * PoQueryBuilder.select('name age address');
+     * ```
+     * Irá retornar apenas os campos `name`, `age` e `address`. E para não mostrar um campo ou mais basta fazer:
+     *
+     * ```
+     * PoQueryBuilder.select('-name -age');
+     * ```
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um método do `PoQueryBuilder`.
+     */
+    findById(id: any, fields?: string): PoQueryBuilder;
+    /**
+     * Semelhante ao método `PoEntity.find()`, porém retorna apenas o primeiro registro encontrado na busca.
+     *
+     * Para que esta busca seja concluída é necessário utilizar o método `PoQueryBuilder.exec()`.
+     * Veja mais em: [PoQueryBuilder](/documentation/po-query-builder).
+     *
+     * @param {any} filter Objeto que contém os campos e valores a serem filtrados no *schema*.
+     * @param {string} fields Campos que serão retornados nos registros. Este campos devem estar dentro de
+     * uma *string* separados por espaço podendo usar o caractere `-` para excluir campos.
+     * Por exemplo, a definição abaixo:
+     *
+     * ```
+     * PoQueryBuilder.select('name age address');
+     * ```
+     * Irá retornar apenas os campos `name`, `age` e `address`. E para não mostrar um campo ou mais basta fazer:
+     *
+     * ```
+     * PoQueryBuilder.select('-name -age');
+     * ```
+     * @returns {PoQueryBuilder} Objeto que possibilita encadear um método do `PoQueryBuilder`.
+     */
+    findOne(filter?: any, fields?: string): PoQueryBuilder;
+    /**
+     * Remove um registro.
+     *
+     * @param {object} record Registro que será removido.
+     * @param {string} customRequestId Identificador customizado do comando.
+     * @returns {Promise} Promessa que é concluída após o registro ser removido.
+     */
+    remove(record: object, customRequestId?: string): Promise<any>;
+    /**
+     * Altera ou inclui um registro.
+     *
+     * > O registro será alterado se ele possuir um *id*, caso contrário um novo registro será criado.
+     *
+     * @param {object} record Registro que será persistido.
+     * @param {string} customRequestId Identificador customizado do comando.
+     * @returns {Promise} Promessa que é concluída após o registro ser alterado ou incluído.
+     */
+    save(record: object, customRequestId?: string): Promise<any>;
+    /**
+     * Salva uma lista de registros em lote.
+     *
+     * > Para cada registro da lista, será inserido um novo registro se o mesmo não tiver *id*, caso contrário
+     * será contado como uma atualização de um registro existente.
+     *
+     * @param {Array<object>} records Lista de registros que serão persistidos.
+     * @param {Array<string> | string} customRequestIds Identificador customizado do comando.
+     *
+     * Ao passar uma lista de identificadores, cada índice da lista de identificadores deverá
+     * corresponder ao índice do registro na lista de registros.
+     * @returns {Promise<any>} Promessa que é concluída após os registros serem alterados ou incluídos.
+     */
+    saveAll(records: Array<object>, customRequestIds?: Array<string> | string): Promise<any>;
+    private create;
+    private createEventOperation;
+    private isNonLocalRecordChanged;
+    private selectSaveType;
+    private update;
+}
+
+/**
+ * @description
+ *
+ * Classe responsável por identificar a conexão de rede disponível no dispositivo.
+ */
+declare class PoNetworkStatus {
+    private _type;
+    constructor(networtkType: any);
+    /**
+     * Retorna se o dispositivo está conectado na rede.
+     *
+     * @returns {boolean} Status da conexão com a rede.
+     */
+    get status(): boolean;
+    /**
+     * Retorna o tipo de conexão do dispositivo.
+     *
+     * @returns {PoNetworkType} Tipo da conexão com a rede.
+     */
+    get type(): PoNetworkType;
+    set type(type: PoNetworkType);
+    private setDefaultTypeNavigation;
+    private setNetworkConnection;
+}
+
+/**
+ * @description
+ *
+ * O `PoNetworkService` é utilizado para verificar o status e o tipo da conexão de rede do dispositivo.
+ */
+declare class PoNetworkService {
+    private networkType;
+    private networkTypeNow;
+    private poNetworkStatus;
+    constructor();
+    /**
+     * Retorna as propriedades tipo e status da conexão do dispositivo no momento da chamada.
+     *
+     * @returns {PoNetworkStatus} Instância de [PoNetworkStatus](/documentation/po-network-status) com as
+     * propriedades da conexão.
+     */
+    getConnectionStatus(): PoNetworkStatus;
+    /**
+     * Notifica as mudanças no tipo de conexão de rede do dispositivo.
+     *
+     * @returns {Observable<{ status: boolean, type: string }>} Observable com as propriedades da conexão.
+     */
+    onChange(): Observable<{
+        status: boolean;
+        type: string;
+    }>;
+    private initNetwork;
+    private getStatus;
+    private initSubscriber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoNetworkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoNetworkService>;
+}
+
+/**
+ * @description
+ *
+ * O `PoSyncService` é utilizado para configurar toda a base de dados que receberá as informações que serão
+ * armazenadas *offline* vindas do servidor. Nele ocorre toda a preparação dos modelos de dados retornados por
+ * cada consulta.
+ */
+declare class PoSyncService {
+    private poEventSourcingService;
+    private poHttpClient;
+    private poNetworkService;
+    private poSchemaDefinitionService;
+    private poSchemaService;
+    models: Array<PoEntity>;
+    private config;
+    private emitter;
+    private eventSub;
+    private finishSyncSubject;
+    private isSyncEnabled;
+    private schemas;
+    private subscription;
+    private syncing;
+    private timer;
+    constructor(poEventSourcingService: PoEventSourcingService, poHttpClient: PoHttpClientService, poNetworkService: PoNetworkService, poSchemaDefinitionService: PoSchemaDefinitionService, poSchemaService: PoSchemaService);
+    /**
+     * Destrói todas as chaves do *storage* referentes ao `po-sync`, ou seja,
+     * as definições dos *schemas*, os registros de cada *schema* e a fila
+     * de eventos que estão para ser enviados ao servidor *(EventSourcing)*.
+     *
+     * > Para que não venham ocorrer erros em ações que dependam das definições dos *schemas*,
+     * recomenda-se utilizar o método `prepare()` em seguida.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Alterando as definições dos schemas](/guides/sync-fundamentals).
+     *
+     * @returns {Promise<any>} Promessa que é resolvida quando as chaves referentes ao `po-sync` forem destruídas.
+     */
+    destroy(): Promise<any>;
+    /**
+     * Desabilita todos os tipos de sincronização de dados (periódica, reativa e manual).
+     *
+     * > Para habilitar novamente a sincronização utilize o método [`PoSyncService.enableSync()`](documentation/po-sync#enable-sync).
+     */
+    disableSync(): void;
+    /**
+     * <a id="enable-sync"></a>
+     * Habilita todos os tipos de sincronização de dados (periódica, reativa e manual).
+     *
+     * Por padrão, sempre que se inicializa uma aplicação com PO Sync as sincronizações já estão habilitadas.
+     */
+    enableSync(): void;
+    /**
+     * Método que disponibiliza a partir de sua inscrição o evento de retorno das operações da fila de eventos que
+     * foram enviadas ao servidor. A cada operação enviada para o servidor, será disparado um evento para a inscrição
+     * deste método.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).
+     *
+     * @returns {Observable<PoSyncResponse>} Observable com um objeto do tipo `PoSyncResponse`.
+     */
+    getResponses(): Observable<PoSyncResponse>;
+    /**
+     * Retorna uma instância de `PoEntity` para um determinado *schema*.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Manipulando os registros de um schema](/guides/sync-fundamentals).
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @returns {PoEntity} Objeto para efetuar consultas e alterações nos dados.
+     */
+    getModel(schemaName: string): PoEntity;
+    /**
+     * Insere uma requisição HTTP na fila de eventos do `po-sync`.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Inserindo requisições HTTP na fila de eventos](/guides/sync-fundamentals).
+     *
+     * @param {PoHttpRequestData} poHttpRequestData Dados da requisição HTTP.
+     * @param {string} customRequestId Identificador customizado da requisição HTTP.
+     * @returns {Promise<number>} Promessa com o identificador da requisição HTTP criada.
+     */
+    insertHttpCommand(requestData: PoHttpRequestData, customRequestId?: string): Promise<number>;
+    /**
+     * Efetua uma chamada na API do servidor para realizar a carga inicial dos dados. Deve ser chamado apenas uma vez
+     * na aplicação, após a preparação dos *schemas* realizada através do método `PoSyncService.prepare()`.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Carga inicial dos dados](/guides/sync-fundamentals).
+     *
+     * @returns {Observable<Array<{ entity: string, data: Array<any> }>>} Observable que notificará quando a
+     * carga inicial for concluída.
+     */
+    loadData(): Observable<Array<{
+        entity: string;
+        data: Array<any>;
+    }>>;
+    /**
+     * Responsável por notificar sempre que houver sincronismo.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Notificação pós-sincronização](/guides/sync-fundamentals).
+     *
+     * @returns {Observable<any>} Observable que é disparado a cada sincronismo realizado.
+     */
+    onSync(): Observable<any>;
+    /**
+     * Prepara a aplicação criando os schemas e aplica as configurações.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Preparando a aplicação](/guides/sync-fundamentals).
+     *
+     * @param {Array<PoSyncSchema>} schemas Lista de *schemas* a serem preparados.
+     * @param {PoSyncConfig} config Configurações adicionais.
+     * @returns {Promise<any>} Promessa que é resolvida quando a aplicação estiver preparada para a utilização do `po-sync`.
+     */
+    prepare(schemas: Array<PoSyncSchema>, config?: PoSyncConfig): Promise<any>;
+    /**
+     * Remove um item da fila de eventos que espera a sincronização.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).
+     *
+     * @param {any} idEventSourcing Identificador do item da fila de eventos.
+     * @returns {Promise<any>} Promessa que é resolvida quando o item da fila de eventos é removido.
+     */
+    removeItemOfSync(idEventSourcing: any): Promise<any>;
+    /**
+     * Reenvia os comandos pendentes na fila (inclusão, alteração e exclusão) e busca novos dados do servidor.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).
+     *
+     * @returns {Promise<any>} Promessa que resolve o sincronismo disparado.
+     */
+    resumeSync(): Promise<any>;
+    /**
+     * Dispara o sincronismo enviando os eventos pendentes (inclusão, alteração e exclusão) e buscando novos dados do servidor.
+     *
+     * O sincronismo somente será executado depois que o acesso a base de dados local do dispositivo for liberada.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Sincronização manual](/guides/sync-fundamentals).
+     *
+     * @returns {Promise<any>} Promessa que é resolvida quando o sincronismo for finalizado.
+     */
+    sync(): Promise<any>;
+    private canSync;
+    private createSubscribe;
+    private finishSync;
+    private getOnePage;
+    private loadEntityData;
+    private reactiveSync;
+    private saveSchemas;
+    private startSync;
+    private startTimer;
+    private syncError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoSyncService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PoSyncService>;
+}
+
+/**
+ * @description
+ *
+ * Módulo do componente PoSync responsável pela sincronia de dados com backends
+ */
+declare class PoSyncModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PoSyncModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PoSyncModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PoSyncModule>;
+}
+
+export { PoDataTransform, PoEntity, PoEventSourcingErrorResponse, PoEventSourcingService, PoHttpClientService, PoHttpRequestType, PoNetworkService, PoNetworkType, PoSyncModule, PoSyncService };
+export type { PoHttpRequestData, PoResponseApi, PoSyncConfig, PoSyncSchema };