using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace Models.Models;

public partial class PhronCareOperationsHubContext : DbContext
{
    public PhronCareOperationsHubContext(DbContextOptions<PhronCareOperationsHubContext> options)
        : base(options)
    {
    }

    public virtual DbSet<PhLsmExpeditionDetail> PhLsmExpeditionDetails { get; set; }

    public virtual DbSet<PhLsmExpeditionHeader> PhLsmExpeditionHeaders { get; set; }

    public virtual DbSet<PhLsmProduct> PhLsmProducts { get; set; }

    public virtual DbSet<PhLsmProductDivision> PhLsmProductDivisions { get; set; }

    public virtual DbSet<PhLsmProductSet> PhLsmProductSets { get; set; }

    public virtual DbSet<PhLsmProductSetItem> PhLsmProductSetItems { get; set; }

    public virtual DbSet<PhLsmStockEntry> PhLsmStockEntries { get; set; }

    public virtual DbSet<PhLsmStockItem> PhLsmStockItems { get; set; }

    public virtual DbSet<PhLsmStockLocation> PhLsmStockLocations { get; set; }

    public virtual DbSet<PhLsmStockOut> PhLsmStockOuts { get; set; }

    public virtual DbSet<PhLsmStockReservation> PhLsmStockReservations { get; set; }

    public virtual DbSet<PhLsmUnitOfMeasure> PhLsmUnitOfMeasures { get; set; }

    public virtual DbSet<PhOhArcadocumentType> PhOhArcadocumentTypes { get; set; }

    public virtual DbSet<PhOhArcataxType> PhOhArcataxTypes { get; set; }

    public virtual DbSet<PhOhExchangeRateHistory> PhOhExchangeRateHistories { get; set; }

    public virtual DbSet<PhOhTaxCondition> PhOhTaxConditions { get; set; }

    public virtual DbSet<PhOhTicket> PhOhTickets { get; set; }

    public virtual DbSet<PhSAccountType> PhSAccountTypes { get; set; }

    public virtual DbSet<PhSAdjustmentReason> PhSAdjustmentReasons { get; set; }

    public virtual DbSet<PhSBusinessUnit> PhSBusinessUnits { get; set; }

    public virtual DbSet<PhSCustomer> PhSCustomers { get; set; }

    public virtual DbSet<PhSCustomerAddress> PhSCustomerAddresses { get; set; }

    public virtual DbSet<PhSCustomerDocument> PhSCustomerDocuments { get; set; }

    public virtual DbSet<PhSDeliveryNote> PhSDeliveryNotes { get; set; }

    public virtual DbSet<PhSDeliveryNoteDetail> PhSDeliveryNoteDetails { get; set; }

    public virtual DbSet<PhSDocumentType> PhSDocumentTypes { get; set; }

    public virtual DbSet<PhSFormSeries> PhSFormSeries { get; set; }

    public virtual DbSet<PhSFormSeriesNextNumber> PhSFormSeriesNextNumbers { get; set; }

    public virtual DbSet<PhSFormType> PhSFormTypes { get; set; }

    public virtual DbSet<PhSInstitution> PhSInstitutions { get; set; }

    public virtual DbSet<PhSPatient> PhSPatients { get; set; }

    public virtual DbSet<PhSPaymentTerm> PhSPaymentTerms { get; set; }

    public virtual DbSet<PhSPeopleGroup> PhSPeopleGroups { get; set; }

    public virtual DbSet<PhSPerson> PhSPeople { get; set; }

    public virtual DbSet<PhSProduct> PhSProducts { get; set; }

    public virtual DbSet<PhSProductCategory> PhSProductCategories { get; set; }

    public virtual DbSet<PhSProfessional> PhSProfessionals { get; set; }

    public virtual DbSet<PhSProfessionalSpecialty> PhSProfessionalSpecialties { get; set; }

    public virtual DbSet<PhSQuoteAdjustment> PhSQuoteAdjustments { get; set; }

    public virtual DbSet<PhSQuoteDetail> PhSQuoteDetails { get; set; }

    public virtual DbSet<PhSQuoteHeader> PhSQuoteHeaders { get; set; }

    public virtual DbSet<PhSQuoteRole> PhSQuoteRoles { get; set; }

    public virtual DbSet<PhSQuoteTaxis> PhSQuoteTaxes { get; set; }

    public virtual DbSet<PhSSalesDocument> PhSSalesDocuments { get; set; }

    public virtual DbSet<PhSSalesDocumentCoverage> PhSSalesDocumentCoverages { get; set; }

    public virtual DbSet<PhSSalesDocumentDetail> PhSSalesDocumentDetails { get; set; }

    public virtual DbSet<PhSSalesFiscalDocument> PhSSalesFiscalDocuments { get; set; }

