const db = require('../models');
const Users = db.users;

const CamerasPtz = db.cameras_ptz;

const Epcs = db.epcs;

const Epis = db.epis;

const EquipesTrabalho = db.equipes_trabalho;

const EstruturaProjeto = db.estrutura_projeto;

const EtapasOuTrechos = db.etapas_ou_trechos;

const FramesImagem = db.frames_imagem;

const GemeosDigitais = db.gemeos_digitais;

const HistoricoAlteracoesProjeto = db.historico_alteracoes_projeto;

const InspecaoAerea = db.inspecao_aerea;

const MaquinasAtividade = db.maquinas_atividade;

const MateriaisAtividade = db.materiais_atividade;

const MembrosEquipe = db.membros_equipe;

const MemoriaisDescritivosAsbuilt = db.memoriais_descritivos_asbuilt;

const ModelosBimAsbuilt = db.modelos_bim_asbuilt;

const Obras = db.obras;

const PermissoesModulo = db.permissoes_modulo;

const PessoasAtividade = db.pessoas_atividade;

const PessoasFrame = db.pessoas_frame;

const PlantasAsbuilt2d = db.plantas_asbuilt_2d;

const RelatorioAndamentoAtual = db.relatorio_andamento_atual;

const RelatoriosAnaliticosVideo = db.relatorios_analiticos_video;

const RelatoriosDiarios = db.relatorios_diarios;

const RelatoriosMensais = db.relatorios_mensais;

const RelatoriosSemanais = db.relatorios_semanais;

const Subcontratadas = db.subcontratadas;

const Usuarios = db.usuarios;

const Clientes = db.clientes;

