klawtil 0.17.0-rc4 → 1.0.0

package/dist/main.d.ts

@@ -1,46 +1,713 @@
+/***************************************************
+ * UTILS
+ * Funções soltas de cunho geral que servem em outros locais do app
+ *
+ ****************************************************/
+/*************************************************************************
+ *
+ * TYPES
+ */
 type ApplyVarsOptions = {
     start: string;
     end: string;
 };
+/*************************************************************************
+ *
+ * COMPARAÇÃO DE VALORES
+ */
+/**
+ * Verifica se um valor é vazio, null, array vazio ou objeto vazio.
+ * Não considera 0 ou false como vazio.
+ *
+ * @example
+ *
+ * empty('') // -> true
+ * empty(null) // -> true
+ * empty(false) // -> false
+ * empty(undefined) // -> true
+ *
+ * @param {*} value
+ * @returns {Boolean}
+ */
 export declare const empty: (value: any) => boolean;
+/*************************************************************************
+ *
+ * VERIFICAÇÃO DE TIPOS
+ */
+/**
+ * Verifica se o valor passado é do tipo array
+ *
+ * @example
+ *
+ * isArray([]) // -> true
+ * isArray({}) // -> false
+ * isArray(0) // -> false
+ * isArray('claudio') // -> false
+ *
+ * @param {*} value
+ * @returns {Boolean}
+ */
 export declare const isArray: (value: any) => boolean;
+/**
+ * Verifica se o valor passado é do tipo objeto
+ */
 export declare const isObject: (value: any) => boolean;
+/**
+ * Verifica se o valor passado é do tipo string
+ *
+ *
+ */
 export declare const isString: (value: any) => boolean;
+/**
+ * Verifica se é um número inteiro.
+ *
+ * @examples
+
+ *   isInteger('1')          // -> true
+ *   isInteger('1', true)    // -> false
+ *   isInteger(1)            // -> true
+ *   isInteger(1.2)          // -> false
+ *   isInteger(1, true)      // -> true
+ *   isInteger('1', true)    // -> false
+ *   isInteger('claudio')    // -> false
+
+ *
+ * @param {Any} value: Valor que será comparado
+ * @param {Boolean} forceType: Define se deve verificar o tipo, e não apenas o número
+ */
 export declare const isInteger: (value: any, forceType?: boolean) => boolean;
+/**
+ * Verifica se é no formato de float, independente do tipo
+ *
+ * @example
+ *
+ *   isFloat('1')            // -> true
+ *   isFloat(1, true)        // -> true
+ *   isFloat('1', true)      // -> false
+ *   isFloat(1)              // -> true
+ *   isFloat(1.2)            // -> true
+ *   isFloat('1.2')          // -> true
+ *   isFloat('1.2', true)    // -> false
+ *   isFloat('claudio')      // -> false
+ *   isFloat(false)          // -> false
+ *
+ * @param {*} value
+ * @returns {Boolean} *
+ */
 export declare const isFloat: (value: any, forceType?: boolean) => boolean;
+/**
+ * Verifica se é no formato de float, independente do tipo
+ *
+ * @example
+ *
+ *   isNumeric('1')               // -> true
+ *   isNumeric(1, true)           // -> true
+ *   isNumeric('1', true)         // -> false
+ *   isNumeric(1)                 // -> true
+ *   isNumeric(1.2)               // -> true
+ *   isNumeric('1.2')             // -> true
+ *   isNumeric('1.2', true)       // -> false
+ *   isNumeric('claudio')         // -> false
+ *   isNumeric(false)             // -> false
+ *
+ * @param {*} value
+ * @returns {Boolean}
+ */
 export declare const isNumeric: (value: any, forceType?: boolean) => boolean;
+/**
+ * Verifica se um dado valor é um objeto JSON
+ *
+ * @example
+ *
+ *   isJSON( true )            // -> false
+ *   isJSON( false )           // -> false
+ *   isJSON( '' )              // -> false
+ *   isJSON( null )            // -> false
+ *   isJSON( undefined )       // -> false
+ *   isJSON( NaN )             // -> false
+ *   isJSON( 'claudio' )       // -> false
+ *   isJSON( 4654 )            // -> false
+ *   isJSON( 0 )               // -> false
+ *   isJSON( [1,2,3] )         // -> false
+ *   isJSON( new Date() )      // -> false
+ *   isJSON( "{ age: 21 }" )   // -> false
+ *   isJSON( { age: 21 } )     // -> true
+ *
+ *
+ * @param {*} value
+ * @returns {Boolean}
+ */
 export declare const isJSON: (value: any) => boolean;
