/// <reference types="angular" />
/// <reference types="angular-resource" />
/// <reference types="angular-jwt" />
declare namespace hurbis.ui.seguranca {
    class Modulo {
        static DEFINICAO: comum.IModuloDefinicao;
        static inicializar(): void;
    }
}
interface ITokenPayload {
    aud: string;
    exp: string;
    iat: string;
    iss: string;
    sub: string;
}
interface ILoginResult {
    accessToken: string;
    idToken: string;
    idTokenPayload?: ITokenPayload;
    refreshToken?: boolean;
    state?: string;
}
declare namespace hurbis.ui.seguranca {
    interface ISegurancaRootScopeService extends angular.IRootScopeService {
        isAuthenticated: boolean;
    }
    interface ISegurancaConfigService {
        getConfiguracao(): IConfiguracao;
    }
    interface IConfiguracaoCookie {
        nomeToken: string;
        nomeTokenAcesso: string;
        nomeProfile: string;
    }
    interface IConfiguracaoGerenciador {
        clientId: string;
        clientSecret: string;
        enderecoApi: string;
        cookieNomeToken: string;
    }
    interface IConfiguracaoInterceptador {
        /**
         * Nome do parâmetro a ser passado com o token do usuário. Exemplo: https://servidor/?nomeParametroUrl=[seuToken]
        **/
        nomeParametroUrl?: string;
        cabecalhoAutorizacao?: string;
        cabecalhoAutorizacaoPrefixo?: string;
        whiteListedDomains?: string[];
        /**
        * Utiilzado para recuperar o token a ser validado durante as transições de estado no Angular e ao realizar um requisição.
        * Para fazer alguma customização do que será retornado, é possível injetar o serviço "options" que na verdade é a requisição do Angular (angular.IRequestConfig).
        **/
        recuperarToken?: angular.Injectable<{
            (...args: any[]): string;
        }>;
        loginUrl?: string;
        naoAutenticadoUrl?: string;
        naoAutenticadoRedirecionador?: angular.Injectable<Function>;
        verificarAoAtualizar?: boolean;
        tokenExpirou?: {
            (event: angular.IAngularEvent, ...args: any[]): void;
        };
    }
    enum TipoConexaoSocial {
        Facebook = 0,
        Google = 1,
    }
    interface IConfiguracao {
        clientId: string;
        callbackUrl?: string;
        logoutUrl?: string;
        dominio: string;
        conexao?: string;
        enderecoApi?: string;
        cookie: IConfiguracaoCookie;
        /**
        * Nome da API configurada no Auth0 o qual deseja permissão de acesso.
        **/
        nomeRecurso?: string;
        /** Utilizado para recuperar os atribuitos user_metadata após conformidade OIDC. Ex.: https://app.empresa.com.br/user_metadata */
        caminhoUserMetadata?: string;
        /** Utilizado para recuperar os atribuitos app_metadata após conformidade OIDC. Ex.: https://app.empresa.com.br/app_metadata */
        caminhoAppMetadata?: string;
        interceptador?: IConfiguracaoInterceptador;
        gerenciador?: IConfiguracaoGerenciador;
    }
    interface IAutenticadorIdentity extends auth0.Auth0Identity {
    }
    interface IAutenticadorUsuario {
        connection: string;
        email?: string;
        email_verified?: boolean;
        verify_email?: boolean;
        username?: string;
        password?: string;
        client_id?: string;
        phone_number?: string;
        phone_verified?: boolean;
        app_metadata?: any;
        user_metadata?: IAutenticadorUserMetadata;
    }
    interface IAutenticadorUsuarioResult extends auth0.Auth0UserProfile {
        identities: IAutenticadorIdentity[];
        user_metadata?: IAutenticadorUserMetadata;
        multifactor?: any;
        last_ip?: string;
        last_login?: number;
        logins_count?: number;
        blocked?: boolean;
    }
    interface IAutenticadorUserMetadata {
        nome: string;
        data_nascimento: string;
        dataNascimento?: string;
        sexo: string;
        foto_url?: string;
        fotoUrl?: string;
    }
    interface IResourceSeguranca<T> extends angular.resource.IResourceClass<T> {
        atualizar: angular.resource.IResourceMethod<T>;
    }
    interface ITokenRequest {
        client_id: string;
        audience: string;
        client_secret: string;
        grantType: string;
    }
    interface ITokenResult {
        accessToken: string;
        tokenType: string;
    }
    interface IAutenticacaoErroDetalhe {
        code: any;
        message: string;
        error_description: string;
    }
    interface IAutenticacaoErro extends auth0.Auth0Error {
    }
}
declare namespace hurbis.ui.seguranca {
    class UsuarioModel {
        usuarioId: number;
        autorizadorUsuarioId: string;
        login: string;
        nome: string;
        email: string;
        senha: string;
        dataNascimento: Date;
        sexo: string;
        fotoURL: string;
    }
}
declare namespace hurbis.ui.seguranca {
    class ConfiguracaoProvider implements angular.IServiceProvider {
        private jwtOptionsProvider;
        private $httpProvider;
        constructor(jwtOptionsProvider: any, $httpProvider: angular.IHttpProvider);
        private _configuracao;
        configurar(configuracao: IConfiguracao): void;
        private configurarInterceptador();
        getConfiguracao: () => IConfiguracao;
        $get: (() => ISegurancaConfigService)[];
        static inicializar(): void;
    }
}
declare namespace hurbis.ui.seguranca {
    class AutenticacaoService {
        private $q;
        private $resource;
        private jwtHelper;
        broker: auth0.WebAuth;
        private configuracao;
        constructor($q: angular.IQService, $resource: angular.resource.IResourceService, jwtHelper: angular.jwt.IJwtHelper, $hbsSegurancaConfig: ISegurancaConfigService);
        token: string;
        tokenAcesso: string;
        usuario: IAutenticadorUsuarioResult;
        consultarUsuario(tokenAcesso: string): angular.IPromise<IAutenticadorUsuarioResult>;
        tokenExpirou(token?: string): boolean;
        private recuperarTipoConexaoSocial(tipoConexaoSocial);
        loginSocial(tipoConexaoSocial: TipoConexaoSocial): ng.IPromise<IAutenticadorUsuarioResult>;
        /**
         * Autentica o usuário.
         * @param usuario Usuário a ser autenticado.
         * @param nomeRecurso Nome do recurso (Identificador da API) definido no Auth0 responsável por identificar o servidor de recursos da aplicação.
         * @param permissao Caso informado o nome do recurso, o parâmetro scope será atribuído inicialmente com "openid" e concatenado com as demais permissões informadas.
                            As permissões deverão estar separadas por espaços.
         */
        login(usuario: UsuarioModel, nomeRecurso?: string, permissao?: string): ng.IPromise<IAutenticadorUsuarioResult>;
        /**
         * Limpa cookies e cache de autenticação.
         * @param forcarServidor Força limpeza de eventuais sessões abertas no servidor de autenticação.
         * Obs.: A aplicação será redirecionada.
         */
        logout(forcarServidor?: boolean): void;
        /**
         * Verifica se o usuário é válido.
         * @param login Login (username) do usuário a ser validado.
         * @param senha Senha do usuário a ser validado.
         */
        validarUsuario(login: string, senha: string): ng.IPromise<boolean>;
        /**
         * Uma nova senha será enviada para o e-mail informado.
         * @param email Endereço de e-mail para onde será enviada a solicitação.
         */
        solicitarNovaSenha(email: string): ng.IPromise<boolean>;
        static inicializar(): void;
    }
}
declare namespace hurbis.ui.seguranca {
    class ManutencaoService {
        private $resource;
        private jwtHelper;
        private $q;
        private configuracao;
        constructor($resource: angular.resource.IResourceService, jwtHelper: angular.jwt.IJwtHelper, $q: angular.IQService, $hbsSegurancaConfig: ISegurancaConfigService);
        private brokerAutenticador;
        private enderecoUsuario;
        private dadoUsuario;
        private tokenManutencao;
        private iniciarRecursosAsync();
        private iniciarServicoUsuario();
        cadastrarUsuario(usuario: UsuarioModel, verificarEmail?: boolean): ng.IPromise<IAutenticadorUsuarioResult>;
        atualizarUsuario(usuario: UsuarioModel): ng.IPromise<IAutenticadorUsuarioResult>;
        alterarSenha(autorizadorUsuarioId: string, senhaNova: string): ng.IPromise<IAutenticadorUsuarioResult>;
        static inicializar(): void;
    }
}