TFS_ANTIGUO/SInCathay/ULA.Cathay.CreditoModel/Credito/CreditoContex.cs

namespace ULA.Cathay.CreditoModel.Credito
{
    using System;
    using System.Data.Entity;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Linq;

    public partial class CreditoContex : DbContext
    {
        public CreditoContex()
              : base(new Ultimus.Utilitarios.ObtieneParametros().GetValueKeyRegedit("BPMCORPORATIVO", true))
        {
            Configuration.ProxyCreationEnabled = false;
            Configuration.LazyLoadingEnabled = true;
            Database.SetInitializer<CreditoContex>(null);
        }

        public virtual DbSet<AnalisisClienteDocumentos> AnalisisClienteDocumentos { get; set; }
        public virtual DbSet<DatosGeneralesAnalisis> DatosGeneralesAnalisis { get; set; }
        public virtual DbSet<AprobacionesComite> AprobacionesComite { get; set; }
        public virtual DbSet<BitacoraControlAprobacion> BitacoraControlAprobacion { get; set; }
        public virtual DbSet<ComentariosEvaluacionCaso> ComentariosEvaluacionCaso { get; set; }
        public virtual DbSet<ComiteCredito> ComiteCredito { get; set; }
        public virtual DbSet<DecisionPorEtapa> DecisionPorEtapa { get; set; }
        public virtual DbSet<DiferenciaDatosSAPBPM> DiferenciaDatosSAPBPM { get; set; }
        public virtual DbSet<EstadosCaratula> EstadosCaratula { get; set; }
        public virtual DbSet<MiembrosComiteCredito> MiembrosComiteCredito { get; set; }
        public virtual DbSet<RazonesDecision> RazonesDecision { get; set; }
        public virtual DbSet<SecuenciaCaratulaCredito> SecuenciaCaratulaCredito { get; set; }
        public virtual DbSet<Abogados> Abogados { get; set; }
        public virtual DbSet<ActividadEconomica> ActividadEconomica { get; set; }
        public virtual DbSet<Analisis> Analisis { get; set; }
        public virtual DbSet<AreaResponsable> AreaResponsable { get; set; }
        public virtual DbSet<BeneficiarioSBD> BeneficiarioSBD { get; set; }
        public virtual DbSet<Canton> Canton { get; set; }
        public virtual DbSet<CapacidadPago> CapacidadPago { get; set; }
        public virtual DbSet<CategoriaPorClasificacionCliente> CategoriaPorClasificacionCliente { get; set; }
        public virtual DbSet<CategoriaRiesgo> CategoriaRiesgo { get; set; }
        public virtual DbSet<CategoriasPorFacilidad> CategoriasPorFacilidad { get; set; }
        public virtual DbSet<CategoriaTipoDocumento> CategoriaTipoDocumento { get; set; }
        public virtual DbSet<ClaseCIIU> ClaseCIIU { get; set; }
        public virtual DbSet<ClasificacionCliente> ClasificacionCliente { get; set; }
        public virtual DbSet<ClasificacionVentanaCartera> ClasificacionVentanaCartera { get; set; }
        public virtual DbSet<ComportamientoPagoHistorico> ComportamientoPagoHistorico { get; set; }
        public virtual DbSet<CondicionesFormalizacion> CondicionesFormalizacion { get; set; }
        public virtual DbSet<CondicionesGeneralesCredito> CondicionesGeneralesCredito { get; set; }
        public virtual DbSet<CondicionesVarias> CondicionesVarias { get; set; }
        public virtual DbSet<ConfiguracionNotificacion> ConfiguracionNotificacion { get; set; }
        public virtual DbSet<ConsultaCIC> ConsultaCIC { get; set; }
        public virtual DbSet<ConsultaEpower> ConsultaEpower { get; set; }
        public virtual DbSet<CorredoraSeguros> CorredoraSeguros { get; set; }
        public virtual DbSet<Criterio> Criterio { get; set; }
        public virtual DbSet<CriterioSeleccion> CriterioSeleccion { get; set; }
        public virtual DbSet<CuadroVerificacion> CuadroVerificacion { get; set; }
        public virtual DbSet<Cumplimiento> Cumplimiento { get; set; }
        public virtual DbSet<Decision> Decision { get; set; }
        public virtual DbSet<DepartamentoNegocios> DepartamentoNegocios { get; set; }
        public virtual DbSet<Devolucion> Devolucion { get; set; }
        public virtual DbSet<Director> Director { get; set; }
        public virtual DbSet<Distrito> Distrito { get; set; }
        public virtual DbSet<DivisionCIIU> DivisionCIIU { get; set; }
        public virtual DbSet<DocumentosFormalizacion> DocumentosFormalizacion { get; set; }
        public virtual DbSet<DocumentosNotificacion> DocumentosNotificacion { get; set; }
        public virtual DbSet<DocumentosRequeridos> DocumentosRequeridos { get; set; }
        public virtual DbSet<Ejecutivo> Ejecutivo { get; set; }
        public virtual DbSet<EjecutivoAsistente> EjecutivoAsistente { get; set; }
        public virtual DbSet<EstadoBandeja> EstadoBandeja { get; set; }
        public virtual DbSet<EstadoLinea> EstadoLinea { get; set; }
        public virtual DbSet<EstadoOferta> EstadoOferta { get; set; }
        public virtual DbSet<EstructuraOrgChart> EstructuraOrgChart { get; set; }
        public virtual DbSet<Etapas> Etapas { get; set; }
        public virtual DbSet<EventoExpediente> EventoExpediente { get; set; }
        public virtual DbSet<Excepciones> Excepciones { get; set; }
        public virtual DbSet<ExcepcionesClasificacion> ExcepcionesClasificacion { get; set; }
        public virtual DbSet<ExcepcionesClasificacionSubsistencia> ExcepcionesClasificacionSubsistencia { get; set; }
        public virtual DbSet<FormaDesembolso> FormaDesembolso { get; set; }
        public virtual DbSet<FormasPagos> FormasPagos { get; set; }
        public virtual DbSet<Garantia> Garantia { get; set; }
        public virtual DbSet<GeneradorMonedaExt> GeneradorMonedaExt { get; set; }
        public virtual DbSet<GrupoCIIU> GrupoCIIU { get; set; }
        public virtual DbSet<GrupoInteresados> GrupoInteresados { get; set; }
        public virtual DbSet<Inciso> Inciso { get; set; }
        public virtual DbSet<IncisoSugef> IncisoSugef { get; set; }
        public virtual DbSet<IndicesEpower> IndicesEpower { get; set; }
        public virtual DbSet<Institucion> Institucion { get; set; }
        public virtual DbSet<Ley8262> Ley8262 { get; set; }
        public virtual DbSet<MantenimientoCatalogos> MantenimientoCatalogos { get; set; }
        public virtual DbSet<MatrizBeneficiarioSBD> MatrizBeneficiarioSBD { get; set; }
        public virtual DbSet<MatrizOferta> MatrizOferta { get; set; }
        public virtual DbSet<MatrizSeleccion> MatrizSeleccion { get; set; }
        public virtual DbSet<MatrizSeleccionRelacion> MatrizSeleccionRelacion { get; set; }
        public virtual DbSet<Moneda> Moneda { get; set; }
        public virtual DbSet<Morosidad> Morosidad { get; set; }
        public virtual DbSet<Nacionalidad> Nacionalidad { get; set; }
        public virtual DbSet<Notario> Notario { get; set; }
        public virtual DbSet<NotificationType> NotificationType { get; set; }
        public virtual DbSet<ParamCategoriaRiesgo> ParamCategoriaRiesgo { get; set; }
        public virtual DbSet<ParametroConsultaEpower> ParametroConsultaEpower { get; set; }
        public virtual DbSet<ParamKilometraje> ParamKilometraje { get; set; }
        public virtual DbSet<PermisoSBNBCCR> PermisoSBNBCCR { get; set; }
        public virtual DbSet<PlantillaCorreo> PlantillaCorreo { get; set; }
        public virtual DbSet<Procesos> Procesos { get; set; }
        public virtual DbSet<PropiedadDiferenciaDatosSAPBPM> PropiedadDiferenciaDatosSAPBPM { get; set; }
        public virtual DbSet<Provincia> Provincia { get; set; }
        public virtual DbSet<RazonesRechazo> RazonesRechazo { get; set; }
        public virtual DbSet<RequisitoDocumental> RequisitoDocumental { get; set; }
        public virtual DbSet<RiesgoCambiario> RiesgoCambiario { get; set; }
        public virtual DbSet<RolFuncional> RolFuncional { get; set; }
        public virtual DbSet<RolFuncionalEstructuraOrgChart> RolFuncionalEstructuraOrgChart { get; set; }
        public virtual DbSet<SeccionCIIU> SeccionCIIU { get; set; }
        public virtual DbSet<Sector> Sector { get; set; }
        public virtual DbSet<SectorEconomico> SectorEconomico { get; set; }
        public virtual DbSet<SectorSugef> SectorSugef { get; set; }
        public virtual DbSet<Secuencias> Secuencias { get; set; }
        public virtual DbSet<StatusVisita> StatusVisita { get; set; }
        public virtual DbSet<SubIndicesEpower> SubIndicesEpower { get; set; }
        public virtual DbSet<SugefDetalle> SugefDetalle { get; set; }
        public virtual DbSet<SugefGeneral> SugefGeneral { get; set; }
        public virtual DbSet<TiemposEjecucionNotificacionesCompletionTime> TiemposEjecucionNotificacionesCompletionTime { get; set; }
        public virtual DbSet<TipoAprobacion> TipoAprobacion { get; set; }
        public virtual DbSet<TipoCambioCondiciones> TipoCambioCondiciones { get; set; }
        public virtual DbSet<TipoCaratula> TipoCaratula { get; set; }
        public virtual DbSet<TipoCategoria> TipoCategoria { get; set; }
        public virtual DbSet<TipoCliente> TipoCliente { get; set; }
        public virtual DbSet<TipoComentario> TipoComentario { get; set; }
        public virtual DbSet<TipoCondicion> TipoCondicion { get; set; }
        public virtual DbSet<TipoConsultaCliente> TipoConsultaCliente { get; set; }
        public virtual DbSet<TipoConsultaEpower> TipoConsultaEpower { get; set; }
        public virtual DbSet<TipoControlCriterio> TipoControlCriterio { get; set; }
        public virtual DbSet<TipoCuenta> TipoCuenta { get; set; }
        public virtual DbSet<TipoDato> TipoDato { get; set; }
        public virtual DbSet<TipoDeudor> TipoDeudor { get; set; }
        public virtual DbSet<TipoDireccion> TipoDireccion { get; set; }
        public virtual DbSet<TipoDocumento> TipoDocumento { get; set; }
        public virtual DbSet<TipoDocumentoEpower> TipoDocumentoEpower { get; set; }
        public virtual DbSet<TipoEdicion> TipoEdicion { get; set; }
        public virtual DbSet<TipoEmail> TipoEmail { get; set; }
        public virtual DbSet<TipoEstructuraOrgChart> TipoEstructuraOrgChart { get; set; }
        public virtual DbSet<TipoEvento> TipoEvento { get; set; }
        public virtual DbSet<TipoExpediente> TipoExpediente { get; set; }
        public virtual DbSet<TipoExpedienteDocumentos> TipoExpedienteDocumentos { get; set; }
        public virtual DbSet<TipoFacilidad> TipoFacilidad { get; set; }
        public virtual DbSet<TipoFuenteIngreso> TipoFuenteIngreso { get; set; }
        public virtual DbSet<TipoGestion> TipoGestion { get; set; }
        public virtual DbSet<TipoHojaPendiente> TipoHojaPendiente { get; set; }
        public virtual DbSet<TipoIdentificacion> TipoIdentificacion { get; set; }
        public virtual DbSet<TipoInstitucion> TipoInstitucion { get; set; }
        public virtual DbSet<TipoObservacion> TipoObservacion { get; set; }
        public virtual DbSet<TipoRequisito> TipoRequisito { get; set; }
        public virtual DbSet<TipoRolCredito> TipoRolCredito { get; set; }
        public virtual DbSet<TipoSeguimiento> TipoSeguimiento { get; set; }
        public virtual DbSet<TipoSeguimientoCorreo> TipoSeguimientoCorreo { get; set; }
        public virtual DbSet<TipoSeleccion> TipoSeleccion { get; set; }
        public virtual DbSet<TiposMetodologia> TiposMetodologia { get; set; }
        public virtual DbSet<TipoSolicitante> TipoSolicitante { get; set; }
        public virtual DbSet<TipoTasa> TipoTasa { get; set; }
        public virtual DbSet<TipoTelefono> TipoTelefono { get; set; }
        public virtual DbSet<TipoTramite> TipoTramite { get; set; }
        public virtual DbSet<TipoValor> TipoValor { get; set; }
        public virtual DbSet<UbicacionEPower> UbicacionEPower { get; set; }
        public virtual DbSet<VBGerenciaNegocios> VBGerenciaNegocios { get; set; }
        public virtual DbSet<Vehiculo> Vehiculo { get; set; }
        public virtual DbSet<BitacoraComisiones> BitacoraComisiones { get; set; }
        public virtual DbSet<BitacoraGarantias> BitacoraGarantias { get; set; }
        public virtual DbSet<CaratulaCredito> CaratulaCredito { get; set; }
        public virtual DbSet<CaratulaCreditoCondicionesEspeciales> CaratulaCreditoCondicionesEspeciales { get; set; }
        public virtual DbSet<CaratulaCreditoExcepcionesPolitica> CaratulaCreditoExcepcionesPolitica { get; set; }
        public virtual DbSet<Condiciones> Condiciones { get; set; }
        public virtual DbSet<Contacto> Contacto { get; set; }
        public virtual DbSet<DetalleRequisitos> DetalleRequisitos { get; set; }
        public virtual DbSet<Exposicion> Exposicion { get; set; }
        public virtual DbSet<FacturasContratosOrdenes> FacturasContratosOrdenes { get; set; }
        public virtual DbSet<GestionExpediente> GestionExpediente { get; set; }
        public virtual DbSet<Oferta> Oferta { get; set; }
        public virtual DbSet<OfertaFacilidades> OfertaFacilidades { get; set; }
        public virtual DbSet<OfertaFacilidadesComisiones> OfertaFacilidadesComisiones { get; set; }
        public virtual DbSet<OfertaFacilidadesGarantias> OfertaFacilidadesGarantias { get; set; }
        public virtual DbSet<OfertaOperaciones> OfertaOperaciones { get; set; }
        public virtual DbSet<OfertaOperacionesComisiones> OfertaOperacionesComisiones { get; set; }
        public virtual DbSet<OfertaOperacionesGarantias> OfertaOperacionesGarantias { get; set; }
        public virtual DbSet<Sucursal> Sucursal { get; set; }
        public virtual DbSet<VerificacionFacturasContratosOrdenes> VerificacionFacturasContratosOrdenes { get; set; }
        public virtual DbSet<BitacoraValidaCumplimiento> BitacoraValidaCumplimiento { get; set; }
        public virtual DbSet<sysdiagrams> sysdiagrams { get; set; }
        public virtual DbSet<ContactoDE> ContactoDE { get; set; }
        public virtual DbSet<DesemboloDetalleOrdenCompra> DesemboloDetalleOrdenCompra { get; set; }
        public virtual DbSet<DesembolsoDatosGenerales> DesembolsoDatosGenerales { get; set; }
        public virtual DbSet<DesembolsoDetalleAdelantosContraContrato> DesembolsoDetalleAdelantosContraContrato { get; set; }
        public virtual DbSet<DesembolsoFacturas> DesembolsoFacturas { get; set; }
        public virtual DbSet<FacturasContratosOrdenesDE> FacturasContratosOrdenesDE { get; set; }
        public virtual DbSet<VerificacionCondiciones> VerificacionCondiciones { get; set; }
        public virtual DbSet<BitacoraControl> BitacoraControl { get; set; }
        public virtual DbSet<BitacoraHojaPendientes> BitacoraHojaPendientes { get; set; }
        public virtual DbSet<CertificadosMandato> CertificadosMandato { get; set; }
        public virtual DbSet<CondicionesVerificacionFormalizacion> CondicionesVerificacionFormalizacion { get; set; }
        public virtual DbSet<DatosGeneralesFormalizacion> DatosGeneralesFormalizacion { get; set; }
        public virtual DbSet<FomalizacionInfoAdicional_CuentasCartaMisiva> FomalizacionInfoAdicional_CuentasCartaMisiva { get; set; }
        public virtual DbSet<FormaliacionInformacionAdicional> FormaliacionInformacionAdicional { get; set; }
        public virtual DbSet<FormalizacionCondicionesGenerales> FormalizacionCondicionesGenerales { get; set; }
        public virtual DbSet<FormalizacionCondicionesVarias> FormalizacionCondicionesVarias { get; set; }
        public virtual DbSet<FormalizacionConfiguracionDocumentosLegales> FormalizacionConfiguracionDocumentosLegales { get; set; }
        public virtual DbSet<FormalizacionDocumentosLegales> FormalizacionDocumentosLegales { get; set; }
        public virtual DbSet<FormalizacionTipoFacilidades> FormalizacionTipoFacilidades { get; set; }
        public virtual DbSet<VarianteConfiguracionDocumentosLegales> VarianteConfiguracionDocumentosLegales { get; set; }
        public virtual DbSet<FiltroCondicionesMaestro> FiltroCondicionesMaestro { get; set; }
        public virtual DbSet<FiltroParametrosGlobalesMaestro> FiltroParametrosGlobalesMaestro { get; set; }
        public virtual DbSet<MaestroCondicionesProceso> MaestroCondicionesProceso { get; set; }
        public virtual DbSet<ParametrosGlobalesProceso> ParametrosGlobalesProceso { get; set; }
        public virtual DbSet<ReglasCondiciones> ReglasCondiciones { get; set; }
        public virtual DbSet<TipoCondiciones> TipoCondiciones { get; set; }
        public virtual DbSet<TipoDatoParametros> TipoDatoParametros { get; set; }
        public virtual DbSet<TipoEvaluacionCondiciones> TipoEvaluacionCondiciones { get; set; }
        public virtual DbSet<TipoParametrosCondiciones> TipoParametrosCondiciones { get; set; }
        public virtual DbSet<AdjuntoEmailSolicitud> AdjuntoEmailSolicitud { get; set; }
        public virtual DbSet<BitacoraComentariosInternos> BitacoraComentariosInternos { get; set; }
        public virtual DbSet<BitacoraCorreosEtapas> BitacoraCorreosEtapas { get; set; }
        public virtual DbSet<BitacoraDetValidarExcepciones> BitacoraDetValidarExcepciones { get; set; }
        public virtual DbSet<BitacoraDocumentosCliente> BitacoraDocumentosCliente { get; set; }
        public virtual DbSet<BitacoraDocumentosFormalizacion> BitacoraDocumentosFormalizacion { get; set; }
        public virtual DbSet<BitacoraDocumentosInformeAnalisis> BitacoraDocumentosInformeAnalisis { get; set; }
        public virtual DbSet<BitacoraDocumentosIngresoCliente> BitacoraDocumentosIngresoCliente { get; set; }
        public virtual DbSet<BitacoraDocumentosSeguimientoAnalisis> BitacoraDocumentosSeguimientoAnalisis { get; set; }
        public virtual DbSet<BitacoraEncValidarExcepciones> BitacoraEncValidarExcepciones { get; set; }
        public virtual DbSet<BitacoraSeguimientoCorreo> BitacoraSeguimientoCorreo { get; set; }
        public virtual DbSet<ClasificacionDocumentosAdjuntos> ClasificacionDocumentosAdjuntos { get; set; }
        public virtual DbSet<Cliente> Cliente { get; set; }
        public virtual DbSet<ConfiguracionRenovacionLineas> ConfiguracionRenovacionLineas { get; set; }
        public virtual DbSet<ControlCartera> ControlCartera { get; set; }
        public virtual DbSet<ControlVisitas> ControlVisitas { get; set; }
        public virtual DbSet<CorreosAutomaticosPendientes> CorreosAutomaticosPendientes { get; set; }
        public virtual DbSet<DireccionCliente> DireccionCliente { get; set; }
        public virtual DbSet<DocumentosCategoria> DocumentosCategoria { get; set; }
        public virtual DbSet<DocumentosEtapa> DocumentosEtapa { get; set; }
        public virtual DbSet<EmailCliente> EmailCliente { get; set; }
        public virtual DbSet<EmailSolicitud> EmailSolicitud { get; set; }
        public virtual DbSet<ExpedienteDetalle> ExpedienteDetalle { get; set; }
        public virtual DbSet<Funcionario> Funcionario { get; set; }
        public virtual DbSet<GestionesVarias> GestionesVarias { get; set; }
        public virtual DbSet<GestionRenovacionLineas> GestionRenovacionLineas { get; set; }
        public virtual DbSet<GrupoInteresEconomico> GrupoInteresEconomico { get; set; }
        public virtual DbSet<GrupoInteresEconomicoDetalle> GrupoInteresEconomicoDetalle { get; set; }
        public virtual DbSet<GrupoInteresEconomicoMiembros> GrupoInteresEconomicoMiembros { get; set; }
        public virtual DbSet<HistorialDecision> HistorialDecision { get; set; }
        public virtual DbSet<HistoricoCaratula> HistoricoCaratula { get; set; }
        public virtual DbSet<HojaSeleccion> HojaSeleccion { get; set; }
        public virtual DbSet<Observacion> Observacion { get; set; }
        public virtual DbSet<ObservacionFormalizacion> ObservacionFormalizacion { get; set; }
        public virtual DbSet<ParticipantesLegalesAdicionales> ParticipantesLegalesAdicionales { get; set; }
        public virtual DbSet<RecipienteEmailSolicitud> RecipienteEmailSolicitud { get; set; }
        public virtual DbSet<Solicitante> Solicitante { get; set; }
        public virtual DbSet<SolicitarRequisitosBasicosCliente> SolicitarRequisitosBasicosCliente { get; set; }
        public virtual DbSet<Solicitud> Solicitud { get; set; }
        public virtual DbSet<TelefonoCliente> TelefonoCliente { get; set; }
        public virtual DbSet<CaratulaCreditoCondicionesEspecialesBitacora> CaratulaCreditoCondicionesEspecialesBitacora { get; set; }
        public virtual DbSet<CaratulaCreditoExcepcionesPoliticaBitacora> CaratulaCreditoExcepcionesPoliticaBitacora { get; set; }
        public virtual DbSet<DatosGeneralesSeguimiento> DatosGeneralesSeguimiento { get; set; }
        public virtual DbSet<ExepdienteEvento> ExepdienteEvento { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<AnalisisClienteDocumentos>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<AnalisisClienteDocumentos>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesAnalisis>()
                .Property(e => e.ComentariosDocumentosAdicionales)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.UserName)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.NombreCompleto)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.NombreIntancia)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.UltimusRecipiente)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.Comentario)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<AprobacionesComite>()
                .Property(e => e.CodigoComite)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.Comentario)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.UsuarioAsignado)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraControlAprobacion>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<ComentariosEvaluacionCaso>()
                .Property(e => e.Comentario)
                .IsUnicode(false);

            modelBuilder.Entity<ComentariosEvaluacionCaso>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.CodigoComite)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.NombreComite)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.ExposicionTotalTope)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<ComiteCredito>()
                .HasMany(e => e.MiembrosComiteCredito)
                .WithRequired(e => e.ComiteCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ComiteCredito>()
                .HasMany(e => e.SecuenciaCaratulaCredito)
                .WithRequired(e => e.ComiteCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DecisionPorEtapa>()
                .HasMany(e => e.RazonesDecision)
                .WithRequired(e => e.DecisionPorEtapa)
                .HasForeignKey(e => e.IdDecisionProEtapa)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DiferenciaDatosSAPBPM>()
                .Property(e => e.CodigoBP)
                .IsUnicode(false);

            modelBuilder.Entity<DiferenciaDatosSAPBPM>()
                .Property(e => e.ValorSAP)
                .IsUnicode(false);

            modelBuilder.Entity<DiferenciaDatosSAPBPM>()
                .Property(e => e.ValorBPM)
                .IsUnicode(false);

            modelBuilder.Entity<EstadosCaratula>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<MiembrosComiteCredito>()
                .Property(e => e.CodigoComite)
                .IsUnicode(false);

            modelBuilder.Entity<MiembrosComiteCredito>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<MiembrosComiteCredito>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<MiembrosComiteCredito>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<MiembrosComiteCredito>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<MiembrosComiteCredito>()
                .HasMany(e => e.AprobacionesComite)
                .WithOptional(e => e.MiembrosComiteCredito)
                .HasForeignKey(e => new { e.CodigoComite, e.IdEstructuraOrgChart });

            modelBuilder.Entity<RazonesDecision>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<RazonesDecision>()
                .Property(e => e.UsuarioModificador)
                .IsUnicode(false);

            modelBuilder.Entity<SecuenciaCaratulaCredito>()
                .Property(e => e.CodigoComite)
                .IsUnicode(false);

            modelBuilder.Entity<SecuenciaCaratulaCredito>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SecuenciaCaratulaCredito>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<SecuenciaCaratulaCredito>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<Abogados>()
                .Property(e => e.Correo)
                .IsUnicode(false);

            modelBuilder.Entity<Abogados>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Abogados>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Abogados>()
                .HasMany(e => e.DatosGeneralesFormalizacion)
                .WithOptional(e => e.Abogados)
                .HasForeignKey(e => e.NotarioCorredora_IdAbogado);

            modelBuilder.Entity<ActividadEconomica>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<ActividadEconomica>()
                .Property(e => e.CIIUoPIB)
                .IsUnicode(false);

            modelBuilder.Entity<ActividadEconomica>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ActividadEconomica>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Analisis>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Analisis>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Analisis>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<AreaResponsable>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<AreaResponsable>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<AreaResponsable>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<BeneficiarioSBD>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<BeneficiarioSBD>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<BeneficiarioSBD>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<BeneficiarioSBD>()
                .HasMany(e => e.MatrizBeneficiarioSBD)
                .WithRequired(e => e.BeneficiarioSBD)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Canton>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Canton>()
                .HasMany(e => e.Distrito)
                .WithRequired(e => e.Canton)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CapacidadPago>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<CapacidadPago>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CapacidadPago>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CapacidadPago>()
                .HasMany(e => e.ParamCategoriaRiesgo)
                .WithRequired(e => e.CapacidadPago)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CategoriaRiesgo>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriaRiesgo>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriaRiesgo>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriaRiesgo>()
                .HasMany(e => e.ParamCategoriaRiesgo)
                .WithRequired(e => e.CategoriaRiesgo)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CategoriasPorFacilidad>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriasPorFacilidad>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriaTipoDocumento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriaTipoDocumento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CategoriaTipoDocumento>()
                .HasMany(e => e.ClasificacionDocumentosAdjuntos)
                .WithRequired(e => e.CategoriaTipoDocumento)
                .HasForeignKey(e => e.IdCategoria)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ClaseCIIU>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<ClaseCIIU>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ClaseCIIU>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionCliente>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionCliente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionCliente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionCliente>()
                .HasMany(e => e.CategoriaPorClasificacionCliente)
                .WithRequired(e => e.ClasificacionCliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ClasificacionVentanaCartera>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionVentanaCartera>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionVentanaCartera>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<ComportamientoPagoHistorico>()
                .HasMany(e => e.ParamCategoriaRiesgo)
                .WithRequired(e => e.ComportamientoPagoHistorico)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CondicionesFormalizacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesFormalizacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesGeneralesCredito>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesGeneralesCredito>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesGeneralesCredito>()
                .HasMany(e => e.CondicionesVerificacionFormalizacion)
                .WithRequired(e => e.CondicionesGeneralesCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CondicionesGeneralesCredito>()
                .HasMany(e => e.FormalizacionCondicionesGenerales)
                .WithRequired(e => e.CondicionesGeneralesCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CondicionesVarias>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesVarias>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesVarias>()
                .HasMany(e => e.FormalizacionCondicionesVarias)
                .WithRequired(e => e.CondicionesVarias)
                .HasForeignKey(e => e.IdCondicion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ConsultaCIC>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<ConsultaCIC>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ConsultaCIC>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CorredoraSeguros>()
                .Property(e => e.Nombre)
                .IsUnicode(false);

            modelBuilder.Entity<CorredoraSeguros>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CorredoraSeguros>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CorredoraSeguros>()
                .HasMany(e => e.DatosGeneralesFormalizacion)
                .WithOptional(e => e.CorredoraSeguros)
                .HasForeignKey(e => e.NotarioCorredora_IdCorredor);

            modelBuilder.Entity<Criterio>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Criterio>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Criterio>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .HasMany(e => e.HojaSeleccion)
                .WithRequired(e => e.CriterioSeleccion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .HasMany(e => e.MatrizSeleccion)
                .WithRequired(e => e.CriterioSeleccion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .HasMany(e => e.MatrizOferta)
                .WithRequired(e => e.CriterioSeleccion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CriterioSeleccion>()
                .HasMany(e => e.MatrizSeleccionRelacion)
                .WithOptional(e => e.CriterioSeleccion)
                .HasForeignKey(e => e.IdCriterioSeleccion);

            modelBuilder.Entity<CriterioSeleccion>()
                .HasMany(e => e.MatrizSeleccionRelacion1)
                .WithOptional(e => e.CriterioSeleccion1)
                .HasForeignKey(e => e.IdCriterioSeleccionRelacion);

            modelBuilder.Entity<CuadroVerificacion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<CuadroVerificacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CuadroVerificacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Cumplimiento>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Cumplimiento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Cumplimiento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Decision>()
                .HasMany(e => e.DatosGeneralesAnalisis)
                .WithOptional(e => e.Decision)
                .HasForeignKey(e => e.IdDecision_InformeAnalisis);

            modelBuilder.Entity<Decision>()
                .HasMany(e => e.BitacoraControlAprobacion)
                .WithRequired(e => e.Decision)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Decision>()
                .HasMany(e => e.DecisionPorEtapa)
                .WithRequired(e => e.Decision)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Decision>()
                .HasMany(e => e.DatosGeneralesFormalizacion)
                .WithOptional(e => e.Decision)
                .HasForeignKey(e => e.Rev_Doc_Leg_IdDecisionDocumentosLegales);

            modelBuilder.Entity<DepartamentoNegocios>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<DepartamentoNegocios>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DepartamentoNegocios>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Devolucion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Devolucion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Devolucion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Director>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Director>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Director>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Distrito>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Distrito>()
                .HasMany(e => e.DireccionCliente)
                .WithOptional(e => e.Distrito)
                .HasForeignKey(e => new { e.IdDistrito, e.IdCanton });

            modelBuilder.Entity<DivisionCIIU>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<DivisionCIIU>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DivisionCIIU>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosFormalizacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosFormalizacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosNotificacion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosNotificacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosNotificacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosRequeridos>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosRequeridos>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosRequeridos>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.Nombre)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.Correo)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.UserId)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.CodigoEjecutivo)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.FormalizadorAsignado_UserID)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .Property(e => e.FormalizadorAsignado_FullName)
                .IsUnicode(false);

            modelBuilder.Entity<Ejecutivo>()
                .HasMany(e => e.EjecutivoAsistente)
                .WithRequired(e => e.Ejecutivo)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<EjecutivoAsistente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<EjecutivoAsistente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<EstadoBandeja>()
                .Property(e => e.IdEstadoBandeja)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<EstadoBandeja>()
                .HasMany(e => e.Solicitud)
                .WithRequired(e => e.EstadoBandeja)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<EstadoLinea>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<EstadoLinea>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<EstadoLinea>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<EstadoOferta>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<EstadoOferta>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<EstadoOferta>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<EstructuraOrgChart>()
                .HasMany(e => e.MiembrosComiteCredito)
                .WithRequired(e => e.EstructuraOrgChart)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<EstructuraOrgChart>()
                .HasMany(e => e.RolFuncionalEstructuraOrgChart)
                .WithRequired(e => e.EstructuraOrgChart)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .Property(e => e.DescripcionEtapa)
                .IsUnicode(false);

            modelBuilder.Entity<Etapas>()
                .Property(e => e.UserId)
                .IsUnicode(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.BitacoraControlAprobacion)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.DecisionPorEtapa)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.ConfiguracionNotificacion)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.BitacoraEncValidarExcepciones)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.BitacoraHojaPendientes)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.BitacoraValidaCumplimiento)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.BitacoraCorreosEtapas)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.ClasificacionDocumentosAdjuntos)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.ConfiguracionRenovacionLineas)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.CorreosAutomaticosPendientes)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Etapas>()
                .HasMany(e => e.DocumentosEtapa)
                .WithRequired(e => e.Etapas)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<EventoExpediente>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<EventoExpediente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<EventoExpediente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Excepciones>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Excepciones>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Excepciones>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<ExcepcionesClasificacion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<ExcepcionesClasificacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ExcepcionesClasificacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<FormaDesembolso>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<FormaDesembolso>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<FormaDesembolso>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<FormaDesembolso>()
                .HasMany(e => e.FormaliacionInformacionAdicional)
                .WithOptional(e => e.FormaDesembolso)
                .HasForeignKey(e => e.Desembolso_IdFormaDesembolso);

            modelBuilder.Entity<FormasPagos>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<FormasPagos>()
                .HasMany(e => e.FormaliacionInformacionAdicional)
                .WithOptional(e => e.FormasPagos)
                .HasForeignKey(e => e.Desembolso_IdFormaPago);

            modelBuilder.Entity<FormasPagos>()
                .HasMany(e => e.OfertaFacilidades)
                .WithOptional(e => e.FormasPagos)
                .HasForeignKey(e => e.IdFormaPagoPropuesto);

            modelBuilder.Entity<FormasPagos>()
                .HasMany(e => e.OfertaOperaciones)
                .WithOptional(e => e.FormasPagos)
                .HasForeignKey(e => e.IdFormaPagoPropuesto);

            modelBuilder.Entity<Garantia>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Garantia>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Garantia>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GeneradorMonedaExt>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<GeneradorMonedaExt>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GeneradorMonedaExt>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoCIIU>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoCIIU>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoCIIU>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresados>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresados>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresados>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Inciso>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Inciso>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Inciso>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<IncisoSugef>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<IncisoSugef>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<IncisoSugef>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<IncisoSugef>()
                .HasMany(e => e.GrupoInteresEconomicoDetalle)
                .WithOptional(e => e.IncisoSugef)
                .HasForeignKey(e => e.CodigoIncisoSUGEF);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.Campo)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.Tipo)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.Largo)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.Requerido)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.Detalle)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<IndicesEpower>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Institucion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Institucion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Institucion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Ley8262>()
                .HasMany(e => e.MatrizBeneficiarioSBD)
                .WithRequired(e => e.Ley8262)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<MantenimientoCatalogos>()
                .Property(e => e.Catalogo)
                .IsUnicode(false);

            modelBuilder.Entity<MantenimientoCatalogos>()
                .Property(e => e.Vista)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizBeneficiarioSBD>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizBeneficiarioSBD>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizOferta>()
                .Property(e => e.Porcentaje)
                .HasPrecision(5, 2);

            modelBuilder.Entity<MatrizOferta>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizOferta>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizSeleccion>()
                .Property(e => e.Valor)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizSeleccion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizSeleccion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizSeleccion>()
                .HasMany(e => e.HojaSeleccion)
                .WithOptional(e => e.MatrizSeleccion)
                .HasForeignKey(e => new { e.IdCriterioSeleccion, e.IdTipoSeleccion });

            modelBuilder.Entity<MatrizSeleccionRelacion>()
                .Property(e => e.ValorCriterioSeleccion)
                .IsUnicode(false);

            modelBuilder.Entity<MatrizSeleccionRelacion>()
                .Property(e => e.ValorCriterioSeleccionRelacion)
                .IsUnicode(false);

            modelBuilder.Entity<Moneda>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Moneda>()
                .Property(e => e.Simbolo)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<Moneda>()
                .Property(e => e.Nemonico)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.CertificadosMandato)
                .WithOptional(e => e.Moneda)
                .HasForeignKey(e => e.IdTipoMoneda);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.ControlCartera)
                .WithRequired(e => e.Moneda)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.DesembolsoDatosGenerales)
                .WithOptional(e => e.Moneda)
                .HasForeignKey(e => e.IdTipoMonedaDesembolso);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.DesembolsoFacturas)
                .WithRequired(e => e.Moneda)
                .HasForeignKey(e => e.IdTipoMoneda)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.GestionRenovacionLineas)
                .WithRequired(e => e.Moneda)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.Oferta)
                .WithOptional(e => e.Moneda)
                .HasForeignKey(e => e.IdMonedaMontoPropuestoLinea);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.OfertaFacilidades)
                .WithOptional(e => e.Moneda)
                .HasForeignKey(e => e.IdMonedaMontoPropuesto);

            modelBuilder.Entity<Moneda>()
                .HasMany(e => e.OfertaOperaciones)
                .WithOptional(e => e.Moneda)
                .HasForeignKey(e => e.IdMonedaMontoPropuesto);

            modelBuilder.Entity<Morosidad>()
                .HasMany(e => e.ParamCategoriaRiesgo)
                .WithRequired(e => e.Morosidad)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Nacionalidad>()
                .Property(e => e.Pais)
                .IsUnicode(false);

            modelBuilder.Entity<Nacionalidad>()
                .Property(e => e.Abreviatura)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<Nacionalidad>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Notario>()
                .Property(e => e.Nombre)
                .IsUnicode(false);

            modelBuilder.Entity<Notario>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Notario>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<NotificationType>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<NotificationType>()
                .HasMany(e => e.ConfiguracionNotificacion)
                .WithRequired(e => e.NotificationType)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<PermisoSBNBCCR>()
                .Property(e => e.DescPermisoSBNBCCR)
                .IsUnicode(false);

            modelBuilder.Entity<PlantillaCorreo>()
                .Property(e => e.NombrePlantilla)
                .IsUnicode(false);

            modelBuilder.Entity<PlantillaCorreo>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<PlantillaCorreo>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Procesos>()
                .Property(e => e.NombreProceso)
                .IsUnicode(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.DecisionPorEtapa)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.ConfiguracionNotificacion)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.Etapas)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.BitacoraDocumentosFormalizacion)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.CondicionesVerificacionFormalizacion)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.ConfiguracionRenovacionLineas)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.DatosGeneralesFormalizacion)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.DatosGeneralesSeguimiento)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.DesembolsoDatosGenerales)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.FormalizacionCondicionesGenerales)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.FormalizacionCondicionesVarias)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.FormalizacionTipoFacilidades)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.Funcionario)
                .WithRequired(e => e.Procesos)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.MaestroCondicionesProceso)
                .WithRequired(e => e.Procesos)
                .HasForeignKey(e => e.CodProceso)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Procesos>()
                .HasMany(e => e.ParametrosGlobalesProceso)
                .WithRequired(e => e.Procesos)
                .HasForeignKey(e => e.CodProceso)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<PropiedadDiferenciaDatosSAPBPM>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<PropiedadDiferenciaDatosSAPBPM>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<PropiedadDiferenciaDatosSAPBPM>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<PropiedadDiferenciaDatosSAPBPM>()
                .HasMany(e => e.DiferenciaDatosSAPBPM)
                .WithRequired(e => e.PropiedadDiferenciaDatosSAPBPM)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Provincia>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Provincia>()
                .HasMany(e => e.Canton)
                .WithRequired(e => e.Provincia)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<RazonesRechazo>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<RazonesRechazo>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<RazonesRechazo>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<RazonesRechazo>()
                .HasMany(e => e.RazonesDecision)
                .WithRequired(e => e.RazonesRechazo)
                .HasForeignKey(e => e.IdRazonRechazo)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<RazonesRechazo>()
                .HasMany(e => e.DatosGeneralesFormalizacion)
                .WithOptional(e => e.RazonesRechazo)
                .HasForeignKey(e => e.Rev_Doc_Leg_IdRazonDocumentosLegales);

            modelBuilder.Entity<RequisitoDocumental>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<RequisitoDocumental>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<RequisitoDocumental>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<RiesgoCambiario>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<RiesgoCambiario>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<RiesgoCambiario>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<RolFuncional>()
                .HasMany(e => e.Funcionario)
                .WithRequired(e => e.RolFuncional)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<RolFuncional>()
                .HasMany(e => e.RolFuncionalEstructuraOrgChart)
                .WithRequired(e => e.RolFuncional)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SeccionCIIU>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<SeccionCIIU>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SeccionCIIU>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<SeccionCIIU>()
                .HasMany(e => e.ClaseCIIU)
                .WithRequired(e => e.SeccionCIIU)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SeccionCIIU>()
                .HasMany(e => e.DivisionCIIU)
                .WithRequired(e => e.SeccionCIIU)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SeccionCIIU>()
                .HasMany(e => e.GrupoCIIU)
                .WithRequired(e => e.SeccionCIIU)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Sector>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Sector>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Sector>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Sector>()
                .HasMany(e => e.MatrizBeneficiarioSBD)
                .WithRequired(e => e.Sector)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<SectorEconomico>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<SectorEconomico>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SectorEconomico>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<SectorSugef>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<SectorSugef>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SectorSugef>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<StatusVisita>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<StatusVisita>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<StatusVisita>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<StatusVisita>()
                .HasMany(e => e.ControlVisitas)
                .WithOptional(e => e.StatusVisita)
                .HasForeignKey(e => e.IdEstatusVisita);

            modelBuilder.Entity<SubIndicesEpower>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<SubIndicesEpower>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SubIndicesEpower>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<SugefDetalle>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<SugefDetalle>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SugefDetalle>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<SugefGeneral>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<SugefGeneral>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<SugefGeneral>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TiemposEjecucionNotificacionesCompletionTime>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TiemposEjecucionNotificacionesCompletionTime>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TiemposEjecucionNotificacionesCompletionTime>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoAprobacion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoAprobacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoAprobacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCambioCondiciones>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCambioCondiciones>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCambioCondiciones>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCategoria>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCategoria>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCategoria>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCategoria>()
                .HasMany(e => e.CategoriaPorClasificacionCliente)
                .WithRequired(e => e.TipoCategoria)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoCategoria>()
                .HasMany(e => e.CategoriasPorFacilidad)
                .WithRequired(e => e.TipoCategoria)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoCliente>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCliente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCliente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCliente>()
                .HasMany(e => e.AnalisisClienteDocumentos)
                .WithRequired(e => e.TipoCliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoComentario>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoComentario>()
                .HasMany(e => e.BitacoraComentariosInternos)
                .WithRequired(e => e.TipoComentario)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoCondicion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCondicion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoConsultaCliente>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoConsultaCliente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoConsultaCliente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoControlCriterio>()
                .Property(e => e.DescripcionTipoCriterio)
                .IsUnicode(false);

            modelBuilder.Entity<TipoControlCriterio>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoControlCriterio>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCuenta>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDato>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDato>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDato>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDeudor>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDeudor>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDeudor>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDireccion>()
                .Property(e => e.IdTipoDireccion)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<TipoDireccion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDocumento>()
                .Property(e => e.Prefijo)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDocumento>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDocumento>()
                .Property(e => e.RutaMachote)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDocumento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDocumento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.AnalisisClienteDocumentos)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.BitacoraDetValidarExcepciones)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.BitacoraDocumentosCliente)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.BitacoraDocumentosFormalizacion)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.BitacoraDocumentosInformeAnalisis)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.BitacoraDocumentosSeguimientoAnalisis)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.DocumentosEtapa)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.FormalizacionDocumentosLegales)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.DocumentosCategoria)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDocumento>()
                .HasMany(e => e.TipoExpedienteDocumentos)
                .WithRequired(e => e.TipoDocumento)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoEdicion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoEdicion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoEdicion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoEmail>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoEvento>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoEvento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoEvento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoExpediente>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoExpediente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoExpediente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoExpediente>()
                .HasMany(e => e.TipoExpedienteDocumentos)
                .WithRequired(e => e.TipoExpediente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoExpedienteDocumentos>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoExpedienteDocumentos>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFacilidad>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFacilidad>()
                .Property(e => e.CodigoSAP)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFacilidad>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFacilidad>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFacilidad>()
                .HasMany(e => e.CategoriasPorFacilidad)
                .WithRequired(e => e.TipoFacilidad)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoFacilidad>()
                .HasMany(e => e.MatrizOferta)
                .WithRequired(e => e.TipoFacilidad)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoFacilidad>()
                .HasMany(e => e.DesembolsoDatosGenerales)
                .WithRequired(e => e.TipoFacilidad)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoFacilidad>()
                .HasMany(e => e.OfertaFacilidades)
                .WithRequired(e => e.TipoFacilidad)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoFacilidad>()
                .HasMany(e => e.VerificacionCondiciones)
                .WithRequired(e => e.TipoFacilidad)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoFuenteIngreso>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFuenteIngreso>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoFuenteIngreso>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoGestion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoGestion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoGestion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoHojaPendiente>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoHojaPendiente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoHojaPendiente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoIdentificacion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoIdentificacion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoIdentificacion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoInstitucion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoInstitucion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoInstitucion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoObservacion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoObservacion>()
                .HasMany(e => e.BitacoraEncValidarExcepciones)
                .WithRequired(e => e.TipoObservacion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoRolCredito>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoRolCredito>()
                .HasMany(e => e.ParticipantesLegalesAdicionales)
                .WithRequired(e => e.TipoRolCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoSeguimiento>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeguimientoCorreo>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeguimientoCorreo>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeguimientoCorreo>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeleccion>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeleccion>()
                .Property(e => e.Porcentaje)
                .HasPrecision(5, 2);

            modelBuilder.Entity<TipoSeleccion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeleccion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSeleccion>()
                .HasMany(e => e.MatrizOferta)
                .WithRequired(e => e.TipoSeleccion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoSeleccion>()
                .HasMany(e => e.MatrizSeleccion)
                .WithRequired(e => e.TipoSeleccion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TiposMetodologia>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TiposMetodologia>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TiposMetodologia>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSolicitante>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoSolicitante>()
                .HasMany(e => e.AnalisisClienteDocumentos)
                .WithRequired(e => e.TipoSolicitante)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoSolicitante>()
                .HasMany(e => e.Solicitante)
                .WithRequired(e => e.TipoSolicitante)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoTasa>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoTasa>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoTasa>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoTelefono>()
                .Property(e => e.IdTipoTelefono)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<TipoTelefono>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoTramite>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoTramite>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoTramite>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<TipoValor>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<TipoValor>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoValor>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<UbicacionEPower>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<UbicacionEPower>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<UbicacionEPower>()
                .HasMany(e => e.ConsultaEpower)
                .WithRequired(e => e.UbicacionEPower)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<VBGerenciaNegocios>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<VBGerenciaNegocios>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<VBGerenciaNegocios>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Vehiculo>()
                .Property(e => e.UserId)
                .IsUnicode(false);

            modelBuilder.Entity<Vehiculo>()
                .Property(e => e.Marca)
                .IsUnicode(false);

            modelBuilder.Entity<Vehiculo>()
                .Property(e => e.TipoVehiculo)
                .IsUnicode(false);

            modelBuilder.Entity<Vehiculo>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Vehiculo>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraComisiones>()
                .Property(e => e.Detalle)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraComisiones>()
                .Property(e => e.Usuario)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraGarantias>()
                .Property(e => e.Detalle)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraGarantias>()
                .Property(e => e.Usuario)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoCaratula)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoComite)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.SubTotalSaldoDolares)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.SubTotalSaldoMonedaLocal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.TotalSaldo)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.SubTotalExposicionDolares)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.SubTotalExposicionMonedaLocal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.TotalExposicion)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.SimboloMonedaTotalExposicion)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.AmortizacionProgMonedaLocal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.AmortizacionProgDolares)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoTipoGIE)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescTipoGie)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.ExposicionNumero)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.ExposicionNombre)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoAcuerdoSUGEF5_04)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescAcuerdoSUGEF5_04)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.TipoCambio)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CapitalAjustado)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.MarginalAcumuladaGrupoEmpresarial)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.PorcentajeGrupoEmpresarial)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.NumeroProductos)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoActividadEconomicaPIB)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescActividadEconomicaPIB)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoActividadEconomicaCIIU)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescActividadEconomicaCIIU)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoSectorEconomicoSUGEF)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescSectorEconomicoSUGEF)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoSUGEFGeneral)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescSUGEFGeneral)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoSUGEFDetallada)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescSUGEFDetallada)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoLey8262)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescLey8262)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.Puntaje)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.CodigoBeneficiarioSBD)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.DescBeneficiarioSBD)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.Recomendacion)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCredito>()
                .HasMany(e => e.AprobacionesComite)
                .WithRequired(e => e.CaratulaCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CaratulaCredito>()
                .HasMany(e => e.CaratulaCreditoCondicionesEspeciales)
                .WithRequired(e => e.CaratulaCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CaratulaCredito>()
                .HasMany(e => e.CaratulaCreditoExcepcionesPolitica)
                .WithRequired(e => e.CaratulaCredito)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspeciales>()
                .Property(e => e.CondicionEspecial)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspeciales>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspeciales>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspeciales>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspeciales>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPolitica>()
                .Property(e => e.Justificacion)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPolitica>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPolitica>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPolitica>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPolitica>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<Condiciones>()
                .Property(e => e.FormaPagoActual)
                .IsUnicode(false);

            modelBuilder.Entity<Condiciones>()
                .Property(e => e.FormaPagoPropuesta)
                .IsUnicode(false);

            modelBuilder.Entity<Condiciones>()
                .Property(e => e.GarantiaActual)
                .IsUnicode(false);

            modelBuilder.Entity<Condiciones>()
                .Property(e => e.GarantiaPropuesta)
                .IsUnicode(false);

            modelBuilder.Entity<Condiciones>()
                .Property(e => e.DetalleGarantiaActual)
                .IsUnicode(false);

            modelBuilder.Entity<Condiciones>()
                .Property(e => e.DetalleGarantiaPropuesta)
                .IsUnicode(false);

            modelBuilder.Entity<Contacto>()
                .Property(e => e.NombreContacto)
                .IsUnicode(false);

            modelBuilder.Entity<Contacto>()
                .Property(e => e.Telefono)
                .IsUnicode(false);

            modelBuilder.Entity<Contacto>()
                .Property(e => e.fax)
                .IsUnicode(false);

            modelBuilder.Entity<Contacto>()
                .Property(e => e.Departamento)
                .IsUnicode(false);

            modelBuilder.Entity<FacturasContratosOrdenes>()
                .Property(e => e.Contrato)
                .IsUnicode(false);

            modelBuilder.Entity<FacturasContratosOrdenes>()
                .Property(e => e.NoFactura)
                .IsUnicode(false);

            modelBuilder.Entity<FacturasContratosOrdenes>()
                .Property(e => e.Observaciones)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.CorreoOrigen)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.CorreoDestino)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.Asunto)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.Detalle)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.InfoAdjunta)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.AdjuntaRespaldo)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.AdjuntaOriginales)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.OpcionElegida)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GestionExpediente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.MontoEquivalentePropuestoLinea)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.DetalleLinea)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.PlazoLinea)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.PlazoActualLinea)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<Oferta>()
                .HasMany(e => e.OfertaFacilidades)
                .WithRequired(e => e.Oferta)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Oferta>()
                .HasMany(e => e.OfertaOperaciones)
                .WithRequired(e => e.Oferta)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.MontoMaximo)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.MontoActual)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.Detalle)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.CodigoNaturalezaGasto)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.DescNaturalezaGasto)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.MontoPropuesto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.MontoEquivalentePropuesto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.RazonSuperandoLimites)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.SubLimiteActual)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.SubLimitePropuesto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.PlazoMaximoActual)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.PlazoMaximoPropuesto)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.FormaPagoActual)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TBPActualMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TasaActualMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.PRActualDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TasaActualDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TBPPropuestaMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TasaPropuestaMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TRPropuestaDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TasaPropuestaDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TotalTBPTasaPropuestaMonedaLocal)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.TotalPRTasaPropuestaDolares)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaFacilidades>()
                .Property(e => e.OtrasTasas)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .HasMany(e => e.FormalizacionTipoFacilidades)
                .WithRequired(e => e.OfertaFacilidades)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad, e.IdSecuenciaFacilidad })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .HasMany(e => e.OfertaFacilidadesComisiones)
                .WithRequired(e => e.OfertaFacilidades)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad, e.Secuencia })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .HasMany(e => e.OfertaFacilidadesGarantias)
                .WithRequired(e => e.OfertaFacilidades)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad, e.Secuencia })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<OfertaFacilidades>()
                .HasOptional(e => e.VerificacionFacturasContratosOrdenes)
                .WithRequired(e => e.OfertaFacilidades);

            modelBuilder.Entity<OfertaFacilidadesComisiones>()
                .Property(e => e.DetalleComision)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesComisiones>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesComisiones>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesComisiones>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesComisiones>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesGarantias>()
                .Property(e => e.DescTipoGarantia)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesGarantias>()
                .Property(e => e.DetalleGarantia)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesGarantias>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesGarantias>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesGarantias>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaFacilidadesGarantias>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.Operacion)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.Linea)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.MontoMaximo)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.MontoActual)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.Detalle)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.CodigoNaturalezaGasto)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.DescNaturalezaGasto)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.MontoPropuesto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.MontoEquivalentePropuesto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.SubLimiteActual)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.SubLimitePropuesto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.PlazoMaximoActual)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.PlazoMaximoPropuesto)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.FormaPagoActual)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TBPActualMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TasaActualMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.PRActualDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TasaActualDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TBPPropuestaMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TasaPropuestaMonedaLocal)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TRPropuestaDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TasaPropuestaDolares)
                .HasPrecision(6, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.OtrasTasas)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TotalTBPTasaPropuestaMonedaLocal)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .Property(e => e.TotalPRTasaPropuestaDolares)
                .HasPrecision(18, 3);

            modelBuilder.Entity<OfertaOperaciones>()
                .HasMany(e => e.OfertaOperacionesComisiones)
                .WithRequired(e => e.OfertaOperaciones)
                .HasForeignKey(e => new { e.IdSolicitud, e.Operacion })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<OfertaOperaciones>()
                .HasMany(e => e.OfertaOperacionesGarantias)
                .WithRequired(e => e.OfertaOperaciones)
                .HasForeignKey(e => new { e.IdSolicitud, e.Operacion })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<OfertaOperacionesComisiones>()
                .Property(e => e.Operacion)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesComisiones>()
                .Property(e => e.DetalleComision)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesComisiones>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesComisiones>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesGarantias>()
                .Property(e => e.Operacion)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesGarantias>()
                .Property(e => e.DescTipoGarantia)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesGarantias>()
                .Property(e => e.DetalleGarantia)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesGarantias>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<OfertaOperacionesGarantias>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Sucursal>()
                .Property(e => e.CodSucursal)
                .IsUnicode(false);

            modelBuilder.Entity<Sucursal>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<Sucursal>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Sucursal>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.Departamento)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.NombrePagador)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.Puesto)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.OtrosPublico)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.OtrosPrivada)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.Otros)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.DepartamentoEncargado)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.DirigirEncargado)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.FechaRecibirCesion)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.HoraRecibirCesion)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.Direccion)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.MedioPago)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.HoraPago)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.FechaConsulta)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.PagoBanco)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.OtrosPagos)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.Firma)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.PuestoVerifica)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .Property(e => e.HoraConsulta)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .HasMany(e => e.Contacto)
                .WithOptional(e => e.VerificacionFacturasContratosOrdenes)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad, e.Secuencia });

            modelBuilder.Entity<VerificacionFacturasContratosOrdenes>()
                .HasMany(e => e.FacturasContratosOrdenes)
                .WithOptional(e => e.VerificacionFacturasContratosOrdenes)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad, e.Secuencia });

            modelBuilder.Entity<BitacoraValidaCumplimiento>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraValidaCumplimiento>()
                .Property(e => e.UsuarioAsignado)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraValidaCumplimiento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraValidaCumplimiento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraValidaCumplimiento>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraValidaCumplimiento>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<ContactoDE>()
                .Property(e => e.NombreContacto)
                .IsUnicode(false);

            modelBuilder.Entity<ContactoDE>()
                .Property(e => e.Telefono)
                .IsUnicode(false);

            modelBuilder.Entity<ContactoDE>()
                .Property(e => e.fax)
                .IsUnicode(false);

            modelBuilder.Entity<ContactoDE>()
                .Property(e => e.Departamento)
                .IsUnicode(false);

            modelBuilder.Entity<DesemboloDetalleOrdenCompra>()
                .Property(e => e.NumeroLicitacion)
                .IsUnicode(false);

            modelBuilder.Entity<DesemboloDetalleOrdenCompra>()
                .Property(e => e.Plazo)
                .IsUnicode(false);

            modelBuilder.Entity<DesemboloDetalleOrdenCompra>()
                .Property(e => e.Pagador)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.Plazo)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.InstruccionesDesposito)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.NumeroLinea)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.MonedaLinea)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.ElaboradoPor)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.CodigoSublimite)
                .IsFixedLength();

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.NroCaratulaSublimite)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.Tasa)
                .HasPrecision(5, 2);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.ProcentajeAceptacion)
                .HasPrecision(5, 2);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .Property(e => e.NumeroOperacion)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .HasMany(e => e.DesemboloDetalleOrdenCompra)
                .WithRequired(e => e.DesembolsoDatosGenerales)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .HasMany(e => e.DesembolsoDetalleAdelantosContraContrato)
                .WithRequired(e => e.DesembolsoDatosGenerales)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DesembolsoDatosGenerales>()
                .HasMany(e => e.DesembolsoFacturas)
                .WithRequired(e => e.DesembolsoDatosGenerales)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DesembolsoDetalleAdelantosContraContrato>()
                .Property(e => e.Linea)
                .IsUnicode(false);

            modelBuilder.Entity<DesembolsoDetalleAdelantosContraContrato>()
                .Property(e => e.Porcentaje)
                .HasPrecision(5, 2);

            modelBuilder.Entity<FacturasContratosOrdenesDE>()
                .Property(e => e.Contrato)
                .IsUnicode(false);

            modelBuilder.Entity<FacturasContratosOrdenesDE>()
                .Property(e => e.NoFactura)
                .IsUnicode(false);

            modelBuilder.Entity<FacturasContratosOrdenesDE>()
                .Property(e => e.Observaciones)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.Departamento)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.NombrePagador)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.Puesto)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.NuevoPagador)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.OtrosPublico)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.OtrosPrivada)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.Otros)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.DepartamentoEncargado)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.DirigirEncargado)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.HoraRecibirCesion)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.Direccion)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.MedioPago)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.HoraPago)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.PagoBanco)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.OtrosPagos)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.Firma)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.PuestoVerifica)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .Property(e => e.HoraConsulta)
                .IsUnicode(false);

            modelBuilder.Entity<VerificacionCondiciones>()
                .HasMany(e => e.ContactoDE)
                .WithOptional(e => e.VerificacionCondiciones)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad });

            modelBuilder.Entity<VerificacionCondiciones>()
                .HasMany(e => e.FacturasContratosOrdenesDE)
                .WithOptional(e => e.VerificacionCondiciones)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdTipoFacilidad });

            modelBuilder.Entity<CertificadosMandato>()
                .Property(e => e.NroCertificado)
                .IsUnicode(false);

            modelBuilder.Entity<CertificadosMandato>()
                .Property(e => e.Emisor)
                .IsUnicode(false);

            modelBuilder.Entity<CertificadosMandato>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<CertificadosMandato>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<CondicionesVerificacionFormalizacion>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.AsigCaso_JobFunctionAsignado)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.AsigCaso_UserIDFormalizadorAsignado)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.ComentariosCrearLineaSAP)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.NumLineaCreadaSAP)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Pignoracion_Instrumento)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Pignoracion_NumSerieInstrumento)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Pignoracion_NumOperacion)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Pignoracion_ValorInstrumento)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Pignoracion_Emisor)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.TransferirContrato_NumeroSolicitud)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.TransferirContrato_LigueGarantias)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.TransferirContrato_Comentarios)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.HoraAgendaFirmaInicio)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.AprobadorHojaPendientes)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.IdAsistenteHojaPendientes)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.HoraAgendaFirmaFin)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.JustificacionRechazoNotificacionDesembolso)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.DetallePendienteGarantiaReal)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .Property(e => e.NumeroGarantiaReal)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .HasMany(e => e.BitacoraHojaPendientes)
                .WithRequired(e => e.DatosGeneralesFormalizacion)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .HasOptional(e => e.FormaliacionInformacionAdicional)
                .WithRequired(e => e.DatosGeneralesFormalizacion);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .HasMany(e => e.FormalizacionTipoFacilidades)
                .WithRequired(e => e.DatosGeneralesFormalizacion)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .HasMany(e => e.FormalizacionDocumentosLegales)
                .WithRequired(e => e.DatosGeneralesFormalizacion)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .HasMany(e => e.FormalizacionCondicionesGenerales)
                .WithRequired(e => e.DatosGeneralesFormalizacion)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DatosGeneralesFormalizacion>()
                .HasMany(e => e.FormalizacionCondicionesVarias)
                .WithRequired(e => e.DatosGeneralesFormalizacion)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<FomalizacionInfoAdicional_CuentasCartaMisiva>()
                .Property(e => e.DescripcionTipoCuenta)
                .IsUnicode(false);

            modelBuilder.Entity<FomalizacionInfoAdicional_CuentasCartaMisiva>()
                .Property(e => e.NumeroCuenta)
                .IsUnicode(false);

            modelBuilder.Entity<FomalizacionInfoAdicional_CuentasCartaMisiva>()
                .Property(e => e.TitularCuenta_Identificacion)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.Pagare_PeridoGracia)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.ContrSobreGiro_NumeroCuenta)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.ContLinCredito_PlazoMaxDesembolso)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.ContLinCredito_PlazoMaxApertura)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.Desembolso_Opciones_Deposito)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Nombre_Pagador)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Descripcion_Gte_Negocio)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Estado_Civil_Gte_Neg)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Identidad_Gte_Neg)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Direccion)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Pagador)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Nombre_Cedente)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Identidad_Cedente)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Repre_Cendente)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Identidad_Repre_Ced)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Nombre_Cesionaria)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Identidad_Cesionaria)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Repre_Cesionaria)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Identidad_Repre_Ces)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Cuentas_Pago)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Nombre_Gte_Negocio)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Plazo)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Profesion_Gte)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.ContrSobreGiro_Nro_CuentaCte)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.Pagare_Nro_Operacion)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.Mandato_Nro_Mandato)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.Mandato_NroProducto)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Identidad_Pagador)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Estado_Civil_Pagador)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .Property(e => e.CesionContrato_Profesion_Pagador)
                .IsUnicode(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .HasMany(e => e.CertificadosMandato)
                .WithRequired(e => e.FormaliacionInformacionAdicional)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<FormaliacionInformacionAdicional>()
                .HasMany(e => e.FomalizacionInfoAdicional_CuentasCartaMisiva)
                .WithRequired(e => e.FormaliacionInformacionAdicional)
                .HasForeignKey(e => new { e.IdSolicitud, e.Incident, e.IdProceso })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<FormalizacionCondicionesGenerales>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<FormalizacionCondicionesVarias>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<FormalizacionTipoFacilidades>()
                .Property(e => e.UsuarioAsignado)
                .IsUnicode(false);

            modelBuilder.Entity<VarianteConfiguracionDocumentosLegales>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<FiltroCondicionesMaestro>()
                .HasMany(e => e.ReglasCondiciones)
                .WithRequired(e => e.FiltroCondicionesMaestro)
                .HasForeignKey(e => new { e.CodProceso, e.CodMaestro, e.CodCondicion })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<MaestroCondicionesProceso>()
                .HasMany(e => e.FiltroCondicionesMaestro)
                .WithRequired(e => e.MaestroCondicionesProceso)
                .HasForeignKey(e => new { e.CodProceso, e.CodMaestro })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<MaestroCondicionesProceso>()
                .HasMany(e => e.FiltroParametrosGlobalesMaestro)
                .WithRequired(e => e.MaestroCondicionesProceso)
                .HasForeignKey(e => new { e.CodProceso, e.CodMaestro })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ParametrosGlobalesProceso>()
                .HasMany(e => e.FiltroParametrosGlobalesMaestro)
                .WithRequired(e => e.ParametrosGlobalesProceso)
                .HasForeignKey(e => new { e.CodProceso, e.CodEvaluacion, e.CodParametro })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ReglasCondiciones>()
                .Property(e => e.OperadorAritmetico)
                .IsUnicode(false);

            modelBuilder.Entity<ReglasCondiciones>()
                .Property(e => e.OperadorLogicaParametro)
                .IsUnicode(false);

            modelBuilder.Entity<ReglasCondiciones>()
                .Property(e => e.OperadorLogicoSubConjunto)
                .IsUnicode(false);

            modelBuilder.Entity<ReglasCondiciones>()
                .Property(e => e.NombreSubConjunto)
                .IsUnicode(false);

            modelBuilder.Entity<ReglasCondiciones>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ReglasCondiciones>()
                .Property(e => e.UsuarioModificador)
                .IsUnicode(false);

            modelBuilder.Entity<TipoCondiciones>()
                .HasMany(e => e.FiltroCondicionesMaestro)
                .WithRequired(e => e.TipoCondiciones)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoDatoParametros>()
                .Property(e => e.NombreTipo)
                .IsUnicode(false);

            modelBuilder.Entity<TipoDatoParametros>()
                .HasMany(e => e.TipoParametrosCondiciones)
                .WithRequired(e => e.TipoDatoParametros)
                .HasForeignKey(e => e.CodTipoDato)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoEvaluacionCondiciones>()
                .HasMany(e => e.ParametrosGlobalesProceso)
                .WithRequired(e => e.TipoEvaluacionCondiciones)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoParametrosCondiciones>()
                .Property(e => e.NombreParametro)
                .IsUnicode(false);

            modelBuilder.Entity<TipoParametrosCondiciones>()
                .HasMany(e => e.ParametrosGlobalesProceso)
                .WithRequired(e => e.TipoParametrosCondiciones)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TipoParametrosCondiciones>()
                .HasMany(e => e.ReglasCondiciones)
                .WithRequired(e => e.TipoParametrosCondiciones)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<AdjuntoEmailSolicitud>()
                .Property(e => e.NombreDocumento)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraComentariosInternos>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraComentariosInternos>()
                .Property(e => e.Etapa)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraCorreosEtapas>()
                .Property(e => e.Asunto)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraDocumentosCliente>()
                .HasMany(e => e.Observacion)
                .WithOptional(e => e.BitacoraDocumentosCliente)
                .HasForeignKey(e => new { e.IdCliente, e.IdTipoDocumento, e.ConsecutivoPeriodo });

            modelBuilder.Entity<BitacoraDocumentosFormalizacion>()
                .HasMany(e => e.ObservacionFormalizacion)
                .WithOptional(e => e.BitacoraDocumentosFormalizacion)
                .HasForeignKey(e => new { e.IdCliente, e.IdSolicitud, e.Incidente, e.IdProceso, e.IdTipoDocumento });

            modelBuilder.Entity<BitacoraDocumentosInformeAnalisis>()
                .Property(e => e.RutaDescarga)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraEncValidarExcepciones>()
                .Property(e => e.JustificacionRechazo)
                .IsUnicode(false);

            modelBuilder.Entity<BitacoraEncValidarExcepciones>()
                .HasMany(e => e.BitacoraDetValidarExcepciones)
                .WithRequired(e => e.BitacoraEncValidarExcepciones)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<BitacoraSeguimientoCorreo>()
                .Property(e => e.Cometario)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionDocumentosAdjuntos>()
                .Property(e => e.NombreDocumento)
                .IsUnicode(false);

            modelBuilder.Entity<ClasificacionDocumentosAdjuntos>()
                .HasMany(e => e.FormalizacionDocumentosLegales)
                .WithOptional(e => e.ClasificacionDocumentosAdjuntos)
                .HasForeignKey(e => e.CodDocumentoAdjunto);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.NumeroIdentificacion)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.PrimerNombre)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.SegundoNombre)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.PrimerApellido)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.SegundoApellido)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.RazonSocial)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.CodigoBP)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.Contacto)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.Puesto)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.ComentariosCIC)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.ComentariosCIBERISK)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.ComentariosCCSS)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.CodigoCiiu)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.DesCiiu)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.CodNivelCapacidadPago)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.DescNivelCapacidadPago)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.CodigoCategoriaRiesgo)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.CategoriaRiesgo)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.DescRiesgoCambiario)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.CodGeneraMonedaExtrangera)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.DescGeneraMonedaExtrangera)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.DescClasificacionMetodologia)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .Property(e => e.Direccion)
                .IsUnicode(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.BitacoraDetValidarExcepciones)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.BitacoraDocumentosCliente)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.BitacoraDocumentosInformeAnalisis)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.BitacoraDocumentosSeguimientoAnalisis)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.BitacoraEncValidarExcepciones)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.ClasificacionDocumentosAdjuntos)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.EmailCliente)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.Solicitante)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Cliente>()
                .HasMany(e => e.TelefonoCliente)
                .WithRequired(e => e.Cliente)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ConfiguracionRenovacionLineas>()
                .Property(e => e.UsuarioIniciador)
                .IsUnicode(false);

            modelBuilder.Entity<ControlCartera>()
                .Property(e => e.IdLinea)
                .IsUnicode(false);

            modelBuilder.Entity<ControlCartera>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ControlCartera>()
                .Property(e => e.NumeroIdentificacion)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.HoraProgramada)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.HoraProgramadaFin)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.UserId)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.UserFullName)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.ComentariosAdicionales)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.AsuntoVisita)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.HoraEjecucion)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.Direccion)
                .IsUnicode(false);

            modelBuilder.Entity<ControlVisitas>()
                .Property(e => e.Etapa)
                .IsUnicode(false);

            modelBuilder.Entity<CorreosAutomaticosPendientes>()
                .Property(e => e.NombreFiltroCorreo)
                .IsUnicode(false);

            modelBuilder.Entity<CorreosAutomaticosPendientes>()
                .Property(e => e.UserID)
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.IdTipoDireccion)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.DirExacta)
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.ApartadoPostal)
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.CodigoPostal)
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.ZonaPostal)
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.NumCasaApto)
                .IsUnicode(false);

            modelBuilder.Entity<DireccionCliente>()
                .Property(e => e.CodigoAreaMetro)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosCategoria>()
                .Property(e => e.NombreMachote)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosCategoria>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DocumentosCategoria>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<EmailCliente>()
                .Property(e => e.Email)
                .IsUnicode(false);

            modelBuilder.Entity<EmailCliente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<EmailCliente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<EmailSolicitud>()
                .Property(e => e.NombrePlantilla)
                .IsUnicode(false);

            modelBuilder.Entity<EmailSolicitud>()
                .Property(e => e.DocumentosAdjuntos)
                .IsUnicode(false);

            modelBuilder.Entity<EmailSolicitud>()
                .HasMany(e => e.BitacoraSeguimientoCorreo)
                .WithRequired(e => e.EmailSolicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<EmailSolicitud>()
                .HasMany(e => e.RecipienteEmailSolicitud)
                .WithRequired(e => e.EmailSolicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.Excepcion)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.VerificadoCumplimento)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.VerificadoAnalisis)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.VerificadoNegocios)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.ObservacNegocios)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.VistoBueno)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.IdEstadoBPM)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.IdEstadoEpower)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.NombreBPM)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.NombreEpower)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.RutaBPM)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.RutaEpower)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.Observaciones)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ExpedienteDetalle>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GestionesVarias>()
                .Property(e => e.Hora)
                .IsUnicode(false);

            modelBuilder.Entity<GestionesVarias>()
                .Property(e => e.Usuario)
                .IsUnicode(false);

            modelBuilder.Entity<GestionesVarias>()
                .Property(e => e.Descripcion)
                .IsUnicode(false);

            modelBuilder.Entity<GestionesVarias>()
                .Property(e => e.Etapa)
                .IsUnicode(false);

            modelBuilder.Entity<GestionesVarias>()
                .Property(e => e.UserId)
                .IsUnicode(false);

            modelBuilder.Entity<GestionRenovacionLineas>()
                .Property(e => e.IdLinea)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.Identificacion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodigoBPSap)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.Nombre)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.PrimerApellido)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.SegundoApellido)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodSectorEconomico)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.SectorEconomico)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodigoCiiu)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodTipoGie)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.DescTipoGie)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.DescRiesgoCambiario)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodProfesion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.DescProfesion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodNivelCapacidadPago)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.DescNivelCapacidadPago)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodEjecutivoActivo)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.DescEjecutivoActivo)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CodGeneraMonedaExtrangera)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.DescGeneraMonedaExtrangera)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.CategoriaRiesgo)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.Direccion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.EstadoCivil)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .HasMany(e => e.GrupoInteresEconomicoDetalle)
                .WithRequired(e => e.GrupoInteresEconomico)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<GrupoInteresEconomico>()
                .HasMany(e => e.GrupoInteresEconomicoMiembros)
                .WithRequired(e => e.GrupoInteresEconomico)
                .HasForeignKey(e => e.IdentificacionAsociado)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.Identificacion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.OperacionLinea)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.MontoSolicitado)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.TasaInteres)
                .HasPrecision(6, 3);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.SaldoPendiente)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.CodEstado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.DescEstado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.TipoOperacion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.DescTipoOperacion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.Moneda)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.Plazo)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.TipoNaturalezaGasto)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.DescNaturalezaGasto)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.TipoDestinoUtilizacion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.DescDestinoUtilizacion)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.TipoGarantia)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.DescTipoGarantia)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.Comisiones)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.FormasDePago)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.ExposicionPropuesta)
                .HasPrecision(18, 3);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoDetalle>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoMiembros>()
                .Property(e => e.IdentificacionPrincipal)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoMiembros>()
                .Property(e => e.IdentificacionAsociado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoMiembros>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoMiembros>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoMiembros>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<GrupoInteresEconomicoMiembros>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<HistorialDecision>()
                .Property(e => e.UsuarioFirma)
                .IsUnicode(false);

            modelBuilder.Entity<HistoricoCaratula>()
                .Property(e => e.Name)
                .IsFixedLength();

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.ValorCriterio)
                .IsUnicode(false);

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.Monto)
                .HasPrecision(18, 3);

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.MontoEquivalente)
                .HasPrecision(18, 3);

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<HojaSeleccion>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<Observacion>()
                .Property(e => e.Usuario)
                .IsUnicode(false);

            modelBuilder.Entity<Observacion>()
                .Property(e => e.DescripcionObservacion)
                .IsUnicode(false);

            modelBuilder.Entity<Observacion>()
                .Property(e => e.Etapa)
                .IsUnicode(false);

            modelBuilder.Entity<ObservacionFormalizacion>()
                .Property(e => e.Usuario)
                .IsUnicode(false);

            modelBuilder.Entity<ObservacionFormalizacion>()
                .Property(e => e.DescripcionObservacion)
                .IsUnicode(false);

            modelBuilder.Entity<ObservacionFormalizacion>()
                .Property(e => e.Etapa)
                .IsUnicode(false);

            modelBuilder.Entity<ParticipantesLegalesAdicionales>()
                .Property(e => e.CodigoBP)
                .IsUnicode(false);

            modelBuilder.Entity<ParticipantesLegalesAdicionales>()
                .Property(e => e.Identificacion)
                .IsUnicode(false);

            modelBuilder.Entity<ParticipantesLegalesAdicionales>()
                .Property(e => e.Posicion)
                .IsUnicode(false);

            modelBuilder.Entity<ParticipantesLegalesAdicionales>()
                .Property(e => e.Calidades)
                .IsUnicode(false);

            modelBuilder.Entity<ParticipantesLegalesAdicionales>()
                .Property(e => e.EstadoCivil_Repre)
                .IsUnicode(false);

            modelBuilder.Entity<ParticipantesLegalesAdicionales>()
                .Property(e => e.Profesion_Repre)
                .IsUnicode(false);

            modelBuilder.Entity<RecipienteEmailSolicitud>()
                .Property(e => e.Email)
                .IsUnicode(false);

            modelBuilder.Entity<RecipienteEmailSolicitud>()
                .Property(e => e.Nombre)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitante>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitante>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitante>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitante>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitante>()
                .Property(e => e.UltimusTaskId)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitante>()
                .Property(e => e.UltimusUserID)
                .IsUnicode(false);

            modelBuilder.Entity<SolicitarRequisitosBasicosCliente>()
                .Property(e => e.SolicitudPara)
                .IsUnicode(false);

            modelBuilder.Entity<SolicitarRequisitosBasicosCliente>()
                .Property(e => e.SolicitudDe)
                .IsUnicode(false);

            modelBuilder.Entity<SolicitarRequisitosBasicosCliente>()
                .Property(e => e.SolicitudAsunto)
                .IsUnicode(false);

            modelBuilder.Entity<SolicitarRequisitosBasicosCliente>()
                .Property(e => e.SolicitudDetalle)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.Proceso)
                .IsFixedLength();

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.Process)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.Step)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.IdSolicitudSAP)
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .Property(e => e.IdEstadoBandeja)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<Solicitud>()
                .HasOptional(e => e.DatosGeneralesAnalisis)
                .WithRequired(e => e.Solicitud);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.BitacoraControlAprobacion)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasOptional(e => e.CaratulaCredito)
                .WithRequired(e => e.Solicitud);

            modelBuilder.Entity<Solicitud>()
                .HasOptional(e => e.DetalleRequisitos)
                .WithRequired(e => e.Solicitud);

            modelBuilder.Entity<Solicitud>()
                .HasOptional(e => e.Oferta)
                .WithRequired(e => e.Solicitud);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.BitacoraValidaCumplimiento)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasOptional(e => e.DesembolsoDatosGenerales)
                .WithRequired(e => e.Solicitud);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.VerificacionCondiciones)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.CondicionesVerificacionFormalizacion)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.DatosGeneralesFormalizacion)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.BitacoraCorreosEtapas)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.BitacoraDocumentosFormalizacion)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.BitacoraEncValidarExcepciones)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.CorreosAutomaticosPendientes)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.Funcionario)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasOptional(e => e.GestionRenovacionLineas)
                .WithRequired(e => e.Solicitud);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.HojaSeleccion)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.ParticipantesLegalesAdicionales)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.Solicitante)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Solicitud>()
                .HasMany(e => e.DatosGeneralesSeguimiento)
                .WithRequired(e => e.Solicitud)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TelefonoCliente>()
                .Property(e => e.IdTipoTelefono)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<TelefonoCliente>()
                .Property(e => e.CodigoArea)
                .IsUnicode(false);

            modelBuilder.Entity<TelefonoCliente>()
                .Property(e => e.Telefono)
                .IsUnicode(false);

            modelBuilder.Entity<TelefonoCliente>()
                .Property(e => e.Extension)
                .IsUnicode(false);

            modelBuilder.Entity<TelefonoCliente>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<TelefonoCliente>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspecialesBitacora>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoCondicionesEspecialesBitacora>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPoliticaBitacora>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<CaratulaCreditoExcepcionesPoliticaBitacora>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesSeguimiento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesSeguimiento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);

            modelBuilder.Entity<DatosGeneralesSeguimiento>()
                .HasMany(e => e.CaratulaCreditoCondicionesEspecialesBitacora)
                .WithRequired(e => e.DatosGeneralesSeguimiento)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdProceso, e.Incident, e.Secuencia, e.IdTipoSeguimiento })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<DatosGeneralesSeguimiento>()
                .HasMany(e => e.CaratulaCreditoExcepcionesPoliticaBitacora)
                .WithRequired(e => e.DatosGeneralesSeguimiento)
                .HasForeignKey(e => new { e.IdSolicitud, e.IdProceso, e.Incident, e.Secuencia, e.IdTipoSeguimiento })
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<ExepdienteEvento>()
                .Property(e => e.UsuarioCreador)
                .IsUnicode(false);

            modelBuilder.Entity<ExepdienteEvento>()
                .Property(e => e.UsuarioModificado)
                .IsUnicode(false);
        }
    }
}