import * as zod from 'zod';
import { z } from 'zod';
import * as p_respostas from 'p-respostas';
import { tipoResposta } from 'p-respostas';

declare const tipos_acesso_quipo: z.ZodEnum<["publico", "governo", "sociedade"]>;
declare const ztokenQuipo: z.ZodObject<{
    provedor: z.ZodString;
    codigo_usuario: z.ZodString;
    nome_usuario: z.ZodString;
    codigo_conta: z.ZodString;
    nome_conta: z.ZodString;
    codigo_acesso_produto: z.ZodString;
    codigo_autenticacao: z.ZodString;
    chave_produto: z.ZodEnum<["betha-meio-ambiente", "e-licencie-gov"]>;
    tipo_de_acesso: z.ZodEnum<["publico", "governo", "sociedade"]>;
    exp: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    provedor: string;
    codigo_usuario: string;
    nome_usuario: string;
    codigo_conta: string;
    nome_conta: string;
    codigo_acesso_produto: string;
    codigo_autenticacao: string;
    chave_produto: "betha-meio-ambiente" | "e-licencie-gov";
    tipo_de_acesso: "publico" | "governo" | "sociedade";
    exp?: number | undefined;
}, {
    provedor: string;
    codigo_usuario: string;
    nome_usuario: string;
    codigo_conta: string;
    nome_conta: string;
    codigo_acesso_produto: string;
    codigo_autenticacao: string;
    chave_produto: "betha-meio-ambiente" | "e-licencie-gov";
    tipo_de_acesso: "publico" | "governo" | "sociedade";
    exp?: number | undefined;
}>;
type tipos_de_acesso_quipo = z.infer<typeof ztokenQuipo>["tipo_de_acesso"];
type tipoTokenQuipo = z.infer<typeof ztokenQuipo>;

declare const zAmbiente: z.ZodEnum<["desenvolvimento", "producao"]>;

type tipoUsuarioExterno = {
    nome: string;
    email: string;
    telefone: string;
    vinculo: string;
    codigo_conta: string;
    chave_produto: string;
};

/** todas as rotas de comunicação com autenticador partem dessa variável */
declare const pAutenticacao: {
    validarToken: ({ ambiente, post, }: {
        ambiente: zod.TypeOf<typeof zAmbiente>;
        post: {
            token: string;
        };
    }) => Promise<"valido" | "erro">;
    urlAutenticacao: (ambiente: zod.TypeOf<typeof zAmbiente>) => string;
    codigoContaSite: ({ ambiente, post, }: {
        ambiente: zod.TypeOf<typeof zAmbiente>;
        post: {
            site: string;
        };
    }) => Promise<p_respostas.tipoResposta<string>>;
    usuarios_quipo_governo: ({ token_produto, ambiente, }: {
        ambiente: zod.TypeOf<typeof zAmbiente>;
        token_produto: string;
    }) => Promise<p_respostas.tipoResposta<tipoUsuarioExterno[]>>;
    usuarios_quipo_vincular: ({ token_produto, ambiente, conta, vinculo, codigo_usuario, email, }: {
        ambiente: zod.TypeOf<typeof zAmbiente>;
        token_produto: string;
        conta: string;
        vinculo: string;
        codigo_usuario?: string;
        email: string;
    }) => Promise<p_respostas.tipoResposta<string>>;
};

declare const chaves_produto: z.ZodEnum<["suporte", "betha-meio-ambiente", "e-licencie-gov", "e-licencie"]>;