    public virtual DbSet<PhSSalesFiscalDocumentAssociation> PhSSalesFiscalDocumentAssociations { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.UseCollation("Modern_Spanish_CI_AS");

        modelBuilder.Entity<PhLsmExpeditionDetail>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Ex__3213E83F030D2D60");

            entity.ToTable("PhLSM_ExpeditionDetails");

            entity.HasIndex(e => e.ExpeditionId, "IX_PhLSM_ExpeditionDetails_Expedition");

            entity.HasIndex(e => new { e.ExpeditionId, e.StockitemId }, "IX_PhLSM_ExpeditionDetails_Expedition_StockItem");

            entity.HasIndex(e => e.ProductId, "IX_PhLSM_ExpeditionDetails_Product");

            entity.HasIndex(e => e.StockitemId, "IX_PhLSM_ExpeditionDetails_StockItem");

            entity.Property(e => e.Id)
                .HasComment("Identificador interno del ítem de expedición")
                .HasColumnName("id");
            entity.Property(e => e.Batch)
                .HasMaxLength(50)
                .HasComment("Número de lote (si aplica trazabilidad)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("batch");
            entity.Property(e => e.Description)
                .HasMaxLength(200)
                .HasComment("Descripción libre del ítem (uso interno o impresión)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("description");
            entity.Property(e => e.EstimatedCurrency)
                .HasMaxLength(3)
                .HasComment("Moneda del precio estimado (ej: ARS, USD)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("estimated_currency");
            entity.Property(e => e.EstimatedExchangerate)
                .HasComment("Tipo de cambio aplicado al precio estimado")
                .HasColumnType("decimal(10, 4)")
                .HasColumnName("estimated_exchangerate");
            entity.Property(e => e.EstimatedUnitprice)
                .HasComment("Precio estimado unitario del producto (sin efecto contable)")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("estimated_unitprice");
            entity.Property(e => e.ExpeditionId)
                .HasComment("Referencia a la cabecera de expedición (PhLSM_ExpeditionHeaders)")
                .HasColumnName("expedition_id");
            entity.Property(e => e.Expiration)
                .HasComment("Fecha de vencimiento del producto (si aplica trazabilidad)")
                .HasColumnName("expiration");
            entity.Property(e => e.LocationId)
                .HasComment("Ubicación específica desde donde se despacha este ítem")
                .HasColumnName("location_id");
            entity.Property(e => e.ProductId)
                .HasComment("Producto médico a despachar")
                .HasColumnName("product_id");
            entity.Property(e => e.Quantity)
                .HasComment("Cantidad solicitada del producto")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("quantity");
            entity.Property(e => e.Serial)
                .HasMaxLength(100)
                .HasComment("Número de serie de la unidad individual, según etiqueta de trazabilidad del fabricante.")
                .HasColumnName("serial");
            entity.Property(e => e.StockitemId)
                .HasComment("Referencia a StockItem (PhLSM_StockItem)")
                .HasColumnName("stockitem_id");

            entity.HasOne(d => d.Expedition).WithMany(p => p.PhLsmExpeditionDetails)
                .HasForeignKey(d => d.ExpeditionId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_ExpeditionDetails_PhLSM_ExpeditionHeaders");

            entity.HasOne(d => d.Product).WithMany(p => p.PhLsmExpeditionDetails)
                .HasForeignKey(d => d.ProductId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_ExpeditionDetails_PhLSM_Product");

            entity.HasOne(d => d.Stockitem).WithMany(p => p.PhLsmExpeditionDetails)
                .HasForeignKey(d => d.StockitemId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_ExpeditionDetails_PhLSM_StockItem");
        });

        modelBuilder.Entity<PhLsmExpeditionHeader>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Ex__3213E83FBD69DF6E");

            entity.ToTable("PhLSM_ExpeditionHeaders");

            entity.HasIndex(e => e.Expeditionnumber, "UX_PhLSM_ExpeditionHeaders_Number").IsUnique();

            entity.Property(e => e.Id)
                .HasComment("Identificador interno de la expedición")
                .HasColumnName("id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Expeditionnumber)
                .HasMaxLength(20)
                .HasComment("Número de expedición (formato EX-00000001)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("expeditionnumber");
            entity.Property(e => e.ExternalReference)
                .HasMaxLength(100)
                .HasComment("ID externo relacionado a otro módulo (ej: ticket, orden)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("external_reference");
            entity.Property(e => e.ExtrainfoJson)
                .HasComment("Información adicional en formato JSON (ej: paciente, médico, etc.)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("extrainfo_json");
            entity.Property(e => e.Issuedate)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de emisión de la expedición")
                .HasColumnType("datetime")
                .HasColumnName("issuedate");
            entity.Property(e => e.LocationId)
                .HasComment("Ubicación (depósito) desde donde se despacha")
                .HasColumnName("location_id");
            entity.Property(e => e.Modifiedat)
                .HasComment("Fecha de última modificación del registro")
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Observations)
                .HasComment("Observaciones generales de la expedición")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("observations");
            entity.Property(e => e.OriginType)
                .HasMaxLength(20)
                .HasComment("Tipo de origen externo (ej: surgery, demo, préstamo)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("origin_type");
            entity.Property(e => e.Printcount)
                .HasComment("Cantidad de veces que se imprimió la nota de expedición")
                .HasColumnName("printcount");
            entity.Property(e => e.RecipientName)
                .HasMaxLength(100)
                .HasComment("Nombre del destinatario visible en la impresión")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("recipient_name");
            entity.Property(e => e.ReferenceNumber)
                .HasMaxLength(50)
                .HasComment("Número o referencia externa asociada")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("reference_number");
            entity.Property(e => e.Status)
                .HasComment("Estado de la expedición (1=Borrador, 2=Confirmada, etc.)")
                .HasColumnName("status");
            entity.Property(e => e.TicketId)
                .HasComment("Referencia al ticket quirúrgico (si aplica)")
                .HasColumnName("ticket_id");
        });

        modelBuilder.Entity<PhLsmProduct>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Pr__3213E83F874510C5");

            entity.ToTable("PhLSM_Product");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del producto médico o industrial")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(255)
                .HasComment("Descripción comercial o práctica del producto (impresión logística, uso cotidiano)")
                .HasColumnName("descripcion");
            entity.Property(e => e.DivisionId)
                .HasComment("División o familia técnica del producto (ej: columna, trauma, descartables, etc.)")
                .HasColumnName("division_id");
            entity.Property(e => e.ExternalCode)
                .HasMaxLength(50)
                .HasComment("Código externo estándar del producto (ej: GTIN, código de proveedor, catálogo EAN, etc.)")
                .HasColumnName("external_code");
            entity.Property(e => e.FactoryCode)
                .HasMaxLength(50)
                .HasComment("Código de producto definido por la fábrica o fabricante. Puede variar según proveedor, presentación o país de origen.")
                .HasColumnName("factory_code");
            entity.Property(e => e.Name)
                .HasMaxLength(255)
                .HasComment("Nombre técnico o estandarizado del producto (ej: ficha técnica, fabricante)")
                .HasColumnName("name");
            entity.Property(e => e.PlusProcess)
                .HasComment("Indica si el producto requiere un proceso adicional previo a su uso (ej: esterilización, calibración, limpieza, inspección, etc.)")
                .HasColumnName("plus_process");
            entity.Property(e => e.ProductType)
                .HasComment("Tipo de producto: 1=Implantable, 2=Instrumental, 3=Inyectable, etc.")
                .HasColumnName("product_type");
            entity.Property(e => e.RegulatoryCode)
                .HasMaxLength(50)
                .HasComment("Código regulatorio (PM) o registro sanitario oficial del producto. Registro otorgado por ANMAT u ente regulador.")
                .HasColumnName("regulatory_code");
            entity.Property(e => e.TraceabilityType)
                .HasComment("Tipo de trazabilidad: 1=No aplica, 2=Por cantidad, 3=Por lote y vencimiento")
                .HasColumnName("traceability_type");
            entity.Property(e => e.UnitId)
                .HasComment("Unidad de medida base del producto (ej: unidad, mililitro, metro)")
                .HasColumnName("unit_id");

            entity.HasOne(d => d.Division).WithMany(p => p.PhLsmProducts)
                .HasForeignKey(d => d.DivisionId)
                .HasConstraintName("FK__PhLSM_Pro__divis__2EFAF1E2");

            entity.HasOne(d => d.Unit).WithMany(p => p.PhLsmProducts)
                .HasForeignKey(d => d.UnitId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_Product_Unit");
        });

        modelBuilder.Entity<PhLsmProductDivision>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Pr__3213E83F27FDF540");

            entity.ToTable("PhLSM_ProductDivision");

            entity.HasIndex(e => e.Code, "UQ_PhLSM_ProductDivision_code").IsUnique();

            entity.Property(e => e.Id)
                .HasComment("Identificador único de la división de productos")
                .HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(50)
                .HasDefaultValue("")
                .HasComment("Código breve de la división, coincide con la línea original (ej: TCLO, CMF_J)")
                .HasColumnName("code");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasComment("Descripción adicional de la división de productos (opcional)")
                .HasColumnName("description");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasComment("Nombre de la división o familia técnica de productos (ej: columna, trauma, descartables, etc.)")
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhLsmProductSet>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Pr__3213E83F047D4048");

            entity.ToTable("PhLSM_ProductSet");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del set de productos")
                .HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(50)
                .HasComment("Código del set (ej: CMF1.2, TRAUMA2.0)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("code");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(255)
                .HasComment("Descripción extendida del set de productos")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("descripcion");
            entity.Property(e => e.Modifiedat)
                .HasComment("Fecha de última modificación del registro")
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasComment("Nombre comercial o técnico del set")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("name");
            entity.Property(e => e.PlusProcess)
                .HasComment("Indica si el set requiere un proceso adicional (ej: esterilización)")
                .HasColumnName("plus_process");
        });

        modelBuilder.Entity<PhLsmProductSetItem>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Pr__3213E83F681F74CE");

            entity.ToTable("PhLSM_ProductSetItem");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del ítem dentro del set")
                .HasColumnName("id");
            entity.Property(e => e.DefaultQuantity)
                .HasComment("Cantidad estándar del producto en el set")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("default_quantity");
            entity.Property(e => e.Mandatory)
                .HasDefaultValue(true)
                .HasComment("Indica si este ítem es obligatorio en la composición del set")
                .HasColumnName("mandatory");
            entity.Property(e => e.ProductId)
                .HasComment("Producto incluido en el set")
                .HasColumnName("product_id");
            entity.Property(e => e.ProductsetId)
                .HasComment("ID del set al que pertenece este ítem")
                .HasColumnName("productset_id");

            entity.HasOne(d => d.Product).WithMany(p => p.PhLsmProductSetItems)
                .HasForeignKey(d => d.ProductId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_ProductSetItem_Product");

            entity.HasOne(d => d.Productset).WithMany(p => p.PhLsmProductSetItems)
                .HasForeignKey(d => d.ProductsetId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_ProductSetItem_Set");
        });

        modelBuilder.Entity<PhLsmStockEntry>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_St__3213E83F7F20E170");

            entity.ToTable("PhLSM_StockEntry");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del ingreso de stock")
                .HasColumnName("id");
            entity.Property(e => e.Batch)
                .HasMaxLength(50)
                .HasComment("Lote del producto ingresado (si aplica trazabilidad)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("batch");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Currency)
                .HasMaxLength(3)
                .HasComment("Moneda utilizada en la valorización (ARS, USD, EUR)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("currency");
            entity.Property(e => e.Entrydate)
                .HasComment("Fecha del ingreso de stock")
                .HasColumnType("datetime")
                .HasColumnName("entrydate");
            entity.Property(e => e.Exchangerate)
                .HasDefaultValue(1m)
                .HasComment("Tasa de conversión de la moneda a ARS")
                .HasColumnType("decimal(10, 4)")
                .HasColumnName("exchangerate");
            entity.Property(e => e.Expiration)
                .HasComment("Fecha de vencimiento del producto ingresado (si aplica)")
                .HasColumnName("expiration");
            entity.Property(e => e.LocationId)
                .HasComment("Ubicación física donde se depositó el producto")
                .HasColumnName("location_id");
            entity.Property(e => e.ProductId)
                .HasComment("Producto ingresado al stock")
                .HasColumnName("product_id");
            entity.Property(e => e.Quantity)
                .HasComment("Cantidad ingresada del producto")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("quantity");
            entity.Property(e => e.Reference)
                .HasMaxLength(100)
                .HasComment("Referencia visible del movimiento (ej: factura, orden de compra)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("reference");
            entity.Property(e => e.SourceId)
                .HasComment("ID de la entidad que generó el ingreso (ej: orden de compra)")
                .HasColumnName("source_id");
            entity.Property(e => e.Sourcetype)
                .HasMaxLength(50)
                .HasComment("Tipo de origen del ingreso (purchase, return, manual, etc.)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("sourcetype");
            entity.Property(e => e.Unitprice)
                .HasComment("Precio unitario usado para valorizar el ingreso")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("unitprice");

            entity.HasOne(d => d.Product).WithMany(p => p.PhLsmStockEntries)
                .HasForeignKey(d => d.ProductId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_StockEntry_PhLSM_Product");
        });

        modelBuilder.Entity<PhLsmStockItem>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_St__3213E83FB413CCCD");

            entity.ToTable("PhLSM_StockItem");

            entity.HasIndex(e => new { e.ProductId, e.LocationId, e.Batch }, "UQ_PhLSM_StockItem_ProdLoc_BatchOnly")
                .IsUnique()
                .HasFilter("([serial] IS NULL AND [batch] IS NOT NULL AND [expiration] IS NULL)");

            entity.HasIndex(e => new { e.ProductId, e.LocationId, e.Batch, e.Expiration }, "UQ_PhLSM_StockItem_ProdLoc_Batch_Exp")
                .IsUnique()
                .HasFilter("([serial] IS NULL AND [batch] IS NOT NULL AND [expiration] IS NOT NULL)");

            entity.HasIndex(e => new { e.ProductId, e.LocationId }, "UQ_PhLSM_StockItem_ProdLoc_None")
                .IsUnique()
                .HasFilter("([serial] IS NULL AND [batch] IS NULL AND [expiration] IS NULL)");

            entity.HasIndex(e => new { e.ProductId, e.Serial }, "UQ_PhLSM_StockItem_Product_Serial")
                .IsUnique()
                .HasFilter("([serial] IS NOT NULL)");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del ítem de stock físico")
                .HasColumnName("id");
            entity.Property(e => e.Batch)
                .HasMaxLength(100)
                .HasComment("Código de lote (si aplica)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("batch");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasComment("Comentario libre u observación sobre este ítem de stock")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("description");
            entity.Property(e => e.Expiration)
                .HasComment("Fecha de vencimiento (si aplica)")
                .HasColumnName("expiration");
            entity.Property(e => e.LocationId)
                .HasComment("Ubicación física del stock (depósito, valija, etc.)")
                .HasColumnName("location_id");
            entity.Property(e => e.Modifiedat)
                .HasComment("Fecha de última modificación del registro")
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.ProductId)
                .HasComment("Producto vinculado al ítem de stock")
                .HasColumnName("product_id");
            entity.Property(e => e.Quantity)
                .HasComment("Cantidad actual disponible en esta unidad de stock")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("quantity");
            entity.Property(e => e.ReservedQuantity)
                .HasComment("Cantidad comprometida o reservada para expediciones futuras")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("reserved_quantity");
            entity.Property(e => e.Serial)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasComment("Número de serie de la unidad individual, según etiqueta de trazabilidad del fabricante.")
                .HasColumnName("serial");
            entity.Property(e => e.Status)
                .HasComment("Estado del ítem (1=Disponible, 2=Reservado, 3=Vencido, etc.)")
                .HasColumnName("status");

            entity.HasOne(d => d.Location).WithMany(p => p.PhLsmStockItems)
                .HasForeignKey(d => d.LocationId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_StockItem_PhLSM_StockLocation");

            entity.HasOne(d => d.Product).WithMany(p => p.PhLsmStockItems)
                .HasForeignKey(d => d.ProductId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_StockItem_PhLSM_Product");
        });

        modelBuilder.Entity<PhLsmStockLocation>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_St__3213E83F68EA6A9A");

            entity.ToTable("PhLSM_StockLocation");

            entity.Property(e => e.Id)
                .HasComment("Identificador único de la ubicación de stock")
                .HasColumnName("id");
            entity.Property(e => e.Descripcion)
                .HasMaxLength(255)
                .HasComment("Descripción o comentario adicional sobre la ubicación")
                .HasColumnName("descripcion");
            entity.Property(e => e.Nombre)
                .HasMaxLength(100)
                .HasComment("Nombre visible de la ubicación (ej: Depósito Central, Cuarentena, Caja A1)")
                .HasColumnName("nombre");
        });

        modelBuilder.Entity<PhLsmStockOut>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_St__3213E83F1399BE0F");

            entity.ToTable("PhLSM_StockOut");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del egreso de stock")
                .HasColumnName("id");
            entity.Property(e => e.Batch)
                .HasMaxLength(50)
                .HasComment("Lote del producto egresado (si aplica trazabilidad)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("batch");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Currency)
                .HasMaxLength(3)
                .HasComment("Moneda utilizada en la valorización (ARS, USD, EUR)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("currency");
            entity.Property(e => e.Exchangerate)
                .HasDefaultValue(1m)
                .HasComment("Tasa de conversión de la moneda a ARS")
                .HasColumnType("decimal(10, 4)")
                .HasColumnName("exchangerate");
            entity.Property(e => e.Expiration)
                .HasComment("Fecha de vencimiento del producto egresado (si aplica)")
                .HasColumnName("expiration");
            entity.Property(e => e.LocationId)
                .HasComment("Ubicación física desde donde se retiró el producto")
                .HasColumnName("location_id");
            entity.Property(e => e.Outdate)
                .HasComment("Fecha del egreso de stock")
                .HasColumnType("datetime")
                .HasColumnName("outdate");
            entity.Property(e => e.ProductId)
                .HasComment("Producto retirado del stock")
                .HasColumnName("product_id");
            entity.Property(e => e.Quantity)
                .HasComment("Cantidad retirada del producto")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("quantity");
            entity.Property(e => e.Reference)
                .HasMaxLength(100)
                .HasComment("Referencia visible del movimiento (NE, devolución, cirugía)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("reference");
            entity.Property(e => e.SourceId)
                .HasComment("ID de la entidad que generó el egreso (ej: nota de expedición)")
                .HasColumnName("source_id");
            entity.Property(e => e.Sourcetype)
                .HasMaxLength(50)
                .HasComment("Tipo de origen del egreso (surgery, expiration, manual, etc.)")
                .UseCollation("Latin1_General_CI_AS")
                .HasColumnName("sourcetype");
            entity.Property(e => e.TicketId)
                .HasComment("Identificador del caso quirúrgico asociado al egreso")
                .HasColumnName("ticket_id");
            entity.Property(e => e.Unitprice)
                .HasComment("Precio unitario usado para valorizar el egreso")
                .HasColumnType("decimal(18, 4)")
                .HasColumnName("unitprice");

            entity.HasOne(d => d.Product).WithMany(p => p.PhLsmStockOuts)
                .HasForeignKey(d => d.ProductId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_StockOut_PhLSM_Product");
        });

        modelBuilder.Entity<PhLsmStockReservation>(entity =>
        {
            entity.ToTable("PhLSM_StockReservation", tb => tb.HasComment("Reservas de stock por origen genérico (source_type/source_id). Cada fila bloquea cantidad sobre un StockItem. No duplica lote/serie/vencimiento; se resuelve por JOIN a PhLSM_StockItem."));

            entity.HasIndex(e => new { e.SourceType, e.SourceId, e.Status }, "IX_PhLSM_StockReservation_Source_Status");

            entity.HasIndex(e => e.StockitemId, "IX_PhLSM_StockReservation_StockItem_Reserved").HasFilter("([status]=(1))");

            entity.HasIndex(e => new { e.SourceType, e.SourceId, e.StockitemId }, "UX_PhLSM_StockReservation_Source_StockItem_Consumed")
                .IsUnique()
                .HasFilter("([status]=(3))");

            entity.HasIndex(e => new { e.SourceType, e.SourceId, e.StockitemId }, "UX_PhLSM_StockReservation_Source_StockItem_Reserved")
                .IsUnique()
                .HasFilter("([status]=(1))");

            entity.Property(e => e.Id)
                .HasComment("Identificador autoincremental de la reserva.")
                .HasColumnName("id");
            entity.Property(e => e.Createdat)
                .HasPrecision(0)
                .HasDefaultValueSql("(sysutcdatetime())")
                .HasComment("Fecha/hora de creación (UTC).")
                .HasColumnName("createdat");
            entity.Property(e => e.Modifiedat)
                .HasPrecision(0)
                .HasComment("Última modificación (UTC). Puede ser NULL si nunca se actualizó.")
                .HasColumnName("modifiedat");
            entity.Property(e => e.ReservedQuantity)
                .HasComment("Cantidad reservada (bloqueada). No disponible mientras status=1 (Reserved).")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("reserved_quantity");
            entity.Property(e => e.Rowversion)
                .IsRowVersion()
                .IsConcurrencyToken()
                .HasComment("Token de concurrencia optimista (ROWVERSION) para actualizaciones seguras.")
                .HasColumnName("rowversion");
            entity.Property(e => e.SourceId)
                .HasComment("Identificador del origen. Ej.: expedition_id cuando source_type=1.")
                .HasColumnName("source_id");
            entity.Property(e => e.SourceType)
                .HasDefaultValue((byte)1)
                .HasComment("Tipo de origen de la reserva. 1=Expedition (extensible a futuros orígenes).")
                .HasColumnName("source_type");
            entity.Property(e => e.Status)
                .HasDefaultValue(1)
                .HasComment("Estado de la reserva: 1=Reserved, 2=Released, 3=Consumed.")
                .HasColumnName("status");
            entity.Property(e => e.StockitemId)
                .HasComment("Referencia al StockItem exacto bloqueado (FK a PhLSM_StockItem). Define producto/ubicación/trazabilidad por JOIN.")
                .HasColumnName("stockitem_id");

            entity.HasOne(d => d.Stockitem).WithMany(p => p.PhLsmStockReservations)
                .HasForeignKey(d => d.StockitemId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhLSM_StockReservation_StockItem");
        });

        modelBuilder.Entity<PhLsmUnitOfMeasure>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhLSM_Un__3213E83FD70349B6");

            entity.ToTable("PhLSM_UnitOfMeasure");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(10)
                .HasComment("Código abreviado de unidad de medida (ej: UN, ML, MT)")
                .HasColumnName("code");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasComment("Descripción extendida o notas adicionales sobre la unidad")
                .HasColumnName("description");
            entity.Property(e => e.Name)
                .HasMaxLength(50)
                .HasComment("Nombre descriptivo de la unidad de medida")
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhOhArcadocumentType>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhOH_ARC__3213E83FF8940395");

            entity.ToTable("PhOH_ARCADocumentTypes", tb => tb.HasComment("Catálogo oficial de tipos de comprobantes AFIP."));

            entity.Property(e => e.Id)
                .ValueGeneratedNever()
                .HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(3)
                .IsUnicode(false)
                .IsFixedLength()
                .HasColumnName("code");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasColumnName("description");
            entity.Property(e => e.Isactive)
                .HasDefaultValue(true)
                .HasColumnName("isactive");
            entity.Property(e => e.Letter)
                .HasMaxLength(1)
                .IsUnicode(false)
                .IsFixedLength()
                .HasColumnName("letter");
        });

        modelBuilder.Entity<PhOhArcataxType>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhOH_ARC__3213E83F4205B7E5");

            entity.ToTable("PhOH_ARCATaxTypes", tb => tb.HasComment("Tabla de referencia de tipos de impuestos según AFIP para operaciones de venta."));

            entity.Property(e => e.Id)
                .HasComment("Identificador único del impuesto.")
                .HasColumnName("id");
            entity.Property(e => e.CreatedAt)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro.")
                .HasColumnType("datetime")
                .HasColumnName("created_at");
            entity.Property(e => e.Description)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasComment("Descripción del impuesto.")
                .HasColumnName("description");
            entity.Property(e => e.IsActive)
                .HasDefaultValue(true)
                .HasComment("Indica si el impuesto está activo (1) o inactivo (0).")
                .HasColumnName("is_active");
            entity.Property(e => e.ModifiedAt)
                .HasComment("Fecha de última modificación del registro.")
                .HasColumnType("datetime")
                .HasColumnName("modified_at");
            entity.Property(e => e.TaxCode)
                .HasComment("Código oficial del impuesto según AFIP.")
                .HasColumnName("tax_code");
            entity.Property(e => e.Taxrate)
                .HasComment("Porcentaje de la alícuota aplicable al impuesto, expresado como un valor decimal. Una alícuota del 21%, se debe almacenar el valor 21.00")
                .HasColumnType("decimal(18, 0)")
                .HasColumnName("taxrate");
        });

        modelBuilder.Entity<PhOhExchangeRateHistory>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhOH_Exc__3213E83F4D9813B8");

            entity.ToTable("PhOH_ExchangeRateHistory", tb => tb.HasComment("Histórico de cotizaciones diarias del dólar oficial del BCRA"));

            entity.HasIndex(e => e.Ratedate, "UQ__PhOH_Exc__81B17E87D8FDABB7").IsUnique();

            entity.Property(e => e.Id)
                .HasComment("Clave primaria autonumérica")
                .HasColumnName("id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(sysutcdatetime())")
                .HasComment("Fecha y hora en que se guardó el registro")
                .HasColumnName("createdat");
            entity.Property(e => e.Purchaserate)
                .HasComment("Tasa de compra del dólar oficial")
                .HasColumnType("decimal(18, 6)")
                .HasColumnName("purchaserate");
            entity.Property(e => e.Ratedate)
                .HasComment("Fecha de la cotización (por ejemplo, 2025-05-06)")
                .HasColumnName("ratedate");
            entity.Property(e => e.Salerate)
                .HasComment("Tasa de venta del dólar oficial")
                .HasColumnType("decimal(18, 6)")
                .HasColumnName("salerate");
            entity.Property(e => e.Source)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasDefaultValue("BCRA")
                .HasComment("Origen del dato (por ejemplo, BCRA, Blue, MEP, etc.)")
                .HasColumnName("source");
        });

        modelBuilder.Entity<PhOhTaxCondition>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhOH_Tax__3213E83F26F7EAEF");

            entity.ToTable("PhOH_Tax_Conditions");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.CmpClase)
                .HasMaxLength(10)
                .HasColumnName("cmp_clase");
            entity.Property(e => e.Description)
                .HasMaxLength(100)
                .HasColumnName("description");
        });

