types-nora-api 0.0.475 → 0.0.478

package/dist/api/graphql/core/index.js

@@ -0,0 +1,420 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Infra pública GraphQL
+import { ApiMetodoHttp, ApiTipoRequisicao, ApiTransporte } from '../../rest';
+function createApiGraphqlGet(definicao) { return definicao; }
+var GraphqlCardinalidade;
+(function (GraphqlCardinalidade) {
+    GraphqlCardinalidade["UNICO"] = "UNICO";
+    GraphqlCardinalidade["LISTA"] = "LISTA";
+    GraphqlCardinalidade["TOTAL_DE_REGISTROS"] = "TOTAL_DE_REGISTROS";
+})(GraphqlCardinalidade || (GraphqlCardinalidade = {}));
+var GraphqlTipoVariavel;
+(function (GraphqlTipoVariavel) {
+    GraphqlTipoVariavel["INT_OBRIGATORIO"] = "Int!";
+    GraphqlTipoVariavel["STRING_OBRIGATORIO"] = "String!";
+    GraphqlTipoVariavel["BOOLEAN_OBRIGATORIO"] = "Boolean!";
+    GraphqlTipoVariavel["ID_OBRIGATORIO"] = "ID!";
+})(GraphqlTipoVariavel || (GraphqlTipoVariavel = {}));
+const GraphqlOrderDirecao = {
+    ASC: 'ASC',
+    DESC: 'DESC',
+};
+const GraphqlFiltroEscopo = {
+    VISUALIZACAO: 'VISUALIZACAO',
+    CONSULTA: 'CONSULTA',
+};
+const GraphqlFiltroCampoTipo = {
+    STRING: 'STRING',
+    NUMBER: 'NUMBER',
+    BOOLEAN: 'BOOLEAN',
+    DATE: 'DATE',
+};
+const GraphqlFiltroControleVisualizacao = {
+    TEXTO: 'TEXTO',
+    VALOR_UNICO: 'VALOR_UNICO',
+    MULTISELECT: 'MULTISELECT',
+    DATA_RANGE: 'DATA_RANGE',
+    BOOLEAN: 'BOOLEAN',
+};
+const GraphqlFiltroOperador = {
+    CONTEM: 'CONTEM',
+    IGUAL: 'IGUAL',
+    DIFERENTE: 'DIFERENTE',
+    MAIOR_QUE: 'MAIOR_QUE',
+    MAIOR_OU_IGUAL: 'MAIOR_OU_IGUAL',
+    MENOR_QUE: 'MENOR_QUE',
+    MENOR_OU_IGUAL: 'MENOR_OU_IGUAL',
+    ESTA_NULO: 'ESTA_NULO',
+};
+const GraphqlFiltroOperadoresPadrao = {
+    STRING: [GraphqlFiltroOperador.CONTEM, GraphqlFiltroOperador.IGUAL, GraphqlFiltroOperador.DIFERENTE, GraphqlFiltroOperador.ESTA_NULO],
+    NUMBER: [GraphqlFiltroOperador.IGUAL, GraphqlFiltroOperador.DIFERENTE, GraphqlFiltroOperador.MAIOR_QUE, GraphqlFiltroOperador.MAIOR_OU_IGUAL, GraphqlFiltroOperador.MENOR_QUE, GraphqlFiltroOperador.MENOR_OU_IGUAL, GraphqlFiltroOperador.ESTA_NULO],
+    BOOLEAN: [GraphqlFiltroOperador.IGUAL, GraphqlFiltroOperador.DIFERENTE, GraphqlFiltroOperador.ESTA_NULO],
+    DATE: [GraphqlFiltroOperador.IGUAL, GraphqlFiltroOperador.DIFERENTE, GraphqlFiltroOperador.MAIOR_QUE, GraphqlFiltroOperador.MAIOR_OU_IGUAL, GraphqlFiltroOperador.MENOR_QUE, GraphqlFiltroOperador.MENOR_OU_IGUAL, GraphqlFiltroOperador.ESTA_NULO],
+};
+const GraphqlFiltroOperadoresConsulta = {
+    STRING: [GraphqlFiltroOperador.IGUAL, GraphqlFiltroOperador.DIFERENTE, GraphqlFiltroOperador.ESTA_NULO],
+    NUMBER: GraphqlFiltroOperadoresPadrao.NUMBER,
+    BOOLEAN: [GraphqlFiltroOperador.IGUAL, GraphqlFiltroOperador.DIFERENTE, GraphqlFiltroOperador.ESTA_NULO],
+    DATE: GraphqlFiltroOperadoresPadrao.DATE,
+};
+function defineGraphqlSelect() {
+    const selecionar = function (...select) {
+        return select;
+    };
+    return selecionar;
+}
+function defineGraphqlCamposFiltroVisualizacao() {
+    return function (campos) {
+        return campos;
+    };
+}
+function defineGraphqlCamposFiltroConsulta() {
+    return function (campos) {
+        return campos;
+    };
+}
+function obtemGraphqlFiltroOperadoresVisualizacao(tipo) { return GraphqlFiltroOperadoresPadrao[tipo]; }
+function obtemGraphqlFiltroOperadoresConsulta(tipo) { return GraphqlFiltroOperadoresConsulta[tipo]; }
+function criaGraphqlCampoFiltro(campo, path, tipo, nullable, operadores, escopo, controleVisualizacao = null, label = null) {
+    return {
+        campo,
+        path,
+        label: label ?? campo,
+        tipo,
+        nullable,
+        operadores,
+        escopos: [escopo],
+        controleVisualizacao,
+    };
+}
+function criaGraphqlCampoFiltroVisualizacao(campo, path, tipo, nullable, controleVisualizacao = null, label = null) {
+    return criaGraphqlCampoFiltro(campo, path, tipo, nullable, obtemGraphqlFiltroOperadoresVisualizacao(tipo), GraphqlFiltroEscopo.VISUALIZACAO, controleVisualizacao, label);
+}
+function criaGraphqlCampoFiltroConsulta(campo, path, tipo, nullable, controleVisualizacao = null, label = null) {
+    return criaGraphqlCampoFiltro(campo, path, tipo, nullable, obtemGraphqlFiltroOperadoresConsulta(tipo), GraphqlFiltroEscopo.CONSULTA, controleVisualizacao, label);
+}
+function defineGraphqlOperacaoConsulta() {
+    return function (definicao) {
+        return definicao;
+    };
+}
+function defineGraphqlEntidade(definicao) { return definicao; }
+function montaConsultaVariaveis(parametros) { return { consulta: parametros }; }
+function montaObtemPorPKVariaveis(parametros) { return { id: parametros.id }; }
+function montaOpcoesFiltrosConsultaVariaveis(parametros) { return { consulta: parametros }; }
+function criaGraphqlDefLeituraPadrao() {
+    return function (definicao) {
+        const obtemPorPK = defineGraphqlOperacaoConsulta()({
+            nome: `${definicao.nome}.porPK`,
+            cardinalidade: GraphqlCardinalidade.UNICO,
+            nomeOperacaoGraphql: definicao.obtemPorPK.nomeOperacaoGraphql,
+            nomeCampoQuery: definicao.obtemPorPK.nomeCampoQuery,
+            nomeAliasResposta: definicao.obtemPorPK.nomeAliasResposta,
+            variaveis: [
+                { nome: 'id', tipo: GraphqlTipoVariavel.INT_OBRIGATORIO },
+            ],
+            montaVariaveis: parametros => montaObtemPorPKVariaveis(parametros),
+        });
+        const obtemUm = defineGraphqlOperacaoConsulta()({
+            nome: `${definicao.nome}.um`,
+            cardinalidade: GraphqlCardinalidade.UNICO,
+            nomeOperacaoGraphql: definicao.obtemUm.nomeOperacaoGraphql,
+            nomeCampoQuery: definicao.obtemUm.nomeCampoQuery,
+            nomeAliasResposta: definicao.obtemUm.nomeAliasResposta,
+            variaveis: [
+                { nome: 'consulta', tipo: 'GraphqlConsulta!' },
+            ],
+            montaVariaveis: parametros => montaConsultaVariaveis(parametros),
+        });
+        const obtemVarios = defineGraphqlOperacaoConsulta()({
+            nome: `${definicao.nome}.varios`,
+            cardinalidade: GraphqlCardinalidade.LISTA,
+            nomeOperacaoGraphql: definicao.obtemVarios.nomeOperacaoGraphql,
+            nomeCampoQuery: definicao.obtemVarios.nomeCampoQuery,
+            nomeAliasResposta: definicao.obtemVarios.nomeAliasResposta,
+            variaveis: [
+                { nome: 'consulta', tipo: 'GraphqlConsulta!' },
+            ],
+            montaVariaveis: parametros => montaConsultaVariaveis(parametros),
+        });
+        const totalDeRegistros = defineGraphqlOperacaoConsulta()({
+            nome: `${definicao.nome}.totalDeRegistros`,
+            cardinalidade: GraphqlCardinalidade.TOTAL_DE_REGISTROS,
+            nomeOperacaoGraphql: definicao.totalDeRegistros.nomeOperacaoGraphql,
+            nomeCampoQuery: definicao.totalDeRegistros.nomeCampoQuery,
+            nomeAliasResposta: definicao.totalDeRegistros.nomeAliasResposta,
+            variaveis: [
+                { nome: 'consulta', tipo: 'GraphqlConsulta!' },
+            ],
+            montaVariaveis: parametros => montaConsultaVariaveis(parametros),
+        });
+        return defineGraphqlEntidade({
+            nome: definicao.nome,
+            operacoes: {
+                obtemPorPK,
+                obtemUm,
+                obtemVarios,
+                totalDeRegistros,
+            },
+        });
+    };
+}
+function criaIndentacaoGraphql(nivel) { return '    '.repeat(nivel); }
+function mesclaCampoSelectGraphql(campoAtual, campoNovo) {
+    if (!campoAtual)
+        return campoNovo;
+    if (campoAtual === true || campoNovo === true)
+        return true;
+    return mesclaSelectGraphql(campoAtual, campoNovo);
+}
+function mesclaSelectGraphql(selectAtual, selectNovo) {
+    const resultado = { ...selectAtual };
+    for (const campo of Object.keys(selectNovo)) {
+        const valorNovo = selectNovo[campo];
+        if (!valorNovo)
+            continue;
+        resultado[campo] = mesclaCampoSelectGraphql(resultado[campo], valorNovo);
+    }
+    return resultado;
+}
+function normalizaSelectGraphql(select) {
+    if (Array.isArray(select)) {
+        const resultado = {};
+        for (const item of select) {
+            if (typeof item === 'string') {
+                resultado[item] = mesclaCampoSelectGraphql(resultado[item], true);
+                continue;
+            }
+            const itemObjeto = item;
+            for (const campo of Object.keys(itemObjeto)) {
+                const valor = itemObjeto[campo];
+                if (!valor)
+                    continue;
+                if (valor === true) {
+                    resultado[campo] = mesclaCampoSelectGraphql(resultado[campo], true);
+                    continue;
+                }
+                resultado[campo] = mesclaCampoSelectGraphql(resultado[campo], normalizaSelectGraphql(valor));
+            }
+        }
+        return resultado;
+    }
+    const selectObjeto = select;
+    const resultado = {};
+    for (const campo of Object.keys(selectObjeto)) {
+        const valor = selectObjeto[campo];
+        if (!valor)
+            continue;
+        if (valor === true) {
+            resultado[campo] = true;
+            continue;
+        }
+        resultado[campo] = normalizaSelectGraphql(valor);
+    }
+    return resultado;
+}
+function obtemValorSelectExpandido(campo, valor, expansoes) {
+    if (valor !== true)
+        return valor;
+    const expansao = expansoes?.[campo];
+    return expansao ?? true;
+}
+function obtemExpansoesAninhadas(campo, expansoes) {
+    const expansao = expansoes?.[campo];
+    if (!expansao || expansao === true)
+        return undefined;
+    return expansao;
+}
+function montaCamposGraphql(select, nivel = 3, expansoes) {
+    const linhas = [];
+    const indentacao = criaIndentacaoGraphql(nivel);
+    for (const campo of Object.keys(select)) {
+        const valor = select[campo];
+        if (!valor)
+            continue;
+        const expansoesAninhadas = obtemExpansoesAninhadas(campo, expansoes);
+        const valorExpandido = obtemValorSelectExpandido(campo, valor, expansoes);
+        if (valorExpandido === true) {
+            linhas.push(`${indentacao}${campo}`);
+            continue;
+        }
+        linhas.push(`${indentacao}${campo} {`);
+        linhas.push(montaCamposGraphql(valorExpandido, nivel + 1, valor === true ? undefined : expansoesAninhadas));
+        linhas.push(`${indentacao}}`);
+    }
+    return linhas.join('\n');
+}
+function garanteSelectComCampos(select) {
+    if (Object.keys(select).length === 0)
+        throw new Error('Select GraphQL precisa ter pelo menos um campo');
+}
+function montaDeclaracaoVariaveisGraphql(variaveis) {
+    return variaveis.map(variavel => `$${variavel.nome}: ${variavel.tipo}`).join(', ');
+}
+function montaArgumentosCampoQueryGraphql(variaveis) {
+    return variaveis.map(variavel => `${variavel.nome}: $${variavel.nome}`).join(', ');
+}
+function montaCampoQueryGraphql(operacao) {
+    const argumentos = montaArgumentosCampoQueryGraphql(operacao.variaveis);
+    if (!argumentos)
+        return `${operacao.nomeAliasResposta}: ${operacao.nomeCampoQuery}`;
+    return `${operacao.nomeAliasResposta}: ${operacao.nomeCampoQuery}(${argumentos})`;
+}
+function resolveNomeGraphqlOpcoesFiltrosConsulta(nomeGraphqlTotalDeRegistros) {
+    const prefixo = 'totalDeRegistros';
+    if (!nomeGraphqlTotalDeRegistros.startsWith(prefixo))
+        return `${nomeGraphqlTotalDeRegistros}OpcoesFiltrosConsulta`;
+    return `opcoesFiltrosConsulta${nomeGraphqlTotalDeRegistros.substring(prefixo.length)}`;
+}
+function montaQueryGraphqlConsulta(operacao, select, expansoesSelect) {
+    const declaracaoVariaveis = montaDeclaracaoVariaveisGraphql(operacao.variaveis);
+    const campoQuery = montaCampoQueryGraphql(operacao);
+    const selectRuntime = normalizaSelectGraphql(select);
+    const camposGraphql = montaCamposGraphql(selectRuntime, 3, expansoesSelect);
+    garanteSelectComCampos(selectRuntime);
+    return `
+        query ${operacao.nomeOperacaoGraphql}(${declaracaoVariaveis}) {
+            ${campoQuery} {
+${camposGraphql}
+            }
+        }
+    `;
+}
+function montaQueryGraphqlTotalDeRegistros(operacao) {
+    const declaracaoVariaveis = montaDeclaracaoVariaveisGraphql(operacao.variaveis);
+    const campoQuery = montaCampoQueryGraphql(operacao);
+    return `
+        query ${operacao.nomeOperacaoGraphql}(${declaracaoVariaveis}) {
+            ${campoQuery}
+        }
+    `;
+}
+function montaQueryGraphqlOpcoesFiltrosConsulta(nomeOperacaoGraphql, nomeCampoQuery) {
+    return `
+        query ${nomeOperacaoGraphql}($consulta: GraphqlConsulta!) {
+            ${nomeCampoQuery}(consulta: $consulta) {
+                campo
+                opcoes {
+                    valor
+                    label
+                    total
+                }
+            }
+        }
+    `;
+}
+function criaApiOperacaoGraphqlConsulta(params) {
+    const selectRuntime = normalizaSelectGraphql(params.select);
+    garanteSelectComCampos(selectRuntime);
+    return {
+        transporte: ApiTransporte.GRAPHQL,
+        tipoRequisicao: ApiTipoRequisicao.GET,
+        metodoHttp: ApiMetodoHttp.POST,
+        nome: params.operacao.nome,
+        endpoint: '/graphql',
+        nomeOperacaoGraphql: params.operacao.nomeOperacaoGraphql,
+        query: montaQueryGraphqlConsulta(params.operacao, selectRuntime, params.expansoesSelect),
+        montaVariaveis: () => params.operacao.montaVariaveis(params.parametros),
+    };
+}
+function criaApiOperacaoGraphqlTotalDeRegistros(params) {
+    return {
+        transporte: ApiTransporte.GRAPHQL,
+        tipoRequisicao: ApiTipoRequisicao.GET,
+        metodoHttp: ApiMetodoHttp.POST,
+        nome: params.operacao.nome,
+        endpoint: '/graphql',
+        nomeOperacaoGraphql: params.operacao.nomeOperacaoGraphql,
+        query: montaQueryGraphqlTotalDeRegistros(params.operacao),
+        montaVariaveis: () => params.operacao.montaVariaveis(params.parametros),
+    };
+}
+function criaApiOperacaoGraphqlOpcoesFiltrosConsulta(params) {
+    const nomeOperacaoGraphql = resolveNomeGraphqlOpcoesFiltrosConsulta(params.nomeOperacaoTotalDeRegistros);
+    const nomeCampoQuery = resolveNomeGraphqlOpcoesFiltrosConsulta(params.nomeCampoQueryTotalDeRegistros);
+    return {
+        transporte: ApiTransporte.GRAPHQL,
+        tipoRequisicao: ApiTipoRequisicao.GET,
+        metodoHttp: ApiMetodoHttp.POST,
+        nome: `${params.nomeEntidade}.opcoesFiltrosConsulta`,
+        endpoint: '/graphql',
+        nomeOperacaoGraphql,
+        query: montaQueryGraphqlOpcoesFiltrosConsulta(nomeOperacaoGraphql, nomeCampoQuery),
+        montaVariaveis: () => montaOpcoesFiltrosConsultaVariaveis(params.parametros),
+    };
+}
+function criaEventoApiGraphqlConsulta(params) {
+    return criaApiOperacaoGraphqlConsulta({
+        operacao: params.operacao,
+        parametros: params.definicao.parametros ?? {},
+        select: params.definicao.select,
+        expansoesSelect: params.expansoesSelect,
+    });
+}
+function criaEventoApiGraphqlTotalDeRegistros(params) {
+    return criaApiOperacaoGraphqlTotalDeRegistros({
+        operacao: params.operacao,
+        parametros: params.definicao.parametros ?? {},
+    });
+}
+function criaEventoApiGraphqlOpcoesFiltrosConsulta(params) {
+    return criaApiOperacaoGraphqlOpcoesFiltrosConsulta({
+        nomeEntidade: params.nomeEntidade,
+        nomeOperacaoTotalDeRegistros: params.def.operacoes.totalDeRegistros.nomeOperacaoGraphql,
+        nomeCampoQueryTotalDeRegistros: params.def.operacoes.totalDeRegistros.nomeCampoQuery,
+        parametros: params.definicao.parametros,
+    });
+}
+function criaEventosApiGraphqlLeituraPadrao(params) {
+    function porPK(definicao) {
+        return criaEventoApiGraphqlConsulta({
+            definicao: {
+                parametros: { id: definicao.id },
+                select: definicao.select,
+            },
+            operacao: params.def.operacoes.obtemPorPK,
+            expansoesSelect: params.expansoesSelect,
+        });
+    }
+    ;
+    function um(definicao) {
+        return criaEventoApiGraphqlConsulta({
+            definicao,
+            operacao: params.def.operacoes.obtemUm,
+            expansoesSelect: params.expansoesSelect,
+        });
+    }
+    ;
+    function varios(definicao) {
+        return criaEventoApiGraphqlConsulta({
+            definicao,
+            operacao: params.def.operacoes.obtemVarios,
+            expansoesSelect: params.expansoesSelect,
+        });
+    }
+    ;
+    function totalDeRegistros(definicao) {
+        return criaEventoApiGraphqlTotalDeRegistros({
+            definicao,
+            operacao: params.def.operacoes.totalDeRegistros,
+        });
+    }
+    ;
+    function opcoesFiltrosConsulta(definicao) {
+        return criaEventoApiGraphqlOpcoesFiltrosConsulta({
+            definicao,
+            nomeEntidade: params.def.nome,
+            def: params.def,
+        });
+    }
+    ;
+    return {
+        porPK,
+        um,
+        varios,
+        totalDeRegistros,
+        opcoesFiltrosConsulta,
+    };
+}
+export { GraphqlCardinalidade, GraphqlFiltroCampoTipo, GraphqlFiltroControleVisualizacao, GraphqlFiltroEscopo, GraphqlFiltroOperador, GraphqlFiltroOperadoresConsulta, GraphqlFiltroOperadoresPadrao, GraphqlOrderDirecao, GraphqlTipoVariavel, criaEventosApiGraphqlLeituraPadrao, criaGraphqlCampoFiltroConsulta, criaGraphqlCampoFiltroVisualizacao, criaGraphqlDefLeituraPadrao, defineGraphqlCamposFiltroConsulta, defineGraphqlCamposFiltroVisualizacao, defineGraphqlSelect, normalizaSelectGraphql };

