using System;
using MapsDb.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace MapsDb
{
    public partial class PostgresDbContext : DbContext
    {
        public virtual DbSet<Authority> Authority { get; set; }
        public virtual DbSet<BusStop> BusStop { get; set; }
        public virtual DbSet<Contractor> Contractor { get; set; }
        public virtual DbSet<CrossSection> CrossSection { get; set; }
        public virtual DbSet<DepartmentAffiliation> DepartmentAffiliation { get; set; }
        public virtual DbSet<FlowIntensity> FlowIntensity { get; set; }
        public virtual DbSet<Node> Node { get; set; }
        public virtual DbSet<NodeToWay> NodeToWay { get; set; }
        public virtual DbSet<Organization> Organization { get; set; }
        public virtual DbSet<Region> Region { get; set; }
        public virtual DbSet<Relation> Relation { get; set; }
        public virtual DbSet<RelationToRoad> RelationToRoad { get; set; }
        public virtual DbSet<Road> Road { get; set; }
        public virtual DbSet<RoadCategory> RoadCategory { get; set; }
        public virtual DbSet<RoadDirection> RoadDirection { get; set; }
        public virtual DbSet<RoadPassport> RoadPassport { get; set; }
        public virtual DbSet<RoadService> RoadService { get; set; }
        public virtual DbSet<RoadSurface> RoadSurface { get; set; }
        public virtual DbSet<RoadToCategory> RoadToCategory { get; set; }
        public virtual DbSet<RoadType> RoadType { get; set; }
        public virtual DbSet<RoadWidth> RoadWidth { get; set; }
        public virtual DbSet<ServiceObject> ServiceObject { get; set; }
        public virtual DbSet<ServiceObjectType> ServiceObjectType { get; set; }
        public virtual DbSet<Settlement> Settlement { get; set; }
        public virtual DbSet<SettlementAddressLink> SettlementAddressLink { get; set; }
        public virtual DbSet<SettlementLocation> SettlementLocation { get; set; }
        public virtual DbSet<StateCommon> StateCommon { get; set; }
        public virtual DbSet<SurfaceTreatment> SurfaceTreatment { get; set; }
        public virtual DbSet<SurfaceType> SurfaceType { get; set; }
        public virtual DbSet<Way> Way { get; set; }
        public virtual DbSet<WayToRelation> WayToRelation { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            #warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
            optionsBuilder.UseNpgsql(@"User ID=coremap;Password=5F9g4V9m;Host=195.248.225.149;Port=5432;Database=coremap;Pooling=true;");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Authority>(entity =>
            {
                entity.ToTable("authority");

                entity.Property(e => e.Id).HasColumnName("id");

                entity.Property(e => e.AuthorityName)
                    .HasColumnName("authority_name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.BeginScheme)
                    .HasColumnName("begin_scheme")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.CrossSectionId).HasColumnName("cross_section_id");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.EndScheme)
                    .HasColumnName("end_scheme")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.Info).HasColumnName("info");

                entity.Property(e => e.Length)
                    .HasColumnName("length")
                    .HasDefaultValueSql("0");

                entity.Property(e => e.RightCoords)
                    .HasColumnName("right_coords")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.RoadSectionNumber).HasColumnName("road_section_number");

                entity.HasOne(d => d.CrossSection)
                    .WithMany(p => p.Authority)
                    .HasForeignKey(d => d.CrossSectionId)
                    .HasConstraintName("authority_cross_section_id_fk");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.Authority)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("authority_road_id_fk");
            });

            modelBuilder.Entity<BusStop>(entity =>
            {
                entity.ToTable("bus_stop");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('bus_stop_bus_stop_id_seq'::regclass)");

                entity.Property(e => e.AreaLandAvailability).HasColumnName("area_land_availability");

                entity.Property(e => e.AreaStopAvailability).HasColumnName("area_stop_availability");

                entity.Property(e => e.BalanceCost).HasColumnName("balance_cost");

                entity.Property(e => e.BusStationCardId).HasColumnName("bus_station_card_id");

                entity.Property(e => e.CrossSectionNumber).HasColumnName("cross_section_number");

                entity.Property(e => e.DateActual).HasColumnName("date_actual");

                entity.Property(e => e.LocationLeft).HasColumnName("location_left");

                entity.Property(e => e.LocationRight).HasColumnName("location_right");

                entity.Property(e => e.PocketAvailability).HasColumnName("pocket_availability");

                entity.Property(e => e.Position)
                    .HasColumnName("position")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RepairCertificate)
                    .HasColumnName("repair_certificate")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.SettlementId).HasColumnName("settlement_id");

                entity.Property(e => e.StateCommonId).HasColumnName("state_common_id");

                entity.Property(e => e.SurfaceTypeId).HasColumnName("surface_type_id");

                entity.Property(e => e.ToiletAvailability).HasColumnName("toilet_availability");

                entity.Property(e => e.YearBuild).HasColumnName("year_build");

                entity.Property(e => e.YearRepair).HasColumnName("year_repair");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.BusStop)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("bus_stop_region_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.BusStop)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("bus_stop_road_id_fkey");

                entity.HasOne(d => d.Settlement)
                    .WithMany(p => p.BusStop)
                    .HasForeignKey(d => d.SettlementId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("bus_stop_settlement_id_fkey");

                entity.HasOne(d => d.StateCommon)
                    .WithMany(p => p.BusStop)
                    .HasForeignKey(d => d.StateCommonId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("bus_stop_state_common_id_fkey");

                entity.HasOne(d => d.SurfaceType)
                    .WithMany(p => p.BusStop)
                    .HasForeignKey(d => d.SurfaceTypeId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("bus_stop_surface_type_id_fkey");
            });

            modelBuilder.Entity<Contractor>(entity =>
            {
                entity.ToTable("contractor");

                entity.Property(e => e.Id).HasColumnName("id");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.BeginScheme)
                    .HasColumnName("begin_scheme")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.ContractorName)
                    .HasColumnName("contractor_name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.ContractorSectionNumber).HasColumnName("contractor_section_number");

                entity.Property(e => e.CrossSectionId).HasColumnName("cross_section_id");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.EndScheme)
                    .HasColumnName("end_scheme")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.Info).HasColumnName("info");

                entity.Property(e => e.Length)
                    .HasColumnName("length")
                    .HasDefaultValueSql("0");

                entity.Property(e => e.RightCoords)
                    .HasColumnName("right_coords")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.RoadSectionNumber).HasColumnName("road_section_number");

                entity.HasOne(d => d.CrossSection)
                    .WithMany(p => p.Contractor)
                    .HasForeignKey(d => d.CrossSectionId)
                    .HasConstraintName("contractor_cross_section_id_fk");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.Contractor)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("contractor_road_id_fk");
            });

            modelBuilder.Entity<CrossSection>(entity =>
            {
                entity.ToTable("cross_section");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('cross_section_cross_section_id_seq'::regclass)");

                entity.Property(e => e.Angle).HasColumnName("angle");

                entity.Property(e => e.Direction)
                    .HasColumnName("direction")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.DistanceEdge).HasColumnName("distance_edge");

                entity.Property(e => e.LengthSection).HasColumnName("length_section");

                entity.Property(e => e.LengthSurface).HasColumnName("length_surface");

                entity.Property(e => e.LocationLeft).HasColumnName("location_left");

                entity.Property(e => e.LocationRight).HasColumnName("location_right");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.SafetyAvailability).HasColumnName("safety_availability");

                entity.Property(e => e.StateCommonId).HasColumnName("state_common_id");

                entity.Property(e => e.SurfaceTypeId).HasColumnName("surface_type_id");

                entity.Property(e => e.TubeAvailability).HasColumnName("tube_availability");

                entity.Property(e => e.Width).HasColumnName("width");

                entity.Property(e => e.YearBuild).HasColumnName("year_build");

                entity.Property(e => e.YearRepair).HasColumnName("year_repair");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.CrossSection)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("cross_section_region_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.CrossSection)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("cross_section_road_id_fkey");

                entity.HasOne(d => d.StateCommon)
                    .WithMany(p => p.CrossSection)
                    .HasForeignKey(d => d.StateCommonId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("cross_section_state_common_id_fkey");

                entity.HasOne(d => d.SurfaceType)
                    .WithMany(p => p.CrossSection)
                    .HasForeignKey(d => d.SurfaceTypeId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("cross_section_surface_type_id_fkey");
            });

            modelBuilder.Entity<DepartmentAffiliation>(entity =>
            {
                entity.ToTable("department_affiliation");

                entity.Property(e => e.DepartmentAffiliationId).HasColumnName("department_affiliation_id");

                entity.Property(e => e.Name)
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<FlowIntensity>(entity =>
            {
                entity.ToTable("flow_intensity");

                entity.Property(e => e.Id).HasColumnName("flow_intensity_id");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.DateAdd).HasColumnName("date_add");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.IntensityBus).HasColumnName("intensity_bus");

                entity.Property(e => e.IntensityBusCoupled).HasColumnName("intensity_bus_coupled");

                entity.Property(e => e.IntensityCar).HasColumnName("intensity_car");

                entity.Property(e => e.IntensityIncrease).HasColumnName("intensity_increase");

                entity.Property(e => e.IntensityLorryThirty).HasColumnName("intensity_lorry_thirty");

                entity.Property(e => e.IntensityLorryTwelve).HasColumnName("intensity_lorry_twelve");

                entity.Property(e => e.IntensityLorryTwelveTwenty).HasColumnName("intensity_lorry_twelve_twenty");

                entity.Property(e => e.IntensityLorryTwentyThirty).HasColumnName("intensity_lorry_twenty_thirty");

                entity.Property(e => e.IntensityMoto).HasColumnName("intensity_moto");

                entity.Property(e => e.IntensityMotoSidecar).HasColumnName("intensity_moto_sidecar");

                entity.Property(e => e.IntensityTotal).HasColumnName("intensity_total");

                entity.Property(e => e.IntensityTractorOverTen).HasColumnName("intensity_tractor_over_ten");

                entity.Property(e => e.IntensityTractorUnderTen).HasColumnName("intensity_tractor_under_ten");

                entity.Property(e => e.IntensityTruckEightFourteen).HasColumnName("intensity_truck_eight_fourteen");

                entity.Property(e => e.IntensityTruckFourteen).HasColumnName("intensity_truck_fourteen");

                entity.Property(e => e.IntensityTruckSixEight).HasColumnName("intensity_truck_six_eight");

                entity.Property(e => e.IntensityTruckTwo).HasColumnName("intensity_truck_two");

                entity.Property(e => e.IntensityTruckTwoSix).HasColumnName("intensity_truck_two_six");

                entity.Property(e => e.Location).HasColumnName("location");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadDirectionId).HasColumnName("road_direction_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.SettlementId).HasColumnName("settlement_id");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.FlowIntensity)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("flow_intensity_region_id_fkey");

                entity.HasOne(d => d.RoadDirection)
                    .WithMany(p => p.FlowIntensity)
                    .HasForeignKey(d => d.RoadDirectionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("flow_intensity_road_direction_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.FlowIntensity)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("flow_intensity_road_id_fkey");

                entity.HasOne(d => d.Settlement)
                    .WithMany(p => p.FlowIntensity)
                    .HasForeignKey(d => d.SettlementId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("flow_intensity_settlement_id_fkey");
            });

            modelBuilder.Entity<Node>(entity =>
            {
                entity.ToTable("node");

                entity.HasIndex(e => e.RemoteId)
                    .HasName("node_remote_id_uindex")
                    .IsUnique();

                entity.Property(e => e.Id).HasColumnName("id");

                entity.Property(e => e.DateAdd)
                    .HasColumnName("date_add")
                    .HasDefaultValueSql("date_part('epoch'::text, now())");

                entity.Property(e => e.Lat).HasColumnName("lat");

                entity.Property(e => e.Lon).HasColumnName("lon");

                entity.Property(e => e.RemoteId)
                    .IsRequired()
                    .HasColumnName("remote_id");

                entity.Property(e => e.Status)
                    .HasColumnName("status")
                    .HasDefaultValueSql("true");
            });

            modelBuilder.Entity<NodeToWay>(entity =>
            {
                entity.HasKey(e => new { e.NodeId, e.WayId })
                    .HasName("PK_node_to_way");

                entity.ToTable("node_to_way");

                entity.HasIndex(e => new { e.NodeId, e.WayId, e.Index })
                    .HasName("node_to_way_node_id_way_id_index_index");

                entity.Property(e => e.NodeId).HasColumnName("node_id");

                entity.Property(e => e.WayId).HasColumnName("way_id");

                entity.Property(e => e.Index).HasColumnName("index");

                entity.HasOne(d => d.Node)
                    .WithMany(p => p.NodeToWay)
                    .HasForeignKey(d => d.NodeId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("node_to_way_node_id_fk");

                entity.HasOne(d => d.Way)
                    .WithMany(p => p.NodeToWay)
                    .HasForeignKey(d => d.WayId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("node_to_way_way_id_fk");
            });

            modelBuilder.Entity<Organization>(entity =>
            {
                entity.ToTable("organization");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('organization_organization_id_seq'::regclass)");

                entity.Property(e => e.DateAdd).HasColumnName("date_add");

                entity.Property(e => e.Name)
                    .IsRequired()
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<Region>(entity =>
            {
                entity.ToTable("region");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.Index).HasColumnName("index");

                entity.Property(e => e.Name)
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<Relation>(entity =>
            {
                entity.ToTable("relation");

                entity.HasIndex(e => e.RemoteId)
                    .HasName("relation_remote_id_uindex")
                    .IsUnique();

                entity.Property(e => e.Id).HasColumnName("id");

                entity.Property(e => e.DateAdd)
                    .HasColumnName("date_add")
                    .HasDefaultValueSql("date_part('epoch'::text, now())");

                entity.Property(e => e.RemoteId)
                    .IsRequired()
                    .HasColumnName("remote_id");

                entity.Property(e => e.Status)
                    .HasColumnName("status")
                    .HasDefaultValueSql("true");
            });

            modelBuilder.Entity<RelationToRoad>(entity =>
            {
                entity.HasKey(e => new { e.RoadId, e.RelationId })
                    .HasName("PK_relation_to_road");

                entity.ToTable("relation_to_road");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.RelationId).HasColumnName("relation_id");

                entity.HasOne(d => d.Relation)
                    .WithMany(p => p.RelationToRoad)
                    .HasForeignKey(d => d.RelationId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("relation_to_road_relation_id_fk");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.RelationToRoad)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("relation_to_road_road_id_fk");
            });

            modelBuilder.Entity<Road>(entity =>
            {
                entity.ToTable("road");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('road_road_id_seq'::regclass)");

                entity.Property(e => e.AcceptTransferDoc)
                    .HasColumnName("accept_transfer_doc")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.AcceptanceDoc)
                    .HasColumnName("acceptance_doc")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.AuthorityAct)
                    .HasColumnName("authority_act")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.EconomicValue).HasColumnName("economic_value");

                entity.Property(e => e.HistoricalBackground).HasColumnName("historical_background");

                entity.Property(e => e.Index).HasColumnName("index");

                entity.Property(e => e.LawDoc)
                    .HasColumnName("law_doc")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.Length).HasColumnName("length");

                entity.Property(e => e.Name)
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.RoadTypeId).HasColumnName("road_type_id");

                entity.Property(e => e.Value).HasColumnName("value");

                entity.HasOne(d => d.RoadType)
                    .WithMany(p => p.Road)
                    .HasForeignKey(d => d.RoadTypeId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_road_type_id_fkey");
            });

            modelBuilder.Entity<RoadCategory>(entity =>
            {
                entity.ToTable("road_category");

                entity.Property(e => e.RoadCategoryId).HasColumnName("road_category_id");

                entity.Property(e => e.Value)
                    .HasColumnName("value")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<RoadDirection>(entity =>
            {
                entity.ToTable("road_direction");

                entity.Property(e => e.RoadDirectionId).HasColumnName("road_direction_id");

                entity.Property(e => e.Name)
                    .IsRequired()
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<RoadPassport>(entity =>
            {
                entity.ToTable("road_passport");

                entity.Property(e => e.RoadPassportId).HasColumnName("road_passport_id");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.RoadPassport)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_passport_region_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.RoadPassport)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_passport_road_id_fkey");
            });

            modelBuilder.Entity<RoadService>(entity =>
            {
                entity.ToTable("road_service");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('road_service_road_service_id_seq'::regclass)");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.OrganizationId).HasColumnName("organization_id");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadDirectionId).HasColumnName("road_direction_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.YearBegin).HasColumnName("year_begin");

                entity.HasOne(d => d.Organization)
                    .WithMany(p => p.RoadService)
                    .HasForeignKey(d => d.OrganizationId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_service_organization_id_fkey");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.RoadService)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_service_region_id_fkey");

                entity.HasOne(d => d.RoadDirection)
                    .WithMany(p => p.RoadService)
                    .HasForeignKey(d => d.RoadDirectionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_service_road_direction_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.RoadService)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_service_road_id_fkey");
            });

            modelBuilder.Entity<RoadSurface>(entity =>
            {
                entity.ToTable("road_surface");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('road_surface_road_surface_id_seq'::regclass)");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.CrossSectionNumber).HasColumnName("cross_section_number");

                entity.Property(e => e.ElastisityModule).HasColumnName("elastisity_module");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.LaneCountLeft).HasColumnName("lane_count_left");

                entity.Property(e => e.LaneCountRight).HasColumnName("lane_count_right");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadDirectionId).HasColumnName("road_direction_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.RoadSurfaceConstructionId)
                    .HasColumnName("road_surface_construction_id")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.StateCommonId).HasColumnName("state_common_id");

                entity.Property(e => e.SurfaceTreatmentId).HasColumnName("surface_treatment_id");

                entity.Property(e => e.SurfaceTypeId).HasColumnName("surface_type_id");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.RoadSurface)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_surface_region_id_fkey");

                entity.HasOne(d => d.RoadDirection)
                    .WithMany(p => p.RoadSurface)
                    .HasForeignKey(d => d.RoadDirectionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_surface_road_direction_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.RoadSurface)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_surface_road_id_fkey");

                entity.HasOne(d => d.StateCommon)
                    .WithMany(p => p.RoadSurface)
                    .HasForeignKey(d => d.StateCommonId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_surface_state_common_id_fkey");

                entity.HasOne(d => d.SurfaceTreatment)
                    .WithMany(p => p.RoadSurface)
                    .HasForeignKey(d => d.SurfaceTreatmentId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_surface_surface_treatment_id_fkey");

                entity.HasOne(d => d.SurfaceType)
                    .WithMany(p => p.RoadSurface)
                    .HasForeignKey(d => d.SurfaceTypeId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_surface_surface_type_id_fkey");
            });

            modelBuilder.Entity<RoadToCategory>(entity =>
            {
                entity.ToTable("road_to_category");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('road_to_category_road_to_category_id_seq'::regclass)");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.Distance).HasColumnName("distance");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadCategoryId).HasColumnName("road_category_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.RoadToCategory)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_to_category_region_id_fkey");

                entity.HasOne(d => d.RoadCategory)
                    .WithMany(p => p.RoadToCategory)
                    .HasForeignKey(d => d.RoadCategoryId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_to_category_road_category_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.RoadToCategory)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_to_category_road_id_fkey");
            });

            modelBuilder.Entity<RoadType>(entity =>
            {
                entity.ToTable("road_type");

                entity.Property(e => e.RoadTypeId).HasColumnName("road_type_id");

                entity.Property(e => e.Definition)
                    .HasColumnName("definition")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.Value)
                    .HasColumnName("value")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<RoadWidth>(entity =>
            {
                entity.ToTable("road_width");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('road_width_road_width_id_seq'::regclass)");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.CountLaneLeft).HasColumnName("count_lane_left");

                entity.Property(e => e.CountLaneRight).HasColumnName("count_lane_right");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.WidthReverseRoad).HasColumnName("width_reverse_road");

                entity.Property(e => e.WidthRoadsideLeft).HasColumnName("width_roadside_left");

                entity.Property(e => e.WidthRoadsideRight).HasColumnName("width_roadside_right");

                entity.Property(e => e.WidthRoadwayForward).HasColumnName("width_roadway_forward");

                entity.Property(e => e.WidthStrip).HasColumnName("width_strip");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.RoadWidth)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_width_region_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.RoadWidth)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("road_width_road_id_fkey");
            });

            modelBuilder.Entity<ServiceObject>(entity =>
            {
                entity.ToTable("service_object");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('service_object_service_object_id_seq'::regclass)");

                entity.Property(e => e.ArrangementElements).HasColumnName("arrangement_elements");

                entity.Property(e => e.Capacity).HasColumnName("capacity");

                entity.Property(e => e.DepartmentAffiliationId).HasColumnName("department_affiliation_id");

                entity.Property(e => e.Distance).HasColumnName("distance");

                entity.Property(e => e.LocationAxis).HasColumnName("location_axis");

                entity.Property(e => e.LocationLeft).HasColumnName("location_left");

                entity.Property(e => e.LocationRight).HasColumnName("location_right");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.ServiceObjectTypeId).HasColumnName("service_object_type_id");

                entity.Property(e => e.SettlementId).HasColumnName("settlement_id");

                entity.HasOne(d => d.DepartmentAffiliation)
                    .WithMany(p => p.ServiceObject)
                    .HasForeignKey(d => d.DepartmentAffiliationId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("service_object_department_affiliation_id_fkey");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.ServiceObject)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("service_object_region_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.ServiceObject)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("service_object_road_id_fkey");

                entity.HasOne(d => d.ServiceObjectType)
                    .WithMany(p => p.ServiceObject)
                    .HasForeignKey(d => d.ServiceObjectTypeId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("service_object_service_object_type_id_fkey");

                entity.HasOne(d => d.Settlement)
                    .WithMany(p => p.ServiceObject)
                    .HasForeignKey(d => d.SettlementId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("service_object_settlement_id_fkey");
            });

            modelBuilder.Entity<ServiceObjectType>(entity =>
            {
                entity.ToTable("service_object_type");

                entity.Property(e => e.ServiceObjectTypeId).HasColumnName("service_object_type_id");

                entity.Property(e => e.Name)
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<Settlement>(entity =>
            {
                entity.ToTable("settlement");

                entity.Property(e => e.SettlementId).HasColumnName("settlement_id");

                entity.Property(e => e.Name)
                    .IsRequired()
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);

                entity.Property(e => e.Sign)
                    .HasColumnName("sign")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<SettlementAddressLink>(entity =>
            {
                entity.ToTable("settlement_address_link");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('settlement_address_link_settlement_address_link_id_seq'::regclass)");

                entity.Property(e => e.Begin).HasColumnName("begin");

                entity.Property(e => e.Distance).HasColumnName("distance");

                entity.Property(e => e.End).HasColumnName("end");

                entity.Property(e => e.RegionId).HasColumnName("region_id");

                entity.Property(e => e.RoadId).HasColumnName("road_id");

                entity.Property(e => e.SettlementId).HasColumnName("settlement_id");

                entity.Property(e => e.SettlementLocationId).HasColumnName("settlement_location_id");

                entity.HasOne(d => d.Region)
                    .WithMany(p => p.SettlementAddressLink)
                    .HasForeignKey(d => d.RegionId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("settlement_address_link_region_id_fkey");

                entity.HasOne(d => d.Road)
                    .WithMany(p => p.SettlementAddressLink)
                    .HasForeignKey(d => d.RoadId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("settlement_address_link_road_id_fkey");

                entity.HasOne(d => d.Settlement)
                    .WithMany(p => p.SettlementAddressLink)
                    .HasForeignKey(d => d.SettlementId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("settlement_address_link_settlement_id_fkey");

                entity.HasOne(d => d.SettlementLocation)
                    .WithMany(p => p.SettlementAddressLink)
                    .HasForeignKey(d => d.SettlementLocationId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("settlement_address_link_settlement_location_id_fkey");
            });

            modelBuilder.Entity<SettlementLocation>(entity =>
            {
                entity.ToTable("settlement_location");

                entity.Property(e => e.Id)
                    .HasColumnName("id")
                    .HasDefaultValueSql("nextval('settlement_location_settlement_location_id_seq'::regclass)");

                entity.Property(e => e.Value)
                    .IsRequired()
                    .HasColumnName("value")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<StateCommon>(entity =>
            {
                entity.ToTable("state_common");

                entity.Property(e => e.StateCommonId).HasColumnName("state_common_id");

                entity.Property(e => e.Value)
                    .HasColumnName("value")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<SurfaceTreatment>(entity =>
            {
                entity.ToTable("surface_treatment");

                entity.Property(e => e.SurfaceTreatmentId).HasColumnName("surface_treatment_id");

                entity.Property(e => e.Name)
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<SurfaceType>(entity =>
            {
                entity.ToTable("surface_type");

                entity.Property(e => e.SurfaceTypeId).HasColumnName("surface_type_id");

                entity.Property(e => e.Name)
                    .HasColumnName("name")
                    .HasColumnType("varchar")
                    .HasMaxLength(255);
            });

            modelBuilder.Entity<Way>(entity =>
            {
                entity.ToTable("way");

                entity.HasIndex(e => e.RemoteId)
                    .HasName("way_remote_id_uindex")
                    .IsUnique();

                entity.Property(e => e.Id).HasColumnName("id");

                entity.Property(e => e.DateAdd)
                    .HasColumnName("date_add")
                    .HasDefaultValueSql("date_part('epoch'::text, now())");

                entity.Property(e => e.RemoteId)
                    .IsRequired()
                    .HasColumnName("remote_id");

                entity.Property(e => e.Status)
                    .HasColumnName("status")
                    .HasDefaultValueSql("true");
            });

            modelBuilder.Entity<WayToRelation>(entity =>
            {
                entity.HasKey(e => new { e.WayId, e.RelationId })
                    .HasName("PK_way_to_relation");

                entity.ToTable("way_to_relation");

                entity.HasIndex(e => new { e.WayId, e.RelationId, e.Index })
                    .HasName("way_to_relation_way_id_relation_id_index_index");

                entity.Property(e => e.WayId).HasColumnName("way_id");

                entity.Property(e => e.RelationId).HasColumnName("relation_id");

                entity.Property(e => e.Index).HasColumnName("index");

                entity.HasOne(d => d.Relation)
                    .WithMany(p => p.WayToRelation)
                    .HasForeignKey(d => d.RelationId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("way_to_relation_relation_id_fk");

                entity.HasOne(d => d.Way)
                    .WithMany(p => p.WayToRelation)
                    .HasForeignKey(d => d.WayId)
                    .OnDelete(DeleteBehavior.Restrict)
                    .HasConstraintName("way_to_relation_way_id_fk");
            });

            modelBuilder.HasSequence("bus_stop_bus_stop_id_seq");

            modelBuilder.HasSequence("cross_section_cross_section_id_seq");

            modelBuilder.HasSequence("organization_organization_id_seq");

            modelBuilder.HasSequence("road_road_id_seq");

            modelBuilder.HasSequence("road_service_road_service_id_seq");

            modelBuilder.HasSequence("road_surface_road_surface_id_seq");

            modelBuilder.HasSequence("road_to_category_road_to_category_id_seq");

            modelBuilder.HasSequence("road_width_road_width_id_seq");

            modelBuilder.HasSequence("service_object_service_object_id_seq");

            modelBuilder.HasSequence("settlement_address_link_settlement_address_link_id_seq");

            modelBuilder.HasSequence("settlement_location_settlement_location_id_seq");
        }
    }
}