const CamerasPtzData = [
  {
    modelo: 'PTZ-1000',

    fabricante: 'CameraTech',

    local_instalacao: 'Entrada principal do canteiro',

    coordenada_lat: -19.916681,

    coordenada_lon: -43.934493,

    altura_instalacao_m: 5,

    angulo_focal: '90 graus',

    ip_acesso: '192.168.1.10',

    status_operacional: 'Operacional',

    data_instalacao: new Date('2024-01-10'),

    observacoes: 'Câmera instalada e em operação',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    modelo: 'PTZ-2000',

    fabricante: 'VisionPro',

    local_instalacao: 'Área de escavação',

    coordenada_lat: -19.917681,

    coordenada_lon: -43.935493,

    altura_instalacao_m: 6,

    angulo_focal: '120 graus',

    ip_acesso: '192.168.1.11',

    status_operacional: 'Operacional',

    data_instalacao: new Date('2024-02-01'),

    observacoes: 'Câmera instalada e em operação',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    modelo: 'PTZ-3000',

    fabricante: 'SecureCam',

    local_instalacao: 'Zona de carga',

    coordenada_lat: -19.918681,

    coordenada_lon: -43.936493,

    altura_instalacao_m: 7,

    angulo_focal: '110 graus',

    ip_acesso: '192.168.1.12',

    status_operacional: 'Operacional',

    data_instalacao: new Date('2024-03-15'),

    observacoes: 'Câmera instalada e em operação',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const EpcsData = [
  {
    nome_epc: 'Barreira de Proteção',

    descricao: 'Barreira para isolamento de áreas de risco',

    // type code here for "relation_one" field
  },

  {
    nome_epc: 'Cone de Sinalização',

    descricao: 'Cone para sinalização de áreas de trabalho',

    // type code here for "relation_one" field
  },

  {
    nome_epc: 'Fita de Sinalização',

    descricao: 'Fita para demarcação de áreas de segurança',

    // type code here for "relation_one" field
  },
];

const EpisData = [
  {
    nome_epi: 'Capacete',

    descricao: 'Capacete de segurança para proteção da cabeça',

    // type code here for "relation_one" field
  },

  {
    nome_epi: 'Colete Refletivo',

    descricao: 'Colete refletivo para visibilidade em áreas de risco',

    // type code here for "relation_one" field
  },

  {
    nome_epi: 'Luvas de Proteção',

    descricao: 'Luvas para proteção das mãos contra abrasões',

    // type code here for "relation_one" field
  },
];

const EquipesTrabalhoData = [
  {
    nome_equipe: 'Equipe Copasa - Juatuba',

    tipo: 'Subcontratada',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_equipe: 'Equipe Copasa - Betim',

    tipo: 'Subcontratada',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_equipe: 'Equipe Automageo - Juatuba',

    tipo: 'Subcontratada',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const EstruturaProjetoData = [
  {
    etapa: 'Etapa 1 - Implantação',

    atividade: 'Escavação e assentamento de tubos',

    descricao: 'Atividade piloto',

    prazo_estimado_dias: 10,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    etapa: 'Etapa 2 - Conclusão',

    atividade: 'Recomposição de pavimento',

    descricao: 'Finalização do trecho',

    prazo_estimado_dias: 15,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    etapa: 'Etapa 1 - Expansão',

    atividade: 'Instalação de nova tubulação',

    descricao: 'Expansão da rede',

    prazo_estimado_dias: 20,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const EtapasOuTrechosData = [
  {
    tipo: 'Etapa',

    nome: 'Escavação Inicial',

    descricao: 'Escavação do terreno para instalação de tubulação',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    tipo: 'Trecho',

    nome: 'Trecho 1 - Avenida Principal',

    descricao: 'Instalação de tubos na avenida principal',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    tipo: 'Etapa',

    nome: 'Recomposição de Pavimento',

    descricao: 'Recomposição do pavimento após instalação',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const FramesImagemData = [
  {
    origem: 'drone',

    imagem_url:
      'https://drive.example.com/engedrones/obra_1/inspecao_201/frame_1.jpg',

    timestamp_frame: new Date('2024-10-15T09:15:30'),

    observacoes: 'Frame 1 da inspeção 201',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    origem: 'ptz',

    imagem_url:
      'https://drive.example.com/engedrones/obra_1/inspecao_201/frame_2.jpg',

    timestamp_frame: new Date('2024-10-15T10:15:30'),

    observacoes: 'Frame 2 da inspeção 201',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    origem: 'drone',

    imagem_url:
      'https://drive.example.com/engedrones/obra_2/inspecao_202/frame_1.jpg',

    timestamp_frame: new Date('2024-10-16T10:00:00'),

    observacoes: 'Frame 1 da inspeção 202',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const GemeosDigitaisData = [
  {
    tipo: 'nuvem_de_pontos',

    arquivo_url: 'https://drive.example.com/engedrones/obra_1/gemeo_1.zip',

    descricao: 'Gêmeo digital (nuvem de pontos) da obra Juatuba',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    tipo: 'mesh_3d',

    arquivo_url: 'https://drive.example.com/engedrones/obra_1/gemeo_2.zip',

    descricao: 'Gêmeo digital (mesh 3D) da obra Juatuba',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    tipo: 'nuvem_de_pontos',

    arquivo_url: 'https://drive.example.com/engedrones/obra_2/gemeo_1.zip',

    descricao: 'Gêmeo digital (nuvem de pontos) da obra Betim',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const HistoricoAlteracoesProjetoData = [
  {
    data_alteracao: new Date('2024-10-15T12:00:00'),

    tipo_alteracao: 'Mudança de Escopo',

    descricao_anterior: 'Escavação inicial',

    descricao_nova: 'Escavação e assentamento',

    motivo_alteracao: 'Necessidade de ajuste no projeto',

    responsavel_alteracao: 'Engenheiro Responsável',

    comentarios: 'Alteração aprovada pelo cliente',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data_alteracao: new Date('2024-10-16T12:00:00'),

    tipo_alteracao: 'Ajuste de Prazo',

    descricao_anterior: 'Recomposição de pavimento',

    descricao_nova: 'Recomposição de pavimento e acabamento',

    motivo_alteracao: 'Atraso na entrega de materiais',

    responsavel_alteracao: 'Gerente de Projeto',

    comentarios: 'Prazo ajustado em 5 dias',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data_alteracao: new Date('2024-10-17T12:00:00'),

    tipo_alteracao: 'Revisão de Materiais',

    descricao_anterior: 'Uso de brita',

    descricao_nova: 'Uso de brita e areia',

    motivo_alteracao: 'Revisão de especificações técnicas',

    responsavel_alteracao: 'Engenheiro de Materiais',

    comentarios: 'Especificações atualizadas',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const InspecaoAereaData = [
  {
    data_inspecao: new Date('2024-10-15T09:15:30'),

    tipo_inspecao: 'Inspeção Aérea',

    observacoes:
      'Condições aceitáveis para inspeção; leve sombra projetada por edificações.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data_inspecao: new Date('2024-10-16T10:00:00'),

    tipo_inspecao: 'Inspeção Aérea',

    observacoes: 'Visibilidade boa; tráfego fluindo em meia pista.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data_inspecao: new Date('2024-10-17T11:30:00'),

    tipo_inspecao: 'Inspeção Aérea',

    observacoes:
      'Obra em trecho urbano com circulação parcialmente restringida.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const MaquinasAtividadeData = [
  {
    quantidade_prevista: 2,

    horas_utilizacao_previstas: 50,

    comentarios: 'Escavadeiras para movimentação de terra',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    quantidade_prevista: 1,

    horas_utilizacao_previstas: 30,

    comentarios: 'Caminhão para transporte de materiais',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    quantidade_prevista: 3,

    horas_utilizacao_previstas: 40,

    comentarios: 'Betoneiras para mistura de concreto',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const MateriaisAtividadeData = [
  {
    quantidade_prevista: 100,

    unidade_medida: 'metros',

    tolerancia_estoque: 5,

    comentarios: 'Tubos de PVC para instalação',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    quantidade_prevista: 50,

    unidade_medida: 'toneladas',

    tolerancia_estoque: 2,

    comentarios: 'Brita para base de pavimento',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    quantidade_prevista: 200,

    unidade_medida: 'sacos',

    tolerancia_estoque: 10,

    comentarios: 'Cimento para concretagem',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const MembrosEquipeData = [
  {
    nome: 'Fulano de Tal',

    funcao: 'Fiscal',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome: 'Ciclano Fornecedor',

    funcao: 'Piloto Drone',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome: 'Beltrano Eng.',

    funcao: 'Engenheiro Responsavel',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const MemoriaisDescritivosAsbuiltData = [
  {
    titulo: 'Memorial Descritivo - Juatuba',

    descricao: 'Memorial descritivo da obra em Juatuba',

    arquivo_digital: 'memorial_juatuba.pdf',

    data_entrega: new Date('2024-01-20'),

    responsavel_tecnico: 'Engenheiro ABC',

    validado_por_copasa: true,

    comentarios_validacao: 'Memorial aprovado sem ressalvas',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    titulo: 'Memorial Descritivo - Betim',

    descricao: 'Memorial descritivo da obra em Betim',

    arquivo_digital: 'memorial_betim.pdf',

    data_entrega: new Date('2024-02-20'),

    responsavel_tecnico: 'Engenheiro XYZ',

    validado_por_copasa: true,

    comentarios_validacao: 'Memorial aprovado com pequenas correções',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    titulo: 'Memorial Descritivo - Contagem',

    descricao: 'Memorial descritivo da obra em Contagem',

    arquivo_digital: 'memorial_contagem.pdf',

    data_entrega: new Date('2024-03-25'),

    responsavel_tecnico: 'Engenheiro 123',

    validado_por_copasa: true,

    comentarios_validacao: 'Memorial em revisão',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const ModelosBimAsbuiltData = [
  {
    nome_modelo: 'Modelo BIM - Juatuba',

    descricao: 'Modelo BIM da obra em Juatuba',

    arquivo_modelo: 'bim_juatuba.ifc',

    formato: 'IFC',

    plataforma_origem: 'Revit',

    data_modelagem: new Date('2024-01-15'),

    responsavel_modelagem: 'Engenheiro ABC',

    nivel_detalhamento: 'LOD 300',

    coordenacao_com_outros_modelos: true,

    comentarios: 'Modelo em conformidade com normas',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_modelo: 'Modelo BIM - Betim',

    descricao: 'Modelo BIM da obra em Betim',

    arquivo_modelo: 'bim_betim.ifc',

    formato: 'IFC',

    plataforma_origem: 'Revit',

    data_modelagem: new Date('2024-02-10'),

    responsavel_modelagem: 'Engenheiro XYZ',

    nivel_detalhamento: 'LOD 350',

    coordenacao_com_outros_modelos: true,

    comentarios: 'Modelo aprovado pelo cliente',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_modelo: 'Modelo BIM - Contagem',

    descricao: 'Modelo BIM da obra em Contagem',

    arquivo_modelo: 'bim_contagem.ifc',

    formato: 'IFC',

    plataforma_origem: 'Revit',

    data_modelagem: new Date('2024-03-20'),

    responsavel_modelagem: 'Engenheiro 123',

    nivel_detalhamento: 'LOD 300',

    coordenacao_com_outros_modelos: true,

    comentarios: 'Modelo em revisão',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const ObrasData = [
  {
    nome_obra: 'Implantacao Rede Esgoto - Juatuba',

    cidade: 'Juatuba',

    estado: 'MG',

    descricao: 'Trecho piloto - rede coletora primária',

    data_inicio: new Date('2024-01-10'),

    data_previsao_termino: new Date('2024-12-15'),

    plantas_2d_georreferenciadas: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_obra: 'Implantacao Rede Esgoto - Betim/Vianopolis',

    cidade: 'Betim',

    estado: 'MG',

    descricao: 'Trecho interligacao - etapa 2',

    data_inicio: new Date('2024-02-01'),

    data_previsao_termino: new Date('2024-11-30'),

    plantas_2d_georreferenciadas: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_obra: 'Expansao Rede Agua - Contagem',

    cidade: 'Contagem',

    estado: 'MG',

    descricao: 'Expansão da rede de água potável',

    data_inicio: new Date('2024-03-15'),

    data_previsao_termino: new Date('2025-01-20'),

    plantas_2d_georreferenciadas: false,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const PermissoesModuloData = [
  {
    modulo: 'Claude Levi-Strauss',

    leitura: true,

    escrita: false,

    aprovacao: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    modulo: 'Charles Sherrington',

    leitura: true,

    escrita: false,

    aprovacao: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    modulo: 'Alfred Binet',

    leitura: true,

    escrita: true,

    aprovacao: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const PessoasAtividadeData = [
  {
    funcao_na_atividade: 'Engenheiro Responsável',

    horas_previstas: 40,

    comentarios: 'Coordenação geral da obra',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    funcao_na_atividade: 'Técnico de Segurança',

    horas_previstas: 20,

    comentarios: 'Monitoramento de segurança',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    funcao_na_atividade: 'Operador de Máquina',

    horas_previstas: 30,

    comentarios: 'Operação de escavadeira',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const PessoasFrameData = [
  {
    atividade: 'Supervisão da escavação',

    posicao_aproximada: 'Bordo da vala, lado direito',

    epi_visiveis: 'capacete laranja, colete refletivo',

    foco_no_trabalho: true,

    operando_maquina: false,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    atividade: 'Operador de escavadeira',

    posicao_aproximada: 'Dentro da escavadeira',

    epi_visiveis: 'capacete amarelo',

    foco_no_trabalho: true,

    operando_maquina: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    atividade: 'Ajudante de campo',

    posicao_aproximada: 'Ao lado de rolos de tubo',

    epi_visiveis: 'capacete azul, luvas',

    foco_no_trabalho: true,

    operando_maquina: true,

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const PlantasAsbuilt2dData = [
  {
    nome_planta: 'Planta Geral - Juatuba',

    descricao: 'Planta geral da obra em Juatuba',

    arquivo_digital: 'planta_juatuba.pdf',

    formato: 'PDF',

    data_criacao: new Date('2024-01-10'),

    responsavel_tecnico: 'Engenheiro ABC',

    georreferenciada: true,

    sistema_referencia: 'SIRGAS 2000',

    comentarios: 'Planta aprovada pelo cliente',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_planta: 'Planta Detalhada - Betim',

    descricao: 'Planta detalhada da obra em Betim',

    arquivo_digital: 'planta_betim.dwg',

    formato: 'DWG',

    data_criacao: new Date('2024-02-01'),

    responsavel_tecnico: 'Engenheiro XYZ',

    georreferenciada: true,

    sistema_referencia: 'SIRGAS 2000',

    comentarios: 'Planta em conformidade com normas',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome_planta: 'Planta de Expansão - Contagem',

    descricao: 'Planta de expansão da rede em Contagem',

    arquivo_digital: 'planta_contagem.dxf',

    formato: 'DXF',

    data_criacao: new Date('2024-03-15'),

    responsavel_tecnico: 'Engenheiro 123',

    georreferenciada: true,

    sistema_referencia: 'WGS 84',

    comentarios: 'Planta em revisão',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const RelatorioAndamentoAtualData = [
  {
    data_ultima_atualizacao: new Date('2024-10-15T12:00:00'),

    status_obra: 'Em andamento',

    percentual_execucao_total: 46.5,

    atividade_atual_predominante: 'Escavação',

    riscos_em_aberto: 'Queda na vala',

    tempo_estimado_para_conclusao: '12 dias',

    grau_conformidade_geral: 'Médio-Alto',

    observacoes_finais:
      'Obra organizada e em progresso; melhorias pontuais de segurança recomendadas.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data_ultima_atualizacao: new Date('2024-10-16T12:00:00'),

    status_obra: 'Em andamento',

    percentual_execucao_total: 50,

    atividade_atual_predominante: 'Assentamento de tubos',

    riscos_em_aberto: 'Contato com rede elétrica',

    tempo_estimado_para_conclusao: '15 dias',

    grau_conformidade_geral: 'Alto',

    observacoes_finais: 'Obra em ritmo adequado; atenção à segurança elétrica.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data_ultima_atualizacao: new Date('2024-10-17T12:00:00'),

    status_obra: 'Em andamento',

    percentual_execucao_total: 60,

    atividade_atual_predominante: 'Recomposição de pavimento',

    riscos_em_aberto: 'Desnível no pavimento',

    tempo_estimado_para_conclusao: '10 dias',

    grau_conformidade_geral: 'Alto',

    observacoes_finais:
      'Pavimento em fase de recomposição; atenção ao nivelamento.',

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const RelatoriosAnaliticosVideoData = [
  {
    json_analise:
      '{contexto:{cliente:COPASA},avaliacao_global:{nota_organizacao_0a10:8,confianca_global:alta},resumo:Relatório analítico de exemplo para inspeção 201}',

    data_geracao: new Date('2024-10-15T12:00:00'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    json_analise:
      '{contexto:{cliente:COPASA},avaliacao_global:{nota_organizacao_0a10:7,confianca_global:média},resumo:Relatório analítico de exemplo para inspeção 202}',

    data_geracao: new Date('2024-10-16T12:00:00'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    json_analise:
      '{contexto:{cliente:COPASA},avaliacao_global:{nota_organizacao_0a10:9,confianca_global:alta},resumo:Relatório analítico de exemplo para inspeção 203}',

    data_geracao: new Date('2024-10-17T12:00:00'),

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const RelatoriosDiariosData = [
  {
    data: new Date('2024-10-15'),

    resumo: 'Resumo diário exemplo para obra 1',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data: new Date('2024-10-16'),

    resumo: 'Resumo diário exemplo para obra 2',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    data: new Date('2024-10-17'),

    resumo: 'Resumo diário exemplo para obra 3',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const RelatoriosMensaisData = [
  {
    mes_referencia: new Date('2024-10-01'),

    resumo: 'Resumo mensal exemplo para obra 1',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    mes_referencia: new Date('2024-10-01'),

    resumo: 'Resumo mensal exemplo para obra 2',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    mes_referencia: new Date('2024-10-01'),

    resumo: 'Resumo mensal exemplo para obra 3',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const RelatoriosSemanaisData = [
  {
    semana_referencia: new Date('2024-10-14'),

    resumo: 'Resumo semanal exemplo para obra 1',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    semana_referencia: new Date('2024-10-14'),

    resumo: 'Resumo semanal exemplo para obra 2',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    semana_referencia: new Date('2024-10-14'),

    resumo: 'Resumo semanal exemplo para obra 3',

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const SubcontratadasData = [
  {
    nome: 'Construtora ABC',

    cnpj: '11223344000199',

    endereco: 'Rua das Obras, 300, Contagem - MG',

    responsavel_tecnico: 'Engenheiro ABC',

    // type code here for "relation_one" field
  },

  {
    nome: 'Infraestrutura XYZ',

    cnpj: '22334455000188',

    endereco: 'Av. Infra, 400, Betim - MG',

    responsavel_tecnico: 'Diretor XYZ',

    // type code here for "relation_one" field
  },

  {
    nome: 'Engenharia 123',

    cnpj: '33445566000177',

    endereco: 'Rua Engenharia, 500, Juatuba - MG',

    responsavel_tecnico: 'Gerente 123',

    // type code here for "relation_one" field
  },
];

const UsuariosData = [
  {
    nome: 'William Herschel',

    email: 'Francis Galton',

    senha_hash: 'Stephen Hawking',

    ativo: true,

    data_criacao: new Date(Date.now()),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome: 'Karl Landsteiner',

    email: 'Richard Feynman',

    senha_hash: 'Marcello Malpighi',

    ativo: false,

    data_criacao: new Date(Date.now()),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },

  {
    nome: 'Euclid',

    email: 'Sheldon Glashow',

    senha_hash: 'Carl Gauss (Karl Friedrich Gauss)',

    ativo: true,

    data_criacao: new Date(Date.now()),

    // type code here for "relation_one" field

    // type code here for "relation_one" field

    // type code here for "relation_one" field
  },
];

const ClientesData = [
  {
    name: 'Hermann von Helmholtz',
  },

  {
    name: 'Charles Darwin',
  },

  {
    name: 'Robert Koch',
  },
];

// Similar logic for "relation_many"

async function associateUserWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const User0 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (User0?.setCliente) {
    await User0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const User1 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (User1?.setCliente) {
    await User1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const User2 = await Users.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (User2?.setCliente) {
    await User2.setCliente(relatedCliente2);
  }
}

async function associateCamerasPtzWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const CamerasPtz0 = await CamerasPtz.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (CamerasPtz0?.setObra) {
    await CamerasPtz0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const CamerasPtz1 = await CamerasPtz.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (CamerasPtz1?.setObra) {
    await CamerasPtz1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const CamerasPtz2 = await CamerasPtz.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (CamerasPtz2?.setObra) {
    await CamerasPtz2.setObra(relatedObra2);
  }
}

async function associateCamerasPtzWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const CamerasPtz0 = await CamerasPtz.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (CamerasPtz0?.setCliente) {
    await CamerasPtz0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const CamerasPtz1 = await CamerasPtz.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (CamerasPtz1?.setCliente) {
    await CamerasPtz1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const CamerasPtz2 = await CamerasPtz.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (CamerasPtz2?.setCliente) {
    await CamerasPtz2.setCliente(relatedCliente2);
  }
}

async function associateEpcWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Epc0 = await Epcs.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Epc0?.setCliente) {
    await Epc0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Epc1 = await Epcs.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Epc1?.setCliente) {
    await Epc1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Epc2 = await Epcs.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Epc2?.setCliente) {
    await Epc2.setCliente(relatedCliente2);
  }
}

async function associateEpiWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Epi0 = await Epis.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Epi0?.setCliente) {
    await Epi0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Epi1 = await Epis.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Epi1?.setCliente) {
    await Epi1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Epi2 = await Epis.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Epi2?.setCliente) {
    await Epi2.setCliente(relatedCliente2);
  }
}

async function associateEquipesTrabalhoWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EquipesTrabalho0 = await EquipesTrabalho.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EquipesTrabalho0?.setObra) {
    await EquipesTrabalho0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EquipesTrabalho1 = await EquipesTrabalho.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EquipesTrabalho1?.setObra) {
    await EquipesTrabalho1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EquipesTrabalho2 = await EquipesTrabalho.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EquipesTrabalho2?.setObra) {
    await EquipesTrabalho2.setObra(relatedObra2);
  }
}

async function associateEquipesTrabalhoWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EquipesTrabalho0 = await EquipesTrabalho.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EquipesTrabalho0?.setCliente) {
    await EquipesTrabalho0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EquipesTrabalho1 = await EquipesTrabalho.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EquipesTrabalho1?.setCliente) {
    await EquipesTrabalho1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EquipesTrabalho2 = await EquipesTrabalho.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EquipesTrabalho2?.setCliente) {
    await EquipesTrabalho2.setCliente(relatedCliente2);
  }
}

async function associateEstruturaProjetoWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EstruturaProjeto0 = await EstruturaProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EstruturaProjeto0?.setObra) {
    await EstruturaProjeto0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EstruturaProjeto1 = await EstruturaProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EstruturaProjeto1?.setObra) {
    await EstruturaProjeto1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EstruturaProjeto2 = await EstruturaProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EstruturaProjeto2?.setObra) {
    await EstruturaProjeto2.setObra(relatedObra2);
  }
}

async function associateEstruturaProjetoWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EstruturaProjeto0 = await EstruturaProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EstruturaProjeto0?.setCliente) {
    await EstruturaProjeto0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EstruturaProjeto1 = await EstruturaProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EstruturaProjeto1?.setCliente) {
    await EstruturaProjeto1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EstruturaProjeto2 = await EstruturaProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EstruturaProjeto2?.setCliente) {
    await EstruturaProjeto2.setCliente(relatedCliente2);
  }
}

async function associateEtapasOuTrechoWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EtapasOuTrecho0 = await EtapasOuTrechos.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EtapasOuTrecho0?.setObra) {
    await EtapasOuTrecho0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EtapasOuTrecho1 = await EtapasOuTrechos.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EtapasOuTrecho1?.setObra) {
    await EtapasOuTrecho1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const EtapasOuTrecho2 = await EtapasOuTrechos.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EtapasOuTrecho2?.setObra) {
    await EtapasOuTrecho2.setObra(relatedObra2);
  }
}

async function associateEtapasOuTrechoWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EtapasOuTrecho0 = await EtapasOuTrechos.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (EtapasOuTrecho0?.setCliente) {
    await EtapasOuTrecho0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EtapasOuTrecho1 = await EtapasOuTrechos.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (EtapasOuTrecho1?.setCliente) {
    await EtapasOuTrecho1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const EtapasOuTrecho2 = await EtapasOuTrechos.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (EtapasOuTrecho2?.setCliente) {
    await EtapasOuTrecho2.setCliente(relatedCliente2);
  }
}

async function associateFramesImagemWithInspecao() {
  const relatedInspecao0 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const FramesImagem0 = await FramesImagem.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (FramesImagem0?.setInspecao) {
    await FramesImagem0.setInspecao(relatedInspecao0);
  }

  const relatedInspecao1 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const FramesImagem1 = await FramesImagem.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (FramesImagem1?.setInspecao) {
    await FramesImagem1.setInspecao(relatedInspecao1);
  }

  const relatedInspecao2 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const FramesImagem2 = await FramesImagem.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (FramesImagem2?.setInspecao) {
    await FramesImagem2.setInspecao(relatedInspecao2);
  }
}

async function associateFramesImagemWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const FramesImagem0 = await FramesImagem.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (FramesImagem0?.setCliente) {
    await FramesImagem0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const FramesImagem1 = await FramesImagem.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (FramesImagem1?.setCliente) {
    await FramesImagem1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const FramesImagem2 = await FramesImagem.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (FramesImagem2?.setCliente) {
    await FramesImagem2.setCliente(relatedCliente2);
  }
}

async function associateGemeosDigitaiWithInspecao() {
  const relatedInspecao0 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const GemeosDigitai0 = await GemeosDigitais.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (GemeosDigitai0?.setInspecao) {
    await GemeosDigitai0.setInspecao(relatedInspecao0);
  }

  const relatedInspecao1 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const GemeosDigitai1 = await GemeosDigitais.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (GemeosDigitai1?.setInspecao) {
    await GemeosDigitai1.setInspecao(relatedInspecao1);
  }

  const relatedInspecao2 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const GemeosDigitai2 = await GemeosDigitais.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (GemeosDigitai2?.setInspecao) {
    await GemeosDigitai2.setInspecao(relatedInspecao2);
  }
}

async function associateGemeosDigitaiWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const GemeosDigitai0 = await GemeosDigitais.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (GemeosDigitai0?.setCliente) {
    await GemeosDigitai0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const GemeosDigitai1 = await GemeosDigitais.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (GemeosDigitai1?.setCliente) {
    await GemeosDigitai1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const GemeosDigitai2 = await GemeosDigitais.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (GemeosDigitai2?.setCliente) {
    await GemeosDigitai2.setCliente(relatedCliente2);
  }
}

async function associateHistoricoAlteracoesProjetoWithEstrutura() {
  const relatedEstrutura0 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const HistoricoAlteracoesProjeto0 = await HistoricoAlteracoesProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (HistoricoAlteracoesProjeto0?.setEstrutura) {
    await HistoricoAlteracoesProjeto0.setEstrutura(relatedEstrutura0);
  }

  const relatedEstrutura1 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const HistoricoAlteracoesProjeto1 = await HistoricoAlteracoesProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (HistoricoAlteracoesProjeto1?.setEstrutura) {
    await HistoricoAlteracoesProjeto1.setEstrutura(relatedEstrutura1);
  }

  const relatedEstrutura2 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const HistoricoAlteracoesProjeto2 = await HistoricoAlteracoesProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (HistoricoAlteracoesProjeto2?.setEstrutura) {
    await HistoricoAlteracoesProjeto2.setEstrutura(relatedEstrutura2);
  }
}

async function associateHistoricoAlteracoesProjetoWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const HistoricoAlteracoesProjeto0 = await HistoricoAlteracoesProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (HistoricoAlteracoesProjeto0?.setCliente) {
    await HistoricoAlteracoesProjeto0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const HistoricoAlteracoesProjeto1 = await HistoricoAlteracoesProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (HistoricoAlteracoesProjeto1?.setCliente) {
    await HistoricoAlteracoesProjeto1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const HistoricoAlteracoesProjeto2 = await HistoricoAlteracoesProjeto.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (HistoricoAlteracoesProjeto2?.setCliente) {
    await HistoricoAlteracoesProjeto2.setCliente(relatedCliente2);
  }
}

async function associateInspecaoAereaWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const InspecaoAerea0 = await InspecaoAerea.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (InspecaoAerea0?.setObra) {
    await InspecaoAerea0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const InspecaoAerea1 = await InspecaoAerea.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (InspecaoAerea1?.setObra) {
    await InspecaoAerea1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const InspecaoAerea2 = await InspecaoAerea.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (InspecaoAerea2?.setObra) {
    await InspecaoAerea2.setObra(relatedObra2);
  }
}

async function associateInspecaoAereaWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const InspecaoAerea0 = await InspecaoAerea.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (InspecaoAerea0?.setCliente) {
    await InspecaoAerea0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const InspecaoAerea1 = await InspecaoAerea.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (InspecaoAerea1?.setCliente) {
    await InspecaoAerea1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const InspecaoAerea2 = await InspecaoAerea.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (InspecaoAerea2?.setCliente) {
    await InspecaoAerea2.setCliente(relatedCliente2);
  }
}

async function associateMaquinasAtividadeWithEstrutura() {
  const relatedEstrutura0 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const MaquinasAtividade0 = await MaquinasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MaquinasAtividade0?.setEstrutura) {
    await MaquinasAtividade0.setEstrutura(relatedEstrutura0);
  }

  const relatedEstrutura1 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const MaquinasAtividade1 = await MaquinasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MaquinasAtividade1?.setEstrutura) {
    await MaquinasAtividade1.setEstrutura(relatedEstrutura1);
  }

  const relatedEstrutura2 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const MaquinasAtividade2 = await MaquinasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MaquinasAtividade2?.setEstrutura) {
    await MaquinasAtividade2.setEstrutura(relatedEstrutura2);
  }
}

async function associateMaquinasAtividadeWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MaquinasAtividade0 = await MaquinasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MaquinasAtividade0?.setCliente) {
    await MaquinasAtividade0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MaquinasAtividade1 = await MaquinasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MaquinasAtividade1?.setCliente) {
    await MaquinasAtividade1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MaquinasAtividade2 = await MaquinasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MaquinasAtividade2?.setCliente) {
    await MaquinasAtividade2.setCliente(relatedCliente2);
  }
}

async function associateMateriaisAtividadeWithEstrutura() {
  const relatedEstrutura0 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const MateriaisAtividade0 = await MateriaisAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MateriaisAtividade0?.setEstrutura) {
    await MateriaisAtividade0.setEstrutura(relatedEstrutura0);
  }

  const relatedEstrutura1 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const MateriaisAtividade1 = await MateriaisAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MateriaisAtividade1?.setEstrutura) {
    await MateriaisAtividade1.setEstrutura(relatedEstrutura1);
  }

  const relatedEstrutura2 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const MateriaisAtividade2 = await MateriaisAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MateriaisAtividade2?.setEstrutura) {
    await MateriaisAtividade2.setEstrutura(relatedEstrutura2);
  }
}

async function associateMateriaisAtividadeWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MateriaisAtividade0 = await MateriaisAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MateriaisAtividade0?.setCliente) {
    await MateriaisAtividade0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MateriaisAtividade1 = await MateriaisAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MateriaisAtividade1?.setCliente) {
    await MateriaisAtividade1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MateriaisAtividade2 = await MateriaisAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MateriaisAtividade2?.setCliente) {
    await MateriaisAtividade2.setCliente(relatedCliente2);
  }
}

async function associateMembrosEquipeWithEquipe() {
  const relatedEquipe0 = await EquipesTrabalho.findOne({
    offset: Math.floor(Math.random() * (await EquipesTrabalho.count())),
  });
  const MembrosEquipe0 = await MembrosEquipe.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MembrosEquipe0?.setEquipe) {
    await MembrosEquipe0.setEquipe(relatedEquipe0);
  }

  const relatedEquipe1 = await EquipesTrabalho.findOne({
    offset: Math.floor(Math.random() * (await EquipesTrabalho.count())),
  });
  const MembrosEquipe1 = await MembrosEquipe.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MembrosEquipe1?.setEquipe) {
    await MembrosEquipe1.setEquipe(relatedEquipe1);
  }

  const relatedEquipe2 = await EquipesTrabalho.findOne({
    offset: Math.floor(Math.random() * (await EquipesTrabalho.count())),
  });
  const MembrosEquipe2 = await MembrosEquipe.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MembrosEquipe2?.setEquipe) {
    await MembrosEquipe2.setEquipe(relatedEquipe2);
  }
}

async function associateMembrosEquipeWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MembrosEquipe0 = await MembrosEquipe.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (MembrosEquipe0?.setCliente) {
    await MembrosEquipe0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MembrosEquipe1 = await MembrosEquipe.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (MembrosEquipe1?.setCliente) {
    await MembrosEquipe1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MembrosEquipe2 = await MembrosEquipe.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (MembrosEquipe2?.setCliente) {
    await MembrosEquipe2.setCliente(relatedCliente2);
  }
}

async function associateMemoriaisDescritivosAsbuiltWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const MemoriaisDescritivosAsbuilt0 =
    await MemoriaisDescritivosAsbuilt.findOne({
      order: [['id', 'ASC']],
      offset: 0,
    });
  if (MemoriaisDescritivosAsbuilt0?.setObra) {
    await MemoriaisDescritivosAsbuilt0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const MemoriaisDescritivosAsbuilt1 =
    await MemoriaisDescritivosAsbuilt.findOne({
      order: [['id', 'ASC']],
      offset: 1,
    });
  if (MemoriaisDescritivosAsbuilt1?.setObra) {
    await MemoriaisDescritivosAsbuilt1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const MemoriaisDescritivosAsbuilt2 =
    await MemoriaisDescritivosAsbuilt.findOne({
      order: [['id', 'ASC']],
      offset: 2,
    });
  if (MemoriaisDescritivosAsbuilt2?.setObra) {
    await MemoriaisDescritivosAsbuilt2.setObra(relatedObra2);
  }
}

async function associateMemoriaisDescritivosAsbuiltWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MemoriaisDescritivosAsbuilt0 =
    await MemoriaisDescritivosAsbuilt.findOne({
      order: [['id', 'ASC']],
      offset: 0,
    });
  if (MemoriaisDescritivosAsbuilt0?.setCliente) {
    await MemoriaisDescritivosAsbuilt0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MemoriaisDescritivosAsbuilt1 =
    await MemoriaisDescritivosAsbuilt.findOne({
      order: [['id', 'ASC']],
      offset: 1,
    });
  if (MemoriaisDescritivosAsbuilt1?.setCliente) {
    await MemoriaisDescritivosAsbuilt1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const MemoriaisDescritivosAsbuilt2 =
    await MemoriaisDescritivosAsbuilt.findOne({
      order: [['id', 'ASC']],
      offset: 2,
    });
  if (MemoriaisDescritivosAsbuilt2?.setCliente) {
    await MemoriaisDescritivosAsbuilt2.setCliente(relatedCliente2);
  }
}

async function associateModelosBimAsbuiltWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const ModelosBimAsbuilt0 = await ModelosBimAsbuilt.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ModelosBimAsbuilt0?.setObra) {
    await ModelosBimAsbuilt0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const ModelosBimAsbuilt1 = await ModelosBimAsbuilt.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ModelosBimAsbuilt1?.setObra) {
    await ModelosBimAsbuilt1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const ModelosBimAsbuilt2 = await ModelosBimAsbuilt.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ModelosBimAsbuilt2?.setObra) {
    await ModelosBimAsbuilt2.setObra(relatedObra2);
  }
}

async function associateModelosBimAsbuiltWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const ModelosBimAsbuilt0 = await ModelosBimAsbuilt.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (ModelosBimAsbuilt0?.setCliente) {
    await ModelosBimAsbuilt0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const ModelosBimAsbuilt1 = await ModelosBimAsbuilt.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (ModelosBimAsbuilt1?.setCliente) {
    await ModelosBimAsbuilt1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const ModelosBimAsbuilt2 = await ModelosBimAsbuilt.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (ModelosBimAsbuilt2?.setCliente) {
    await ModelosBimAsbuilt2.setCliente(relatedCliente2);
  }
}

async function associateObraWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Obra0 = await Obras.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Obra0?.setCliente) {
    await Obra0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Obra1 = await Obras.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Obra1?.setCliente) {
    await Obra1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Obra2 = await Obras.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Obra2?.setCliente) {
    await Obra2.setCliente(relatedCliente2);
  }
}

async function associateObraWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Obra0 = await Obras.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Obra0?.setCliente) {
    await Obra0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Obra1 = await Obras.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Obra1?.setCliente) {
    await Obra1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Obra2 = await Obras.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Obra2?.setCliente) {
    await Obra2.setCliente(relatedCliente2);
  }
}

async function associatePermissoesModuloWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PermissoesModulo0 = await PermissoesModulo.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PermissoesModulo0?.setCliente) {
    await PermissoesModulo0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PermissoesModulo1 = await PermissoesModulo.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PermissoesModulo1?.setCliente) {
    await PermissoesModulo1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PermissoesModulo2 = await PermissoesModulo.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PermissoesModulo2?.setCliente) {
    await PermissoesModulo2.setCliente(relatedCliente2);
  }
}

async function associatePessoasAtividadeWithEstrutura() {
  const relatedEstrutura0 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const PessoasAtividade0 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PessoasAtividade0?.setEstrutura) {
    await PessoasAtividade0.setEstrutura(relatedEstrutura0);
  }

  const relatedEstrutura1 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const PessoasAtividade1 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PessoasAtividade1?.setEstrutura) {
    await PessoasAtividade1.setEstrutura(relatedEstrutura1);
  }

  const relatedEstrutura2 = await EstruturaProjeto.findOne({
    offset: Math.floor(Math.random() * (await EstruturaProjeto.count())),
  });
  const PessoasAtividade2 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PessoasAtividade2?.setEstrutura) {
    await PessoasAtividade2.setEstrutura(relatedEstrutura2);
  }
}

async function associatePessoasAtividadeWithMembro() {
  const relatedMembro0 = await MembrosEquipe.findOne({
    offset: Math.floor(Math.random() * (await MembrosEquipe.count())),
  });
  const PessoasAtividade0 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PessoasAtividade0?.setMembro) {
    await PessoasAtividade0.setMembro(relatedMembro0);
  }

  const relatedMembro1 = await MembrosEquipe.findOne({
    offset: Math.floor(Math.random() * (await MembrosEquipe.count())),
  });
  const PessoasAtividade1 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PessoasAtividade1?.setMembro) {
    await PessoasAtividade1.setMembro(relatedMembro1);
  }

  const relatedMembro2 = await MembrosEquipe.findOne({
    offset: Math.floor(Math.random() * (await MembrosEquipe.count())),
  });
  const PessoasAtividade2 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PessoasAtividade2?.setMembro) {
    await PessoasAtividade2.setMembro(relatedMembro2);
  }
}

async function associatePessoasAtividadeWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PessoasAtividade0 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PessoasAtividade0?.setCliente) {
    await PessoasAtividade0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PessoasAtividade1 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PessoasAtividade1?.setCliente) {
    await PessoasAtividade1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PessoasAtividade2 = await PessoasAtividade.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PessoasAtividade2?.setCliente) {
    await PessoasAtividade2.setCliente(relatedCliente2);
  }
}

async function associatePessoasFrameWithFrame() {
  const relatedFrame0 = await FramesImagem.findOne({
    offset: Math.floor(Math.random() * (await FramesImagem.count())),
  });
  const PessoasFrame0 = await PessoasFrame.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PessoasFrame0?.setFrame) {
    await PessoasFrame0.setFrame(relatedFrame0);
  }

  const relatedFrame1 = await FramesImagem.findOne({
    offset: Math.floor(Math.random() * (await FramesImagem.count())),
  });
  const PessoasFrame1 = await PessoasFrame.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PessoasFrame1?.setFrame) {
    await PessoasFrame1.setFrame(relatedFrame1);
  }

  const relatedFrame2 = await FramesImagem.findOne({
    offset: Math.floor(Math.random() * (await FramesImagem.count())),
  });
  const PessoasFrame2 = await PessoasFrame.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PessoasFrame2?.setFrame) {
    await PessoasFrame2.setFrame(relatedFrame2);
  }
}

async function associatePessoasFrameWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PessoasFrame0 = await PessoasFrame.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PessoasFrame0?.setCliente) {
    await PessoasFrame0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PessoasFrame1 = await PessoasFrame.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PessoasFrame1?.setCliente) {
    await PessoasFrame1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PessoasFrame2 = await PessoasFrame.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PessoasFrame2?.setCliente) {
    await PessoasFrame2.setCliente(relatedCliente2);
  }
}

async function associatePlantasAsbuilt2dWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const PlantasAsbuilt2d0 = await PlantasAsbuilt2d.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PlantasAsbuilt2d0?.setObra) {
    await PlantasAsbuilt2d0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const PlantasAsbuilt2d1 = await PlantasAsbuilt2d.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PlantasAsbuilt2d1?.setObra) {
    await PlantasAsbuilt2d1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const PlantasAsbuilt2d2 = await PlantasAsbuilt2d.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PlantasAsbuilt2d2?.setObra) {
    await PlantasAsbuilt2d2.setObra(relatedObra2);
  }
}

async function associatePlantasAsbuilt2dWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PlantasAsbuilt2d0 = await PlantasAsbuilt2d.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (PlantasAsbuilt2d0?.setCliente) {
    await PlantasAsbuilt2d0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PlantasAsbuilt2d1 = await PlantasAsbuilt2d.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (PlantasAsbuilt2d1?.setCliente) {
    await PlantasAsbuilt2d1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const PlantasAsbuilt2d2 = await PlantasAsbuilt2d.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (PlantasAsbuilt2d2?.setCliente) {
    await PlantasAsbuilt2d2.setCliente(relatedCliente2);
  }
}

async function associateRelatorioAndamentoAtualWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatorioAndamentoAtual0 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatorioAndamentoAtual0?.setObra) {
    await RelatorioAndamentoAtual0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatorioAndamentoAtual1 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatorioAndamentoAtual1?.setObra) {
    await RelatorioAndamentoAtual1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatorioAndamentoAtual2 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatorioAndamentoAtual2?.setObra) {
    await RelatorioAndamentoAtual2.setObra(relatedObra2);
  }
}

async function associateRelatorioAndamentoAtualWithUltimo_relatorio_video() {
  const relatedUltimo_relatorio_video0 =
    await RelatoriosAnaliticosVideo.findOne({
      offset: Math.floor(
        Math.random() * (await RelatoriosAnaliticosVideo.count()),
      ),
    });
  const RelatorioAndamentoAtual0 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatorioAndamentoAtual0?.setUltimo_relatorio_video) {
    await RelatorioAndamentoAtual0.setUltimo_relatorio_video(
      relatedUltimo_relatorio_video0,
    );
  }

  const relatedUltimo_relatorio_video1 =
    await RelatoriosAnaliticosVideo.findOne({
      offset: Math.floor(
        Math.random() * (await RelatoriosAnaliticosVideo.count()),
      ),
    });
  const RelatorioAndamentoAtual1 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatorioAndamentoAtual1?.setUltimo_relatorio_video) {
    await RelatorioAndamentoAtual1.setUltimo_relatorio_video(
      relatedUltimo_relatorio_video1,
    );
  }

  const relatedUltimo_relatorio_video2 =
    await RelatoriosAnaliticosVideo.findOne({
      offset: Math.floor(
        Math.random() * (await RelatoriosAnaliticosVideo.count()),
      ),
    });
  const RelatorioAndamentoAtual2 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatorioAndamentoAtual2?.setUltimo_relatorio_video) {
    await RelatorioAndamentoAtual2.setUltimo_relatorio_video(
      relatedUltimo_relatorio_video2,
    );
  }
}

async function associateRelatorioAndamentoAtualWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatorioAndamentoAtual0 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatorioAndamentoAtual0?.setCliente) {
    await RelatorioAndamentoAtual0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatorioAndamentoAtual1 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatorioAndamentoAtual1?.setCliente) {
    await RelatorioAndamentoAtual1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatorioAndamentoAtual2 = await RelatorioAndamentoAtual.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatorioAndamentoAtual2?.setCliente) {
    await RelatorioAndamentoAtual2.setCliente(relatedCliente2);
  }
}

async function associateRelatoriosAnaliticosVideoWithInspecao() {
  const relatedInspecao0 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const RelatoriosAnaliticosVideo0 = await RelatoriosAnaliticosVideo.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosAnaliticosVideo0?.setInspecao) {
    await RelatoriosAnaliticosVideo0.setInspecao(relatedInspecao0);
  }

  const relatedInspecao1 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const RelatoriosAnaliticosVideo1 = await RelatoriosAnaliticosVideo.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosAnaliticosVideo1?.setInspecao) {
    await RelatoriosAnaliticosVideo1.setInspecao(relatedInspecao1);
  }

  const relatedInspecao2 = await InspecaoAerea.findOne({
    offset: Math.floor(Math.random() * (await InspecaoAerea.count())),
  });
  const RelatoriosAnaliticosVideo2 = await RelatoriosAnaliticosVideo.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosAnaliticosVideo2?.setInspecao) {
    await RelatoriosAnaliticosVideo2.setInspecao(relatedInspecao2);
  }
}

async function associateRelatoriosAnaliticosVideoWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosAnaliticosVideo0 = await RelatoriosAnaliticosVideo.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosAnaliticosVideo0?.setCliente) {
    await RelatoriosAnaliticosVideo0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosAnaliticosVideo1 = await RelatoriosAnaliticosVideo.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosAnaliticosVideo1?.setCliente) {
    await RelatoriosAnaliticosVideo1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosAnaliticosVideo2 = await RelatoriosAnaliticosVideo.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosAnaliticosVideo2?.setCliente) {
    await RelatoriosAnaliticosVideo2.setCliente(relatedCliente2);
  }
}

async function associateRelatoriosDiarioWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosDiario0 = await RelatoriosDiarios.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosDiario0?.setObra) {
    await RelatoriosDiario0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosDiario1 = await RelatoriosDiarios.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosDiario1?.setObra) {
    await RelatoriosDiario1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosDiario2 = await RelatoriosDiarios.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosDiario2?.setObra) {
    await RelatoriosDiario2.setObra(relatedObra2);
  }
}

async function associateRelatoriosDiarioWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosDiario0 = await RelatoriosDiarios.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosDiario0?.setCliente) {
    await RelatoriosDiario0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosDiario1 = await RelatoriosDiarios.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosDiario1?.setCliente) {
    await RelatoriosDiario1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosDiario2 = await RelatoriosDiarios.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosDiario2?.setCliente) {
    await RelatoriosDiario2.setCliente(relatedCliente2);
  }
}

async function associateRelatoriosMensaiWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosMensai0 = await RelatoriosMensais.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosMensai0?.setObra) {
    await RelatoriosMensai0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosMensai1 = await RelatoriosMensais.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosMensai1?.setObra) {
    await RelatoriosMensai1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosMensai2 = await RelatoriosMensais.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosMensai2?.setObra) {
    await RelatoriosMensai2.setObra(relatedObra2);
  }
}

async function associateRelatoriosMensaiWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosMensai0 = await RelatoriosMensais.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosMensai0?.setCliente) {
    await RelatoriosMensai0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosMensai1 = await RelatoriosMensais.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosMensai1?.setCliente) {
    await RelatoriosMensai1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosMensai2 = await RelatoriosMensais.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosMensai2?.setCliente) {
    await RelatoriosMensai2.setCliente(relatedCliente2);
  }
}

async function associateRelatoriosSemanaiWithObra() {
  const relatedObra0 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosSemanai0 = await RelatoriosSemanais.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosSemanai0?.setObra) {
    await RelatoriosSemanai0.setObra(relatedObra0);
  }

  const relatedObra1 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosSemanai1 = await RelatoriosSemanais.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosSemanai1?.setObra) {
    await RelatoriosSemanai1.setObra(relatedObra1);
  }

  const relatedObra2 = await Obras.findOne({
    offset: Math.floor(Math.random() * (await Obras.count())),
  });
  const RelatoriosSemanai2 = await RelatoriosSemanais.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosSemanai2?.setObra) {
    await RelatoriosSemanai2.setObra(relatedObra2);
  }
}

async function associateRelatoriosSemanaiWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosSemanai0 = await RelatoriosSemanais.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (RelatoriosSemanai0?.setCliente) {
    await RelatoriosSemanai0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosSemanai1 = await RelatoriosSemanais.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (RelatoriosSemanai1?.setCliente) {
    await RelatoriosSemanai1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const RelatoriosSemanai2 = await RelatoriosSemanais.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (RelatoriosSemanai2?.setCliente) {
    await RelatoriosSemanai2.setCliente(relatedCliente2);
  }
}

async function associateSubcontratadaWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Subcontratada0 = await Subcontratadas.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Subcontratada0?.setCliente) {
    await Subcontratada0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Subcontratada1 = await Subcontratadas.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Subcontratada1?.setCliente) {
    await Subcontratada1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Subcontratada2 = await Subcontratadas.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Subcontratada2?.setCliente) {
    await Subcontratada2.setCliente(relatedCliente2);
  }
}

