jsegd/dist/jsegd.d.ts

Utilitário de ferramentas para desenvolvimento

/**
 * Endereço
 * @hideconstructor
 */
declare class Address {
    /** * Código de Endereçamento Postal (CEP) * @public */
    private _cep;
    /**   * @public   */
    private _logradouro;
    /** * @public */
    private _complemento;
    /** * @public */
    private _unidade;
    /** * @public */
    private _bairro;
    /** * @public */
    private _localidade;
    /** * @public */
    private _uf;
    /** * @public */
    private _estado;
    /** * @public */
    private _regiao;
    /** * @public */
    private _ibge;
    /** * @public */
    private _gia;
    /** * @public */
    private _ddd;
    /** * @public */
    private _siafi;
    protected constructor(cep: string, logradouro: string, complemento: string, unidade: string, bairro: string, localidade: string, uf: string, estado: string, regiao: string, ibge: string, gia: string, ddd: string, siafi: string);
    get cep(): string;
    get logradouro(): string;
    get complemento(): string;
    get unidade(): string;
    get bairro(): string;
    get localidade(): string;
    get uf(): string;
    get estado(): string;
    get regiao(): string;
    get ibge(): string;
    get gia(): string;
    get ddd(): string;
    get siafi(): string;
}

/**
 *
 * @hideconstructor
 */
declare class AddressController {
    private addressService;
    constructor();
    /**
     *
     * @param cep Cep contendo 8 dígitos
     * @returns {Promise<Address>}
     */
    pesquisarPorCep(cep: string): Promise<Address>;
}

/**
 * Implementa um botão para gerenciar anexos
 * @hideconstructor
 * @example
 * ```html
 * <attachment-button description="CONTRATO"></attachment-button>
 * ```
 */
declare class AttachButton extends HTMLElement {
    /**
     * Descrição do anexo
     * @defaultValue `anexo`
     */
    description: string;
    accept: string | null;
    noaddbutton: string | null;
    noviewbutton: string | null;
    noeditbutton: string | null;
    nodeletebutton: string | null;
    constructor();
    /**
     * @private
     */
    connectedCallback(): void;
    private displayButtons;
    private addButton;
    private viewButton;
    private removeButton;
    private showModal;
}

/**
 * @hideconstructor
 */
declare class Bank {
    /**
     * Identificador de Sistema de Pagamentos Brasileiro
     * * @public
     */
    private _ispb;
    /**
     * Nome reduzido do banco
     * * @public
     */
    private _name;
    /**
     * Código referente ao Sistema de Compensação de Cheques e Outros Papéis
     * * @public
     */
    private _code;
    /**
     * Nome completo do banco
     * * @public
     */
    private _fullName;
    protected constructor(ispb: string, name: string, code: number, fullName: string);
    get ispb(): string;
    get name(): string;
    get code(): number;
    get fullName(): string;
    toString(): string;
}

/**
 *
 * @hideconstructor
 */
declare class BankController {
    private bankService;
    constructor();
    /**
     *
     * @returns {Promise<Bank>}
     * @example Listar bancos
     * ## Uso
     * ```javascript
     * const controller = await new BankController()
     * const banks = controller.list()
     * for (const bank of banks) {
     *  console.log(bank.toString());
     * }
     * ```
     */
    list(): Promise<Bank[]>;
    findByFullName(query: string): Promise<Bank[]>;
    filterByCodeOrFullName(query: string): Promise<Bank[]>;
}

declare enum ConstraintsType {
    MUST = "MUST",
    MUST_NOT = "MUST_NOT",
    SHOULD = "SHOULD"
}
interface SearchParams {
    datasetId: string;
    field: string[];
    offset: number;
    limit: number;
    orderby: string;
    constraintsField: string[];
    constraintsInitialValue: string[];
    constraintsFinalValue: string[];
    constraintsType: ConstraintsType[];
    constraintsLikeSearch: boolean[];
}
type CancelablePromise<T> = {
    promise: Promise<T>;
    cancel: () => void;
};
declare enum Status {
    SUCCESS = "success",
    ERROR = "error",
    WARNING = "warning",
    FAIL = "fail"
}
interface ErrorDetail {
    code: string;
    message: string;
    field?: string;
}
interface DatasetValue {
    status: Status;
    code: number;
    message: string;
    data?: unknown | null;
    errors?: ErrorDetail[];
}