package/dist/api/graphql/index.d.ts

@@ -1,5 +1,2 @@
-declare class TesteGraphqlSessaoDto {
-    id: number;
-    tituloSessao: string;
-}
-export { TesteGraphqlSessaoDto };
+export * from './core';
+export * from './leituras';

package/dist/api/graphql/index.js

@@ -1,7 +1,4 @@
 // AUTO-GENERATED FILE - DO NOT EDIT
-// Contratos GraphQL
-class TesteGraphqlSessaoDto {
-    id;
-    tituloSessao;
-}
-export { TesteGraphqlSessaoDto };
+// Gerado automaticamente por gerarTypesNoraApi.ts
+export * from './core';
+export * from './leituras';

package/dist/api/graphql/leituras/Arquivo/index.d.ts

@@ -0,0 +1,41 @@
+import type { GraphqlEntidadeDefLeituraPadrao, GraphqlItemEntidade, GraphqlListaEntidade, GraphqlObtemUmParametrosEntidade, GraphqlObtemUmVariaveisEntidade, GraphqlObtemVariosParametrosEntidade, GraphqlObtemVariosVariaveisEntidade, GraphqlOperacaoTotalDeRegistrosEntidade, GraphqlOperacaoUmEntidade, GraphqlOperacaoVariosEntidade, GraphqlRespostaTotalDeRegistrosEntidade, GraphqlRespostaUmEntidade, GraphqlRespostaVariosEntidade, GraphqlResultadoEntidade, GraphqlSelectEntidade, GraphqlTotalDeRegistrosParametrosEntidade, GraphqlTotalDeRegistrosVariaveisEntidade } from '../../core';
+import type { DetalheArquivoInternoGraphqlDto } from '../DetalheArquivoInterno';
+import type { TipoArquivoGraphqlDto } from '../TipoArquivo';
+import type { UsuarioGraphqlDto } from '../Usuario';
+declare class ArquivoGraphqlDto {
+    id: number;
+    tipoArquivo: Pick<TipoArquivoGraphqlDto, 'id' | 'nome'>;
+    usuario: Pick<UsuarioGraphqlDto, 'id' | 'username'>;
+    detalheArquivoInterno: Pick<DetalheArquivoInternoGraphqlDto, 'fkArquivoId' | 'nomeInterno'> | null;
+    caminhoArquivo: string;
+    tipoMime: string;
+    dataCriacao: Date;
+    dataAtualizacao: Date | null;
+    pendenteAprovacao: boolean;
+    nomeGeralArquivo: string | null;
+}
+type ArquivoGraphqlDefTipo = GraphqlEntidadeDefLeituraPadrao<ArquivoGraphqlDto, 'Arquivo', 'ArquivoPorPK', 'arquivoPorPKGraphql', 'arquivoPorPKGraphql', 'ArquivoUm', 'arquivoGraphql', 'arquivoGraphql', 'ArquivoVarios', 'arquivosGraphql', 'arquivosGraphql', 'ArquivoTotalDeRegistros', 'totalDeRegistrosArquivosGraphql', 'totalDeRegistros'>;
+declare const EventosApiGraphqlArquivo: import("../../core").GraphqlEventosApiLeituraPadrao<ArquivoGraphqlDto, ArquivoGraphqlDefTipo>;
+declare namespace GraphqlTypesArquivo {
+    const eventos: import("../../core").GraphqlEventosApiLeituraPadrao<ArquivoGraphqlDto, ArquivoGraphqlDefTipo>;
+    type ObtemUmParametros = GraphqlObtemUmParametrosEntidade<ArquivoGraphqlDto>;
+    type ObtemUmVariaveis = GraphqlObtemUmVariaveisEntidade<ObtemUmParametros>;
+    type ObtemVariosParametros = GraphqlObtemVariosParametrosEntidade<ArquivoGraphqlDto>;
+    type ObtemVariosVariaveis = GraphqlObtemVariosVariaveisEntidade<ObtemVariosParametros>;
+    type TotalDeRegistrosParametros = GraphqlTotalDeRegistrosParametrosEntidade<ArquivoGraphqlDto>;
+    type TotalDeRegistrosVariaveis = GraphqlTotalDeRegistrosVariaveisEntidade<TotalDeRegistrosParametros>;
+    const CamposFiltroVisualizacao: readonly [import("../../core").GraphqlFiltroVisualizacaoCampoDef<ArquivoGraphqlDto, "tipoArquivo.nome", readonly ["tipoArquivo", "nome"]>, import("../../core").GraphqlFiltroVisualizacaoCampoDef<ArquivoGraphqlDto, "usuario.username", readonly ["usuario", "username"]>, import("../../core").GraphqlFiltroVisualizacaoCampoDef<ArquivoGraphqlDto, "dataCriacao", readonly ["dataCriacao"]>, import("../../core").GraphqlFiltroVisualizacaoCampoDef<ArquivoGraphqlDto, "nomeGeralArquivo", readonly ["nomeGeralArquivo"]>];
+    const CamposFiltroConsulta: readonly [import("../../core").GraphqlFiltroConsultaCampoDef<ArquivoGraphqlDto, "tipoArquivo.nome", readonly ["tipoArquivo", "nome"]>, import("../../core").GraphqlFiltroConsultaCampoDef<ArquivoGraphqlDto, "usuario.username", readonly ["usuario", "username"]>, import("../../core").GraphqlFiltroConsultaCampoDef<ArquivoGraphqlDto, "dataCriacao", readonly ["dataCriacao"]>];
+    type Select = GraphqlSelectEntidade<ArquivoGraphqlDto>;
+    const select: import("../../core").GraphqlSelectDef<ArquivoGraphqlDto>;
+    type Resultado<TSelect extends Select> = GraphqlResultadoEntidade<ArquivoGraphqlDto, TSelect>;
+    type Item<TSelect extends Select> = GraphqlItemEntidade<ArquivoGraphqlDto, TSelect>;
+    type Lista<TSelect extends Select> = GraphqlListaEntidade<ArquivoGraphqlDto, TSelect>;
+    type RespostaUm<TSelect extends Select> = GraphqlRespostaUmEntidade<ArquivoGraphqlDefTipo, ArquivoGraphqlDto, TSelect>;
+    type RespostaVarios<TSelect extends Select> = GraphqlRespostaVariosEntidade<ArquivoGraphqlDefTipo, ArquivoGraphqlDto, TSelect>;
+    type RespostaTotalDeRegistros = GraphqlRespostaTotalDeRegistrosEntidade<ArquivoGraphqlDefTipo>;
+    type OperacaoUm<TSelect extends Select> = GraphqlOperacaoUmEntidade<'Arquivo', ObtemUmParametros, TSelect>;
+    type OperacaoVarios<TSelect extends Select> = GraphqlOperacaoVariosEntidade<'Arquivo', ObtemVariosParametros, TSelect>;
+    type OperacaoTotalDeRegistros = GraphqlOperacaoTotalDeRegistrosEntidade<'Arquivo', TotalDeRegistrosParametros>;
+}
+export { ArquivoGraphqlDto, EventosApiGraphqlArquivo, GraphqlTypesArquivo };