/** aplica a todas as consultas */
declare const z_padroes: z.ZodObject<{
    tabela: z.ZodString;
    filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
        coluna: z.ZodString;
        valor: z.ZodAny;
        operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
    }, "strip", z.ZodTypeAny, {
        coluna: string;
        operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
        valor?: any;
    }, {
        coluna: string;
        operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
        valor?: any;
    }>, "many">>;
    descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    tabela: string;
    filtros?: {
        coluna: string;
        operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
        valor?: any;
    }[] | undefined;
    descricao_pelo_usuario?: string | undefined;
}, {
    tabela: string;
    filtros?: {
        coluna: string;
        operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
        valor?: any;
    }[] | undefined;
    descricao_pelo_usuario?: string | undefined;
}>;
declare const visoes_pilao: {
    z_contagem_em_barra_vertical: z.ZodObject<{
        colanuEixoX: z.ZodString;
        colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        colanuEixoX: string;
        colunaAgrupamento?: string[] | undefined;
    }, {
        colanuEixoX: string;
        colunaAgrupamento?: string[] | undefined;
    }>;
    z_contagem_em_pizza: z.ZodObject<{
        classes: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        classes: string;
    }, {
        classes: string;
    }>;
    z_tabela: z.ZodObject<{
        colunas: z.ZodArray<z.ZodString, "many">;
        coluna_ordem: z.ZodOptional<z.ZodString>;
        direcao_ordem: z.ZodOptional<z.ZodEnum<["asc", "desc", "1", "-1"]>>;
    }, "strip", z.ZodTypeAny, {
        colunas: string[];
        coluna_ordem?: string | undefined;
        direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
    }, {
        colunas: string[];
        coluna_ordem?: string | undefined;
        direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
    }>;
    z_soma_em_barra_vertical: z.ZodObject<{
        colanuEixoX: z.ZodString;
        colunaSoma: z.ZodString;
        unidadeSoma: z.ZodOptional<z.ZodString>;
        colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        colanuEixoX: string;
        colunaSoma: string;
        colunaAgrupamento?: string[] | undefined;
        unidadeSoma?: string | undefined;
    }, {
        colanuEixoX: string;
        colunaSoma: string;
        colunaAgrupamento?: string[] | undefined;
        unidadeSoma?: string | undefined;
    }>;
};

declare const z_tipos_campos_reg_grafico: z.ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>;
type tipo_estrutura_visao_grafico<T extends keyof typeof visoes_pilao> = {
    /** Nome da Visão */
    visao: T;
    /** Rotulo */
    rotulo: string;
    /** Retorna a tabela Referente ao Registro */
    tabela: (_: z.infer<(typeof visoes_pilao)[T]> & z.infer<typeof z_padroes>) => string;
    /** Descrição */
    descricao: (_: z.infer<(typeof visoes_pilao)[T]> & z.infer<typeof z_padroes>) => string;
    /** Lista os campos e suas configurações */
    campos: {
        [c in keyof Required<z.infer<(typeof visoes_pilao)[T]> & z.infer<typeof z_padroes>>]: {
            rotulo: string;
            tipo_campo: z.infer<typeof z_tipos_campos_reg_grafico>;
            order: number;
        };
    };
};

declare const zp_deletar_registros: z.ZodObject<{
    tabela: z.ZodString;
    codigos: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    tabela: string;
    codigos: string[];
}, {
    tabela: string;
    codigos: string[];
}>;
declare const PREFIXO_PILAO = "/pilao-de-dados";
declare const urlPilao: (emDesenvolvimento?: boolean | null | undefined) => {
    api: string;
    site: string;
};