interface EntityOptions {
    dataset: string;
    constraintsField?: string[];
    constraintsInitialValue?: string[];
    constraintsFinalValue?: string[];
    constraintsType?: ConstraintsType[];
    orderby?: string;
    offset?: number;
    limit?: number;
}
/**
 *
 * @param options Configurações do decorator entity.
 * @param options.dataset Nome do dataset a ser consultado.
 * @param options.constraintsField Campos para aplicar restrições.
 * @param options.constraintsInitialValue Valores iniciais para as restrições.
 * @param options.constraintsFinalValue Valores finais para as restrições.
 * @param options.constraintsType Tipos de restrição (MUST, MUST_NOT, SHOULD).
 * @param options.orderby Campo para ordenação dos resultados.
 * @param options.offset Ponto de partida para a busca (para paginação).
 * @param options.limit Limite de resultados a serem retornados.
 * @example
 * ```typescript
 * @entity({
 *     dataset: 'meu_dataset_de_produtos',
 *     constraintsField: ['status'],
 *     constraintsInitialValue: ['ATIVO'],
 *     constraintsFinalValue: [],
 *     constraintsType: [ConstraintsType.MUST],
 *     orderby: 'descricao_DESC',
 *     offset: 0,
 *     limit: 1,
 * })
 * export class ModelExemplo extends ModelBase {
 *     AtributoExemplo!: string
 *     OutroAtributo!: number
 * }
 *
 * const model = await ModelExemplo.createAsync()
 * console.log(model.AtributoExemplo, model.OutroAtributo)
 * ```
 * @returns
 */
declare function entity(options: EntityOptions): <T extends {
    new (...args: any[]): {};
}>(target: T) => {
    new (...args: any[]): {};
} & T;

declare class DocumentHandler {
    private attachments;
    private blob?;
    private state;
    private processInstanceId;
    private static allowedTransitions;
    constructor();
    render(template: ArrayBuffer | Blob, data: Record<string, unknown>): Promise<this>;
    download(filename: string, blob?: Blob): this;
    upload(description: string, type?: string, blob?: Blob): this;
    view(description: string): void;
    private attachmentAbortController?;
    loadAttachment(description: string, cancelPrevious?: boolean): Promise<this>;
    private documentAbortController?;
    loadDocument(id: number, cancelPrevious?: boolean): Promise<Blob>;
    blobToJSON<T = unknown>(defaultValue?: T): Promise<T>;
    private assertBlobLoaded;
    private assertState;
    private sanitize;
}

declare global {
    interface HTMLElement {
        setValue(value: string): void;
        getValue(): string;
        clear(): void;
        toggleClass(token: string, condition: boolean): void;
    }
}
/**
 * Retorna o primeiro elemento dentro do documento
 * @param selector é uma string que contém um [seletor CSS](https://developer.mozilla.org/pt-BR/docs/Web/CSS/CSS_selectors)
 */
declare function get(selector: string, parent?: HTMLElement): HTMLElement | null;
/**
 * Retorna uma lista de elementos presentes no documento
 * @param selector é uma string que contém um [seletor CSS](https://developer.mozilla.org/pt-BR/docs/Web/CSS/CSS_selectors)
 */
declare function getAll(selector: string): HTMLElement[];
declare function getData(formId: string): {
    [key: string]: FormDataEntryValue;
};

type FieldError = {
    field?: HTMLElement | null;
    errorMessage: string;
};
declare class BeforeSendValidate {
    private static clearAllErrors;
    static throwValidationError(fields: FieldError[]): never;
}

