Importar

// npm install termo_core --save-exact
import * as leads from "termo_core/leads";
// ou: import { leads } from "termo_core";

function cancelar_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<tipos.ImportProgress>

import { CredencialDeAcesso } from "termo_core";
import { cancelar_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await cancelar_importar(credencial_de_acesso);

function iniciar_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<tipos.ImportProgress>

import { CredencialDeAcesso } from "termo_core";
import { iniciar_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await iniciar_importar(credencial_de_acesso);

function relatorios_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<Array<tipos.ImportResumo>>

import { CredencialDeAcesso } from "termo_core";
import { relatorios_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await relatorios_importar(credencial_de_acesso);

function sincronizar_importar(
  credencial_de_acesso: CredencialDeAcesso,
  corpo_da_requisicao: tipos.SincronizarCnpjInput,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<tipos.SincronizacaoProgress>

import { CredencialDeAcesso } from "termo_core";
import { sincronizar_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await sincronizar_importar(credencial_de_acesso, corpo_da_requisicao);

function sincronizar_cancelar_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<tipos.SincronizacaoProgress>

import { CredencialDeAcesso } from "termo_core";
import { sincronizar_cancelar_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await sincronizar_cancelar_importar(credencial_de_acesso);

function sincronizar_pontos_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<Array<tipos.PontoSincronizacao>>

import { CredencialDeAcesso } from "termo_core";
import { sincronizar_pontos_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await sincronizar_pontos_importar(credencial_de_acesso);

function sincronizar_status_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<tipos.SincronizacaoProgress>

import { CredencialDeAcesso } from "termo_core";
import { sincronizar_status_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await sincronizar_status_importar(credencial_de_acesso);

function status_importar(
  credencial_de_acesso: CredencialDeAcesso,
  opcoes_da_chamada?: OpcoesDaChamada,
): Promise<tipos.ImportProgress>

import { CredencialDeAcesso } from "termo_core";
import { status_importar } from "termo_core/leads";

const credencial_de_acesso = CredencialDeAcesso.token_do_usuario_logado(token_do_usuario);
const resposta = await status_importar(credencial_de_acesso);

import type { ArquivoStatus } from "termo_core/leads";

export interface ArquivoStatus {
  /**
   * Bytes baixados
   */
  bytes: number;
  /**
   * `pendente`, `baixando`, `concluido` ou `falha`
   */
  estado: string;
  /**
   * Nome do arquivo
   */
  nome: string;
  /**
   * Tamanho do arquivo em bytes, quando conhecido
   */
  total?: number | null;
}

import type { DownloadProgress } from "termo_core/leads";

export interface DownloadProgress {
  /**
   * Situação do download de cada arquivo
   */
  arquivos: Array<ArquivoStatus>;
  /**
   * Quantidade de arquivos já baixados
   */
  arquivosConcluidos: number;
  /**
   * Total de bytes baixados
   */
  bytesBaixados: number;
  /**
   * Total de bytes a baixar, quando conhecido
   */
  bytesTotal?: number | null;
  /**
   * Mensagens dos arquivos cujo download falhou
   */
  falhas: Array<string>;
  /**
   * Quantidade de arquivos a baixar
   */
  totalArquivos: number;
}

import type { ImportArquivo } from "termo_core/leads";

export interface ImportArquivo {
  /**
   * Bytes já lidos
   */
  bytesLidos: number;
  /**
   * Tamanho do arquivo descompactado, em bytes
   */
  bytesTotal: number;
  /**
   * Registros malformados descartados
   */
  descartadas: number;
  /**
   * Erro do arquivo, quando falhou
   */
  erro?: string | null;
  /**
   * `pendente`, `importando`, `concluido` ou `falha`
   */
  estado: string;
  /**
   * Linhas lidas
   */
  linhas: number;
  /**
   * Nome do arquivo
   */
  nome: string;
  /**
   * Destino dos dados do arquivo
   */
  tabela: string;
}

import type { ImportProgress } from "termo_core/leads";

export interface ImportProgress {
  /**
   * Situação de cada arquivo processado
   */
  arquivos: Array<ImportArquivo>;
  /**
   * Quantidade de arquivos já processados
   */
  arquivosConcluidos: number;
  /**
   * `true` depois que o cancelamento foi pedido
   */
  cancelando: boolean;
  /**
   * Progresso do download dos arquivos da Receita
   */
  download: DownloadProgress;
  /**
   * Erro que interrompeu a importação, quando houve
   */
  erro?: string | null;
  /**
   * Etapa atual: vazia antes da primeira importação, depois `preparando`, `baixando`, `importando`, `montagem`, `indices` ou `concluido`
   */
  etapa: string;
  /**
   * Faixa em montagem
   */
  faixaAtual: number;
  /**
   * Quantidade de faixas da montagem da base
   */
  faixasTotal: number;
  /**
   * Mensagens dos arquivos que falharam
   */
  falhas: Array<string>;
  /**
   * `true` quando a última importação terminou, com sucesso, erro ou cancelamento
   */
  finalizado: boolean;
  /**
   * Total de registros malformados descartados
   */
  linhasDescartadasTotal: number;
  /**
   * Total de linhas lidas
   */
  linhasTotal: number;
  /**
   * Últimas 200 linhas do log da importação
   */
  log: Array<string>;
  /**
   * Mês da base importada, no formato AAAA-MM, conhecido depois do download
   */
  mes?: string | null;
  /**
   * Quantidade de estabelecimentos já montados
   */
  montagemFeitas: number;
  /**
   * Quantidade de estabelecimentos a montar
   */
  montagemTotal: number;
  /**
   * `true` enquanto a importação está em andamento
   */
  running: boolean;
  /**
   * Quantidade de arquivos a processar
   */
  totalArquivos: number;
}

import type { ImportResumo } from "termo_core/leads";

export interface ImportResumo {
  /**
   * Quantidade de arquivos processados sem falha
   */
  arquivosOk: number;
  /**
   * Erro da execução, quando houve
   */
  erro?: string | null;
  /**
   * Fim da execução, data e hora em RFC 3339; nulo enquanto executa
   */
  finalizadoEm?: string | null;
  /**
   * Id da execução (UUID)
   */
  id: string;
  /**
   * Início da execução, data e hora em RFC 3339
   */
  iniciadoEm?: string | null;
  /**
   * Total de linhas lidas
   */
  linhasTotal: number;
  /**
   * Mês da base importada, no formato AAAA-MM
   */
  mes?: string | null;
  /**
   * `executando`, `concluido`, `concluido_com_falhas`, `erro` ou `cancelado`
   */
  status: string;
  /**
   * Quantidade de arquivos da importação
   */
  totalArquivos: number;
}

import type { PontoSincronizacao } from "termo_core/leads";

export interface PontoSincronizacao {
  /**
   * Destino: `sandbox` ou `production`
   */
  ambiente: string;
  /**
   * Quando o ponto foi gravado, data e hora em RFC 3339
   */
  atualizadoEm: string;
  /**
   * Último CNPJ confirmado pelo destino, salvo no banco local
   */
  ultimoCnpj: string;
}

import type { SincronizacaoProgress } from "termo_core/leads";

export interface SincronizacaoProgress {
  /**
   * Destino: `sandbox` ou `production`
   */
  ambiente: string;
  /**
   * `true` depois que o cancelamento foi pedido
   */
  cancelando: boolean;
  /**
   * URL base do backend de destino
   */
  destino: string;
  /**
   * Linhas enviadas e confirmadas pelo destino nesta execução
   */
  enviados: number;
  /**
   * Erro que interrompeu a sincronização, quando houve
   */
  erro?: string | null;
  /**
   * `true` quando a última sincronização terminou, com sucesso, erro ou cancelamento
   */
  finalizado: boolean;
  /**
   * Linhas que o destino inseriu ou alterou
   */
  gravados: number;
  /**
   * Linhas da tabela local até o CNPJ de retomada, enviadas numa execução anterior; zero quando começa do início
   */
  jaSincronizados: number;
  /**
   * Últimas 200 linhas do log da sincronização
   */
  log: Array<string>;
  /**
   * Lotes enviados
   */
  lotes: number;
  /**
   * `true` enquanto a sincronização está em andamento
   */
  running: boolean;
  /**
   * Total aproximado de linhas da tabela `cnpj` local
   */
  totalEstimado: number;
  /**
   * Último CNPJ confirmado pelo destino, ponto de retomada
   */
  ultimoCnpj?: string | null;
}

import type { SincronizarCnpjInput } from "termo_core/leads";

export interface SincronizarCnpjInput {
  /**
   * Destino da sincronização: `sandbox` ou `production`
   */
  ambiente: string;
  /**
   * Continua depois deste CNPJ (retomada de uma sincronização interrompida); vazio começa do início
   */
  retomarDe?: string | null;
}