package/dist/api/graphql/leituras/Arquivo/index.js

@@ -0,0 +1,74 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Contratos GraphQL de leitura: Arquivo
+import { GraphqlFiltroCampoTipo, GraphqlFiltroControleVisualizacao, criaEventosApiGraphqlLeituraPadrao, criaGraphqlCampoFiltroConsulta, criaGraphqlCampoFiltroVisualizacao, criaGraphqlDefLeituraPadrao, defineGraphqlCamposFiltroConsulta, defineGraphqlCamposFiltroVisualizacao, defineGraphqlSelect } from '../../core';
+class ArquivoGraphqlDto {
+    id;
+    tipoArquivo;
+    usuario;
+    detalheArquivoInterno;
+    caminhoArquivo;
+    tipoMime;
+    dataCriacao;
+    dataAtualizacao;
+    pendenteAprovacao;
+    nomeGeralArquivo;
+}
+const ArquivoGraphqlSelectExpansoes = {
+    detalheArquivoInterno: {
+        fkArquivoId: true,
+        nomeInterno: true,
+    },
+    tipoArquivo: {
+        id: true,
+        nome: true,
+    },
+    usuario: {
+        id: true,
+        username: true,
+    },
+};
+const ArquivoGraphqlDef = criaGraphqlDefLeituraPadrao()({
+    nome: 'Arquivo',
+    obtemPorPK: {
+        nomeOperacaoGraphql: 'ArquivoPorPK',
+        nomeCampoQuery: 'arquivoPorPKGraphql',
+        nomeAliasResposta: 'arquivoPorPKGraphql',
+    },
+    obtemUm: {
+        nomeOperacaoGraphql: 'ArquivoUm',
+        nomeCampoQuery: 'arquivoGraphql',
+        nomeAliasResposta: 'arquivoGraphql',
+    },
+    obtemVarios: {
+        nomeOperacaoGraphql: 'ArquivoVarios',
+        nomeCampoQuery: 'arquivosGraphql',
+        nomeAliasResposta: 'arquivosGraphql',
+    },
+    totalDeRegistros: {
+        nomeOperacaoGraphql: 'ArquivoTotalDeRegistros',
+        nomeCampoQuery: 'totalDeRegistrosArquivosGraphql',
+        nomeAliasResposta: 'totalDeRegistros',
+    },
+});
+const EventosApiGraphqlArquivo = criaEventosApiGraphqlLeituraPadrao({
+    def: ArquivoGraphqlDef,
+    expansoesSelect: ArquivoGraphqlSelectExpansoes,
+});
+var GraphqlTypesArquivo;
+(function (GraphqlTypesArquivo) {
+    GraphqlTypesArquivo.eventos = EventosApiGraphqlArquivo;
+    GraphqlTypesArquivo.CamposFiltroVisualizacao = defineGraphqlCamposFiltroVisualizacao()([
+        criaGraphqlCampoFiltroVisualizacao('tipoArquivo.nome', ['tipoArquivo', 'nome'], GraphqlFiltroCampoTipo.STRING, false, GraphqlFiltroControleVisualizacao.MULTISELECT, 'Tipo de Arquivo'),
+        criaGraphqlCampoFiltroVisualizacao('usuario.username', ['usuario', 'username'], GraphqlFiltroCampoTipo.STRING, false, GraphqlFiltroControleVisualizacao.MULTISELECT, 'Usuário'),
+        criaGraphqlCampoFiltroVisualizacao('dataCriacao', ['dataCriacao'], GraphqlFiltroCampoTipo.DATE, false, GraphqlFiltroControleVisualizacao.DATA_RANGE, 'Data Criação'),
+        criaGraphqlCampoFiltroVisualizacao('nomeGeralArquivo', ['nomeGeralArquivo'], GraphqlFiltroCampoTipo.STRING, true, GraphqlFiltroControleVisualizacao.TEXTO, 'Nome Interno')
+    ]);
+    GraphqlTypesArquivo.CamposFiltroConsulta = defineGraphqlCamposFiltroConsulta()([
+        criaGraphqlCampoFiltroConsulta('tipoArquivo.nome', ['tipoArquivo', 'nome'], GraphqlFiltroCampoTipo.STRING, false, GraphqlFiltroControleVisualizacao.MULTISELECT, 'Tipo de Arquivo'),
+        criaGraphqlCampoFiltroConsulta('usuario.username', ['usuario', 'username'], GraphqlFiltroCampoTipo.STRING, false, GraphqlFiltroControleVisualizacao.MULTISELECT, 'Usuário'),
+        criaGraphqlCampoFiltroConsulta('dataCriacao', ['dataCriacao'], GraphqlFiltroCampoTipo.DATE, false, GraphqlFiltroControleVisualizacao.DATA_RANGE, 'Data Criação')
+    ]);
+    GraphqlTypesArquivo.select = defineGraphqlSelect();
+})(GraphqlTypesArquivo || (GraphqlTypesArquivo = {}));
+;
+export { ArquivoGraphqlDto, EventosApiGraphqlArquivo, GraphqlTypesArquivo };