+/**
+ * checkTypes
+ * Verifica se o valor passado bate com algum dos tipos
+ * http://tobyho.com/2011/01/28/checking-types-in-javascript/
+ *
+ *   checkTypes( 1, String )                           // -> false
+ *   checkTypes( '1', String )                         // -> true
+ *   checkTypes( 1, Number )                           // -> true
+ *   checkTypes( '1', Number )                         // -> false
+ *   checkTypes( 1, [String, Number] )                 // -> true
+ *   checkTypes( 'a', [String, Number] )               // -> true
+ *   checkTypes( {}, [String, Number] )                // -> false
+ *   checkTypes( [], [String, Number] )                // -> false
+ *   checkTypes( [], [String, Number, Array] )         // -> true
+ *   checkTypes( {}, [String, Number, Array] )         // -> false
+ *   checkTypes( {}, [String, Number, Array, Object] ) // -> true
+ *
+ * @param {*} value
+ * @param {*|[*]} types
+ * @returns {Boolean}
+ */
 export declare const checkTypes: (value: any, types: any | any[]) => boolean;
+/*************************************************************************
+ *
+ * COMPARAÇÃO DE FORMATOS
+ */
+/**
+ * Verifica se é um e-mail
+ *
+ *    isEmail("claudio")              // -> false
+ *    isEmail("claudio@claudio.com")  // -> true
+ *    isEmail("")                     // -> false
+ *    isEmail(null)                   // -> false
+ *    isEmail(undefined)              // -> false
+ *    isEmail([])                     // -> false
+ *    isEmail({})                     // -> false
+ *    isEmail(123)                    // -> false
+ *
+ */
 export declare const isEmail: (value: any) => boolean;
+/**
+ * Verifica se é uma data em um formato aceito pelo javascript
+ *
+ * @example
+ *
+ * isDate('12/12/29')        // ->  true
+ * isDate('31/12/29')        // ->  false
+ * isDate('12/31/29')        // ->  true
+ * isDate('12/12/2029')      // ->  true
+ * isDate('2029-12-12')      // ->  true
+ *
+ * @param {String|Number|Date}
+ * @returns {Boolean}
+ */
 export declare const isDate: (value: string | number | Date) => boolean;
+/**
+ * Verifica se é uma data válida em portugues
+ *
+ * @example
+ *   isDateBR('31/07/2020') // true
+ *   isDateBR('32/07/2020') // false
+ *
+ *
+ * @param {String}
+ * @returns {Boolean}
+ */
 export declare const isDateBR: (value: string) => boolean;
+/**
+ * Verifica se uma hora informada possui o formato de hora:
+ * 00:00 ou 00:00:00.
+ * Por padrão na verifica os segundos. Passe seconds=true para
+ * verificar também os segundos
+ *
+ * @example
+ *
+ *     isTime('12:00')                // ->  true
+ *     isTime('23:00')                // ->  true
+ *     isTime('23:59')                // ->  true
+ *     isTime('24:00')                // ->  false
+ *     isTime('00:00')                // ->  true
+ *     isTime('-12:00')               // ->  false
+ *     isTime('aa:pp')                // ->  false
+ *     isTime('23:60')                // ->  false
+
+ *     isTime('00:00:00', true)       // ->  true
+ *     isTime('23:59:59', true)       // ->  true
+ *     isTime('24:59:59', true)       // ->  false
+ *     isTime('23:60:59', true)       // ->  false
+ *     isTime('23:59:65', true)       // ->  false
+ *     isTime('aa:bb:dd', true)       // ->  false
+ *
+ *
+ *
+ * @param {String} value
+ * @param {Boolean} seconds
+ *
+ *
+ */
 export declare const isTime: (value: string, seconds?: boolean) => boolean;
+/**
+ * Verifica se um valor é falsy, ou seja, mesmo convertido
+ * para string a intenção dele deveria ser falso
+ *
+ * @example
+ *
+ *  isFalsy(0) // -> true
+ *  isFalsy('') // -> true
+ *  isFalsy('0') // -> true
+ *  isFalsy(NaN) // -> true
+ *  isFalsy(null) // -> true
+ *  isFalsy('NaN') // -> true
+ *  isFalsy(false) // -> true
+ *  isFalsy('null') // -> true
+ *  isFalsy('false') // -> true
+ *  isFalsy(undefined) // -> true
+ *  isFalsy('undefined') // -> true
+ *
+ * @param {any} value
+ */
 export declare const isFalsy: (value: any) => boolean;