        modelBuilder.Entity<PhOhTicket>(entity =>
        {
            entity.HasKey(e => e.TicketId).HasName("PK__PhOH_Tic__712CC607E630F981");

            entity.ToTable("PhOH_Tickets");

            entity.Property(e => e.TicketId).HasDefaultValueSql("(newid())");
            entity.Property(e => e.AsignadoAusuarioId)
                .HasMaxLength(128)
                .HasColumnName("AsignadoAUsuarioId");
            entity.Property(e => e.Categoria).HasMaxLength(50);
            entity.Property(e => e.CreadorUsuarioId).HasMaxLength(128);
            entity.Property(e => e.Departamento).HasMaxLength(50);
            entity.Property(e => e.Estado).HasMaxLength(50);
            entity.Property(e => e.FechaCreacion).HasColumnType("datetime");
            entity.Property(e => e.FechaEjecucion).HasColumnType("datetime");
            entity.Property(e => e.Impacto).HasMaxLength(50);
            entity.Property(e => e.Prioridad).HasMaxLength(50);
            entity.Property(e => e.Urgencia).HasMaxLength(50);
        });

        modelBuilder.Entity<PhSAccountType>(entity =>
        {
            entity.ToTable("PhS_AccountTypes");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.CreationDate)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("creation_date");
            entity.Property(e => e.CreditLimit)
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("credit_limit");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasColumnName("description");
            entity.Property(e => e.Name)
                .HasMaxLength(50)
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhSAdjustmentReason>(entity =>
        {
            entity.HasKey(e => e.Code).HasName("PK__PhS_Adju__357D4CF809676D8C");

            entity.ToTable("PhS_AdjustmentReasons");

            entity.Property(e => e.Code)
                .HasMaxLength(50)
                .IsUnicode(false)
                .HasColumnName("code");
            entity.Property(e => e.Active)
                .HasDefaultValue(true)
                .HasColumnName("active");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Description)
                .HasMaxLength(100)
                .HasColumnName("description");
        });