async function associateUsuarioWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Usuario0 = await Usuarios.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Usuario0?.setCliente) {
    await Usuario0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Usuario1 = await Usuarios.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Usuario1?.setCliente) {
    await Usuario1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Usuario2 = await Usuarios.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Usuario2?.setCliente) {
    await Usuario2.setCliente(relatedCliente2);
  }
}

async function associateUsuarioWithCliente() {
  const relatedCliente0 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Usuario0 = await Usuarios.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Usuario0?.setCliente) {
    await Usuario0.setCliente(relatedCliente0);
  }

  const relatedCliente1 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Usuario1 = await Usuarios.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Usuario1?.setCliente) {
    await Usuario1.setCliente(relatedCliente1);
  }

  const relatedCliente2 = await Clientes.findOne({
    offset: Math.floor(Math.random() * (await Clientes.count())),
  });
  const Usuario2 = await Usuarios.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Usuario2?.setCliente) {
    await Usuario2.setCliente(relatedCliente2);
  }
}

module.exports = {
  up: async (queryInterface, Sequelize) => {
    await CamerasPtz.bulkCreate(CamerasPtzData);

    await Epcs.bulkCreate(EpcsData);

    await Epis.bulkCreate(EpisData);

    await EquipesTrabalho.bulkCreate(EquipesTrabalhoData);

    await EstruturaProjeto.bulkCreate(EstruturaProjetoData);

    await EtapasOuTrechos.bulkCreate(EtapasOuTrechosData);

    await FramesImagem.bulkCreate(FramesImagemData);

    await GemeosDigitais.bulkCreate(GemeosDigitaisData);

    await HistoricoAlteracoesProjeto.bulkCreate(HistoricoAlteracoesProjetoData);

    await InspecaoAerea.bulkCreate(InspecaoAereaData);

    await MaquinasAtividade.bulkCreate(MaquinasAtividadeData);

    await MateriaisAtividade.bulkCreate(MateriaisAtividadeData);

    await MembrosEquipe.bulkCreate(MembrosEquipeData);

    await MemoriaisDescritivosAsbuilt.bulkCreate(
      MemoriaisDescritivosAsbuiltData,
    );

    await ModelosBimAsbuilt.bulkCreate(ModelosBimAsbuiltData);

    await Obras.bulkCreate(ObrasData);

    await PermissoesModulo.bulkCreate(PermissoesModuloData);

    await PessoasAtividade.bulkCreate(PessoasAtividadeData);

    await PessoasFrame.bulkCreate(PessoasFrameData);

    await PlantasAsbuilt2d.bulkCreate(PlantasAsbuilt2dData);

    await RelatorioAndamentoAtual.bulkCreate(RelatorioAndamentoAtualData);

    await RelatoriosAnaliticosVideo.bulkCreate(RelatoriosAnaliticosVideoData);

    await RelatoriosDiarios.bulkCreate(RelatoriosDiariosData);

    await RelatoriosMensais.bulkCreate(RelatoriosMensaisData);

    await RelatoriosSemanais.bulkCreate(RelatoriosSemanaisData);

    await Subcontratadas.bulkCreate(SubcontratadasData);

    await Usuarios.bulkCreate(UsuariosData);

    await Clientes.bulkCreate(ClientesData);

    await Promise.all([
      // Similar logic for "relation_many"

      await associateUserWithCliente(),

      await associateCamerasPtzWithObra(),

      await associateCamerasPtzWithCliente(),

      await associateEpcWithCliente(),

      await associateEpiWithCliente(),

      await associateEquipesTrabalhoWithObra(),

      await associateEquipesTrabalhoWithCliente(),

      await associateEstruturaProjetoWithObra(),

      await associateEstruturaProjetoWithCliente(),

      await associateEtapasOuTrechoWithObra(),

      await associateEtapasOuTrechoWithCliente(),

      await associateFramesImagemWithInspecao(),

      await associateFramesImagemWithCliente(),

      await associateGemeosDigitaiWithInspecao(),

      await associateGemeosDigitaiWithCliente(),

      await associateHistoricoAlteracoesProjetoWithEstrutura(),

      await associateHistoricoAlteracoesProjetoWithCliente(),

      await associateInspecaoAereaWithObra(),

      await associateInspecaoAereaWithCliente(),

      await associateMaquinasAtividadeWithEstrutura(),

      await associateMaquinasAtividadeWithCliente(),

      await associateMateriaisAtividadeWithEstrutura(),

      await associateMateriaisAtividadeWithCliente(),

      await associateMembrosEquipeWithEquipe(),

      await associateMembrosEquipeWithCliente(),

      await associateMemoriaisDescritivosAsbuiltWithObra(),

      await associateMemoriaisDescritivosAsbuiltWithCliente(),

      await associateModelosBimAsbuiltWithObra(),

      await associateModelosBimAsbuiltWithCliente(),

      await associateObraWithCliente(),

      await associateObraWithCliente(),

      await associatePermissoesModuloWithCliente(),

      await associatePessoasAtividadeWithEstrutura(),

      await associatePessoasAtividadeWithMembro(),

      await associatePessoasAtividadeWithCliente(),

      await associatePessoasFrameWithFrame(),

      await associatePessoasFrameWithCliente(),

      await associatePlantasAsbuilt2dWithObra(),

      await associatePlantasAsbuilt2dWithCliente(),

      await associateRelatorioAndamentoAtualWithObra(),

      await associateRelatorioAndamentoAtualWithUltimo_relatorio_video(),

      await associateRelatorioAndamentoAtualWithCliente(),

      await associateRelatoriosAnaliticosVideoWithInspecao(),

      await associateRelatoriosAnaliticosVideoWithCliente(),

      await associateRelatoriosDiarioWithObra(),

      await associateRelatoriosDiarioWithCliente(),

      await associateRelatoriosMensaiWithObra(),

      await associateRelatoriosMensaiWithCliente(),

      await associateRelatoriosSemanaiWithObra(),

      await associateRelatoriosSemanaiWithCliente(),

      await associateSubcontratadaWithCliente(),

      await associateUsuarioWithCliente(),

      await associateUsuarioWithCliente(),
    ]);
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.bulkDelete('cameras_ptz', null, {});

    await queryInterface.bulkDelete('epcs', null, {});

    await queryInterface.bulkDelete('epis', null, {});

    await queryInterface.bulkDelete('equipes_trabalho', null, {});

    await queryInterface.bulkDelete('estrutura_projeto', null, {});

    await queryInterface.bulkDelete('etapas_ou_trechos', null, {});

    await queryInterface.bulkDelete('frames_imagem', null, {});

    await queryInterface.bulkDelete('gemeos_digitais', null, {});

    await queryInterface.bulkDelete('historico_alteracoes_projeto', null, {});

    await queryInterface.bulkDelete('inspecao_aerea', null, {});

    await queryInterface.bulkDelete('maquinas_atividade', null, {});

    await queryInterface.bulkDelete('materiais_atividade', null, {});

    await queryInterface.bulkDelete('membros_equipe', null, {});

    await queryInterface.bulkDelete('memoriais_descritivos_asbuilt', null, {});

    await queryInterface.bulkDelete('modelos_bim_asbuilt', null, {});

    await queryInterface.bulkDelete('obras', null, {});

    await queryInterface.bulkDelete('permissoes_modulo', null, {});

    await queryInterface.bulkDelete('pessoas_atividade', null, {});

    await queryInterface.bulkDelete('pessoas_frame', null, {});

    await queryInterface.bulkDelete('plantas_asbuilt_2d', null, {});

    await queryInterface.bulkDelete('relatorio_andamento_atual', null, {});

    await queryInterface.bulkDelete('relatorios_analiticos_video', null, {});

    await queryInterface.bulkDelete('relatorios_diarios', null, {});

    await queryInterface.bulkDelete('relatorios_mensais', null, {});

    await queryInterface.bulkDelete('relatorios_semanais', null, {});

    await queryInterface.bulkDelete('subcontratadas', null, {});

    await queryInterface.bulkDelete('usuarios', null, {});

    await queryInterface.bulkDelete('clientes', null, {});
  },
};