+/**
+ * Verifica se um valor é falsy, ou seja, mesmo convertido
+ * para string a intenção dele deveria ser falso
+ *
+ * @example
+ *
+ *  isTruthy(0) // -> false
+ *  isTruthy('') // -> false
+ *  isTruthy('0') // -> false
+ *  isTruthy(NaN) // -> false
+ *  isTruthy(null) // -> false
+ *  isTruthy('NaN') // -> false
+ *  isTruthy(false) // -> false
+ *  isTruthy('null') // -> false
+ *  isTruthy('false') // -> false
+ *  isTruthy(undefined) // -> false
+ *  isTruthy('undefined') // -> false
+ *
+ * @param {any} value
+ */
 export declare const isTruthy: (value: any) => boolean;
+/*************************************************************************
+ *
+ * CONVERSÃO DE FORMATOS
+ */
+/********************
+ * BUSCA
+ */
+/**
+ * Verifica 2 arrays e retorna os valores que estão em ambos
+ *
+ * @example
+ *
+ * intersect([1,2,3], [3,4,5])  // -> [ 3 ]
+ *
+ * @param {Array} array1
+ * @param {Array} array2
+ * @return {Array} Array contendo os valores que estão nos 2 arrays
+ */
 export declare const intersect: (array1: any[], array2: any[]) => any[];
+/**
+ * Retorna o valor de uma chave em um objeto de múltiplos níveis
+ *
+ * @example
+ * let obj = { a:'1',  b:{ c:10, d:2, e:{ f:'4', g:'5', h:{ i:'6' } } } }
+ * objectPath( obj , 'b.e.h.i' ); // -> '6'
+ *
+ * @param  {Object} obj
+ * @param  {String} path Endereço no formato 'chave.subchave.outrasubchave'
+ * @returns {*}  Valor de acordo com o caminho
+ */
 export declare function objectPath(obj: any, path: string): any;
+/********************
+ * FUNÇÕES DE APOIO
+ */
+/**
+ * Agrupa um array de objetos por uma das chaves desse array.
+ *
+ * @todo Mesclar com o objectPath() acima e permitir agurpamentos multidimensionais
+ * com
+ *
+ * @exemplo
+ * const list = [
+ *  {"id":1,"name":"claudio","age":37,"city":"fortaleza"},
+ *  {"id":2,"name":"isa","age":9,"city":"natal"},
+ *  {"id":3,"name":"jose","age":37,"city":"fortaleza"},
+ *  {"id":4,"name":"marta","age":42,"city":"afonso bezerra"},
+ *  {"id":5,"name":"joelma","age":42,"city":"afonso bezerra"},
+ *  {"id":6,"name":"jose","age":24,"city":"assu"}
+ * ]
+ *
+ * groupBy( list, 'name' )
+ *
+ * {
+ *  "claudio":[
+ *    {"id":1,"name":"claudio","age":37,"city":"fortaleza"}
+ *  ],
+ *  "isa":[
+ *    {"id":2,"name":"isa","age":9,"city":"natal"}
+ *  ],
+ *  "jose":[
+ *    {"id":3,"name":"jose","age":37,"city":"fortaleza"},
+ *    {"id":6,"name":"jose","age":24,"city":"assu"}
+ *  ],
+ *  "marta":[
+ *    {"id":4,"name":"marta","age":42,"city":"afonso bezerra"}
+ *  ],
+ *  "joelma":[
+ *    {"id":5,"name":"joelma","age":42,"city":"afonso bezerra"}
+ *  ]
+ * }
+ *
+ *
+ * @param {Array} items Lista de objetos
+ * @param {String} key Nome da chave que agrupará os demais dados
+ */
 export declare const groupBy: (items: object[], key: any) => any;
+/**
+ * Gerador de chaves aleatórias
+ * Pelo menos 1 dos parâmetros numbers, lower e upper precisa ser true.
+ * Para que haja a máxima proteção contra conflitos, os três podem ser true
+ * https://gist.github.com/6174/6062387#gistcomment-2742945
+ *
+ * @example
+ *
+ *    keyGenerator(5)                         // -> 11S9P
+ *    keyGenerator(5, false)                  // -> HrmTF
+ *    keyGenerator(5, false, false)           // -> RHCWJ
+ *    keyGenerator(5, false, true, false)     // -> vzuyn
+ *
+ * @param {Integer} length Tamanho gerado
+ * @param {Boolean} numbers Define se existirão números
+ * @param {Boolean} lower Define se existirão letras minúsculas
+ * @param {Boolean} upper Define se existirão letras maiúsculas
+ * @returns {String}
+ */
 export declare const keyGenerator: (length?: number, numbers?: boolean, lower?: boolean, upper?: boolean) => string;
