475 lines
14 KiB
TypeScript
475 lines
14 KiB
TypeScript
import z, { z as z$1 } from 'zod';
|
|
export { Dayjs, ManipulateType, default as dayjsbr } from 'dayjs';
|
|
export { default as duration } from 'dayjs/plugin/duration';
|
|
export { default as isSameOrAfter } from 'dayjs/plugin/isSameOrAfter';
|
|
export { default as isSameOrBefore } from 'dayjs/plugin/isSameOrBefore';
|
|
export { default as minMax } from 'dayjs/plugin/minMax';
|
|
export { default as relativeTime } from 'dayjs/plugin/relativeTime';
|
|
export { default as timezone } from 'dayjs/plugin/timezone';
|
|
export { default as utc } from 'dayjs/plugin/utc';
|
|
export { default as weekOfYear } from 'dayjs/plugin/weekOfYear';
|
|
import { v4 } from 'uuid';
|
|
|
|
declare const aleatorio: (tamanho?: number) => string;
|
|
|
|
/** gerar uma função de cache para uso em memoria */
|
|
declare const cacheM: <T>(chave: any, valor?: T, validadeSeg?: number) => T | undefined;
|
|
declare const verCacheM: () => {
|
|
[k: string]: {
|
|
/** new Date().getTime() */
|
|
validade?: number | undefined;
|
|
valor: any;
|
|
} | undefined;
|
|
};
|
|
declare const cacheMemoria: <T>(chave: any, valor?: T, validadeSeg?: number) => T | undefined;
|
|
/** para uso fixo dentro de uma função, trava a chave */
|
|
declare const cacheMFixo: (chave: any) => <T>(valor?: T) => T | undefined;
|
|
|
|
declare const uuid_null = "00000000-0000-0000-0000-000000000000";
|
|
/** Colunas Presentes n maioria das tabelas */
|
|
declare enum camposComuns {
|
|
codigo = "codigo",
|
|
excluido = "excluido",
|
|
data_hora_criacao = "data_hora_criacao",
|
|
data_hora_atualizacao = "data_hora_atualizacao",
|
|
codigo_usuario_criacao = "codigo_usuario_criacao",
|
|
codigo_usuario_atualizacao = "codigo_usuario_atualizacao",
|
|
versao = "versao"
|
|
}
|
|
/** Palavras comumente usadas */
|
|
declare enum tx {
|
|
token = "token"
|
|
}
|
|
declare enum tipoUsuarioResiduos {
|
|
Usuario = "usuario",
|
|
Fornecedor = "fornecedor"
|
|
}
|
|
|
|
declare enum operadores {
|
|
"=" = "=",
|
|
"!=" = "!=",
|
|
">" = ">",
|
|
">=" = ">=",
|
|
"<" = "<",
|
|
"<=" = "<=",
|
|
like = "like",
|
|
in = "in",
|
|
isNull = "isNull"
|
|
}
|
|
type tipoFiltro = {
|
|
coluna: string;
|
|
valor: any;
|
|
operador: keyof typeof operadores | operadores;
|
|
ou?: boolean;
|
|
};
|
|
type interfaceConsulta = {
|
|
offset?: number;
|
|
limit?: number;
|
|
filtros?: tipoFiltro[];
|
|
ordem?: string;
|
|
ordemTipo?: "asc" | "desc";
|
|
colunas?: string[];
|
|
apenasConsulta?: boolean;
|
|
apenasContagem?: boolean;
|
|
};
|
|
declare const zOperadores: z.ZodEnum<{
|
|
"=": "=";
|
|
"!=": "!=";
|
|
">": ">";
|
|
">=": ">=";
|
|
"<": "<";
|
|
"<=": "<=";
|
|
like: "like";
|
|
in: "in";
|
|
isNull: "isNull";
|
|
}>;
|
|
declare const zFiltro: z.ZodObject<{
|
|
coluna: z.ZodString;
|
|
valor: z.ZodAny;
|
|
operador: z.ZodEnum<{
|
|
"=": "=";
|
|
"!=": "!=";
|
|
">": ">";
|
|
">=": ">=";
|
|
"<": "<";
|
|
"<=": "<=";
|
|
like: "like";
|
|
in: "in";
|
|
isNull: "isNull";
|
|
}>;
|
|
ou: z.ZodOptional<z.ZodBoolean>;
|
|
}, z.core.$strip>;
|
|
|
|
declare const link_paiol = "https://paiol.idz.one";
|
|
|
|
type tiposArquivo = "imagem" | "documento" | "vídeo" | "outros";
|
|
declare const extensoes: {
|
|
ext: string;
|
|
tipo: tiposArquivo;
|
|
mime: string;
|
|
}[];
|
|
/**
|
|
* Função que retorna o tipo do arquivo
|
|
* @param nomeArquivo
|
|
* @returns
|
|
*/
|
|
declare const tipoArquivo: (nomeArquivo: string | null | undefined) => tiposArquivo;
|
|
|
|
/**
|
|
* LocalStorage Tipado
|
|
* Lê ou grava um valor no localStorage, mantendo o tipo genérico <T>.
|
|
*/
|
|
declare const localValor: <T>(chave_: string | any, valor?: T | null) => T | null;
|
|
|
|
/**
|
|
* Trata um objeto para ser imput para postgres
|
|
* @param entrada
|
|
* @returns
|
|
*/
|
|
declare const paraObjetoRegistroPg: (entrada: {
|
|
[k: string]: any;
|
|
}) => {
|
|
[k: string]: string | boolean | null | undefined | number;
|
|
};
|
|
declare const pgObjeto: (entrada: {
|
|
[k: string]: any;
|
|
}) => {
|
|
[k: string]: string | boolean | null | undefined | number;
|
|
};
|
|
declare const objetoPg: (entrada: {
|
|
[k: string]: any;
|
|
}) => {
|
|
[k: string]: string | boolean | null | undefined | number;
|
|
};
|
|
|
|
declare enum Produtos {
|
|
"e-licencie" = "e-licencie",
|
|
"gov.e-licencie" = "gov.e-licencie"
|
|
}
|
|
|
|
declare enum tiposSituacoesElicencie {
|
|
modelo = "000_modelo",
|
|
vencida = "100_vencida",
|
|
expirado = "200_expirado",
|
|
alerta = "300_alerta",
|
|
protocoladafora = "350_protocoladafora",
|
|
protocolada = "400_protocolada",
|
|
protocoladaApenas = "430_protocolada",
|
|
protocolada_alteracao = "450_protocolada",
|
|
prazo = "500_prazo",
|
|
emitida = "515_emitida",
|
|
valida = "518_valida",
|
|
novo = "520_novo",
|
|
recebido = "521_recebido",
|
|
em_andamento = "530_em_andamento",
|
|
aguardando = "530_aguardando",
|
|
aguardandoresposta = "540_aguardandoresposta",
|
|
suspensaotemporaria = "540_suspensaotemporaria",
|
|
cancelada = "550_cancelada",
|
|
execucao = "560_execucao",
|
|
pendente = "570_pendente",
|
|
executadafora = "600_executadafora",
|
|
executada = "700_executada",
|
|
naoexecutada = "701_naoexecutada",
|
|
concluida = "730_concluida",
|
|
respondido_negado = "740_respondido_negado",
|
|
respondido_aceito = "741_respondido_aceito",
|
|
atendidoparcial = "742_atendidoparcial",
|
|
naoatendido = "743_naoatendido",
|
|
atendido = "744_atendido",
|
|
renovada = "760_renovada",
|
|
finalizada = "800_finalizada",
|
|
emitirnota = "101_emitirnota",
|
|
faturaatrasada = "301_faturaatrasada",
|
|
pagarfatura = "302_pagarfatura",
|
|
aguardandoconfirmacao = "531_aguardandoconfirmacao",
|
|
agendado = "701_agendado",
|
|
faturapaga = "801_faturapaga",
|
|
excluida = "999_excluida",
|
|
requerida = "401_requerida",
|
|
vigente = "516_vigente",
|
|
emrenovacao = "402_emrenovacao",
|
|
arquivada = "801_arquivada",
|
|
aguardando_sincronizacao = "999_aguardando_sincronizacao",
|
|
nao_conforme = "710_nao_conforme",
|
|
conforme = "720_conforme",
|
|
nao_aplicavel = "730_nao_aplicavel",
|
|
parcial = "715_parcial"
|
|
}
|
|
|
|
declare const umaFuncao: () => string;
|
|
|
|
declare const umaVariavel = "Ol\u00E1 Mundo! (vari\u00E1vel)";
|
|
|
|
/** gerar o texto de busca removendo caracteres especies e caixa alta */
|
|
declare const texto_busca: (...texto: any[]) => string;
|
|
|
|
/** Gerar uma classe que facilita a gestão de rotas com a tipagem das querys
|
|
*
|
|
* Definições:
|
|
*
|
|
* caminho = "/aplicacao/funcionalidade"
|
|
*
|
|
* endereco = "http://localhost:3000/aplicacao/funcionalidade"
|
|
*
|
|
* parametros = {nome:"José"}
|
|
*/
|
|
declare class TipagemRotas<T extends {
|
|
[q: string]: any;
|
|
}> {
|
|
_partesCaminho: string[];
|
|
_acaoIr?: (endereco: string) => undefined;
|
|
rotulo: string | undefined;
|
|
/** Ao criar novo obijeto de tipagem de rota é necessário passar o caminho parcial
|
|
** export const mCaminho = new TipagemRotas<{q:string}>("aplicacao","funcionalidade")
|
|
*/
|
|
constructor({ caminho, acaoIr, rotulo, }: {
|
|
caminho: (string | null | undefined)[] | string;
|
|
acaoIr?: undefined | ((endereco: string) => undefined);
|
|
/** Rotulo da página
|
|
* Inicio | Controle
|
|
*/
|
|
rotulo?: string;
|
|
});
|
|
/** Retorna o caminho completo da rota
|
|
** console.log(mCaminho.caminho)
|
|
** "/caminho"
|
|
*/
|
|
get caminho(): string;
|
|
/** Define o caminho completo da rota
|
|
** mCaminho.caminho = "/novoCaminho"
|
|
** console.log(mCaminho.caminho)
|
|
** "/novoCaminho"
|
|
** */
|
|
set caminho(caminhoParcial: string);
|
|
/** Retorna o caminho completo da rota com a query
|
|
** console.log(mCaminho.resolve({q:"query"}))
|
|
** "http://localhost:3000/caminho?q=query"
|
|
*/
|
|
endereco(query: T, usarComoHash?: boolean): string;
|
|
/** Vai para a url
|
|
** mCaminho.ir({q:"query"})
|
|
** window.location.href = "http://localhost:3000/caminho?q=query"
|
|
*/
|
|
ir(query: T): void;
|
|
/** Retorna os parametros da url
|
|
** console.log(mCaminho.parametros())
|
|
** {q:"query"}
|
|
*/
|
|
parametros(urlEntrada?: string): Partial<T>;
|
|
}
|
|
|
|
/**
|
|
* =============================================================================
|
|
* tipoFiltro26<T>
|
|
* =============================================================================
|
|
*
|
|
* OBJETIVO
|
|
* -----------------------------------------------------------------------------
|
|
* Gerar automaticamente a tipagem de filtros compatíveis com operadores
|
|
* padrão do PostgreSQL, a partir de um tipo base T.
|
|
*
|
|
* Este tipo foi projetado para:
|
|
* - Construção de filtros dinâmicos
|
|
* - Geração posterior de WHERE (Knex / SQL)
|
|
* - Uso seguro por IA (evita filtros inválidos em nível de tipo)
|
|
*
|
|
*
|
|
* FORMATO DO FILTRO
|
|
* -----------------------------------------------------------------------------
|
|
* 1) Campos simples:
|
|
*
|
|
* {
|
|
* idade: { ">=": 18 }
|
|
* }
|
|
*
|
|
* 2) Campos aninhados:
|
|
*
|
|
* {
|
|
* carro: {
|
|
* ano: { "=": 2020 }
|
|
* }
|
|
* }
|
|
*
|
|
* 3) Operador E (AND):
|
|
*
|
|
* {
|
|
* E: [
|
|
* { idade: { ">=": 18 } },
|
|
* { nome: { like: "%pa%" } }
|
|
* ]
|
|
* }
|
|
*
|
|
* 4) Operador OU (OR):
|
|
*
|
|
* {
|
|
* OU: [
|
|
* { idade: { "<": 18 } },
|
|
* { idade: { ">=": 60 } }
|
|
* ]
|
|
* }
|
|
*
|
|
* 5) Combinação complexa:
|
|
*
|
|
* {
|
|
* idade: { ">=": 18 },
|
|
* OU: [
|
|
* { nome: { like: "%pa%" } },
|
|
* {
|
|
* E: [
|
|
* { carro: { ano: { "=": 2020 } } },
|
|
* { carro: { modelo: { in: ["Civic"] } } }
|
|
* ]
|
|
* }
|
|
* ]
|
|
* }
|
|
*
|
|
*
|
|
* REGRAS IMPORTANTES (PARA IA)
|
|
* -----------------------------------------------------------------------------
|
|
* - Apenas campos existentes em T podem ser usados.
|
|
* - Operadores são restritos por tipo do campo.
|
|
* - Objetos são tratados recursivamente.
|
|
* - Arrays NÃO são tratados como objeto recursivo.
|
|
* - Funções NÃO são consideradas campos filtráveis.
|
|
*
|
|
*
|
|
* OPERADORES SUPORTADOS
|
|
* -----------------------------------------------------------------------------
|
|
* number:
|
|
* =, !=, >, >=, <, <=, in
|
|
*
|
|
* string:
|
|
* =, !=, like, in
|
|
*
|
|
* boolean:
|
|
* =, !=, in
|
|
*
|
|
* Não há suporte automático a:
|
|
* - null
|
|
* - date
|
|
* - jsonb
|
|
* - arrays
|
|
*
|
|
* Essas extensões devem ser adicionadas explicitamente.
|
|
*
|
|
* =============================================================================
|
|
*/
|
|
declare enum operadores26 {
|
|
"=" = "=",
|
|
"!=" = "!=",
|
|
">" = ">",
|
|
">=" = ">=",
|
|
"<" = "<",
|
|
"<=" = "<=",
|
|
like = "like",
|
|
in = "in"
|
|
}
|
|
declare enum agrupadores26 {
|
|
E = "E",
|
|
OU = "OU"
|
|
}
|
|
type PgOpsNumber = {
|
|
[K in Extract<operadores26, "=" | "!=" | ">" | ">=" | "<" | "<=">]?: number;
|
|
} & {
|
|
[K in Extract<operadores26, "in">]?: number[];
|
|
};
|
|
type PgOpsString = {
|
|
[K in Extract<operadores26, "=" | "!=" | "like">]?: string;
|
|
} & {
|
|
[K in Extract<operadores26, "in">]?: string[];
|
|
};
|
|
type PgOpsBoolean = {
|
|
[K in Extract<operadores26, "=" | "!=">]?: boolean;
|
|
} & {
|
|
[K in Extract<operadores26, "in">]?: boolean[];
|
|
};
|
|
type PgOpsFor<V> = V extends number ? PgOpsNumber : V extends string ? PgOpsString : V extends boolean ? PgOpsBoolean : never;
|
|
type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends readonly any[] ? false : true : false;
|
|
type FiltroCampos<T> = {
|
|
[K in keyof T]?: IsPlainObject<T[K]> extends true ? tipoFiltro26<T[K]> : PgOpsFor<T[K]>;
|
|
};
|
|
type tipoFiltro26<T> = FiltroCampos<T> & {
|
|
/**
|
|
* E => AND lógico
|
|
* Todos os filtros dentro do array devem ser verdadeiros.
|
|
*/
|
|
E?: tipoFiltro26<T>[];
|
|
/**
|
|
* OU => OR lógico
|
|
* Pelo menos um filtro dentro do array deve ser verdadeiro.
|
|
*/
|
|
OU?: tipoFiltro26<T>[];
|
|
};
|
|
declare const zFiltro26: z$1.ZodType<any>;
|
|
declare const criarFiltro26: <T>(filtro: tipoFiltro26<T>) => tipoFiltro26<T>;
|
|
|
|
/**
|
|
* Essa variável se conecta a tabela_lidades
|
|
*
|
|
* onde sigla se conecta com sigla
|
|
*
|
|
* Usuário terá mais opções de unidades, quando fazer o envio para o mtr, usar a opção fornecida pelo usuarios, caso não tenha
|
|
* usar a normalizada
|
|
*/
|
|
declare enum siglas_unidades_medida {
|
|
UN = "UN",
|
|
KG = "KG",
|
|
TON = "TON",
|
|
g = "g",
|
|
"M³" = "M\u00B3",
|
|
Lt = "Lt"
|
|
}
|
|
declare const unidades_medida: {
|
|
sigla_unidade: keyof typeof siglas_unidades_medida;
|
|
nome: string;
|
|
sigla_normalizada: keyof typeof siglas_unidades_medida;
|
|
normalizar: (valor: number) => number;
|
|
tipo: "massa" | "volume" | "comprimento" | "unidade";
|
|
}[];
|
|
|
|
/**
|
|
* Valida se uma string é um UUID válido (qualquer versão).
|
|
*
|
|
* @param valor - A string que será validada.
|
|
* @returns booleano indicando se é um UUID válido.
|
|
*/
|
|
declare const erUuid: RegExp;
|
|
declare const validarUuid: (uuid: string | number | undefined | null) => boolean;
|
|
/**
|
|
* Gera um UUID determinístico (versão 3) com base em uma chave e um grupo (namespace).
|
|
*
|
|
* - Usa o algoritmo MD5 (RFC 4122).
|
|
* - Sempre retorna o mesmo UUID para a mesma combinação chave + grupo.
|
|
* - Caso o grupo não seja informado, usa o UUID "nil" como namespace.
|
|
*
|
|
* @param chave - Qualquer valor que será convertido em string para gerar o UUID (ex: número, string ou objeto).
|
|
* @param grupo - Opcional. Namespace para separar domínios diferentes de UUIDs.
|
|
* @returns UUID v3 (determinístico)
|
|
*/
|
|
declare const uuidV3: (chave: any, grupo?: any) => string;
|
|
/**
|
|
* Gera um UUID v4 (aleatório, não determinístico).
|
|
*
|
|
* - Usado quando unicidade é necessária, mas não se exige que seja previsível.
|
|
*/
|
|
declare const uuidV4: typeof v4;
|
|
/**
|
|
* @deprecated Esta variável será descontinuada em versões futuras.
|
|
* Use a função `uuidV4()` diretamente.
|
|
*/
|
|
declare const uuid: typeof v4;
|
|
|
|
declare const esperar: (ms: number) => Promise<true>;
|
|
/**
|
|
* Usado para retronat o no de uma variável, deve ser usado dentro de um objeto
|
|
* const nomex = {a: 1, b: 2}
|
|
* nomeVariavel({nomex}) // retorna "nomex"
|
|
* @param v
|
|
* @returns
|
|
*/
|
|
declare const nomeVariavel: (v: {
|
|
[key: string]: any;
|
|
}) => string;
|
|
|
|
export { Produtos, TipagemRotas, agrupadores26, aleatorio, cacheM, cacheMFixo, cacheMemoria, camposComuns, criarFiltro26, erUuid, esperar, extensoes, type interfaceConsulta, link_paiol, localValor, nomeVariavel, objetoPg, operadores, operadores26, paraObjetoRegistroPg, pgObjeto, siglas_unidades_medida, texto_busca, tipoArquivo, type tipoFiltro, type tipoFiltro26, tipoUsuarioResiduos, tiposSituacoesElicencie, tx, umaFuncao, umaVariavel, unidades_medida, uuid, uuidV3, uuidV4, uuid_null, validarUuid, verCacheM, zFiltro, zFiltro26, zOperadores };
|