declare enum ToastType {
    'danger' = "danger",
    'success' = "success",
    'warning' = "warning",
    'info' = "info"
}
declare class Exception extends Error {
    type?: ToastType;
    context?: string;
    cause?: Error;
    constructor(message: string, options?: {
        type?: ToastType;
        context?: string;
        cause?: Error;
    });
    /**
     * Exibe notificação ao usuário automaticamente ao instanciar Exception.
     */
    private notify;
}

declare abstract class ModelBase {
    static createAsync<T extends ModelBase>(this: new () => T): Promise<T>;
}

declare class Municipality {
    municipio_id: string;
    municipio_nome: string;
    microrregiao_id: string;
    microrregiao_nome: string;
    mesorregiao_id: string;
    mesorregiao_nome: string;
    regiao_imediata_id: string;
    regiao_imediata_nome: string;
    regiao_intermediaria_id: string;
    regiao_intermediaria_nome: string;
    UF_id: string;
    UF_sigla: string;
    UF_nome: string;
    regiao_id: string;
    regiao_sigla: string;
    regiao_nome: string;
    constructor(municipio_id: string, municipio_nome: string, microrregiao_id: string, microrregiao_nome: string, mesorregiao_id: string, mesorregiao_nome: string, regiao_imediata_id: string, regiao_imediata_nome: string, regiao_intermediaria_id: string, regiao_intermediaria_nome: string, UF_id: string, UF_sigla: string, UF_nome: string, regiao_id: string, regiao_sigla: string, regiao_nome: string);
}

declare class MunicipalityController {
    private municipalityService;
    constructor();
    findByName(name: string): Promise<Municipality[]>;
}

declare abstract class OnlyNumbers {
    private static specialKeys;
    private static regex;
    static onKeyDown(e: KeyboardEvent): void;
    static onKeyPress(e: KeyboardEvent): void;
    static onPaste(event: ClipboardEvent): void;
    static onDrop(event: DragEvent): void;
}

declare enum TypePix {
    DOCUMENT = 0,
    EMAIL = 1,
    MOBILE = 2,
    EVP = 3
}
declare class Pix {
    private type;
    private key;
    constructor(type: TypePix, key: string);
    validate(): Promise<boolean>;
    private documentValidate;
    private mobileValidate;
    private emailValidate;
    private evpValidate;
}

type EventCallback = (...args: any[]) => void;
declare class EventBus {
    private static instance;
    events: Record<string, EventCallback[]>;
    private constructor();
    /**
     * Retorna a única instância do EventBus.
     */
    static getInstance(): EventBus;
    /**
     * Inscreve um callback para um evento específico.
     */
    subscribe(eventName: string, callback: EventCallback): () => void;
    /**
     * Desinscreve um callback específico de um evento.
     */
    unsubscribe(eventName: string, callback: EventCallback): void;
    /**
     * Publica um evento, executando todos os callbacks inscritos para ele.
     */
    publish(eventName: string, ...args: any[]): void;
    /**
     * Limpa todos os callbacks inscritos para um evento específico.
     */
    clearEvent(eventName: string): void;
    /**
     * Limpa todos os eventos e callbacks registrados no EventBus.
     */
    clearAllEvents(): void;
}