package/dist/api/graphql/leituras/ArquivoTipadoArte/index.d.ts

@@ -0,0 +1,35 @@
+import type { CaminhoArquivoArte } from '../../../../dtos';
+import type { GraphqlEntidadeDefLeituraPadrao, GraphqlItemEntidade, GraphqlListaEntidade, GraphqlObtemUmParametrosEntidade, GraphqlObtemUmVariaveisEntidade, GraphqlObtemVariosParametrosEntidade, GraphqlObtemVariosVariaveisEntidade, GraphqlOperacaoTotalDeRegistrosEntidade, GraphqlOperacaoUmEntidade, GraphqlOperacaoVariosEntidade, GraphqlRespostaTotalDeRegistrosEntidade, GraphqlRespostaUmEntidade, GraphqlRespostaVariosEntidade, GraphqlResultadoEntidade, GraphqlSelectEntidade, GraphqlTotalDeRegistrosParametrosEntidade, GraphqlTotalDeRegistrosVariaveisEntidade } from '../../core';
+declare class ArquivoTipadoArteGraphqlDto {
+    id: number;
+    caminhoArquivoArte: string | null;
+    dadosArteCapa: {
+        temCapaConfigurada: boolean;
+        caminhoArquivoArteCapa: CaminhoArquivoArte;
+    };
+}
+type ArquivoTipadoArteGraphqlDefTipo = GraphqlEntidadeDefLeituraPadrao<ArquivoTipadoArteGraphqlDto, 'ArquivoTipadoArte', 'ArquivoTipadoArtePorPK', 'arquivoTipadoArtePorPKGraphql', 'arquivoTipadoArtePorPKGraphql', 'ArquivoTipadoArteUm', 'arquivoTipadoArteGraphql', 'arquivoTipadoArteGraphql', 'ArquivoTipadoArteVarios', 'arquivoTipadoArtesGraphql', 'arquivoTipadoArtesGraphql', 'ArquivoTipadoArteTotalDeRegistros', 'totalDeRegistrosArquivoTipadoArtesGraphql', 'totalDeRegistros'>;
+declare const EventosApiGraphqlArquivoTipadoArte: import("../../core").GraphqlEventosApiLeituraPadrao<ArquivoTipadoArteGraphqlDto, ArquivoTipadoArteGraphqlDefTipo>;
+declare namespace GraphqlTypesArquivoTipadoArte {
+    const eventos: import("../../core").GraphqlEventosApiLeituraPadrao<ArquivoTipadoArteGraphqlDto, ArquivoTipadoArteGraphqlDefTipo>;
+    type ObtemUmParametros = GraphqlObtemUmParametrosEntidade<ArquivoTipadoArteGraphqlDto>;
+    type ObtemUmVariaveis = GraphqlObtemUmVariaveisEntidade<ObtemUmParametros>;
+    type ObtemVariosParametros = GraphqlObtemVariosParametrosEntidade<ArquivoTipadoArteGraphqlDto>;
+    type ObtemVariosVariaveis = GraphqlObtemVariosVariaveisEntidade<ObtemVariosParametros>;
+    type TotalDeRegistrosParametros = GraphqlTotalDeRegistrosParametrosEntidade<ArquivoTipadoArteGraphqlDto>;
+    type TotalDeRegistrosVariaveis = GraphqlTotalDeRegistrosVariaveisEntidade<TotalDeRegistrosParametros>;
+    const CamposFiltroVisualizacao: readonly [];
+    const CamposFiltroConsulta: readonly [];
+    type Select = GraphqlSelectEntidade<ArquivoTipadoArteGraphqlDto>;
+    const select: import("../../core").GraphqlSelectDef<ArquivoTipadoArteGraphqlDto>;
+    type Resultado<TSelect extends Select> = GraphqlResultadoEntidade<ArquivoTipadoArteGraphqlDto, TSelect>;
+    type Item<TSelect extends Select> = GraphqlItemEntidade<ArquivoTipadoArteGraphqlDto, TSelect>;
+    type Lista<TSelect extends Select> = GraphqlListaEntidade<ArquivoTipadoArteGraphqlDto, TSelect>;
+    type RespostaUm<TSelect extends Select> = GraphqlRespostaUmEntidade<ArquivoTipadoArteGraphqlDefTipo, ArquivoTipadoArteGraphqlDto, TSelect>;
+    type RespostaVarios<TSelect extends Select> = GraphqlRespostaVariosEntidade<ArquivoTipadoArteGraphqlDefTipo, ArquivoTipadoArteGraphqlDto, TSelect>;
+    type RespostaTotalDeRegistros = GraphqlRespostaTotalDeRegistrosEntidade<ArquivoTipadoArteGraphqlDefTipo>;
+    type OperacaoUm<TSelect extends Select> = GraphqlOperacaoUmEntidade<'ArquivoTipadoArte', ObtemUmParametros, TSelect>;
+    type OperacaoVarios<TSelect extends Select> = GraphqlOperacaoVariosEntidade<'ArquivoTipadoArte', ObtemVariosParametros, TSelect>;
+    type OperacaoTotalDeRegistros = GraphqlOperacaoTotalDeRegistrosEntidade<'ArquivoTipadoArte', TotalDeRegistrosParametros>;
+}
+export { ArquivoTipadoArteGraphqlDto, EventosApiGraphqlArquivoTipadoArte, GraphqlTypesArquivoTipadoArte };