declare const zp_registrar_base_dados: z.ZodObject<{
    tabela: z.ZodString;
    colunas: z.ZodArray<z.ZodObject<{
        coluna: z.ZodString;
        tipo: z.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>;
    }, "strip", z.ZodTypeAny, {
        coluna: string;
        tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
    }, {
        coluna: string;
        tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    tabela: string;
    colunas: {
        coluna: string;
        tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
    }[];
}, {
    tabela: string;
    colunas: {
        coluna: string;
        tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
    }[];
}>;
declare const zp_enviar_registros: z.ZodObject<{
    tabela: z.ZodString;
    registros: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodObject<{
        valor: z.ZodAny;
        tipo: z.ZodNullable<z.ZodOptional<z.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>>>;
    }, "strip", z.ZodTypeAny, {
        valor?: any;
        tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
    }, {
        valor?: any;
        tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
    }>>, "many">;
}, "strip", z.ZodTypeAny, {
    tabela: string;
    registros: Record<string, {
        valor?: any;
        tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
    }>[];
}, {
    tabela: string;
    registros: Record<string, {
        valor?: any;
        tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
    }>[];
}>;

/**
 * {
 * 'rota':{
 *        pr:{}// paramentros de entrada
 *        rs:{}// resposta
 * }
 * }
 */
type tipo_pilao_api = {
    /** retorna da data e hora do servido em formato iso */
    estado_servidor: {
        pr: {};
        rs: {
            data_hora: string;
        };
    };
    tabelas: {
        pr: {};
        rs: z.infer<typeof zp_registrar_base_dados>[];
    };
    unicos: {
        pr: {
            tabela: string;
            coluna: string;
        };
        rs: any[];
    };
};

type tipoConstrutorPilao = {
    produto: string;
    conta: string;
};
type tipoRetornoSerieconsulta<T extends keyof typeof visoes_pilao> = {
    registros: any[];
    legenda: string;
    serie: z.infer<(typeof visoes_pilao)[T]> & z.infer<typeof z_padroes>;
};

/** Drive completo do piilão de dados */

declare class ClassPilao {
    #private;
    constructor({ conta, produto, emDesenvolvimento, ver_log, }: tipoConstrutorPilao & {
        ver_log?: boolean;
        emDesenvolvimento?: boolean;
    });
    rotaEnviarRegistros(): {
        rota: string;
        url: string;
    };
    rotaDeletarRegistro(): {
        rota: string;
        url: string;
    };
    rotaConsultarSerie(tipoVisao: keyof typeof visoes_pilao | ":tipoVisao"): {
        rota: string;
        url: string;
    };
    rotaIframeSerie(tipoVisao: keyof typeof visoes_pilao | ":tipoVisao"): {
        rota: string;
        url: string;
    };
    rotaFuncaoApi(funcao: keyof tipo_pilao_api | ":funcao"): {
        rota: string;
        url: string;
    };
    consultarApi<T extends keyof tipo_pilao_api>(funcao: T, parametros: tipo_pilao_api[T]["pr"]): Promise<tipoResposta<tipo_pilao_api[T]["rs"]>>;
    get baseUrlApi(): "https://carro-de-boi.idz.one" | "http://localhost:5080";
    get baseUrlSite(): "https://carro-de-boi.idz.one" | "http://localhost:5081";
    validarCliente(_: any): tipoResposta<tipoConstrutorPilao>;
    adicionarRegistroParaEnviar(tabela: string, ...registros: z.infer<typeof zp_enviar_registros>["registros"]): this;
    adicionarCodigoParaDeletar(tabela: string, ...codigos: z.infer<typeof zp_deletar_registros>["codigos"]): this;
    private processarRegistros;
    salvarRegistros(): Promise<tipoResposta<true>>;
    serieConsultar<T extends keyof typeof visoes_pilao>(tipoVisao: T, parametros: z.infer<(typeof visoes_pilao)[T]> & z.infer<typeof z_padroes>): {
        dados: () => Promise<tipoResposta<tipoRetornoSerieconsulta<T>>>;
        url: () => string;
    };
    urlLaboratorio(): {
        rota: string;
        url: string;
    };
}
declare const Pilao: (_: tipoConstrutorPilao & {
    ver_log?: boolean;
    emDesenvolvimento?: boolean;
}) => ClassPilao;

declare const pPilao: {
    extruturas_de_campos: {
        z_contagem_em_barra_vertical: tipo_estrutura_visao_grafico<"z_contagem_em_barra_vertical">;
        z_contagem_em_pizza: tipo_estrutura_visao_grafico<"z_contagem_em_pizza">;
        z_tabela: tipo_estrutura_visao_grafico<"z_tabela">;
        z_soma_em_barra_vertical: tipo_estrutura_visao_grafico<"z_soma_em_barra_vertical">;
    };
    z_contagem_em_barra_vertical: zod.ZodObject<{
        colanuEixoX: zod.ZodString;
        colunaAgrupamento: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
    }, "strip", zod.ZodTypeAny, {
        colanuEixoX: string;
        colunaAgrupamento?: string[] | undefined;
    }, {
        colanuEixoX: string;
        colunaAgrupamento?: string[] | undefined;
    }>;
    z_contagem_em_pizza: zod.ZodObject<{
        classes: zod.ZodString;
    }, "strip", zod.ZodTypeAny, {
        classes: string;
    }, {
        classes: string;
    }>;
    z_tabela: zod.ZodObject<{
        colunas: zod.ZodArray<zod.ZodString, "many">;
        coluna_ordem: zod.ZodOptional<zod.ZodString>;
        direcao_ordem: zod.ZodOptional<zod.ZodEnum<["asc", "desc", "1", "-1"]>>;
    }, "strip", zod.ZodTypeAny, {
        colunas: string[];
        coluna_ordem?: string | undefined;
        direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
    }, {
        colunas: string[];
        coluna_ordem?: string | undefined;
        direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
    }>;
    z_soma_em_barra_vertical: zod.ZodObject<{
        colanuEixoX: zod.ZodString;
        colunaSoma: zod.ZodString;
        unidadeSoma: zod.ZodOptional<zod.ZodString>;
        colunaAgrupamento: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
    }, "strip", zod.ZodTypeAny, {
        colanuEixoX: string;
        colunaSoma: string;
        colunaAgrupamento?: string[] | undefined;
        unidadeSoma?: string | undefined;
    }, {
        colanuEixoX: string;
        colunaSoma: string;
        colunaAgrupamento?: string[] | undefined;
        unidadeSoma?: string | undefined;
    }>;
    zp_deletar_registros: zod.ZodObject<{
        tabela: zod.ZodString;
        codigos: zod.ZodArray<zod.ZodString, "many">;
    }, "strip", zod.ZodTypeAny, {
        tabela: string;
        codigos: string[];
    }, {
        tabela: string;
        codigos: string[];
    }>;
    zp_registrar_base_dados: zod.ZodObject<{
        tabela: zod.ZodString;
        colunas: zod.ZodArray<zod.ZodObject<{
            coluna: zod.ZodString;
            tipo: zod.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>;
        }, "strip", zod.ZodTypeAny, {
            coluna: string;
            tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
        }, {
            coluna: string;
            tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
        }>, "many">;
    }, "strip", zod.ZodTypeAny, {
        tabela: string;
        colunas: {
            coluna: string;
            tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
        }[];
    }, {
        tabela: string;
        colunas: {
            coluna: string;
            tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
        }[];
    }>;
    z_tipos_dados_registro: zod.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>;
    zp_enviar_registros: zod.ZodObject<{
        tabela: zod.ZodString;
        registros: zod.ZodArray<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            valor: zod.ZodAny;
            tipo: zod.ZodNullable<zod.ZodOptional<zod.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>>>;
        }, "strip", zod.ZodTypeAny, {
            valor?: any;
            tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
        }, {
            valor?: any;
            tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
        }>>, "many">;
    }, "strip", zod.ZodTypeAny, {
        tabela: string;
        registros: Record<string, {
            valor?: any;
            tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
        }>[];
    }, {
        tabela: string;
        registros: Record<string, {
            valor?: any;
            tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
        }>[];
    }>;
    zp_produto_conta: zod.ZodObject<{
        produto: zod.ZodString;
        conta: zod.ZodString;
        emDesenvolvimento: zod.ZodOptional<zod.ZodBoolean>;
        ver_log: zod.ZodOptional<zod.ZodBoolean>;
    }, "strip", zod.ZodTypeAny, {
        conta: string;
        produto: string;
        emDesenvolvimento?: boolean | undefined;
        ver_log?: boolean | undefined;
    }, {
        conta: string;
        produto: string;
        emDesenvolvimento?: boolean | undefined;
        ver_log?: boolean | undefined;
    }>;
    validarZ: <T>(zodType: zod.ZodType<T, any>, objeto: any, mensagem: string) => p_respostas.tipoRespostaErro | p_respostas.tipoRespostaSucesso<T>;
    operadores_pilao: zod.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
    operadores_permitidos_por_tipo: {
        texto: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        numero: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        confirmacao: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        lista_texto: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        lista_numero: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        lista_mes: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        lista_data: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        mes: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
        data: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
    };
    z_filtro: zod.ZodObject<{
        coluna: zod.ZodString;
        valor: zod.ZodAny;
        operador: zod.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
    }, "strip", zod.ZodTypeAny, {
        coluna: string;
        operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
        valor?: any;
    }, {
        coluna: string;
        operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
        valor?: any;
    }>;
    visoes_pilao: {
        z_contagem_em_barra_vertical: zod.ZodObject<{
            colanuEixoX: zod.ZodString;
            colunaAgrupamento: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
        }, "strip", zod.ZodTypeAny, {
            colanuEixoX: string;
            colunaAgrupamento?: string[] | undefined;
        }, {
            colanuEixoX: string;
            colunaAgrupamento?: string[] | undefined;
        }>;
        z_contagem_em_pizza: zod.ZodObject<{
            classes: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            classes: string;
        }, {
            classes: string;
        }>;
        z_tabela: zod.ZodObject<{
            colunas: zod.ZodArray<zod.ZodString, "many">;
            coluna_ordem: zod.ZodOptional<zod.ZodString>;
            direcao_ordem: zod.ZodOptional<zod.ZodEnum<["asc", "desc", "1", "-1"]>>;
        }, "strip", zod.ZodTypeAny, {
            colunas: string[];
            coluna_ordem?: string | undefined;
            direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
        }, {
            colunas: string[];
            coluna_ordem?: string | undefined;
            direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
        }>;
        z_soma_em_barra_vertical: zod.ZodObject<{
            colanuEixoX: zod.ZodString;
            colunaSoma: zod.ZodString;
            unidadeSoma: zod.ZodOptional<zod.ZodString>;
            colunaAgrupamento: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
        }, "strip", zod.ZodTypeAny, {
            colanuEixoX: string;
            colunaSoma: string;
            colunaAgrupamento?: string[] | undefined;
            unidadeSoma?: string | undefined;
        }, {
            colanuEixoX: string;
            colunaSoma: string;
            colunaAgrupamento?: string[] | undefined;
            unidadeSoma?: string | undefined;
        }>;
    };
};