/**
 * Este exemplo fornece uma estrutura clara de como consumir o WorkerManager e lidar tanto com resultados de sucesso, quanto com falhas (erros propagados via rejeição da Promise), aderindo às melhores práticas de Promises em JavaScript.
 * @example
 * ```typescript
    import { WorkerManager, ConstraintsType} from 'jsegd';

    // --- Configuração e Instanciação do WorkerManager ---
    const cacheOptions = {
        storeName: 'mySearchCache',       // Nome para o armazenamento local do cache
        cacheExpirationMs: 24 * 60 * 60 * 1000 // 24 horas de expiração para o cache
    };
    const workerPoolSize = 4; // Número de workers no pool

    const manager = new WorkerManager(workerPoolSize, cacheOptions);

    // --- Exemplo de Parâmetros de Busca ---
    const commonSearchParams = {
        datasetId: 'meu_dataset_de_produtos',
        field: ['codigo', 'descricao', 'preco'],
        offset: 0,
        limit: 10,
        orderby: 'descricao_DESC',
        constraintsField: [],
        constraintsInitialValue: [],
        constraintsFinalValue: [],
        constraintsType: [],
        constraintsLikeSearch: []
    };

    // --- Função Assíncrona para Demonstrar o Uso ---
    async function performSearchExamples() {
        const baseUrl = 'https://api.exemplo.com/fluig-integracao'; // URL base para a sua API

        console.log('--- Exemplo 1: Busca com Sucesso ---');
        try {
            const paramsSuccess = {
                ...commonSearchParams,
                constraintsField: ['status'],
                constraintsInitialValue: ['ATIVO'],
                constraintsType: [ConstraintsType.MUST], // ou o tipo adequado
            };

            const { promise: successPromise, cancel: cancelSuccess } = manager.search(baseUrl, paramsSuccess);

            // Você pode cancelar a promessa a qualquer momento antes que ela resolva ou rejeite
            // setTimeout(() => {
            //     console.log('Tentando cancelar a busca de sucesso (pode não ter efeito se já concluída)');
            //     cancelSuccess();
            // }, 500);

            const data = await successPromise;
            console.log('Resultado da busca (Sucesso):', data);
            // data aqui será o objeto contido no campo 'data' do seu DatasetResult (o payload puro)
            console.log('Primeiro produto:', data && data.length > 0 ? data[0] : 'Nenhum dado retornado.');

        } catch (error: any) {
            console.error('Erro na busca de sucesso (NÃO ESPERADO):', error);
            // Se houver um erro aqui, significa que a Promise rejeitou,
            // o que pode indicar um erro de rede, erro no worker, ou um erro tratado e relançado
            // pelo WorkerManager.
            if (error.statusCode) { // Se for um erro com status code
                console.error('Detalhes do erro:', {
                    statusCode: error.statusCode,
                    message: error.message,
                    details: error.errorDetails,
                });
            }
        }

        console.log('\n--- Exemplo 2: Busca com Erro (Parâmetros Inválidos) ---');
        try {
            const paramsError = {
                ...commonSearchParams,
                // Simular um cenário onde um parâmetro obrigatório está faltando
                // ou tem um valor inválido, causando um erro 400 da API
                datasetId: '', // Exemplo: datasetId vazio
            };

            const { promise: errorPromise, cancel: cancelError } = manager.search(baseUrl, paramsError);

            const data = await errorPromise;
            // Se a promise resolver aqui, algo está errado, pois esperamos um erro
            console.log('Resultado da busca com erro (NÃO ESPERADO RESOLVER):', data);

        } catch (error: any) {
            console.error('Erro na busca (ESPERADO):', error);
            // Aqui, 'error' deve ser o DTO de erro ou a instância de Error que você rejeitou.
            if (error.statusCode) { // Se for um erro com status code
                console.error('Detalhes do erro:', {
                    statusCode: error.statusCode,
                    message: error.message,
                    details: error.errorDetails,
                });
            } else { // Outro tipo de erro, como erro de rede ou interno do worker
                console.error('Erro geral:', error.message);
            }
        }

        console.log('\n--- Exemplo 3: Busca que será Cancelada ---');
        try {
            const paramsToCancel = {
                ...commonSearchParams,
                // Adicionar uma constraint que talvez demore ou seja irrelevante
                constraintsField: ['algumCampoPesado'],
                constraintsInitialValue: ['valorQueDemora'],
                constraintsType: [ConstraintsType.SHOULD], // ou o tipo adequado
            };

            const { promise: cancelablePromise, cancel: triggerCancel } = manager.search(baseUrl, paramsToCancel);

            // Cancelar a busca após um curto período de tempo
            setTimeout(() => {
                console.log('Cancelando a busca...');
                triggerCancel();
            }, 100); // Tentar cancelar após 100ms

            const data = await cancelablePromise;
            console.log('Resultado da busca cancelável (NÃO ESPERADO RESOLVER):', data);

        } catch (error: any) {
            console.error('Erro na busca cancelável (ESPERADO CANCELAMENTO):', error);
            if (error.message === 'Requisição cancelada') {
                console.log('A promessa foi cancelada com sucesso.');
            } else {
                console.error('Erro inesperado na busca cancelável:', error);
            }
        }
    }

    // Chamar a função para executar os exemplos
    performSearchExamples();
    ```
 */