+/**
+ * Gerador de slug
+ * Create SLUG from a string
+ * This function rewrite the string prototype and also
+ * replace latin and other special characters.
+ *
+ *  @link
+ *  Forked by Gabriel Fróes - https://gist.github.com/gabrielfroes
+ *  Original Author: Mathew Byrne - https://gist.github.com/mathewbyrne/1280286
+ *
+ *  @example
+ *
+ *  slug('José Cláudio + ')             // -> 'jose-claudio
+ *  slug('José --    /\|<>Cláu=dio ')   // -> 'jose-claudio
+ *
+ *  @param {String} value
+ *  @returns {String} Valor convertido para slug
+ */
 export declare const slug: (value: string) => string;
+/**
+ * Converte um número passado para o formato do Real Brasileiro
+ *
+ * https://stackoverflow.com/a/64909632/3240078
+ * NumberFormat use small non-breaking space (\u202f) for thousand separator
+ * and normal non-breaking space beforece currency (\xa0)
+ *
+ * @example
+ *  currencyBR(12.34)    // -> 'R$ 12,34'
+ *  currencyBR('12.34')  // -> 'R$ 12,34'
+ *  currencyBR('12,34')  // -> null
+ *
+ * @param {Number|String} value
+ * @returns {String}
+ */
 export declare const currencyBR: (value: number | string) => string;
+/**
+ * Converte um nome para as primeiras em maiúsculas, exceto as partes
+ * que normalmente continuam em minúsculas, tipo "de", "dos" etc.
+ *
+ * @example
+ * upperFirst('jose claudio medeiros de lima') // -> Jose Claudio Medeiros de Lima
+ * upperFirst('JOSE CLAUDIO MEDEIROS DE LIMA') // -> Jose Claudio Medeiros de Lima
+ * upperFirst('JoSe cLaUdIo MeDeIrOs De LiMa') // -> Jose Claudio Medeiros de Lima
+ *
+ * @param {String} value
+ * @returns {String}
+ *
+ */
 export declare const upperFirst: (value: string) => string;
+/**
+ * Reescreve um objeto aplicando um prefixo definido às suas chaves
+ *
+ * @example
+ * const original = {
+ *    name: 'ze',
+ *    age: 23
+ * }
+ *
+ * prefixObjectKeys( original, 'people.*.' )
+ * // ->
+ * {
+ *    'people.*.name': 'ze',
+ *    'people.*.age': 23,
+ * }
+ *
+ *
+ * @param {Object} obj Objecto original
+ * @param {String} prefix Prefixo que será aplicado
+ */
 export declare function prefixObjectKeys(obj: any, prefix?: string): any;
+/**
+ * objectFlat()
+ * Recebe um objeto e o transforma em uma versão plana, com suas chaves
+ * multinível unidas por um ponto.
+ *
+ * @link https://stackoverflow.com/a/34514143/3240078
+ *
+ * @example
+ *
+ *   const obj = {
+ *     name: 'claudio'
+ *     address: { street': 'Monkey St.' }
+ *   }
+ *
+ *   objectFlat( obj )
+ *     // -> { name: 'claudio', 'address.street': 'Monkey St.' }
+ *
+ *   objectFlat( obj, '_' )
+ *     // -> { name: 'claudio', address_street: 'Monkey St.' }
+ *
+ *   objectFlat( {name:'ze', info:{age:null}}, '_' )
+ *     // -> { name: 'claudio', address_street: 'Monkey St.' }
+ *
+ *   objectFlat( {name:'ze', info:{age:null}}, '_' )
+ *     // -> { name: 'ze', info_age: null }
+ *
+ *   objectFlat( {name:'ze', info:{age:null}}, '_' )
+ *     // -> { name: 'ze', info_age: null }
+ *
+ *    objectFlat({ birth: new Date('1982-07-31'), address: {  number: null, } }, '_')
+ *      // -> { birth: new Date('1982-07-31'), address_number: null }
+ *
+ * @param {Object} obj
+ * @param {String} separator Default "."
+ * @returns {Object}
+ */
 export declare function objectFlat(obj: Record<string, any>, separator?: string): Record<string, any>;