        modelBuilder.Entity<PhSBusinessUnit>(entity =>
        {
            entity.ToTable("PhS_BusinessUnits");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(10)
                .HasColumnName("code");
            entity.Property(e => e.Description)
                .HasMaxLength(100)
                .HasColumnName("description");
            entity.Property(e => e.Manager)
                .HasMaxLength(50)
                .HasColumnName("manager");
        });

        modelBuilder.Entity<PhSCustomer>(entity =>
        {
            entity.ToTable("PhS_Customers");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.AccounttypesId).HasColumnName("accounttypes_id");
            entity.Property(e => e.Active).HasColumnName("active");
            entity.Property(e => e.BusinessName)
                .HasMaxLength(100)
                .HasColumnName("business_name");
            entity.Property(e => e.CreditLimit)
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("credit_limit");
            entity.Property(e => e.ExternalCode)
                .HasMaxLength(10)
                .IsFixedLength()
                .HasColumnName("external_code");
            entity.Property(e => e.HasCreditAccount).HasColumnName("has_credit_account");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasColumnName("name");
            entity.Property(e => e.TaxConditionId).HasColumnName("tax_condition_id");

            entity.HasOne(d => d.Accounttypes).WithMany(p => p.PhSCustomers)
                .HasForeignKey(d => d.AccounttypesId)
                .HasConstraintName("FK_PhS_Customers_PhS_AccountTypes");

            entity.HasOne(d => d.TaxCondition).WithMany(p => p.PhSCustomers)
                .HasForeignKey(d => d.TaxConditionId)
                .HasConstraintName("FK_PhS_Customers_PhOH_Tax_Conditions");
        });

        modelBuilder.Entity<PhSCustomerAddress>(entity =>
        {
            entity.ToTable("PhS_CustomerAddress");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.BusinessName)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasColumnName("business_name");
            entity.Property(e => e.City)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasColumnName("city");
            entity.Property(e => e.Country)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasColumnName("country");
            entity.Property(e => e.CustomersId).HasColumnName("customers_id");
            entity.Property(e => e.Email)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasColumnName("email");
            entity.Property(e => e.Latitude)
                .HasColumnType("decimal(9, 6)")
                .HasColumnName("latitude");
            entity.Property(e => e.Longitude)
                .HasColumnType("decimal(9, 6)")
                .HasColumnName("longitude");
            entity.Property(e => e.Notes)
                .HasMaxLength(255)
                .IsUnicode(false)
                .HasColumnName("notes");
            entity.Property(e => e.Phonenumber)
                .HasMaxLength(25)
                .IsUnicode(false)
                .HasColumnName("phonenumber");
            entity.Property(e => e.Postalcode)
                .HasMaxLength(20)
                .IsUnicode(false)
                .HasColumnName("postalcode");
            entity.Property(e => e.Stateprovince)
                .HasMaxLength(100)
                .IsUnicode(false)
                .HasColumnName("stateprovince");
            entity.Property(e => e.Streetaddress1)
                .HasMaxLength(255)
                .IsUnicode(false)
                .HasColumnName("streetaddress1");
            entity.Property(e => e.Streetaddress2)
                .HasMaxLength(255)
                .IsUnicode(false)
                .HasColumnName("streetaddress2");

            entity.HasOne(d => d.Customers).WithMany(p => p.PhSCustomerAddresses)
                .HasForeignKey(d => d.CustomersId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_CustomerAddress_PhS_Customers");
        });

        modelBuilder.Entity<PhSCustomerDocument>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Cust__3213E83F32E80850");

            entity.ToTable("PhS_CustomerDocuments");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.CustomersId).HasColumnName("customers_id");
            entity.Property(e => e.DocumentNumber)
                .HasMaxLength(50)
                .HasColumnName("document_number");
            entity.Property(e => e.DocumenttypesId).HasColumnName("documenttypes_id");
            entity.Property(e => e.ExpiryDate).HasColumnName("expiry_date");
            entity.Property(e => e.IssueDate).HasColumnName("issue_date");

            entity.HasOne(d => d.Customers).WithMany(p => p.PhSCustomerDocuments)
                .HasForeignKey(d => d.CustomersId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK__PhS_Custo__custo__6754599E");

            entity.HasOne(d => d.Documenttypes).WithMany(p => p.PhSCustomerDocuments)
                .HasForeignKey(d => d.DocumenttypesId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_CustomerDocuments_PhS_DocumentTypes");
        });

        modelBuilder.Entity<PhSDeliveryNote>(entity =>
        {
            entity.ToTable("PhS_DeliveryNotes");

            entity.HasIndex(e => e.CustomerId, "IX_PhS_DeliveryNotes_customer_id");

            entity.HasIndex(e => e.Issuedate, "IX_PhS_DeliveryNotes_issuedate");

            entity.HasIndex(e => e.QuoteId, "IX_PhS_DeliveryNotes_quote_id");

            entity.HasIndex(e => e.Status, "IX_PhS_DeliveryNotes_status");

            entity.HasIndex(e => e.Deliverynotenumber, "UQ_PhS_DeliveryNotes_deliverynotenumber").IsUnique();

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.CustomerId).HasColumnName("customer_id");
            entity.Property(e => e.Deliverynotenumber)
                .HasMaxLength(20)
                .IsUnicode(false)
                .HasColumnName("deliverynotenumber");
            entity.Property(e => e.ExtrainfoJson).HasColumnName("extrainfo_json");
            entity.Property(e => e.Issuedate)
                .HasColumnType("datetime")
                .HasColumnName("issuedate");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Observations)
                .HasMaxLength(1000)
                .HasColumnName("observations");
            entity.Property(e => e.Printcount).HasColumnName("printcount");
            entity.Property(e => e.QuoteId).HasColumnName("quote_id");
            entity.Property(e => e.SalesinvoiceId).HasColumnName("salesinvoice_id");
            entity.Property(e => e.Status)
                .HasMaxLength(20)
                .IsUnicode(false)
                .HasColumnName("status");

            entity.HasOne(d => d.Customer).WithMany(p => p.PhSDeliveryNotes)
                .HasForeignKey(d => d.CustomerId)
                .OnDelete(DeleteBehavior.ClientSetNull);

            entity.HasOne(d => d.Quote).WithMany(p => p.PhSDeliveryNotes).HasForeignKey(d => d.QuoteId);
        });

        modelBuilder.Entity<PhSDeliveryNoteDetail>(entity =>
        {
            entity.ToTable("PhS_DeliveryNoteDetails");

            entity.HasIndex(e => e.DeliverynoteId, "IX_PhS_DeliveryNoteDetails_deliverynote_id");

            entity.HasIndex(e => new { e.DeliverynoteId, e.LineNumber }, "IX_PhS_DeliveryNoteDetails_deliverynote_id_line_number");

            entity.HasIndex(e => new { e.OriginType, e.OriginId }, "IX_PhS_DeliveryNoteDetails_origin_type_origin_id");

            entity.HasIndex(e => e.QuoteDetailId, "IX_PhS_DeliveryNoteDetails_quote_detail_id");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.DeliverynoteId).HasColumnName("deliverynote_id");
            entity.Property(e => e.Description).HasColumnName("description");
            entity.Property(e => e.LineNumber).HasColumnName("line_number");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Notes)
                .HasMaxLength(1000)
                .HasDefaultValue("")
                .HasColumnName("notes");
            entity.Property(e => e.OriginId).HasColumnName("origin_id");
            entity.Property(e => e.OriginType).HasColumnName("origin_type");
            entity.Property(e => e.Quantity)
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("quantity");
            entity.Property(e => e.QuoteDetailId).HasColumnName("quote_detail_id");

            entity.HasOne(d => d.Deliverynote).WithMany(p => p.PhSDeliveryNoteDetails)
                .HasForeignKey(d => d.DeliverynoteId)
                .OnDelete(DeleteBehavior.ClientSetNull);

            entity.HasOne(d => d.QuoteDetail).WithMany(p => p.PhSDeliveryNoteDetails).HasForeignKey(d => d.QuoteDetailId);
        });

        modelBuilder.Entity<PhSDocumentType>(entity =>
        {
            entity.ToTable("PhS_DocumentTypes");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(4)
                .HasColumnName("code");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasColumnName("description");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhSFormSeries>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Form__3213E83F7D86A419");

            entity.ToTable("PhS_FormSeries", tb => tb.HasComment("FormSeries: talonarios/series por tipo de formulario, letra y punto de venta."));

            entity.HasIndex(e => e.FormtypeId, "IX_PhS_FormSeries_FormType");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.FormtypeId)
                .HasComment("FK a tipo de formulario (PhS_FormTypes).")
                .HasColumnName("formtype_id");
            entity.Property(e => e.Isactive)
                .HasDefaultValue(true)
                .HasComment("Indica si está habilitada.")
                .HasColumnName("isactive");
            entity.Property(e => e.Isdefault)
                .HasComment("Marca esta serie como predeterminada.")
                .HasColumnName("isdefault");
            entity.Property(e => e.Letter)
                .HasMaxLength(1)
                .IsUnicode(false)
                .IsFixedLength()
                .HasComment("Letra de serie (A,B,C...).")
                .HasColumnName("letter");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.NumberingSource)
                .HasMaxLength(20)
                .IsUnicode(false)
                .HasDefaultValue("INTERNAL")
                .HasColumnName("numbering_source");
            entity.Property(e => e.Pointofsale)
                .HasComment("Punto de venta asignado.")
                .HasColumnName("pointofsale");

            entity.HasOne(d => d.Formtype).WithMany(p => p.PhSFormSeries)
                .HasForeignKey(d => d.FormtypeId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_FormSeries_FormTypes");
        });

        modelBuilder.Entity<PhSFormSeriesNextNumber>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Form__3213E83F60B7AAE4");

            entity.ToTable("PhS_FormSeriesNextNumber", tb => tb.HasComment("Mantiene el siguiente número correlativo para cada FormSeries."));

            entity.HasIndex(e => e.FormseriesId, "IX_PhS_NextNumber_FormSeriesId").IsUnique();

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.FormseriesId)
                .HasComment("FK a PhS_FormSeries.")
                .HasColumnName("formseries_id");
            entity.Property(e => e.Nextnumber)
                .HasComment("Próximo número correlativo.")
                .HasColumnName("nextnumber");

            entity.HasOne(d => d.Formseries).WithOne(p => p.PhSFormSeriesNextNumber)
                .HasForeignKey<PhSFormSeriesNextNumber>(d => d.FormseriesId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_NextNumber_FormSeries");
        });

        modelBuilder.Entity<PhSFormType>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Form__3213E83FF7278F22");

            entity.ToTable("PhS_FormTypes", tb => tb.HasComment("Tipos genéricos de formularios del sistema (presupuesto, factura, recibo, etc.)"));

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Code)
                .HasMaxLength(20)
                .IsUnicode(false)
                .HasColumnName("code");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhSInstitution>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Inst__3213E83F7645655B");

            entity.ToTable("PhS_Institutions");

            entity.HasIndex(e => e.Name, "IDX_PhS_Institutions_Name");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.City)
                .HasMaxLength(100)
                .HasColumnName("city");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Email)
                .HasMaxLength(150)
                .HasColumnName("email");
            entity.Property(e => e.Isactive)
                .HasDefaultValue(true)
                .HasColumnName("isactive");
            entity.Property(e => e.Name)
                .HasMaxLength(200)
                .HasColumnName("name");
            entity.Property(e => e.Operatingroominfo)
                .HasMaxLength(200)
                .HasColumnName("operatingroominfo");
            entity.Property(e => e.Phone)
                .HasMaxLength(50)
                .HasColumnName("phone");
            entity.Property(e => e.Province)
                .HasMaxLength(100)
                .HasColumnName("province");
            entity.Property(e => e.Streetaddress)
                .HasMaxLength(250)
                .HasColumnName("streetaddress");
            entity.Property(e => e.Type)
                .HasMaxLength(15)
                .HasColumnName("type");
        });

        modelBuilder.Entity<PhSPatient>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Pati__3213E83F93A6EB7E");

            entity.ToTable("PhS_Patients");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Address)
                .HasMaxLength(250)
                .HasColumnName("address");
            entity.Property(e => e.AffiliateNumber)
                .HasMaxLength(100)
                .HasColumnName("affiliate_number");
            entity.Property(e => e.Birthdate).HasColumnName("birthdate");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.CustomerId).HasColumnName("customer_id");
            entity.Property(e => e.DocumentNumber)
                .HasMaxLength(50)
                .HasColumnName("document_number");
            entity.Property(e => e.DocumenttypesId).HasColumnName("documenttypes_id");
            entity.Property(e => e.Email)
                .HasMaxLength(150)
                .HasColumnName("email");
            entity.Property(e => e.Firstname)
                .HasMaxLength(100)
                .HasColumnName("firstname");
            entity.Property(e => e.Gender)
                .HasMaxLength(10)
                .HasColumnName("gender");
            entity.Property(e => e.Lastname)
                .HasMaxLength(100)
                .HasColumnName("lastname");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Notes).HasColumnName("notes");
            entity.Property(e => e.Phone)
                .HasMaxLength(50)
                .HasColumnName("phone");

            entity.HasOne(d => d.Customer).WithMany(p => p.PhSPatients)
                .HasForeignKey(d => d.CustomerId)
                .HasConstraintName("FK_Patients_Customers");

            entity.HasOne(d => d.Documenttypes).WithMany(p => p.PhSPatients)
                .HasForeignKey(d => d.DocumenttypesId)
                .HasConstraintName("FK_Patients_DocumentTypes");
        });

        modelBuilder.Entity<PhSPaymentTerm>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Paym__3213E83F53A19842");

            entity.ToTable("PhS_PaymentTerms", tb => tb.HasComment("Tabla de condiciones o términos de pago aplicables a los presupuestos."));

            entity.Property(e => e.Id)
                .HasComment("Identificador único de la condición de pago.")
                .HasColumnName("id");
            entity.Property(e => e.Days)
                .HasComment("Cantidad de días establecidos para el pago. Contado = 0, 30 días = 30, etc.")
                .HasColumnName("days");
            entity.Property(e => e.Description)
                .HasMaxLength(100)
                .HasComment("Descripción de la condición de pago (ej: Contado, 30 días, etc.).")
                .HasColumnName("description");
            entity.Property(e => e.Isactive)
                .HasDefaultValue(true)
                .HasComment("Indica si el término de pago está activo (1) o no (0).")
                .HasColumnName("isactive");
        });

        modelBuilder.Entity<PhSPeopleGroup>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Peop__3213E83F8005BEA1");

            entity.ToTable("PhS_PeopleGroups");

            entity.Property(e => e.Id)
                .HasComment("Identificador único del grupo de personas")
                .HasColumnName("id");
            entity.Property(e => e.Active)
                .HasDefaultValue(true)
                .HasComment("Estado activo o inactivo del grupo")
                .HasColumnName("active");
            entity.Property(e => e.BusinessunitsId)
                .HasComment("Unidad de negocio relacionada (opcional)")
                .HasColumnName("businessunits_id");
            entity.Property(e => e.CreatedAt)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del grupo")
                .HasColumnType("datetime")
                .HasColumnName("created_at");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasComment("Descripción adicional del grupo")
                .HasColumnName("description");
            entity.Property(e => e.ModifiedAt)
                .HasComment("Fecha de última modificación")
                .HasColumnType("datetime")
                .HasColumnName("modified_at");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasComment("Nombre del grupo de vendedores")
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhSPerson>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Peop__3213E83F52F7C072");

            entity.ToTable("PhS_People");

            entity.Property(e => e.Id)
                .HasComment("Identificador único de la persona (vendedor/agente)")
                .HasColumnName("id");
            entity.Property(e => e.Active)
                .HasDefaultValue(true)
                .HasComment("Activo/Inactivo")
                .HasColumnName("active");
            entity.Property(e => e.BusinessunitsId)
                .HasComment("Unidad de negocio asignada")
                .HasColumnName("businessunits_id");
            entity.Property(e => e.CreatedAt)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación")
                .HasColumnType("datetime")
                .HasColumnName("created_at");
            entity.Property(e => e.DefaultCommissionPercent)
                .HasComment("Porcentaje de comisión por defecto")
                .HasColumnType("decimal(5, 2)")
                .HasColumnName("default_commission_percent");
            entity.Property(e => e.Email)
                .HasMaxLength(100)
                .HasComment("Correo electrónico de la persona")
                .HasColumnName("email");
            entity.Property(e => e.ModifiedAt)
                .HasComment("Fecha de última modificación")
                .HasColumnType("datetime")
                .HasColumnName("modified_at");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasComment("Nombre de la persona")
                .HasColumnName("name");
            entity.Property(e => e.PeoplegroupsId)
                .HasComment("Grupo comercial opcional")
                .HasColumnName("peoplegroups_id");
            entity.Property(e => e.Phone)
                .HasMaxLength(50)
                .HasComment("Teléfono de contacto de la persona")
                .HasColumnName("phone");

            entity.HasOne(d => d.Businessunits).WithMany(p => p.PhSPeople)
                .HasForeignKey(d => d.BusinessunitsId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_people_businessunits");

            entity.HasOne(d => d.Peoplegroups).WithMany(p => p.PhSPeople)
                .HasForeignKey(d => d.PeoplegroupsId)
                .HasConstraintName("FK_people_peoplegroups");
        });

        modelBuilder.Entity<PhSProduct>(entity =>
        {
            entity.ToTable("PhS_Products");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Baseprice)
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("baseprice");
            entity.Property(e => e.BusinessunitsId).HasColumnName("businessunits_id");
            entity.Property(e => e.Categoryid).HasColumnName("categoryid");
            entity.Property(e => e.Currency)
                .HasMaxLength(3)
                .IsUnicode(false)
                .HasDefaultValue("ARS")
                .HasColumnName("currency");
            entity.Property(e => e.Description).HasColumnName("description");
            entity.Property(e => e.Isactive)
                .HasDefaultValue(true)
                .HasColumnName("isactive");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .IsFixedLength()
                .HasColumnName("name");
            entity.Property(e => e.Origin)
                .HasMaxLength(12)
                .IsUnicode(false)
                .HasColumnName("origin");

            entity.HasOne(d => d.Businessunits).WithMany(p => p.PhSProducts)
                .HasForeignKey(d => d.BusinessunitsId)
                .HasConstraintName("FK_PhS_Products_PhS_BusinessUnits");

            entity.HasOne(d => d.Category).WithMany(p => p.PhSProducts)
                .HasForeignKey(d => d.Categoryid)
                .HasConstraintName("FK_PhS_Products_Categories");
        });

        modelBuilder.Entity<PhSProductCategory>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Prod__3214EC070BF59892");

            entity.ToTable("PhS_ProductCategories");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Description)
                .HasMaxLength(250)
                .HasColumnName("description");
            entity.Property(e => e.Isactive)
                .HasDefaultValue(true)
                .HasColumnName("isactive");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhSProfessional>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Prof__3213E83F86B052AD");

            entity.ToTable("PhS_Professionals");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Active)
                .HasDefaultValue(true)
                .HasColumnName("active");
            entity.Property(e => e.Address)
                .HasMaxLength(250)
                .HasColumnName("address");
            entity.Property(e => e.City)
                .HasMaxLength(100)
                .HasColumnName("city");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.DocumentNumber)
                .HasMaxLength(50)
                .HasColumnName("document_number");
            entity.Property(e => e.DocumenttypeName)
                .HasMaxLength(100)
                .HasColumnName("documenttype_name");
            entity.Property(e => e.Email)
                .HasMaxLength(150)
                .HasColumnName("email");
            entity.Property(e => e.Fullname)
                .HasMaxLength(200)
                .HasColumnName("fullname");
            entity.Property(e => e.License)
                .HasMaxLength(50)
                .HasColumnName("license");
            entity.Property(e => e.Phone1)
                .HasMaxLength(50)
                .HasColumnName("phone1");
            entity.Property(e => e.Phone2)
                .HasMaxLength(50)
                .HasColumnName("phone2");
            entity.Property(e => e.Postalcode)
                .HasMaxLength(20)
                .HasColumnName("postalcode");
            entity.Property(e => e.Province)
                .HasMaxLength(100)
                .HasColumnName("province");
            entity.Property(e => e.SpecialtyId).HasColumnName("specialty_id");
            entity.Property(e => e.Type)
                .HasMaxLength(25)
                .HasColumnName("type");

            entity.HasOne(d => d.Specialty).WithMany(p => p.PhSProfessionals)
                .HasForeignKey(d => d.SpecialtyId)
                .HasConstraintName("FK_Professionals_Specialty");
        });

        modelBuilder.Entity<PhSProfessionalSpecialty>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Prof__3213E83F14C8B007");

            entity.ToTable("PhS_ProfessionalSpecialties");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Active)
                .HasDefaultValue(true)
                .HasColumnName("active");
            entity.Property(e => e.Name)
                .HasMaxLength(100)
                .HasColumnName("name");
        });

        modelBuilder.Entity<PhSQuoteAdjustment>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Quot__3213E83FFBF7D244");

            entity.ToTable("PhS_QuoteAdjustments", tb => tb.HasComment("Tabla de ajustes aplicados a presupuestos comerciales"));

            entity.Property(e => e.Id)
                .HasComment("ID interno del ajuste aplicado al presupuesto")
                .HasColumnName("id");
            entity.Property(e => e.Amount)
                .HasComment("Importe del ajuste realizado (positivo o nulo)")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("amount");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de registro del ajuste")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasComment("Descripción adicional del ajuste")
                .HasColumnName("description");
            entity.Property(e => e.QuoteheaderId)
                .HasComment("FK al presupuesto (PhS_QuoteHeaders)")
                .HasColumnName("quoteheader_id");
            entity.Property(e => e.ReasonCode)
                .HasMaxLength(50)
                .IsUnicode(false)
                .HasComment("Código del motivo de ajuste (FK a PhS_AdjustmentReasons)")
                .HasColumnName("reason_code");

            entity.HasOne(d => d.Quoteheader).WithMany(p => p.PhSQuoteAdjustments)
                .HasForeignKey(d => d.QuoteheaderId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_QuoteAdjustments_Header");

            entity.HasOne(d => d.ReasonCodeNavigation).WithMany(p => p.PhSQuoteAdjustments)
                .HasForeignKey(d => d.ReasonCode)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_QuoteAdjustments_Reason");
        });

        modelBuilder.Entity<PhSQuoteDetail>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Quot__3213E83F94207114");

            entity.ToTable("PhS_QuoteDetails", tb => tb.HasComment("Tabla de detalles de presupuestos"));

            entity.Property(e => e.Id)
                .HasComment("ID interno")
                .HasColumnName("id");
            entity.Property(e => e.Approved)
                .HasComment("¿Aprobado? (0=No, 1=Si)")
                .HasColumnName("approved");
            entity.Property(e => e.Approvedamount)
                .HasComment("Importe aprobado final")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("approvedamount");
            entity.Property(e => e.Approvedquantity)
                .HasComment("Cantidad aprobada para este ítem del presupuesto.")
                .HasColumnName("approvedquantity");
            entity.Property(e => e.Approvedunitprice)
                .HasComment("Precio unitario aprobado (puede diferir del original).")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("approvedunitprice");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Modifiedat)
                .HasComment("Fecha de última modificación")
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.ProductDescription)
                .HasComment("Descripción modificable del producto (puede diferir del original)")
                .HasColumnName("product_description");
            entity.Property(e => e.ProductId)
                .HasComment("ID del producto original")
                .HasColumnName("product_id");
            entity.Property(e => e.Quantity)
                .HasDefaultValue(1)
                .HasComment("Cantidad")
                .HasColumnName("quantity");
            entity.Property(e => e.QuoteheaderId)
                .HasComment("FK a encabezado de presupuesto")
                .HasColumnName("quoteheader_id");
            entity.Property(e => e.Unitprice)
                .HasComment("Precio unitario original")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("unitprice");

            entity.HasOne(d => d.Product).WithMany(p => p.PhSQuoteDetails)
                .HasForeignKey(d => d.ProductId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_QuoteDetails_PhS_Products");

            entity.HasOne(d => d.Quoteheader).WithMany(p => p.PhSQuoteDetails)
                .HasForeignKey(d => d.QuoteheaderId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_QuoteDetails_Header");
        });

        modelBuilder.Entity<PhSQuoteHeader>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Quot__3213E83FA0B43134");

            entity.ToTable("PhS_QuoteHeaders", tb => tb.HasComment("Tabla de cabeceras de presupuestos"));

            entity.HasIndex(e => e.PaymenttermId, "ix_quoteheaders_paymenttermid");

            entity.Property(e => e.Id)
                .HasComment("ID interno")
                .HasColumnName("id");
            entity.Property(e => e.Approvaldate)
                .HasComment("Fecha de aprobación")
                .HasColumnType("datetime")
                .HasColumnName("approvaldate");
            entity.Property(e => e.Approvedamount)
                .HasComment("Importe aprobado")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("approvedamount");
            entity.Property(e => e.BusinessunitId)
                .HasComment("Unidad de negocio")
                .HasColumnName("businessunit_id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Currency)
                .HasMaxLength(3)
                .IsUnicode(false)
                .HasDefaultValue("ARS")
                .HasComment("Código de moneda pactada (ISO 4217). Ej: ARS, USD")
                .HasColumnName("currency");
            entity.Property(e => e.CustomerId)
                .HasComment("Cliente asociado")
                .HasColumnName("customer_id");
            entity.Property(e => e.DispatchInstruction)
                .HasMaxLength(255)
                .HasComment("Instrucción dirigida al área de logística para detallar qué debe prepararse o despacharse (ej: “CMF 1.5 + INSTRUMENTAL”)")
                .HasColumnName("dispatch_instruction");
            entity.Property(e => e.Estimateddate)
                .HasComment("Fecha tentativa (de cirugía por ej.)")
                .HasColumnType("datetime")
                .HasColumnName("estimateddate");
            entity.Property(e => e.Exchangerate)
                .HasComment("Tipo de cambio pactado para conversión a pesos argentinos")
                .HasColumnType("decimal(18, 6)")
                .HasColumnName("exchangerate");
            entity.Property(e => e.Issuedate)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de emisión")
                .HasColumnType("datetime")
                .HasColumnName("issuedate");
            entity.Property(e => e.Modifiedat)
                .HasComment("Fecha de modificación")
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Netamount)
                .HasComment("Importe neto antes de aplicar impuestos, expresado en la moneda pactada del presupuesto")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("netamount");
            entity.Property(e => e.Observations)
                .HasComment("Observaciones internas")
                .HasColumnName("observations");
            entity.Property(e => e.Offervaliditydays)
                .HasComment("Días de validez de la oferta. Indica cuántos días estará vigente el presupuesto desde su fecha de emisión.")
                .HasColumnName("offervaliditydays");
            entity.Property(e => e.OutOfTown)
                .HasComment("Indica si la cirugía se realizará fuera de la ciudad/localidad habitual (“out of town”)")
                .HasColumnName("out_of_town");
            entity.Property(e => e.PaymenttermId)
                .HasComment("Condición de pago seleccionada para el presupuesto.")
                .HasColumnName("paymentterm_id");
            entity.Property(e => e.PeopleId)
                .HasDefaultValue(1)
                .HasComment("Identificador único del vendedor")
                .HasColumnName("people_id");
            entity.Property(e => e.Printcount)
                .HasComment("Cantidad de impresiones")
                .HasColumnName("printcount");
            entity.Property(e => e.Quotenumber)
                .HasMaxLength(20)
                .IsUnicode(false)
                .HasComment("Número visible del presupuesto")
                .HasColumnName("quotenumber");
            entity.Property(e => e.Status)
                .HasMaxLength(15)
                .IsUnicode(false)
                .HasDefaultValue("Emitido")
                .HasComment("Estado: E (Emitido), A (Aprobado), AC (Aprobado para cirugia), etc.")
                .HasColumnName("status");
            entity.Property(e => e.TicketId)
                .HasComment("Relación con Tickets")
                .HasColumnName("ticket_id");
            entity.Property(e => e.Total)
                .HasComment("Importe total del presupuesto en moneda local, calculado incluyendo impuestos y convertido según tipo de cambio pactado")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("total");
            entity.Property(e => e.TotalForeign)
                .HasComment("Importe total del presupuesto expresado en la moneda pactada (extranjera), incluyendo impuestos y ajustes comerciales")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("total_foreign");

            entity.HasOne(d => d.Paymentterm).WithMany(p => p.PhSQuoteHeaders)
                .HasForeignKey(d => d.PaymenttermId)
                .OnDelete(DeleteBehavior.SetNull)
                .HasConstraintName("fk_quoteheaders_paymenttermid");
        });

        modelBuilder.Entity<PhSQuoteRole>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Quot__3213E83F7BBCA6FF");

            entity.ToTable("PhS_QuoteRoles", tb => tb.HasComment("Tabla de roles asociados a presupuestos"));

            entity.HasIndex(e => new { e.Entitytype, e.EntityId }, "IX_QuoteRoles_Entity");

            entity.HasIndex(e => e.QuoteheaderId, "IX_QuoteRoles_HeaderId");

            entity.HasIndex(e => e.Role, "IX_QuoteRoles_Role");

            entity.Property(e => e.Id)
                .HasComment("ID interno")
                .HasColumnName("id");
            entity.Property(e => e.EntityId)
                .HasComment("ID de la entidad asociada")
                .HasColumnName("entity_id");
            entity.Property(e => e.Entitytype)
                .HasMaxLength(50)
                .IsUnicode(false)
                .HasComment("Tipo de entidad asociada (Ej: PhS_Professionals, PhS_Institutions, PhS_Patients)")
                .HasColumnName("entitytype");
            entity.Property(e => e.QuoteheaderId)
                .HasComment("FK a encabezado de presupuesto (PhS_QuoteHeaders)")
                .HasColumnName("quoteheader_id");
            entity.Property(e => e.Role)
                .HasMaxLength(50)
                .IsUnicode(false)
                .HasComment("Rol que cumple la entidad en el presupuesto (Ej: Medico, Hospital, Paciente)")
                .HasColumnName("role");

            entity.HasOne(d => d.Quoteheader).WithMany(p => p.PhSQuoteRoles)
                .HasForeignKey(d => d.QuoteheaderId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_QuoteRoles_Header");
        });

        modelBuilder.Entity<PhSQuoteTaxis>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__PhS_Quot__3213E83F06626551");

            entity.ToTable("PhS_QuoteTaxes");

            entity.Property(e => e.Id)
                .HasComment("Clave primaria autoincremental")
                .HasColumnName("id");
            entity.Property(e => e.CreatedAt)
                .HasDefaultValueSql("(getdate())")
                .HasComment("Fecha de creación del registro")
                .HasColumnType("datetime")
                .HasColumnName("created_at");
            entity.Property(e => e.IsIncludedInPrice)
                .HasComment("Indica si el impuesto está incluido en el precio final (1 = sí)")
                .HasColumnName("is_included_in_price");
            entity.Property(e => e.ModifiedAt)
                .HasComment("Fecha de modificación del registro")
                .HasColumnType("datetime")
                .HasColumnName("modified_at");
            entity.Property(e => e.QuoteheaderId)
                .HasComment("Referencia al presupuesto (PhS_QuoteHeaders)")
                .HasColumnName("quoteheader_id");
            entity.Property(e => e.TaxableAmount)
                .HasComment("Base imponible del impuesto (importe gravado)")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("taxable_amount");
            entity.Property(e => e.Taxamount)
                .HasComment("Importe final del impuesto calculado")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("taxamount");
            entity.Property(e => e.Taxcode)
                .HasMaxLength(50)
                .HasComment("Código o identificador oficial del impuesto (ej. AFIP)")
                .HasColumnName("taxcode");
            entity.Property(e => e.Taxname)
                .HasMaxLength(100)
                .HasComment("Nombre descriptivo del impuesto")
                .HasColumnName("taxname");
            entity.Property(e => e.Taxrate)
                .HasComment("Alícuota aplicada (porcentaje)")
                .HasColumnType("decimal(5, 2)")
                .HasColumnName("taxrate");

            entity.HasOne(d => d.Quoteheader).WithMany(p => p.PhSQuoteTaxes)
                .HasForeignKey(d => d.QuoteheaderId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_QuoteTaxes_QuoteHeaders");
        });

        modelBuilder.Entity<PhSSalesDocument>(entity =>
        {
            entity.ToTable("PhS_SalesDocuments", tb => tb.HasComment("Documentos comerciales internos de venta: facturas, notas de debito, notas de credito, FCE, NDE y NCE. Mantiene la emision interna separada de la autorizacion fiscal ARCA."));

            entity.HasIndex(e => e.BillToCustomerId, "IX_PhS_SalesDocuments_BillToCustomer");

            entity.HasIndex(e => e.CustomerId, "IX_PhS_SalesDocuments_Customer");

            entity.HasIndex(e => e.FormseriesId, "IX_PhS_SalesDocuments_FormSeries");

            entity.HasIndex(e => e.IssueDate, "IX_PhS_SalesDocuments_IssueDate");

            entity.HasIndex(e => new { e.PeriodFrom, e.PeriodTo }, "IX_PhS_SalesDocuments_Period");

            entity.HasIndex(e => e.QuoteId, "IX_PhS_SalesDocuments_Quote");

            entity.HasIndex(e => e.Status, "IX_PhS_SalesDocuments_Status");

            entity.HasIndex(e => new { e.FormseriesId, e.InternalDocumentNumber }, "UX_PhS_SalesDocuments_InternalDocumentNumber")
                .IsUnique()
                .HasFilter("([formseries_id] IS NOT NULL AND [internal_document_number] IS NOT NULL)");

            entity.HasIndex(e => new { e.FormseriesId, e.InternalSequenceNumber }, "UX_PhS_SalesDocuments_InternalNumber")
                .IsUnique()
                .HasFilter("([formseries_id] IS NOT NULL AND [internal_sequence_number] IS NOT NULL)");

            entity.Property(e => e.Id)
                .HasComment("Identificador interno del documento comercial.")
                .HasColumnName("id");
            entity.Property(e => e.AssociatedDocumentDate)
                .HasComment("Fecha del documento interno asociado opcional.")
                .HasColumnType("datetime")
                .HasColumnName("associated_document_date");
            entity.Property(e => e.AssociatedDocumentNumber)
                .HasMaxLength(50)
                .HasComment("Numero del documento interno asociado opcional.")
                .HasColumnName("associated_document_number");
            entity.Property(e => e.AssociatedDocumentType)
                .HasMaxLength(50)
                .HasComment("Tipo de documento interno asociado opcional, por ejemplo remito, orden de compra o autorizacion. No representa CbtesAsoc fiscal.")
                .HasColumnName("associated_document_type");
            entity.Property(e => e.BillToCustomerId)
                .HasComment("Cliente al que se factura realmente. Permite escenarios obra social / particular u otros terceros pagadores.")
                .HasColumnName("bill_to_customer_id");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Currency)
                .HasMaxLength(10)
                .HasDefaultValue("ARS")
                .HasComment("Moneda del documento comercial.")
                .HasColumnName("currency");
            entity.Property(e => e.CustomerId)
                .HasComment("Cliente origen de la operacion comercial.")
                .HasColumnName("customer_id");
            entity.Property(e => e.DocumentType)
                .HasComment("Tipo comercial interno del documento. Ejemplos: Invoice, DebitNote, CreditNote, CreditInvoice, CreditDebitNote, CreditCreditNote.")
                .HasColumnName("document_type");
            entity.Property(e => e.ExchangeRate)
                .HasDefaultValue(1m)
                .HasComment("Cotizacion utilizada para la moneda del documento.")
                .HasColumnType("decimal(18, 6)")
                .HasColumnName("exchange_rate");
            entity.Property(e => e.ExtraInfoJson)
                .HasComment("Snapshot JSON con informacion extra contextual del documento.")
                .HasColumnName("extra_info_json");
            entity.Property(e => e.FiscalVoucherLetter)
                .HasMaxLength(5)
                .HasComment("Letra fiscal prevista del comprobante: A, B, C u otras segun configuracion fiscal.")
                .HasColumnName("fiscal_voucher_letter");
            entity.Property(e => e.FiscalVoucherType)
                .HasComment("Tipo de comprobante fiscal AFIP/ARCA previsto para autorizacion futura. Ejemplos: 1, 6, 11, 201, 202, 203.")
                .HasColumnName("fiscal_voucher_type");
            entity.Property(e => e.FormseriesId)
                .HasComment("Talonario/serie interna existente en PhronCare. Reutiliza PhS_FormSeries para numeracion interna.")
                .HasColumnName("formseries_id");
            entity.Property(e => e.InternalDocumentNumber)
                .HasMaxLength(50)
                .HasComment("Numero visible interno del documento, formado desde la serie/talonario interno. Puede diferir del numero fiscal.")
                .HasColumnName("internal_document_number");
            entity.Property(e => e.InternalSequenceNumber)
                .HasComment("Numero secuencial interno asignado al emitir internamente el documento. No corresponde al numero fiscal ARCA.")
                .HasColumnName("internal_sequence_number");
            entity.Property(e => e.IssueDate)
                .HasComment("Fecha de emision interna del documento comercial.")
                .HasColumnType("datetime")
                .HasColumnName("issue_date");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.NetAmount)
                .HasComment("Importe neto total del documento.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("net_amount");
            entity.Property(e => e.Observations)
                .HasComment("Observaciones comerciales del documento.")
                .HasColumnName("observations");
            entity.Property(e => e.PeriodFrom)
                .HasComment("Fecha inicial del periodo comercial facturado. Aplica especialmente a facturacion por capita o periodos mensuales.")
                .HasColumnType("datetime")
                .HasColumnName("period_from");
            entity.Property(e => e.PeriodTo)
                .HasComment("Fecha final del periodo comercial facturado. Aplica especialmente a facturacion por capita o periodos mensuales.")
                .HasColumnType("datetime")
                .HasColumnName("period_to");
            entity.Property(e => e.QuoteId)
                .HasComment("Presupuesto origen opcional. Puede ser NULL para ventas manuales o de escritorio.")
                .HasColumnName("quote_id");
            entity.Property(e => e.Status)
                .HasComment("Estado comercial interno. Ejemplos: Draft, Validated, Issued, Cancelled. Independiente del estado fiscal.")
                .HasColumnName("status");
            entity.Property(e => e.TaxAmount)
                .HasComment("Importe total de impuestos del documento.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("tax_amount");
            entity.Property(e => e.TotalAmount)
                .HasComment("Importe total del documento.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("total_amount");

            entity.HasOne(d => d.BillToCustomer).WithMany(p => p.PhSSalesDocumentBillToCustomers)
                .HasForeignKey(d => d.BillToCustomerId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesDocuments_BillToCustomers");

            entity.HasOne(d => d.Customer).WithMany(p => p.PhSSalesDocumentCustomers)
                .HasForeignKey(d => d.CustomerId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesDocuments_Customers");

            entity.HasOne(d => d.Formseries).WithMany(p => p.PhSSalesDocuments)
                .HasForeignKey(d => d.FormseriesId)
                .HasConstraintName("FK_PhS_SalesDocuments_FormSeries");

            entity.HasOne(d => d.Quote).WithMany(p => p.PhSSalesDocuments)
                .HasForeignKey(d => d.QuoteId)
                .HasConstraintName("FK_PhS_SalesDocuments_QuoteHeaders");
        });

        modelBuilder.Entity<PhSSalesDocumentCoverage>(entity =>
        {
            entity.ToTable("PhS_SalesDocumentCoverage", tb => tb.HasComment("Presupuestos/casos cubiertos por un documento de venta. Es la fuente real para determinar si un presupuesto queda pendiente de facturacion o ya fue cubierto, incluyendo facturacion 1 a 1 y capita."));

            entity.HasIndex(e => e.SalesdocumentId, "IX_PhS_SalesDocumentCoverage_Document");

            entity.HasIndex(e => e.SalesdocumentdetailId, "IX_PhS_SalesDocumentCoverage_DocumentDetail");

            entity.HasIndex(e => new { e.PeriodFrom, e.PeriodTo }, "IX_PhS_SalesDocumentCoverage_Period");

            entity.HasIndex(e => e.QuoteId, "IX_PhS_SalesDocumentCoverage_Quote");

            entity.HasIndex(e => e.QuoteDetailId, "IX_PhS_SalesDocumentCoverage_QuoteDetail");

            entity.Property(e => e.Id)
                .HasComment("Identificador interno de la cobertura.")
                .HasColumnName("id");
            entity.Property(e => e.CoverageAmount)
                .HasComment("Importe de referencia cubierto por el documento, cuando aplique.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("coverage_amount");
            entity.Property(e => e.CoveragePercentage)
                .HasComment("Porcentaje del presupuesto/caso cubierto por el documento. Permite 100% en facturacion directa o particiones 60/40.")
                .HasColumnType("decimal(9, 4)")
                .HasColumnName("coverage_percentage");
            entity.Property(e => e.CoverageType)
                .HasDefaultValue(1)
                .HasComment("Tipo de cobertura. Valores esperados en Domain: Direct, Capita, Adjustment.")
                .HasColumnName("coverage_type");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.Notes)
                .HasComment("Notas internas de cobertura.")
                .HasColumnName("notes");
            entity.Property(e => e.PeriodFrom)
                .HasComment("Fecha inicial del periodo de cobertura.")
                .HasColumnType("datetime")
                .HasColumnName("period_from");
            entity.Property(e => e.PeriodTo)
                .HasComment("Fecha final del periodo de cobertura.")
                .HasColumnType("datetime")
                .HasColumnName("period_to");
            entity.Property(e => e.QuoteDetailId)
                .HasComment("Detalle de presupuesto cubierto, cuando se requiera trazabilidad granular por item.")
                .HasColumnName("quote_detail_id");
            entity.Property(e => e.QuoteId)
                .HasComment("Presupuesto/caso cubierto por el documento de venta. Se usa tanto para facturacion directa como para capita.")
                .HasColumnName("quote_id");
            entity.Property(e => e.SalesdocumentId)
                .HasComment("Documento de venta que cubre el presupuesto/caso.")
                .HasColumnName("salesdocument_id");
            entity.Property(e => e.SalesdocumentdetailId)
                .HasComment("Detalle del documento de venta asociado a esta cobertura, cuando aplique. En capita puede apuntar a la linea agregada mensual.")
                .HasColumnName("salesdocumentdetail_id");

            entity.HasOne(d => d.QuoteDetail).WithMany(p => p.PhSSalesDocumentCoverages)
                .HasForeignKey(d => d.QuoteDetailId)
                .HasConstraintName("FK_PhS_SalesDocumentCoverage_QuoteDetails");

            entity.HasOne(d => d.Quote).WithMany(p => p.PhSSalesDocumentCoverages)
                .HasForeignKey(d => d.QuoteId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesDocumentCoverage_QuoteHeaders");

            entity.HasOne(d => d.Salesdocument).WithMany(p => p.PhSSalesDocumentCoverages)
                .HasForeignKey(d => d.SalesdocumentId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesDocumentCoverage_SalesDocuments");

            entity.HasOne(d => d.Salesdocumentdetail).WithMany(p => p.PhSSalesDocumentCoverages)
                .HasForeignKey(d => d.SalesdocumentdetailId)
                .HasConstraintName("FK_PhS_SalesDocumentCoverage_SalesDocumentDetails");
        });

        modelBuilder.Entity<PhSSalesDocumentDetail>(entity =>
        {
            entity.ToTable("PhS_SalesDocumentDetails", tb => tb.HasComment("Detalles valorizados de documentos comerciales de venta."));

            entity.HasIndex(e => e.SalesdocumentId, "IX_PhS_SalesDocumentDetails_Document");

            entity.HasIndex(e => e.QuoteDetailId, "IX_PhS_SalesDocumentDetails_QuoteDetail");

            entity.HasIndex(e => new { e.SalesdocumentId, e.LineNumber }, "UX_PhS_SalesDocumentDetails_Line").IsUnique();

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.AuthorizedAmount)
                .HasComment("Importe autorizado o de referencia proveniente del origen comercial.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("authorized_amount");
            entity.Property(e => e.AuthorizedUnitPrice)
                .HasComment("Precio unitario autorizado o de referencia proveniente del origen comercial.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("authorized_unit_price");
            entity.Property(e => e.BilledPercentage)
                .HasComment("Porcentaje facturado sobre el origen. Permite facturacion parcial obra social / particular.")
                .HasColumnType("decimal(9, 4)")
                .HasColumnName("billed_percentage");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Description)
                .HasMaxLength(255)
                .HasComment("Descripcion visible de la linea facturada.")
                .HasColumnName("description");
            entity.Property(e => e.LineNumber)
                .HasComment("Numero de linea dentro del documento.")
                .HasColumnName("line_number");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.NetAmount)
                .HasComment("Importe neto de la linea.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("net_amount");
            entity.Property(e => e.OriginId)
                .HasComment("Identificador generico del origen cuando aplique.")
                .HasColumnName("origin_id");
            entity.Property(e => e.OriginSnapshotJson)
                .HasComment("Snapshot JSON del origen de la linea para trazabilidad historica.")
                .HasColumnName("origin_snapshot_json");
            entity.Property(e => e.OriginType)
                .HasMaxLength(50)
                .HasComment("Origen logico del item: Manual, QuoteDetail, Adjustment u otro valor definido por Domain/Core.")
                .HasColumnName("origin_type");
            entity.Property(e => e.ProductId)
                .HasComment("Producto asociado a la linea, si aplica.")
                .HasColumnName("product_id");
            entity.Property(e => e.Quantity)
                .HasComment("Cantidad facturada.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("quantity");
            entity.Property(e => e.QuoteDetailId)
                .HasComment("Detalle del presupuesto aprobado que origina la linea, cuando exista. Puede ser NULL en ventas manuales.")
                .HasColumnName("quote_detail_id");
            entity.Property(e => e.SalesdocumentId)
                .HasComment("Documento comercial al que pertenece el detalle.")
                .HasColumnName("salesdocument_id");
            entity.Property(e => e.TaxAmount)
                .HasComment("Importe de impuestos de la linea.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("tax_amount");
            entity.Property(e => e.TotalAmount)
                .HasComment("Importe total de la linea.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("total_amount");
            entity.Property(e => e.UnitPrice)
                .HasComment("Precio unitario efectivo de la linea del documento.")
                .HasColumnType("decimal(18, 2)")
                .HasColumnName("unit_price");

            entity.HasOne(d => d.Product).WithMany(p => p.PhSSalesDocumentDetails)
                .HasForeignKey(d => d.ProductId)
                .HasConstraintName("FK_PhS_SalesDocumentDetails_Products");

            entity.HasOne(d => d.QuoteDetail).WithMany(p => p.PhSSalesDocumentDetails)
                .HasForeignKey(d => d.QuoteDetailId)
                .HasConstraintName("FK_PhS_SalesDocumentDetails_QuoteDetails");

            entity.HasOne(d => d.Salesdocument).WithMany(p => p.PhSSalesDocumentDetails)
                .HasForeignKey(d => d.SalesdocumentId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesDocumentDetails_SalesDocuments");
        });

        modelBuilder.Entity<PhSSalesFiscalDocument>(entity =>
        {
            entity.ToTable("PhS_SalesFiscalDocuments", tb => tb.HasComment("Documento fiscal asociado a un documento comercial de venta. Guarda estado, CAE, numeracion fiscal, request/response e idempotencia ARCA."));

            entity.HasIndex(e => e.SalesdocumentId, "IX_PhS_SalesFiscalDocuments_Document");

            entity.HasIndex(e => e.SalesdocumentId, "UX_PhS_SalesFiscalDocuments_Document").IsUnique();

            entity.HasIndex(e => new { e.Environment, e.PointOfSale, e.VoucherType, e.VoucherNumber }, "UX_PhS_SalesFiscalDocuments_FiscalNumber")
                .IsUnique()
                .HasFilter("([point_of_sale] IS NOT NULL AND [voucher_type] IS NOT NULL AND [voucher_number] IS NOT NULL)");

            entity.HasIndex(e => new { e.Environment, e.PointOfSale, e.VoucherType, e.RequestFingerprint }, "UX_PhS_SalesFiscalDocuments_Idempotency")
                .IsUnique()
                .HasFilter("([point_of_sale] IS NOT NULL AND [voucher_type] IS NOT NULL AND [request_fingerprint] IS NOT NULL)");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.ArcaRequestPayloadJson)
                .HasComment("Payload JSON enviado a ARCA/AFIP.")
                .HasColumnName("arca_request_payload_json");
            entity.Property(e => e.ArcaResponsePayloadJson)
                .HasComment("Payload JSON recibido desde ARCA/AFIP.")
                .HasColumnName("arca_response_payload_json");
            entity.Property(e => e.AttemptedAtUtc)
                .HasComment("Fecha/hora UTC del intento de autorizacion fiscal.")
                .HasColumnType("datetime")
                .HasColumnName("attempted_at_utc");
            entity.Property(e => e.Cae)
                .HasMaxLength(20)
                .HasComment("Codigo de autorizacion electronico obtenido desde ARCA/AFIP.")
                .HasColumnName("cae");
            entity.Property(e => e.CaeExpirationDate)
                .HasComment("Fecha de vencimiento del CAE.")
                .HasColumnType("datetime")
                .HasColumnName("cae_expiration_date");
            entity.Property(e => e.CompletedAtUtc)
                .HasComment("Fecha/hora UTC de finalizacion del flujo fiscal.")
                .HasColumnType("datetime")
                .HasColumnName("completed_at_utc");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.Environment)
                .HasMaxLength(20)
                .HasComment("Ambiente fiscal usado para autorizacion: homologacion, produccion u otro valor definido por configuracion.")
                .HasColumnName("environment");
            entity.Property(e => e.ErrorsJson)
                .HasComment("Errores devueltos por ARCA/AFIP serializados como JSON.")
                .HasColumnName("errors_json");
            entity.Property(e => e.EventsJson)
                .HasComment("Eventos devueltos por ARCA/AFIP serializados como JSON.")
                .HasColumnName("events_json");
            entity.Property(e => e.FiscalStatus)
                .HasComment("Estado fiscal independiente del estado comercial. Ejemplos: None, Pending, Authorized, Rejected, Error, PendingReconciliation.")
                .HasColumnName("fiscal_status");
            entity.Property(e => e.IsFinal)
                .HasComment("Indica si el resultado fiscal es final y no debe volver a mutar salvo procesos controlados de auditoria.")
                .HasColumnName("is_final");
            entity.Property(e => e.Modifiedat)
                .HasColumnType("datetime")
                .HasColumnName("modifiedat");
            entity.Property(e => e.ObservationsJson)
                .HasComment("Observaciones devueltas por ARCA/AFIP serializadas como JSON.")
                .HasColumnName("observations_json");
            entity.Property(e => e.PointOfSale)
                .HasComment("Punto de venta fiscal ARCA/AFIP.")
                .HasColumnName("point_of_sale");
            entity.Property(e => e.ReconciledAfterTimeout)
                .HasComment("Indica que el documento fiscal fue resuelto mediante reconciliacion posterior a timeout o resultado ambiguo.")
                .HasColumnName("reconciled_after_timeout");
            entity.Property(e => e.RequestFingerprint)
                .HasMaxLength(255)
                .HasComment("Huella de idempotencia fiscal para evitar duplicacion de solicitudes ante ARCA.")
                .HasColumnName("request_fingerprint");
            entity.Property(e => e.SalesdocumentId)
                .HasComment("Documento comercial interno vinculado al documento fiscal.")
                .HasColumnName("salesdocument_id");
            entity.Property(e => e.VoucherLetter)
                .HasMaxLength(5)
                .HasComment("Letra fiscal del comprobante autorizado o a autorizar.")
                .HasColumnName("voucher_letter");
            entity.Property(e => e.VoucherNumber)
                .HasComment("Numero fiscal del comprobante asignado para ARCA. Se mantiene separado del numero interno.")
                .HasColumnName("voucher_number");
            entity.Property(e => e.VoucherType)
                .HasComment("Tipo de comprobante fiscal ARCA/AFIP utilizado en FECAESolicitar.")
                .HasColumnName("voucher_type");

            entity.HasOne(d => d.Salesdocument).WithOne(p => p.PhSSalesFiscalDocument)
                .HasForeignKey<PhSSalesFiscalDocument>(d => d.SalesdocumentId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesFiscalDocuments_SalesDocuments");
        });

        modelBuilder.Entity<PhSSalesFiscalDocumentAssociation>(entity =>
        {
            entity.ToTable("PhS_SalesFiscalDocumentAssociations", tb => tb.HasComment("Comprobantes fiscales asociados enviados como CbtesAsoc. Aplica a notas de credito, notas de debito, NCE/NDE y casos FCE donde corresponda."));

            entity.HasIndex(e => e.AssociatedSalesdocumentId, "IX_PhS_SalesFiscalDocumentAssociations_AssociatedDocument");

            entity.HasIndex(e => e.SalesfiscaldocumentId, "IX_PhS_SalesFiscalDocumentAssociations_FiscalDocument");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.AssociatedPointOfSale)
                .HasComment("Punto de venta fiscal del comprobante asociado.")
                .HasColumnName("associated_point_of_sale");
            entity.Property(e => e.AssociatedSalesdocumentId)
                .HasComment("Documento comercial interno asociado, si existe dentro de PhronCare.")
                .HasColumnName("associated_salesdocument_id");
            entity.Property(e => e.AssociatedVoucherCuit)
                .HasMaxLength(20)
                .HasComment("CUIT emisor del comprobante asociado, cuando sea requerido por ARCA.")
                .HasColumnName("associated_voucher_cuit");
            entity.Property(e => e.AssociatedVoucherDate)
                .HasComment("Fecha del comprobante fiscal asociado.")
                .HasColumnType("datetime")
                .HasColumnName("associated_voucher_date");
            entity.Property(e => e.AssociatedVoucherNumber)
                .HasComment("Numero fiscal del comprobante asociado.")
                .HasColumnName("associated_voucher_number");
            entity.Property(e => e.AssociatedVoucherType)
                .HasComment("Tipo fiscal ARCA/AFIP del comprobante asociado.")
                .HasColumnName("associated_voucher_type");
            entity.Property(e => e.Createdat)
                .HasDefaultValueSql("(getdate())")
                .HasColumnType("datetime")
                .HasColumnName("createdat");
            entity.Property(e => e.SalesfiscaldocumentId)
                .HasComment("Documento fiscal que contiene esta asociacion.")
                .HasColumnName("salesfiscaldocument_id");

            entity.HasOne(d => d.AssociatedSalesdocument).WithMany(p => p.PhSSalesFiscalDocumentAssociations)
                .HasForeignKey(d => d.AssociatedSalesdocumentId)
                .HasConstraintName("FK_PhS_SalesFiscalDocumentAssociations_SalesDocuments");

            entity.HasOne(d => d.Salesfiscaldocument).WithMany(p => p.PhSSalesFiscalDocumentAssociations)
                .HasForeignKey(d => d.SalesfiscaldocumentId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("FK_PhS_SalesFiscalDocumentAssociations_FiscalDocuments");
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}
