module.exports = {
  /**
   * @param {QueryInterface} queryInterface
   * @param {Sequelize} Sequelize
   * @returns {Promise<void>}
   */
  async up(queryInterface, Sequelize) {
    /**
     * @type {Transaction}
     */
    const transaction = await queryInterface.sequelize.transaction();
    try {
      await queryInterface.createTable(
        'users',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'activities',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'attachments',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'clients',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'deals',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'leads',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'notes',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'organizations',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'products',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'roles',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'permissions',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.createTable(
        'organização',
        {
          id: {
            type: Sequelize.DataTypes.UUID,
            defaultValue: Sequelize.DataTypes.UUIDV4,
            primaryKey: true,
          },
          createdById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          updatedById: {
            type: Sequelize.DataTypes.UUID,
            references: {
              key: 'id',
              model: 'users',
            },
          },
          createdAt: { type: Sequelize.DataTypes.DATE },
          updatedAt: { type: Sequelize.DataTypes.DATE },
          deletedAt: { type: Sequelize.DataTypes.DATE },
          importHash: {
            type: Sequelize.DataTypes.STRING(255),
            allowNull: true,
            unique: true,
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'firstName',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'lastName',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'phoneNumber',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'email',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'disabled',
        {
          type: Sequelize.DataTypes.BOOLEAN,

          defaultValue: false,
          allowNull: false,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'password',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'emailVerified',
        {
          type: Sequelize.DataTypes.BOOLEAN,

          defaultValue: false,
          allowNull: false,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'emailVerificationToken',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'emailVerificationTokenExpiresAt',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'passwordResetToken',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'passwordResetTokenExpiresAt',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'provider',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'dealId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'deals',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'type',
        {
          type: Sequelize.DataTypes.ENUM,

          values: ['VISITA', 'MEETING', 'WHATSAPP', 'LIGACAO', 'PROPOSTA'],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'title',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'detailed_description',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'action_datetime',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'duration',
        {
          type: Sequelize.DataTypes.INTEGER,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'outcome',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'next_steps',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'responsible_sellerId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'users',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'activities',
        'location',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'activityId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'activities',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'file_name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'file_type',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'file_url',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'size',
        {
          type: Sequelize.DataTypes.DECIMAL,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'upload_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'attachments',
        'uploaded_byId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'users',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'type',
        {
          type: Sequelize.DataTypes.ENUM,

          values: [
            'Prefeitura',
            'GovernoEstadual',
            'GovernoFederal',
            'Entidade',
            'Conselho',
            'Empresa',
          ],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'cnpj_cpf',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'primary_email',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'primary_phone',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'full_address',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'city',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'state',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'postal_code',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'contact_person',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'registration_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'last_interaction_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'status',
        {
          type: Sequelize.DataTypes.ENUM,

          values: ['active', 'inactive'],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'responsible_sellerId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'users',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'notes',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'contract_end_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'current_contract_value',
        {
          type: Sequelize.DataTypes.DECIMAL,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'clients',
        'custom_fields',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'deal_name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'client_leadId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'clients',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'offered_productId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'products',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'responsible_sellerId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'users',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'current_phase',
        {
          type: Sequelize.DataTypes.ENUM,

          values: [
            'LEAD',
            'APRESENTAÇÃO',
            'PROPOSTA',
            'FOLLOWUP',
            'ORÇAMENTO',
            'PRELANÇAMENTO',
            'LANÇADO',
            'GANHO',
            'RECURSO',
            'CONCORRENTE',
          ],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'proposal_value',
        {
          type: Sequelize.DataTypes.DECIMAL,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'last_modified',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'phase_entry_dates',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'closure_probability',
        {
          type: Sequelize.DataTypes.INTEGER,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'expected_closure_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'status',
        {
          type: Sequelize.DataTypes.ENUM,

          values: ['active', 'won', 'lost', 'paused'],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'loss_pause_reason',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'latitude',
        {
          type: Sequelize.DataTypes.DECIMAL,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'longitude',
        {
          type: Sequelize.DataTypes.DECIMAL,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'deal_address',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'general_notes',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'competitor_name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'competitor_contract_end_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'deals',
        'custom_fields',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'type',
        {
          type: Sequelize.DataTypes.ENUM,

          values: [
            'Prefeitura',
            'GovernoEstadual',
            'GovernoFederal',
            'Entidade',
            'Conselho',
            'Empresa',
          ],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'email',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'phone',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'city',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'state',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'lead_source',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'registration_date',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'status',
        {
          type: Sequelize.DataTypes.ENUM,

          values: ['active', 'converted', 'discarded'],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'responsible_sellerId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'users',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'notes',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'score',
        {
          type: Sequelize.DataTypes.INTEGER,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'last_contact',
        {
          type: Sequelize.DataTypes.DATE,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'leads',
        'custom_fields',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'notes',
        'dealId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'deals',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'notes',
        'clientId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'clients',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'notes',
        'content',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'notes',
        'sellerId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'users',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'notes',
        'type',
        {
          type: Sequelize.DataTypes.ENUM,

          values: ['general', 'important', 'reminder'],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'notes',
        'color_category',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'organizations',
        'name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'organizations',
        'description',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'products',
        'product_name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'products',
        'description',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'products',
        'category',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'products',
        'base_price',
        {
          type: Sequelize.DataTypes.DECIMAL,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'products',
        'status',
        {
          type: Sequelize.DataTypes.ENUM,

          values: ['active', 'inactive'],
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'permissions',
        'name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'roles',
        'name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'roles',
        'role_customization',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'users',
        'app_roleId',
        {
          type: Sequelize.DataTypes.UUID,

          references: {
            model: 'roles',
            key: 'id',
          },
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'organização',
        'name',
        {
          type: Sequelize.DataTypes.TEXT,
        },
        { transaction },
      );

      await queryInterface.addColumn(
        'roles',
        'globalAccess',
        {
          type: Sequelize.DataTypes.BOOLEAN,

          defaultValue: false,
          allowNull: false,
        },
        { transaction },
      );

      await transaction.commit();
    } catch (err) {
      await transaction.rollback();
      throw err;
    }
  },
  /**
   * @param {QueryInterface} queryInterface
   * @param {Sequelize} Sequelize
   * @returns {Promise<void>}
   */
  async down(queryInterface, Sequelize) {
    /**
     * @type {Transaction}
     */
    const transaction = await queryInterface.sequelize.transaction();
    try {
      await queryInterface.removeColumn('roles', 'globalAccess', {
        transaction,
      });

      await queryInterface.removeColumn('organização', 'name', { transaction });

      await queryInterface.removeColumn('users', 'app_roleId', { transaction });

      await queryInterface.removeColumn('roles', 'role_customization', {
        transaction,
      });

      await queryInterface.removeColumn('roles', 'name', { transaction });

      await queryInterface.removeColumn('permissions', 'name', { transaction });

      await queryInterface.removeColumn('products', 'status', { transaction });

      await queryInterface.removeColumn('products', 'base_price', {
        transaction,
      });

      await queryInterface.removeColumn('products', 'category', {
        transaction,
      });

      await queryInterface.removeColumn('products', 'description', {
        transaction,
      });

      await queryInterface.removeColumn('products', 'product_name', {
        transaction,
      });

      await queryInterface.removeColumn('organizations', 'description', {
        transaction,
      });

      await queryInterface.removeColumn('organizations', 'name', {
        transaction,
      });

      await queryInterface.removeColumn('notes', 'color_category', {
        transaction,
      });

      await queryInterface.removeColumn('notes', 'type', { transaction });

      await queryInterface.removeColumn('notes', 'sellerId', { transaction });

      await queryInterface.removeColumn('notes', 'content', { transaction });

      await queryInterface.removeColumn('notes', 'clientId', { transaction });

      await queryInterface.removeColumn('notes', 'dealId', { transaction });

      await queryInterface.removeColumn('leads', 'custom_fields', {
        transaction,
      });

      await queryInterface.removeColumn('leads', 'last_contact', {
        transaction,
      });

      await queryInterface.removeColumn('leads', 'score', { transaction });

      await queryInterface.removeColumn('leads', 'notes', { transaction });

      await queryInterface.removeColumn('leads', 'responsible_sellerId', {
        transaction,
      });

      await queryInterface.removeColumn('leads', 'status', { transaction });

      await queryInterface.removeColumn('leads', 'registration_date', {
        transaction,
      });

      await queryInterface.removeColumn('leads', 'lead_source', {
        transaction,
      });

      await queryInterface.removeColumn('leads', 'state', { transaction });

      await queryInterface.removeColumn('leads', 'city', { transaction });

      await queryInterface.removeColumn('leads', 'phone', { transaction });

      await queryInterface.removeColumn('leads', 'email', { transaction });

      await queryInterface.removeColumn('leads', 'type', { transaction });

      await queryInterface.removeColumn('leads', 'name', { transaction });

      await queryInterface.removeColumn('deals', 'custom_fields', {
        transaction,
      });

      await queryInterface.removeColumn(
        'deals',
        'competitor_contract_end_date',
        { transaction },
      );

      await queryInterface.removeColumn('deals', 'competitor_name', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'general_notes', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'deal_address', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'longitude', { transaction });

      await queryInterface.removeColumn('deals', 'latitude', { transaction });

      await queryInterface.removeColumn('deals', 'loss_pause_reason', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'status', { transaction });

      await queryInterface.removeColumn('deals', 'expected_closure_date', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'closure_probability', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'phase_entry_dates', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'last_modified', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'proposal_value', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'current_phase', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'responsible_sellerId', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'offered_productId', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'client_leadId', {
        transaction,
      });

      await queryInterface.removeColumn('deals', 'deal_name', { transaction });

      await queryInterface.removeColumn('clients', 'custom_fields', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'current_contract_value', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'contract_end_date', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'notes', { transaction });

      await queryInterface.removeColumn('clients', 'responsible_sellerId', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'status', { transaction });

      await queryInterface.removeColumn('clients', 'last_interaction_date', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'registration_date', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'contact_person', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'postal_code', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'state', { transaction });

      await queryInterface.removeColumn('clients', 'city', { transaction });

      await queryInterface.removeColumn('clients', 'full_address', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'primary_phone', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'primary_email', {
        transaction,
      });

      await queryInterface.removeColumn('clients', 'cnpj_cpf', { transaction });

      await queryInterface.removeColumn('clients', 'type', { transaction });

      await queryInterface.removeColumn('clients', 'name', { transaction });

      await queryInterface.removeColumn('attachments', 'uploaded_byId', {
        transaction,
      });

      await queryInterface.removeColumn('attachments', 'upload_date', {
        transaction,
      });

      await queryInterface.removeColumn('attachments', 'size', { transaction });

      await queryInterface.removeColumn('attachments', 'file_url', {
        transaction,
      });

      await queryInterface.removeColumn('attachments', 'file_type', {
        transaction,
      });

      await queryInterface.removeColumn('attachments', 'file_name', {
        transaction,
      });

      await queryInterface.removeColumn('attachments', 'activityId', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'location', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'responsible_sellerId', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'next_steps', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'outcome', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'duration', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'action_datetime', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'detailed_description', {
        transaction,
      });

      await queryInterface.removeColumn('activities', 'title', { transaction });

      await queryInterface.removeColumn('activities', 'type', { transaction });

      await queryInterface.removeColumn('activities', 'dealId', {
        transaction,
      });

      await queryInterface.removeColumn('users', 'provider', { transaction });

      await queryInterface.removeColumn(
        'users',
        'passwordResetTokenExpiresAt',
        { transaction },
      );

      await queryInterface.removeColumn('users', 'passwordResetToken', {
        transaction,
      });

      await queryInterface.removeColumn(
        'users',
        'emailVerificationTokenExpiresAt',
        { transaction },
      );

      await queryInterface.removeColumn('users', 'emailVerificationToken', {
        transaction,
      });

      await queryInterface.removeColumn('users', 'emailVerified', {
        transaction,
      });

      await queryInterface.removeColumn('users', 'password', { transaction });

      await queryInterface.removeColumn('users', 'disabled', { transaction });

      await queryInterface.removeColumn('users', 'email', { transaction });

      await queryInterface.removeColumn('users', 'phoneNumber', {
        transaction,
      });

      await queryInterface.removeColumn('users', 'lastName', { transaction });

      await queryInterface.removeColumn('users', 'firstName', { transaction });

      await queryInterface.dropTable('organização', { transaction });

      await queryInterface.dropTable('permissions', { transaction });

      await queryInterface.dropTable('roles', { transaction });

      await queryInterface.dropTable('products', { transaction });

      await queryInterface.dropTable('organizations', { transaction });

      await queryInterface.dropTable('notes', { transaction });

      await queryInterface.dropTable('leads', { transaction });

      await queryInterface.dropTable('deals', { transaction });

      await queryInterface.dropTable('clients', { transaction });

      await queryInterface.dropTable('attachments', { transaction });

      await queryInterface.dropTable('activities', { transaction });

      await queryInterface.dropTable('users', { transaction });

      await transaction.commit();
    } catch (err) {
      await transaction.rollback();
      throw err;
    }
  },
};