+/**
+ * Mantém somente as chaves do objeto que estão na lista branca
+ *
+ * @example
+ *
+ *
+ * const address = {
+ *   id: 1,
+ *   description: 'decrição',
+ *   city_id: 123,
+ *   city: {
+ *     id: 123,
+ *     name: 'açu'
+ *   }
+ * }
+ *
+ * whiteList(address, ['id', 'description', 'city_id'])
+ * // -> { id: 1, description: 'decrição', city_id: 123 }
+ *
+ * whiteList([address, address], ['id', 'description'])
+ * // -> [
+ *   { id: 1, description: 'decrição' },
+ *   { id: 1, description: 'decrição' }
+ * ]
+ *
+ * @param {Object|Array} obj Objeto inicial. Se for array, aplica um loop aos elementos
+ * @param {Array} keys Lista de chaves permitidas
+ */
 export declare const whiteList: (obj: any | any[], keys: any[]) => any;
+/**
+ * Substitui os caracteres acentuados por semelhantes não acentuados respeitando
+ * maiúsculas e minúsculas
+ *
+ * @example
+ * removeAccent('Açu') // -> Acu
+ *
+ * @param value
+ * @returns
+ */
 export declare const removeAccent: (value: string) => string;
+/**
+ * randomNumber()
+ * Cria um número aleatório com o número de caracteres
+ *
+ * @example
+ * randomNumber(8, true) // -> 00083159
+ * randomNumber(4) // -> 831
+ *
+ * @param {Integer} length
+ * @param {Boolean} forceLength Adiciona zeros à esquerda para ter os números de caractes exatos
+ * @returns {String}
+ */
 export declare function randomNumber(length: number, forceLength?: boolean): number | string;
+/**
+ * Limpa um número informado, retirando caracteres diferentes de números,
+ * preenchendo com zeros à esquerda se for menor que o tamanho exato e
+ * removendo uma parte do número se for maior que tamanho definido.
+ *
+ * 1) Retira caracteres não-numéricos
+ * 2) Preenche com zeros à esquerda se 'value' for menor que 'length'
+ * 3) Remove caracteres à direita se 'value' for maior que 'length'
+ *
+ * @example
+ *  clearNumber(12345-6, 6) // -> 123456
+ *  clearNumber(12345678, 3) // -> 123
+ *  clearNumber(12345, 10) // -> 0000001234
+ *
+ * @param {Number|String} value
+ * @param {Number} length Tamanho exato. Se for null, só retira os caracteres não-numéricos
+ * @returns {String} Número com o tamanho exato
+ */
 export declare function clearNumber(value: string | number, length?: number | null): string;
+/**
+ * Limpa os valores falsy do objeto informado
+ *
+ * @example
+ * clearFalsy({ id:1, age:'0', idade: 'NaN', birth: '' }); // -> { id: 1 }
+ *
+ * @param {Object} value
+ * @returns {Object} Objeto sem os valores
+ */
 export declare function clearFalsy(value: Record<string, any>): Record<string, any>;
+/**
+ * insertAtPosition()
+ * Insere um conjunto de caracteres em um local específico de uma string
+ *
+ * @example
+ * insertAtPosition('AAABBB', 'C', 3) // -> AAACBBB
+ * insertAtPosition('000011122223445555', 99, 7) // -> 00001119922223445555
+ *
+ * @param {String} value Valor original
+ * @param {String|Number} insertValue Valor que será inserido
+ * @param {Number} position Posição que receberá o novo valor
+ * @returns {String}
+ *
+ */
 export declare function insertAtPosition(value: string, insertValue: string | number, position: number): string;
+/**
+ * removeFromPosition()
+ * Retira um conjunto de caracteres de um local específico de uma string
+ *
+ * @example
+ * removeFromPosition('00001119922223445555', 7,9) // -> 000011122223445555
+ * removeFromPosition('AAACBBB', 3,4) // -> AAABBB
+ *
+ * @param {String|Number} value Valor original
+ * @param {String|Number} startPosition
+ * @param {String|Number} endPosition
+ * @returns {String}
+ *
+ */
 export declare function removeFromPosition(value: string, startPosition: number, endPosition: number): string;
