hurbis-comum-v1/hurbis-comum-v1.d.ts

Biblioteca para uso do AngularJS com TypeScript.

/// <reference types="angular" />
/// <reference types="angular-translate" />
/// <reference types="angular-resource" />
/// <reference types="googlemaps" />
declare namespace hurbis.comum {
    interface IModuloDefinicao {
        nome: string;
        requisitos: string[];
    }
    enum FuncionalidadeTipo {
        Fabrica = 0,
        Provedor = 1,
        Controladora = 2,
        Servico = 3,
        Diretiva = 4,
        Componente = 5,
        Filtro = 6,
        Notacao = 7,
    }
    interface IFuncionalidadeDefinicao {
        /**
         * Módulo o qual a funcionalidade será registrada.
         */
        moduloDefinicao?: IModuloDefinicao;
        /**
         * Tipo de funcionalidade.
         * Obs.: Caso seja apenas uma configuração do módulo não é necessário informar.
         */
        tipo?: FuncionalidadeTipo;
        /**
         * Nome da funcionalidade.
         * Obs.: Caso seja apenas uma configuração do módulo não é necessário informar.
         */
        nome?: string;
        /**
         * Implementação da funcionalidade ou objeto (caso seja um componente).
         * Permite informar função com notação para injeção de independência. Ex.: ["teste", (teste)=>{ ... }].
         * Caso esteja registrando um componente, passar o objeto (IComponentOptions) com as devidas definições.
         */
        objeto: angular.Injectable<Function> | angular.Injectable<angular.FilterFactory> | angular.Injectable<angular.IDirectiveFactory> | angular.IComponentOptions | angular.IServiceProviderFactory | angular.IServiceProviderClass;
    }
    class GestorModulo {
        private static MODULO_PADRAO;
        static registrarModulo(moduloDefinicao: IModuloDefinicao): void;
        /**
         * Recupera/cria o módulo do Angular.
         * @param moduloDefinicao Módulo a ser recuperado. O módulo padrão é: "hurbis.comum"
         */
        private static modulo(moduloDefinicao?);
        /**
         * Delega funcionalidade para executar no comando "config" do Angular.
         * @param funcionalidade Implementação a ser executada.
         * @returns {}
         */
        static configurarModulo(funcionalidade: IFuncionalidadeDefinicao): void;
        /**
         * Delega funcionalidade para executar no comando "run" do Angular.
         * @param funcionalidade Implementação a ser executada.
         * @returns {}
         */
        static inicializarModulo(funcionalidade: IFuncionalidadeDefinicao): void;
        static registrarValor(nome: string, valor: any, moduloDefinicao?: IModuloDefinicao): void;
        static registrarConstante(nome: string, valor: any, moduloDefinicao?: IModuloDefinicao): void;
        static registrarFuncionalidade(funcionalidade: IFuncionalidadeDefinicao): void;
        static inicializar(): void;
    }
}
declare namespace hurbis.comum {
    interface IScriptDefinicao {
        nome: string;
        arquivos: string[];
    }
    abstract class GestorScriptBase {
        desconverter(itens: oc.IModuleConfig[]): IScriptDefinicao[];
        converter(itens: IScriptDefinicao[]): oc.IModuleConfig[];
    }
}
declare namespace hurbis.comum {
    class GestorScriptProvider extends GestorScriptBase implements angular.IServiceProvider {
        private $ocLazyLoadProvider;
        constructor($ocLazyLoadProvider: oc.ILazyLoadProvider);
        configurar(itens: IScriptDefinicao[]): void;
        criarMetodoCarregar(...tipos: string[]): any;
        $get: (string | ((leitor: oc.ILazyLoad, $q: angular.IQService) => GestorScriptService))[];
        static inicializar(): void;
    }
}
declare namespace hurbis.comum {
    class GestorScriptService extends GestorScriptBase {
        private leitor;
        private $q;
        constructor(leitor: oc.ILazyLoad, $q: angular.IQService);
        readonly scripts: string[];
        getScriptDefinicao(nome: string): IScriptDefinicao;
        configurar(itens: IScriptDefinicao[]): void;
        carregar(tipos: string[]): angular.IPromise<any>;
    }
}
declare namespace hurbis.comum.util {
    class Localizacao {
        private $translate;
        constructor($translate: angular.translate.ITranslateService);
        private static configurar($translateProvider);
        traduzir(linguagem?: string): void;
        traducao(palavras: string[]): ng.IPromise<{
            [key: string]: string;
        }>;
        selecionada(): string;
        sugerida(): string;
        static inicializar(): void;
    }
}
declare namespace hurbis.comum.util.mapa {
    interface IIP {
        ip: string;
        country_code: string;
        country_name: string;
        region_code: string;
        region_name: string;
        city: string;
        zip_code: string;
        time_zone: string;
        latitude: number;
        longitude: number;
        metro_code: string;
    }
    /**
     * Serviço para auxiliar em funcionalidades que utilizem mapas. Padrão: Google Maps.
     */
    class MapaService {
        private static ENDERECO_BASE_MAPA_POR_IP;
        private enderecoServico;
        dado: angular.resource.IResourceClass<any>;
        constructor($resource: angular.resource.IResourceService);
        /**
         * Calcula a distância entre 2 pontos informados.
         * @param pontoA
         * @param pontoB
         */
        static calcularDistancia(pontoA: google.maps.LatLng, pontoB: google.maps.LatLng, exibirUnidade?: boolean): string;
        static inicializar(): void;
    }
}
declare namespace hurbis.comum.util {
    class Objeto {
        static copiar<T>(origem: T, destino?: T): T;
        static estender(destino: any, ...fontes: any[]): void;
        /**
         * Recupera a instância do serviço.
         * @param nomeServico Nome do serviço a ser recuperado.
         * @param modulos Lista dos módulos onde o serviço deverá ser procurado para ser recuperado.
         * @param elemento Nome do elemento raiz da árvore o qual o serviço será recuperado. Valor padrão: "document.body".
         */
        static recuperarServico<T>(nomeServico: string, modulos?: string[], elemento?: HTMLElement): T;
        private static excecaoObjetoNaoCarregado(objeto);
    }
}
declare namespace hurbis.comum.util {
    class Gerador {
        /**
         * Gera um código aleatório.
         * @param tamanho Tamanho do código desejado.
         */
        static gerarCodigoAleatorio(tamanho: number): string;
        /** Gera código utilizando lógica e formato GUID. */
        static gerarGUID(): string;
    }
}
declare namespace hurbis.comum.util {
    interface IArquivo {
        nome: string;
        tipo: string;
        conteudo: string;
    }
    class Arquivo {
        static fromBase64ToByteArray(conteudo: string, sliceSize?: number): Uint8Array[];
        static fromByteArrayToBlob(conteudo: Uint8Array[], tipo: string): Blob;
        static fromBase64ToBlob(conteudo: string, tipo?: string, sliceSize?: number): Blob;
        static toBlob(arquivo: IArquivo): Blob;
    }
}
declare namespace hurbis.comum.util.email {
    interface IConfiguracao {
        apiKey: string;
        url: string;
    }
    interface IEndereco {
        email: string;
        name?: string;
    }
    interface IPersonalization {
        to: IEndereco[];
        cc?: IEndereco[];
        bco?: IEndereco[];
        subject?: string;
    }
    interface IConteudo {
        type: string;
        value: string;
    }
    interface IEmail {
        from: IEndereco;
        personalizations: IPersonalization[];
        content: IConteudo[];
        subject: string;
    }
    interface IEmailService {
        enviar(email: IEmail): angular.IHttpPromise<{}>;
    }
}
declare namespace hurbis.comum.util.email {
    class EmailService implements IEmailService {
        private $http;
        private configuracao;
        constructor($http: angular.IHttpService, configuracao: IConfiguracao);
        enviar(email: IEmail): angular.IHttpPromise<{}>;
    }
}
declare namespace hurbis.comum.util.email {
    class EmailProvider implements angular.IServiceProvider {
        $get: (string | (($http: angular.IHttpService) => IEmailService))[];
        private _configuracao;
        configurar(configuracao: IConfiguracao): void;
        static inicializar(): void;
    }
}
declare namespace hurbis.comum.util.validador {
    class CPF {
        private static LISTA_IGNORADA;
        private static STRICT_STRIP_REGEX;
        private static LOOSE_STRIP_REGEX;
        private static retornarDigito(numeros);
        static formatar(numero: string): string;
        static limpar(numero: string, strict?: boolean): string;
        private static atualizarComDV(numeroSemDV);
        static validar(numero: string, strict?: boolean): boolean;
        static gerar(formatado: boolean): string;
    }
}
declare namespace hurbis.comum.util.validador {
    class CNPJ {
        private static LISTA_IGNORADA;
        private static STRICT_STRIP_REGEX;
        private static LOOSE_STRIP_REGEX;
        private static retornarDigito(numeros);
        static formatar(numero: string): string;
        static limpar(numero: string, strict?: boolean): string;
        private static atualizarComDV(numeroSemDV);
        static validar(numero: string, strict?: boolean): boolean;
        static gerar(formatado: boolean): string;
    }
}