package/dist/api/graphql/leituras/ArquivoTipadoArte/index.js

@@ -0,0 +1,50 @@
+// AUTO-GENERATED FILE - DO NOT EDIT
+// Contratos GraphQL de leitura: ArquivoTipadoArte
+import { criaEventosApiGraphqlLeituraPadrao, criaGraphqlDefLeituraPadrao, defineGraphqlCamposFiltroConsulta, defineGraphqlCamposFiltroVisualizacao, defineGraphqlSelect } from '../../core';
+class ArquivoTipadoArteGraphqlDto {
+    id;
+    caminhoArquivoArte;
+    dadosArteCapa;
+}
+const ArquivoTipadoArteGraphqlSelectExpansoes = {
+    dadosArteCapa: {
+        caminhoArquivoArteCapa: true,
+        temCapaConfigurada: true,
+    },
+};
+const ArquivoTipadoArteGraphqlDef = criaGraphqlDefLeituraPadrao()({
+    nome: 'ArquivoTipadoArte',
+    obtemPorPK: {
+        nomeOperacaoGraphql: 'ArquivoTipadoArtePorPK',
+        nomeCampoQuery: 'arquivoTipadoArtePorPKGraphql',
+        nomeAliasResposta: 'arquivoTipadoArtePorPKGraphql',
+    },
+    obtemUm: {
+        nomeOperacaoGraphql: 'ArquivoTipadoArteUm',
+        nomeCampoQuery: 'arquivoTipadoArteGraphql',
+        nomeAliasResposta: 'arquivoTipadoArteGraphql',
+    },
+    obtemVarios: {
+        nomeOperacaoGraphql: 'ArquivoTipadoArteVarios',
+        nomeCampoQuery: 'arquivoTipadoArtesGraphql',
+        nomeAliasResposta: 'arquivoTipadoArtesGraphql',
+    },
+    totalDeRegistros: {
+        nomeOperacaoGraphql: 'ArquivoTipadoArteTotalDeRegistros',
+        nomeCampoQuery: 'totalDeRegistrosArquivoTipadoArtesGraphql',
+        nomeAliasResposta: 'totalDeRegistros',
+    },
+});
+const EventosApiGraphqlArquivoTipadoArte = criaEventosApiGraphqlLeituraPadrao({
+    def: ArquivoTipadoArteGraphqlDef,
+    expansoesSelect: ArquivoTipadoArteGraphqlSelectExpansoes,
+});
+var GraphqlTypesArquivoTipadoArte;
+(function (GraphqlTypesArquivoTipadoArte) {
+    GraphqlTypesArquivoTipadoArte.eventos = EventosApiGraphqlArquivoTipadoArte;
+    GraphqlTypesArquivoTipadoArte.CamposFiltroVisualizacao = defineGraphqlCamposFiltroVisualizacao()([]);
+    GraphqlTypesArquivoTipadoArte.CamposFiltroConsulta = defineGraphqlCamposFiltroConsulta()([]);
+    GraphqlTypesArquivoTipadoArte.select = defineGraphqlSelect();
+})(GraphqlTypesArquivoTipadoArte || (GraphqlTypesArquivoTipadoArte = {}));
+;
+export { ArquivoTipadoArteGraphqlDto, EventosApiGraphqlArquivoTipadoArte, GraphqlTypesArquivoTipadoArte };