+/**
+ * applyVars()
+ * Aplica variáveis a um texto
+ *
+ * @example
+ * const values = { id: 1, name: 'claudio', age: 39, email: 'email@mail.com' }
+ *
+ * applyVars('Olá, :name. Seu e-mail ainda é :email?', values)
+ * applyVars('Olá, {name}. Seu e-mail ainda é {email}?', values,     { start: '{',  end: '}' })
+ * applyVars('Olá, {{name}}. Seu e-mail ainda é {{email}}?', values, { start: '{{', end: '}}'})
+ *
+ * @param {String} text
+ * @param {Object} vars
+ * @param {ApplyVarsOptions} options
+ */
 export declare function applyVars(value: string, vars: Record<string, any>, options?: Partial<ApplyVarsOptions>): string;
+/**
+ * Remove specialChars
+ */
 export declare function removeSpecialChars(value: string): string;
+/**
+ * applyMask()
+ * Aplica uma máscara a uma string
+ *
+ * @example
+ * applyMask('59650000', '00.000-000') // -> 59.650-000
+ * applyMask('99877665544', '(00) 0 0000-0000') // -> (99) 8 7766-5544
+ *
+ * @param {String|Number} value Valor original
+ * @param {String} mask
+ * @returns {String}
+ *
+ */
 export declare function applyMask(value: string | number, mask: string): string;
+/**
+ * randomLetter()
+ * Pega uma letra maiúscula aleatoriamente
+ *
+ * @example
+ * randomLetter() // -> A
+ * randomLetter() // -> S
+ *
+ * @returns {String}
+ */
 export declare function randomLetter(): string;
+/**
+ * Exibe uma quantidade como string numérica
+ *
+ * @example
+ * quantity(0, 'mensagens', 'mensagem', 'nenhuma mensagem') // nenhuma mensagem
+ * quantity(0, 'mensagens', 'mensagem', null)               // 0 mensagem
+ * quantity(1, 'mensagens', 'mensagem', 'nenhuma mensagem') // 1 mensagem
+ * quantity(2, 'mensagens', 'mensagem', 'nenhuma mensagem') // 2 mensagens
+ *
+ * @param {Number|'String} A quantidade
+ * @param {String} Sufixo que será usado quando a quantidade for mais de um
+ * @param {String} Sufixo que será usado quando a quantidade for 1
+ * @param {String|Null} Texto usado quando a quantidade for zero. Se estiver em branco,
+ *                 será usado o sufixo individual
+ *
+ * @return {String} Texto contendo as variações
+ */
 export declare const quantity: (qty: number | string, suffixMany: string, suffixOne: string, textEmpty: string | null) => string;
+/**
+ * Converte bytes em um de seus múltiplos.
+ *
+ * @example
+ * filesize(null) // -> 0 Kb
+ * filesize('') // -> 0 Kb
+ * filesize(12354353) // -> 11 mb
+ *
+ * @param {Number} bytes
+ * @return {String} Valor convertido para kb, mb etc
+ */
 export declare const filesize: (bytes: number | string) => string;
+/**
+ * Ordena um array de objetos a partir de uma chave
+ *
+ * sortByKey( [{name: 'marta'}, {name: 'claudio'}, {name: 'isa'}], 'name' )
+ *  // -> [ {name: 'claudio',}, {name: 'isa',}, {name: 'marta',} ]
+ *
+ * @param {Object[]} list
+ */
 export declare const sortByKey: (list: Array<Record<string, any>>, key: any) => Record<string, any>[];
+/**
+ *
+ * Converte um valor boolean, analisando seu conteúdo, mesmo que seja uma string.
+ * Se for um valor possivelmente falsy, converte para falsy
+ *
+ * @example
+ * toBoolean("a"); // -> true
+ * toBoolean(1); // -> true
+ * toBoolean("true"); // -> true
+ * toBoolean("0"); // -> false
+ * toBoolean(0); // -> false
+ * toBoolean("false"); // -> false
+ * toBoolean(false); // -> false
+ * toBoolean(""); // -> false
+ * toBoolean("undefined"); // -> false
+ * toBoolean(undefined); // -> false
+ * toBoolean("NaN"); // -> false
+ * toBoolean(NaN); // -> false
+ * toBoolean("null"); // -> false
+ * toBoolean(null); // -> false
+ *
+ * @param {*} value
+ * @returns {Boolean}
+ */
 export declare function toBoolean(value: any): boolean;
+/**
+ *
+ * Gera um UUID V4 ordenável, usando a data atual como base
+ *
+ */
 export declare function timeUUID(): string;
 export {};
 //# sourceMappingURL=main.d.ts.map