/** Estrutura que deve ser aplicada para solictação de autenticação, deve ser feito via back */
declare const zAuntenticacaoResiduosSolicitar: z.ZodObject<{
    codigo_token: z.ZodOptional<z.ZodString>;
    codigo_usuario: z.ZodString;
    nome_usuario: z.ZodString;
    email_usuario: z.ZodString;
    documento_usuario: z.ZodString;
    organizacao: z.ZodString;
    rotas: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
    url_usuarios: z.ZodString;
    url_empreendedores: z.ZodString;
    url_empreendimentos: z.ZodString;
    tipo_usuario: z.ZodString;
    sistema: z.ZodString;
    sistema_cor: z.ZodString;
    sistema_nome: z.ZodString;
    sistema_logo: z.ZodString;
}, "strip", z.ZodTypeAny, {
    codigo_usuario: string;
    nome_usuario: string;
    email_usuario: string;
    documento_usuario: string;
    organizacao: string;
    rotas: {};
    url_usuarios: string;
    url_empreendedores: string;
    url_empreendimentos: string;
    tipo_usuario: string;
    sistema: string;
    sistema_cor: string;
    sistema_nome: string;
    sistema_logo: string;
    codigo_token?: string | undefined;
}, {
    codigo_usuario: string;
    nome_usuario: string;
    email_usuario: string;
    documento_usuario: string;
    organizacao: string;
    rotas: {};
    url_usuarios: string;
    url_empreendedores: string;
    url_empreendimentos: string;
    tipo_usuario: string;
    sistema: string;
    sistema_cor: string;
    sistema_nome: string;
    sistema_logo: string;
    codigo_token?: string | undefined;
}>;
/** Tipagem usada para o processo de sincronização entre modulos  */
declare const zUsuarioSincronizar: z.ZodObject<{
    codigo: z.ZodString;
    documento: z.ZodString;
    excluido: z.ZodBoolean;
    nome: z.ZodString;
    permicoes: z.ZodRecord<z.ZodString, z.ZodAny>;
    versao: z.ZodNumber;
    credenciais_sinir: z.ZodOptional<z.ZodObject<{
        login: z.ZodString;
        senha: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        login: string;
        senha: string;
    }, {
        login: string;
        senha: string;
    }>>;
}, "strip", z.ZodTypeAny, {
    codigo: string;
    documento: string;
    excluido: boolean;
    nome: string;
    permicoes: Record<string, any>;
    versao: number;
    credenciais_sinir?: {
        login: string;
        senha: string;
    } | undefined;
}, {
    codigo: string;
    documento: string;
    excluido: boolean;
    nome: string;
    permicoes: Record<string, any>;
    versao: number;
    credenciais_sinir?: {
        login: string;
        senha: string;
    } | undefined;
}>;
type tipo_zUsuarioSincronizar = z.infer<typeof zUsuarioSincronizar>;
/** Tipagem usada para o processo de sincronização entre modulos  */
declare const zEmpreendedorSincronizar: z.ZodObject<{
    codigo: z.ZodString;
    documento: z.ZodString;
    excluido: z.ZodBoolean;
    nome: z.ZodString;
    versao: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    codigo: string;
    documento: string;
    excluido: boolean;
    nome: string;
    versao: number;
}, {
    codigo: string;
    documento: string;
    excluido: boolean;
    nome: string;
    versao: number;
}>;
/** Tipagem usada para o processo de sincronização entre modulos  */
declare const zEmpreendimentoSincronizar: z.ZodObject<{
    codigo: z.ZodString;
    codigo_empreendedor: z.ZodString;
    documento: z.ZodString;
    excluido: z.ZodBoolean;
    nome: z.ZodString;
    unidade_sinir: z.ZodString;
    versao: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    codigo: string;
    documento: string;
    excluido: boolean;
    nome: string;
    versao: number;
    codigo_empreendedor: string;
    unidade_sinir: string;
}, {
    codigo: string;
    documento: string;
    excluido: boolean;
    nome: string;
    versao: number;
    codigo_empreendedor: string;
    unidade_sinir: string;
}>;
declare const nomesSincronizacoes: z.ZodEnum<["usuarios", "empreendedores", "empreendimentos"]>;

type tipo_proxima_avaliacao = {
    parametros: {
        sistema: string;
        codigo_organizacao: string;
        codigo_usuario: string;
        nome_organizacao: string;
        nome_usuario: string;
        contatos_usuario: string;
        data_criacao_conta: string;
    };
    retorno: tipoResposta<string>;
};

declare const abrirNps: (emDesenvolvimento: boolean) => (parametros: tipo_proxima_avaliacao["parametros"]) => Promise<void>;

export { PREFIXO_PILAO, Pilao, abrirNps, chaves_produto, nomesSincronizacoes, pAutenticacao, pPilao, type tipoConstrutorPilao, type tipoRetornoSerieconsulta, type tipoTokenQuipo, type tipoUsuarioExterno, type tipo_pilao_api, type tipo_proxima_avaliacao, type tipo_zUsuarioSincronizar, tipos_acesso_quipo, type tipos_de_acesso_quipo, urlPilao, zAuntenticacaoResiduosSolicitar, zEmpreendedorSincronizar, zEmpreendimentoSincronizar, zUsuarioSincronizar, ztokenQuipo };