declare class WorkerManager {
    private poolSize;
    private pool;
    private workerMeta;
    private taskQueue;
    private inFlight;
    private cache;
    constructor(poolSize: number | undefined, cacheOptions: {
        storeName: string;
        cacheExpirationMs: number;
    });
    search(baseUrl: string, params: SearchParams): CancelablePromise<DatasetValue>;
    private enqueueRequest;
    private scheduleNext;
    private removeFromQueue;
    private handleResponse;
    private buildUrl;
}

declare function shortenText(text: string): Promise<string>;

declare enum Months {
    "Janeiro" = 0,
    "Fevereiro" = 1,
    "Março" = 2,
    "Abril" = 3,
    "Maio" = 4,
    "Junho" = 5,
    "Julho" = 6,
    "Agosto" = 7,
    "Setembro" = 8,
    "Outubro" = 9,
    "Novembro" = 10
}
/**
 * @hideconstructor
 */
declare class Util {
    /**
     * Permite apenas entrada de digitos, vírgula e ponto /^[0-9,\.]+$/
     * @param event {KeyboardEvent}
     * @returns
     */
    static onlyDecimalNumbers(event: KeyboardEvent): void;
    static cleanAndConvertToNumber(value: string): Promise<number>;
    static convertToMonetaryValue(value: number): string;
    static removeSpecialCharacters(value: string): Promise<string>;
    static addTextToLeft(value: string, text: string, limit: number): Promise<string>;
}

/**
 * @hideconstructor
 */
declare abstract class Validate {
    /**
     *
     * @example Validate.emailValidate('contato@email.com')
     */
    static emailValidate(email: string): Promise<boolean>;
    static mobileValidate(mobile: string): Promise<boolean>;
    static cnpjValidate(cnpj: string): Promise<boolean>;
    static cpfValidate(cpf: string): Promise<boolean>;
    static cepValidate(cep: string): Promise<boolean>;
}

declare enum DeadlineUnits {
    'Day' = 0,
    'Month' = 1,
    'Year' = 2
}
/**
 * @hideconstructor
 */
declare abstract class WrittenOut {
    /**
     *
     * @param value Valor que será escrito por extenso
     * @param unit Unidade do valor
     * @example
     * ```typescript
     * import { WrittenOut, DeadlineUnits } from "jsegd";
     * const result = await WrittenOut.deadlineWrittenOut(5, DeadlineUnits.Day);
     * console.log(result); // "5 dias"
     * ```
     * @returns
     */
    static deadlineWrittenOut(value: number, unit: DeadlineUnits): Promise<string>;
    /**
     *
     * @param value Valor que será escrito por extenso
     * @example
     * ```typescript
     * import { WrittenOut } from "jsegd";
     * const result = await WrittenOut.numberWrittenOut(12345);
     * console.log(result); // "doze mil trezentos e quarenta e cinco
     * ```
     * @returns
     */
    static numberWrittenOut(value: number): Promise<string>;
    /**
     *
     * @param date Data que será escrita por extenso
     * @example
     * ```typescript
     * import { WrittenOut } from "jsegd";
     * const result = await WrittenOut.dateWrittenOut(new Date("2023-10-01"));
     * console.log(result); // "primeiro de outubro de dois mil e vinte e três"
     * ```
     * @returns
     */
    static dateWrittenOut(date: Date): Promise<string>;
}

export { Address, AddressController, AttachButton, Bank, BankController, BeforeSendValidate, type CancelablePromise, ConstraintsType, type DatasetValue, DeadlineUnits, DocumentHandler, type ErrorDetail, EventBus, Exception, type FieldError, ModelBase, Months, Municipality, MunicipalityController, OnlyNumbers, Pix, type SearchParams, Status, ToastType, TypePix, Util, Validate, WorkerManager, WrittenOut, entity, get, getAll, getData, shortenText };