/**
 * EliTabela
 * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
 */
/** Dependências do Vue (Composition API) */
import { PropType } from "vue";
import type { tipoEliColuna } from "./types-eli-tabela";
/** Tipos da configuração/contrato da tabela */
import type { tipoEliTabelaConsulta } from "./types-eli-tabela";
import { type EliTabelaColunasConfig } from "./colunasStorage";
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    /** Configuração principal da tabela (colunas, consulta e ações) */
    tabela: {
        type: PropType<tipoEliTabelaConsulta<any>>;
        required: true;
    };
}>, {
    isDev: boolean;
    tabela: import("vue").ComputedRef<tipoEliTabelaConsulta<any>>;
    carregando: import("vue").Ref<boolean, boolean>;
    erro: import("vue").Ref<string | null, string | null>;
    linhas: import("vue").Ref<unknown[], unknown[]>;
    linhasPaginadas: import("vue").ComputedRef<unknown[]>;
    filtrosAvancadosAtivos: import("vue").ComputedRef<{
        coluna: string;
        valor: any;
        operador: "in" | "=" | "!=" | ">" | ">=" | "<" | "<=" | "like" | "isNull";
        ou?: boolean | undefined;
    }[]>;
    quantidadeFiltrada: import("vue").ComputedRef<number>;
    quantidade: import("vue").Ref<number, number>;
    menuAberto: import("vue").Ref<number | null, number | null>;
    valorBusca: import("vue").Ref<string, string>;
    paginaAtual: import("vue").Ref<number, number>;
    colunaOrdenacao: import("vue").Ref<string | null, string | null>;
    direcaoOrdenacao: import("vue").Ref<"desc" | "asc", "desc" | "asc">;
    totalPaginas: import("vue").ComputedRef<number>;
    registrosPorConsulta: import("vue").ComputedRef<number>;
    exibirBusca: import("vue").ComputedRef<boolean>;
    exibirFiltroAvancado: import("vue").ComputedRef<boolean>;
    acoesCabecalho: import("vue").ComputedRef<{
        icone?: import("lucide-vue-next").LucideIcon;
        cor?: string;
        rotulo: string;
        acao: () => void;
        atualizarConsulta?: () => Promise<void>;
        editarLista?: ((lista: any[]) => Promise<any[]>) | undefined;
    }[]>;
    temAcoesCabecalho: import("vue").ComputedRef<boolean>;
    temAcoes: import("vue").ComputedRef<boolean>;
    totalColunas: import("vue").ComputedRef<number>;
    colunasEfetivas: import("vue").ComputedRef<any[]>;
    rotulosColunas: import("vue").ComputedRef<string[]>;
    modalColunasAberto: import("vue").Ref<boolean, boolean>;
    configColunas: import("vue").Ref<{
        visiveis: string[];
        invisiveis: string[];
    }, EliTabelaColunasConfig | {
        visiveis: string[];
        invisiveis: string[];
    }>;
    temColunasInvisiveis: import("vue").ComputedRef<boolean>;
    colunasInvisiveisEfetivas: import("vue").ComputedRef<tipoEliColuna<any>[]>;
    linhasExpandidas: import("vue").Ref<Record<number, boolean>, Record<number, boolean>>;
    abrirModalColunas: () => void;
    abrirModalFiltro: () => void;
    fecharModalColunas: () => void;
    salvarModalColunas: (cfg: EliTabelaColunasConfig) => void;
    modalFiltroAberto: import("vue").Ref<boolean, boolean>;
    filtrosUi: import("vue").Ref<{
        coluna: string | number | symbol;
        valor: any;
    }[], {
        coluna: string | number | symbol;
        valor: any;
    }[] | {
        coluna: string | number | symbol;
        valor: any;
    }[]>;
    salvarFiltrosAvancados: (novo: any[]) => void;
    limparFiltrosAvancados: () => void;
    fecharModalFiltro: () => void;
    alternarLinhaExpandida: (indice: number) => void;
    alternarOrdenacao: (chave?: string) => void;
    atualizarBusca: (texto: string) => void;
    irParaPagina: (pagina: number) => void;
    acoesDisponiveisPorLinha: (i: number) => {
        acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
        indice: number;
        visivel: boolean;
    }[];
    possuiAcoes: (i: number) => boolean;
    toggleMenu: (i: number, evento?: MouseEvent) => void;
    menuPopup: import("vue").Ref<{
        menuEl: {
            value: HTMLElement | null;
        };
    } | null, {
        menuEl: {
            value: HTMLElement | null;
        };
    } | {
        menuEl: {
            value: HTMLElement | null;
        };
    } | null>;
    menuPopupPos: import("vue").Ref<{
        top: number;
        left: number;
    }, {
        top: number;
        left: number;
    } | {
        top: number;
        left: number;
    }>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    /** Configuração principal da tabela (colunas, consulta e ações) */
    tabela: {
        type: PropType<tipoEliTabelaConsulta<any>>;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {
    EliTabelaCabecalho: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        exibirBusca: {
            type: BooleanConstructor;
            required: true;
        };
        exibirBotaoColunas: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        exibirBotaoFiltroAvancado: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        valorBusca: {
            type: StringConstructor;
            required: true;
        };
        acoesCabecalho: {
            type: PropType<Array<{
                icone
                /**
                 * EliTabela
                 * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                 */
                /** Dependências do Vue (Composition API) */
                ?: any;
                cor
                /**
                 * EliTabela
                 * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                 */
                /** Dependências do Vue (Composition API) */
                ?: string;
                rotulo: string;
                acao: () => void;
            }>>;
            required: true;
        };
    }>, {
        temAcoesCabecalho: import("vue").ComputedRef<boolean>;
        emitBuscar: (texto: string) => void;
        emitColunas: () => void;
        emitFiltroAvancado: () => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        buscar(valor: string): boolean;
        colunas(): true;
        filtroAvancado(): true;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        exibirBusca: {
            type: BooleanConstructor;
            required: true;
        };
        exibirBotaoColunas: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        exibirBotaoFiltroAvancado: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        valorBusca: {
            type: StringConstructor;
            required: true;
        };
        acoesCabecalho: {
            type: PropType<Array<{
                icone
                /**
                 * EliTabela
                 * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                 */
                /** Dependências do Vue (Composition API) */
                ?: any;
                cor
                /**
                 * EliTabela
                 * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                 */
                /** Dependências do Vue (Composition API) */
                ?: string;
                rotulo: string;
                acao: () => void;
            }>>;
            required: true;
        };
    }>> & Readonly<{
        onBuscar?: ((valor: string) => any) | undefined;
        onColunas?: (() => any) | undefined;
        onFiltroAvancado?: (() => any) | undefined;
    }>, {
        exibirBotaoColunas: boolean;
        exibirBotaoFiltroAvancado: boolean;
    }, {}, {
        EliTabelaCaixaDeBusca: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            modelo: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>, {
            texto: import("vue").Ref<string, string>;
            emitirBusca: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            buscar(valor: string): boolean;
        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            modelo: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>> & Readonly<{
            onBuscar?: ((valor: string) => any) | undefined;
        }>, {
            modelo: string;
        }, {}, {
            Search: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaEstados: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        carregando: {
            type: BooleanConstructor;
            required: true;
        };
        erro: {
            type: PropType<string | null>;
            required: true;
        };
        mensagemVazio: {
            type: PropType<string | undefined>;
            required: false;
            default: undefined;
        };
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        carregando: {
            type: BooleanConstructor;
            required: true;
        };
        erro: {
            type: PropType<string | null>;
            required: true;
        };
        mensagemVazio: {
            type: PropType<string | undefined>;
            required: false;
            default: undefined;
        };
    }>> & Readonly<{}>, {
        mensagemVazio: string | undefined;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaDebug: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        isDev: {
            type: BooleanConstructor;
            required: true;
        };
        menuAberto: {
            type: PropType<number | null>;
            required: true;
        };
        menuPopupPos: {
            type: PropType<{
                top: number;
                left: number;
            }>;
            required: true;
        };
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        isDev: {
            type: BooleanConstructor;
            required: true;
        };
        menuAberto: {
            type: PropType<number | null>;
            required: true;
        };
        menuPopupPos: {
            type: PropType<{
                top: number;
                left: number;
            }>;
            required: true;
        };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaHead: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        colunas: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
        temAcoes: {
            type: BooleanConstructor;
            required: true;
        };
        temColunasInvisiveis: {
            type: BooleanConstructor;
            required: true;
        };
        colunaOrdenacao: {
            type: PropType<string | null>;
            required: true;
        };
        direcaoOrdenacao: {
            type: PropType<"asc" | "desc">;
            required: true;
        };
    }>, {
        ArrowUp: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        ArrowDown: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        isOrdenavel: (coluna: any) => boolean;
        emitAlternarOrdenacao: (chave: string) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        alternarOrdenacao(chave: string): boolean;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        colunas: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
        temAcoes: {
            type: BooleanConstructor;
            required: true;
        };
        temColunasInvisiveis: {
            type: BooleanConstructor;
            required: true;
        };
        colunaOrdenacao: {
            type: PropType<string | null>;
            required: true;
        };
        direcaoOrdenacao: {
            type: PropType<"asc" | "desc">;
            required: true;
        };
    }>> & Readonly<{
        onAlternarOrdenacao?: ((chave: string) => any) | undefined;
    }>, {}, {}, {
        ArrowUp: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        ArrowDown: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaBody: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        colunas: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
        colunasInvisiveis: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
        temColunasInvisiveis: {
            type: BooleanConstructor;
            required: true;
        };
        linhasExpandidas: {
            type: PropType<Record<number, boolean>>;
            required: true;
        };
        linhas: {
            type: PropType<Array<unknown>>;
            required: true;
        };
        temAcoes: {
            type: BooleanConstructor;
            required: true;
        };
        menuAberto: {
            type: PropType<number | null>;
            required: true;
        };
        possuiAcoes: {
            type: PropType<(i: number) => boolean>;
            required: true;
        };
        toggleMenu: {
            type: PropType<(indice: number, evento: MouseEvent) => void>;
            required: true;
        };
        alternarLinhaExpandida: {
            type: PropType<(indice: number) => void>;
            required: true;
        };
    }>, {
        ChevronRight: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        ChevronDown: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        colunas: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
        colunasInvisiveis: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
        temColunasInvisiveis: {
            type: BooleanConstructor;
            required: true;
        };
        linhasExpandidas: {
            type: PropType<Record<number, boolean>>;
            required: true;
        };
        linhas: {
            type: PropType<Array<unknown>>;
            required: true;
        };
        temAcoes: {
            type: BooleanConstructor;
            required: true;
        };
        menuAberto: {
            type: PropType<number | null>;
            required: true;
        };
        possuiAcoes: {
            type: PropType<(i: number) => boolean>;
            required: true;
        };
        toggleMenu: {
            type: PropType<(indice: number, evento: MouseEvent) => void>;
            required: true;
        };
        alternarLinhaExpandida: {
            type: PropType<(indice: number) => void>;
            required: true;
        };
    }>> & Readonly<{}>, {}, {}, {
        EliTabelaCelula: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            celula: {
                type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
                required: true;
            };
        }>, {
            Componente: import("vue").ComputedRef<import("vue").Component>;
            dadosParaComponente: import("vue").ComputedRef<{
                texto: string;
                acao?: () => void;
            } | {
                texto: string;
                acao?: () => void;
            } | {
                numero: number;
                prefixo?: string;
                sufixo?: string;
                acao?: () => void;
            } | {
                opcoes: {
                    rotulo: string;
                    cor
                    /**
                     * EliTabela
                     * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                     */
                    /** Dependências do Vue (Composition API) */
                    ?: string;
                    icone
                    /**
                     * EliTabela
                     * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                     */
                    /** Dependências do Vue (Composition API) */
                    ?: import("lucide-vue-next").LucideIcon;
                    acao
                    /**
                     * EliTabela
                     * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                     */
                    /** Dependências do Vue (Composition API) */
                    ?: () => void;
                }[];
            } | {
                valor: string;
                formato: "data" | "data_hora" | "relativo";
                acao?: () => void;
            }>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            celula: {
                type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
                required: true;
            };
        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        EliTabelaDetalhesLinha: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            linha: {
                type: PropType<unknown>;
                required: true;
            };
            colunasInvisiveis: {
                type: PropType<Array<tipoEliColuna<any>>>;
                required: true;
            };
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            linha: {
                type: PropType<unknown>;
                required: true;
            };
            colunasInvisiveis: {
                type: PropType<Array<tipoEliColuna<any>>>;
                required: true;
            };
        }>> & Readonly<{}>, {}, {}, {
            EliTabelaCelula: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                celula: {
                    type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
                    required: true;
                };
            }>, {
                Componente: import("vue").ComputedRef<import("vue").Component>;
                dadosParaComponente: import("vue").ComputedRef<{
                    texto: string;
                    acao?: () => void;
                } | {
                    texto: string;
                    acao?: () => void;
                } | {
                    numero: number;
                    prefixo?: string;
                    sufixo?: string;
                    acao?: () => void;
                } | {
                    opcoes: {
                        rotulo: string;
                        cor
                        /**
                         * EliTabela
                         * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                         */
                        /** Dependências do Vue (Composition API) */
                        ?: string;
                        icone
                        /**
                         * EliTabela
                         * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                         */
                        /** Dependências do Vue (Composition API) */
                        ?: import("lucide-vue-next").LucideIcon;
                        acao
                        /**
                         * EliTabela
                         * Componente de tabela consultável com busca, paginação, ordenação e ações por linha.
                         */
                        /** Dependências do Vue (Composition API) */
                        ?: () => void;
                    }[];
                } | {
                    valor: string;
                    formato: "data" | "data_hora" | "relativo";
                    acao?: () => void;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                celula: {
                    type: PropType<import("./types-eli-tabela").tipoComponenteCelula>;
                    required: true;
                };
            }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        MoreVertical: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        ChevronRight: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
        ChevronDown: import("vue").FunctionalComponent<import("lucide-vue-next").LucideProps, {}, any, {}>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaMenuAcoes: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        menuAberto: {
            type: PropType<number | null>;
            required: true;
        };
        posicao: {
            type: PropType<{
                top: number;
                left: number;
            }>;
            required: true;
        };
        acoes: {
            type: PropType<Array<{
                acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
                indice: number;
                visivel: boolean;
            }>>;
            required: true;
        };
        linha: {
            type: PropType<unknown | null>;
            required: true;
        };
    }>, {
        menuEl: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
        possuiAcoes: import("vue").ComputedRef<boolean>;
        emitExecutar: (item: {
            acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
        }) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        executar(payload: {
            acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
            linha: unknown;
        }): boolean;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        menuAberto: {
            type: PropType<number | null>;
            required: true;
        };
        posicao: {
            type: PropType<{
                top: number;
                left: number;
            }>;
            required: true;
        };
        acoes: {
            type: PropType<Array<{
                acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
                indice: number;
                visivel: boolean;
            }>>;
            required: true;
        };
        linha: {
            type: PropType<unknown | null>;
            required: true;
        };
    }>> & Readonly<{
        onExecutar?: ((payload: {
            acao: import("./types-eli-tabela").tipoEliTabelaAcao<any>;
            linha: unknown;
        }) => any) | undefined;
    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaPaginacao: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        pagina: {
            type: NumberConstructor;
            required: true;
        };
        totalPaginas: {
            type: NumberConstructor;
            required: true;
        };
        maximoBotoes: {
            type: NumberConstructor;
            required: false;
        };
    }>, {
        botoes: import("vue").ComputedRef<{
            label: string;
            pagina?: number;
            ativo?: boolean;
            ehEllipsis?: boolean;
        }[]>;
        irParaPagina: (pagina: number | undefined) => void;
        anteriorDesabilitado: import("vue").ComputedRef<boolean>;
        proximaDesabilitada: import("vue").ComputedRef<boolean>;
        paginaAtual: import("vue").ComputedRef<number>;
        totalPaginasExibidas: import("vue").ComputedRef<number>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        alterar(pagina: number): boolean;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        pagina: {
            type: NumberConstructor;
            required: true;
        };
        totalPaginas: {
            type: NumberConstructor;
            required: true;
        };
        maximoBotoes: {
            type: NumberConstructor;
            required: false;
        };
    }>> & Readonly<{
        onAlterar?: ((pagina: number) => any) | undefined;
    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaModalColunas: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        aberto: {
            type: BooleanConstructor;
            required: true;
        };
        rotulosColunas: {
            type: PropType<string[]>;
            required: true;
        };
        configInicial: {
            type: PropType<EliTabelaColunasConfig>;
            required: true;
        };
        colunas: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
    }>, {
        visiveisLocal: import("vue").Ref<string[], string[]>;
        invisiveisLocal: import("vue").Ref<string[], string[]>;
        emitFechar: () => void;
        emitSalvar: () => void;
        onDragStart: (e: DragEvent, rotulo: string, origem: "visiveis" | "invisiveis", index: number) => void;
        onDropItem: (e: DragEvent, destino: "visiveis" | "invisiveis", index: number) => void;
        onDropLista: (e: DragEvent, destino: "visiveis" | "invisiveis", _index: number | null) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        fechar(): true;
        salvar(_config: EliTabelaColunasConfig): true;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        aberto: {
            type: BooleanConstructor;
            required: true;
        };
        rotulosColunas: {
            type: PropType<string[]>;
            required: true;
        };
        configInicial: {
            type: PropType<EliTabelaColunasConfig>;
            required: true;
        };
        colunas: {
            type: PropType<Array<tipoEliColuna<any>>>;
            required: true;
        };
    }>> & Readonly<{
        onFechar?: (() => any) | undefined;
        onSalvar?: ((_config: EliTabelaColunasConfig) => any) | undefined;
    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EliTabelaModalFiltroAvancado: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        aberto: {
            type: BooleanConstructor;
            required: true;
        };
        filtrosBase: {
            type: PropType<Array<{
                coluna: string | number | symbol;
                operador: import("p-comuns").operadores | keyof typeof import("p-comuns").operadores;
                entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada;
            }>>;
            required: true;
        };
        modelo: {
            type: PropType<Array<any>>;
            required: true;
        };
    }>, {
        linhas: import("vue").Ref<{
            coluna: string | number | symbol;
            entrada: readonly ["texto", {
                rotulo: string;
                placeholder?: string | undefined;
                limiteCaracteres?: number | undefined;
                formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep" | undefined;
            }] | readonly ["dataHora", {
                rotulo: string;
                placeholder?: string | undefined;
                modo?: "data" | "dataHora" | undefined;
                limpavel?: boolean | undefined;
                erro?: boolean | undefined;
                mensagensErro?: string | string[] | undefined;
                dica?: string | undefined;
                dicaPersistente?: boolean | undefined;
                min?: string | undefined;
                max?: string | undefined;
                densidade?: import("../../index.js").CampoDensidade | undefined;
                variante?: import("../../index.js").CampoVariante | undefined;
            }] | readonly ["numero", {
                rotulo: string;
                placeholder?: string | undefined;
                sufixo?: string | undefined;
                prefixo?: string | undefined;
                precisao?: number | undefined;
            }] | readonly ["paragrafo", {
                rotulo: string;
                placeholder?: string | undefined;
                linhas?: number | undefined;
                limiteCaracteres?: number | undefined;
                limpavel?: boolean | undefined;
                erro?: boolean | undefined;
                mensagensErro?: string | string[] | undefined;
                dica?: string | undefined;
                dicaPersistente?: boolean | undefined;
                densidade?: import("../../index.js").CampoDensidade | undefined;
                variante?: import("../../index.js").CampoVariante | undefined;
            }] | readonly ["selecao", {
                rotulo: string;
                placeholder?: string | undefined;
                itens: () => {
                    chave: string;
                    rotulo: string;
                }[] | Promise<{
                    chave: string;
                    rotulo: string;
                }[]>;
                limpavel?: boolean | undefined;
                erro?: boolean | undefined;
                mensagensErro?: string | string[] | undefined;
                dica?: string | undefined;
                dicaPersistente?: boolean | undefined;
                densidade?: import("../../index.js").CampoDensidade | undefined;
                variante?: import("../../index.js").CampoVariante | undefined;
            }];
            operador: string;
            valor: any;
        }[], {
            coluna: string | number | symbol;
            entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada;
            operador: string;
            valor: any;
        }[] | {
            coluna: string | number | symbol;
            entrada: readonly ["texto", {
                rotulo: string;
                placeholder?: string | undefined;
                limiteCaracteres?: number | undefined;
                formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep" | undefined;
            }] | readonly ["dataHora", {
                rotulo: string;
                placeholder?: string | undefined;
                modo?: "data" | "dataHora" | undefined;
                limpavel?: boolean | undefined;
                erro?: boolean | undefined;
                mensagensErro?: string | string[] | undefined;
                dica?: string | undefined;
                dicaPersistente?: boolean | undefined;
                min?: string | undefined;
                max?: string | undefined;
                densidade?: import("../../index.js").CampoDensidade | undefined;
                variante?: import("../../index.js").CampoVariante | undefined;
            }] | readonly ["numero", {
                rotulo: string;
                placeholder?: string | undefined;
                sufixo?: string | undefined;
                prefixo?: string | undefined;
                precisao?: number | undefined;
            }] | readonly ["paragrafo", {
                rotulo: string;
                placeholder?: string | undefined;
                linhas?: number | undefined;
                limiteCaracteres?: number | undefined;
                limpavel?: boolean | undefined;
                erro?: boolean | undefined;
                mensagensErro?: string | string[] | undefined;
                dica?: string | undefined;
                dicaPersistente?: boolean | undefined;
                densidade?: import("../../index.js").CampoDensidade | undefined;
                variante?: import("../../index.js").CampoVariante | undefined;
            }] | readonly ["selecao", {
                rotulo: string;
                placeholder?: string | undefined;
                itens: () => {
                    chave: string;
                    rotulo: string;
                }[] | Promise<{
                    chave: string;
                    rotulo: string;
                }[]>;
                limpavel?: boolean | undefined;
                erro?: boolean | undefined;
                mensagensErro?: string | string[] | undefined;
                dica?: string | undefined;
                dicaPersistente?: boolean | undefined;
                densidade?: import("../../index.js").CampoDensidade | undefined;
                variante?: import("../../index.js").CampoVariante | undefined;
            }];
            operador: string;
            valor: any;
        }[]>;
        opcoesParaAdicionar: import("vue").ComputedRef<{
            coluna: string | number | symbol;
            operador: import("p-comuns").operadores | keyof typeof import("p-comuns").operadores;
            entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada;
        }[]>;
        colunaParaAdicionar: import("vue").Ref<string, string>;
        componenteEntrada: (entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada) => import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            value: {
                type: PropType<string | null | undefined>;
                default: undefined;
            };
            opcoes: {
                type: PropType<{
                    rotulo: string;
                    placeholder?: string;
                } & {
                    limiteCaracteres?: number;
                    formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep";
                }>;
                required: true;
            };
        }>, {
            attrs: {
                [x: string]: unknown;
            };
            emit: ((event: "update:value", _v: string | null | undefined) => void) & ((event: "input", _v: string | null | undefined) => void) & ((event: "change", _v: string | null | undefined) => void) & ((event: "focus") => void) & ((event: "blur") => void);
            localValue: import("vue").WritableComputedRef<string | null | undefined, string | null | undefined>;
            inputHtmlType: import("vue").ComputedRef<"text" | "email" | "url">;
            inputMode: import("vue").ComputedRef<string | undefined>;
            onInput: (e: Event) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            "update:value": (_v: string | null | undefined) => true;
            input: (_v: string | null | undefined) => true;
            change: (_v: string | null | undefined) => true;
            focus: () => true;
            blur: () => true;
        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            value: {
                type: PropType<string | null | undefined>;
                default: undefined;
            };
            opcoes: {
                type: PropType<{
                    rotulo: string;
                    placeholder?: string;
                } & {
                    limiteCaracteres?: number;
                    formato?: "texto" | "email" | "url" | "telefone" | "cpfCnpj" | "cep";
                }>;
                required: true;
            };
        }>> & Readonly<{
            "onUpdate:value"?: ((_v: string | null | undefined) => any) | undefined;
            onInput?: ((_v: string | null | undefined) => any) | undefined;
            onChange?: ((_v: string | null | undefined) => any) | undefined;
            onFocus?: (() => any) | undefined;
            onBlur?: (() => any) | undefined;
        }>, {
            value: string | null | undefined;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any> | import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            value: {
                type: PropType<number | null | undefined>;
                default: undefined;
            };
            opcoes: {
                type: PropType<{
                    rotulo: string;
                    placeholder?: string;
                } & {
                    sufixo?: string;
                    prefixo?: string;
                    precisao?: number;
                }>;
                required: true;
            };
        }>, {
            attrs: {
                [x: string]: unknown;
            };
            emit: ((event: "update:value", _v: number | null | undefined) => void) & ((event: "input", _v: number | null | undefined) => void) & ((event: "change", _v: number | null | undefined) => void) & ((event: "focus") => void) & ((event: "blur") => void);
            displayValue: import("vue").Ref<string, string>;
            isInteiro: import("vue").ComputedRef<boolean>;
            onUpdateModelValue: (texto: string) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            "update:value": (_v: number | null | undefined) => true;
            input: (_v: number | null | undefined) => true;
            change: (_v: number | null | undefined) => true;
            focus: () => true;
            blur: () => true;
        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            value: {
                type: PropType<number | null | undefined>;
                default: undefined;
            };
            opcoes: {
                type: PropType<{
                    rotulo: string;
                    placeholder?: string;
                } & {
                    sufixo?: string;
                    prefixo?: string;
                    precisao?: number;
                }>;
                required: true;
            };
        }>> & Readonly<{
            "onUpdate:value"?: ((_v: number | null | undefined) => any) | undefined;
            onInput?: ((_v: number | null | undefined) => any) | undefined;
            onChange?: ((_v: number | null | undefined) => any) | undefined;
            onFocus?: (() => any) | undefined;
            onBlur?: (() => any) | undefined;
        }>, {
            value: number | null | undefined;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any> | import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            value: {
                type: PropType<string | null | undefined>;
                default: undefined;
            };
            opcoes: {
                type: PropType<{
                    rotulo: string;
                    placeholder?: string;
                } & {
                    modo?: "data" | "dataHora";
                    limpavel?: boolean;
                    erro?: boolean;
                    mensagensErro?: string | string[];
                    dica?: string;
                    dicaPersistente?: boolean;
                    min?: string;
                    max?: string;
                    densidade?: import("../../index.js").CampoDensidade;
                    variante?: import("../../index.js").CampoVariante;
                }>;
                required: false;
                default: undefined;
            };
            modelValue: {
                type: PropType<string | null>;
                default: null;
            };
            modo: {
                type: PropType<"data" | "dataHora" | undefined>;
                default: undefined;
            };
            rotulo: {
                type: StringConstructor;
                default: undefined;
            };
            placeholder: {
                type: StringConstructor;
                default: undefined;
            };
            desabilitado: {
                type: BooleanConstructor;
                default: undefined;
            };
            limpavel: {
                type: BooleanConstructor;
                default: undefined;
            };
            erro: {
                type: BooleanConstructor;
                default: undefined;
            };
            mensagensErro: {
                type: PropType<string | string[]>;
                default: undefined;
            };
            dica: {
                type: StringConstructor;
                default: undefined;
            };
            dicaPersistente: {
                type: BooleanConstructor;
                default: undefined;
            };
            densidade: {
                type: PropType<import("../../index.js").CampoDensidade>;
                default: undefined;
            };
            variante: {
                type: PropType<import("../../index.js").CampoVariante>;
                default: undefined;
            };
            min: {
                type: PropType<string | undefined>;
                default: undefined;
            };
            max: {
                type: PropType<string | undefined>;
                default: undefined;
            };
        }>, {
            attrs: {
                [x: string]: unknown;
            };
            valor: import("vue").WritableComputedRef<string, string>;
            tipoInput: import("vue").ComputedRef<"date" | "datetime-local">;
            minLocal: import("vue").ComputedRef<string | undefined>;
            maxLocal: import("vue").ComputedRef<string | undefined>;
            opcoesEfetivas: import("vue").ComputedRef<{
                rotulo: string;
                placeholder?: string;
            } & {
                modo?: "data" | "dataHora";
                limpavel?: boolean;
                erro?: boolean;
                mensagensErro?: string | string[];
                dica?: string;
                dicaPersistente?: boolean;
                min?: string;
                max?: string;
                densidade?: import("../../index.js").CampoDensidade;
                variante?: import("../../index.js").CampoVariante;
            }>;
            desabilitadoEfetivo: import("vue").ComputedRef<boolean>;
            emitCompatFocus: () => void;
            emitCompatBlur: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            "update:value": (_v: string | null) => true;
            input: (_v: string | null) => true;
            change: (_v: string | null) => true;
            "update:modelValue": (_v: string | null) => true;
            alterar: (_v: string | null) => true;
            foco: () => true;
            desfoco: () => true;
            focus: () => true;
            blur: () => true;
        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            value: {
                type: PropType<string | null | undefined>;
                default: undefined;
            };
            opcoes: {
                type: PropType<{
                    rotulo: string;
                    placeholder?: string;
                } & {
                    modo?: "data" | "dataHora";
                    limpavel?: boolean;
                    erro?: boolean;
                    mensagensErro?: string | string[];
                    dica?: string;
                    dicaPersistente?: boolean;
                    min?: string;
                    max?: string;
                    densidade?: import("../../index.js").CampoDensidade;
                    variante?: import("../../index.js").CampoVariante;
                }>;
                required: false;
                default: undefined;
            };
            modelValue: {
                type: PropType<string | null>;
                default: null;
            };
            modo: {
                type: PropType<"data" | "dataHora" | undefined>;
                default: undefined;
            };
            rotulo: {
                type: StringConstructor;
                default: undefined;
            };
            placeholder: {
                type: StringConstructor;
                default: undefined;
            };
            desabilitado: {
                type: BooleanConstructor;
                default: undefined;
            };
            limpavel: {
                type: BooleanConstructor;
                default: undefined;
            };
            erro: {
                type: BooleanConstructor;
                default: undefined;
            };
            mensagensErro: {
                type: PropType<string | string[]>;
                default: undefined;
            };
            dica: {
                type: StringConstructor;
                default: undefined;
            };
            dicaPersistente: {
                type: BooleanConstructor;
                default: undefined;
            };
            densidade: {
                type: PropType<import("../../index.js").CampoDensidade>;
                default: undefined;
            };
            variante: {
                type: PropType<import("../../index.js").CampoVariante>;
                default: undefined;
            };
            min: {
                type: PropType<string | undefined>;
                default: undefined;
            };
            max: {
                type: PropType<string | undefined>;
                default: undefined;
            };
        }>> & Readonly<{
            "onUpdate:value"?: ((_v: string | null) => any) | undefined;
            onInput?: ((_v: string | null) => any) | undefined;
            onChange?: ((_v: string | null) => any) | undefined;
            onFocus?: (() => any) | undefined;
            onBlur?: (() => any) | undefined;
            "onUpdate:modelValue"?: ((_v: string | null) => any) | undefined;
            onAlterar?: ((_v: string | null) => any) | undefined;
            onFoco?: (() => any) | undefined;
            onDesfoco?: (() => any) | undefined;
        }>, {
            modo: "data" | "dataHora" | undefined;
            limpavel: boolean;
            erro: boolean;
            mensagensErro: string | string[];
            dica: string;
            dicaPersistente: boolean;
            min: string | undefined;
            max: string | undefined;
            densidade: import("../../index.js").CampoDensidade;
            variante: import("../../index.js").CampoVariante;
            opcoes: {
                rotulo: string;
                placeholder?: string;
            } & {
                modo?: "data" | "dataHora";
                limpavel?: boolean;
                erro?: boolean;
                mensagensErro?: string | string[];
                dica?: string;
                dicaPersistente?: boolean;
                min?: string;
                max?: string;
                densidade?: import("../../index.js").CampoDensidade;
                variante?: import("../../index.js").CampoVariante;
            };
            value: string | null | undefined;
            placeholder: string;
            modelValue: string | null;
            rotulo: string;
            desabilitado: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        opcoesEntrada: (entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada) => any;
        adicionar: () => void;
        remover: (idx: number) => void;
        emitFechar: () => void;
        emitSalvar: () => void;
        emitLimpar: () => void;
        rotuloDoFiltro: (f: {
            coluna: string | number | symbol;
            operador: import("p-comuns").operadores | keyof typeof import("p-comuns").operadores;
            entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada;
        }) => string;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        fechar: () => true;
        limpar: () => true;
        salvar: (_linhas: any[]) => true;
    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        aberto: {
            type: BooleanConstructor;
            required: true;
        };
        filtrosBase: {
            type: PropType<Array<{
                coluna: string | number | symbol;
                operador: import("p-comuns").operadores | keyof typeof import("p-comuns").operadores;
                entrada: import("../EliEntrada/tiposEntradas.js").ComponenteEntrada;
            }>>;
            required: true;
        };
        modelo: {
            type: PropType<Array<any>>;
            required: true;
        };
    }>> & Readonly<{
        onFechar?: (() => any) | undefined;
        onSalvar?: ((_linhas: any[]) => any) | undefined;
        onLimpar?: (() => any) | undefined;
    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
declare const _default: typeof __VLS_export;
export default _default;
