public void MergeFrom(TaxedIncidentalReservationNightlyQuote other)
 {
     if (other == null)
     {
         return;
     }
     if (other.opsdate_ != null)
     {
         if (opsdate_ == null)
         {
             opsdate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
         }
         Opsdate.MergeFrom(other.Opsdate);
     }
     if (other.pretaxIncidentalPrice_ != null)
     {
         if (pretaxIncidentalPrice_ == null)
         {
             pretaxIncidentalPrice_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         PretaxIncidentalPrice.MergeFrom(other.PretaxIncidentalPrice);
     }
     taxEstimates_.Add(other.taxEstimates_);
     if (other.incidentalItem_ != null)
     {
         if (incidentalItem_ == null)
         {
             incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         IncidentalItem.MergeFrom(other.IncidentalItem);
     }
 }
Пример #2
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (item_ == null)
                    {
                        item_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(item_);
                    break;
                }

                case 18: {
                    if (prevDateRange_ == null)
                    {
                        prevDateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
                    }
                    input.ReadMessage(prevDateRange_);
                    break;
                }

                case 24: {
                    PrevRequestedQuantity = input.ReadUInt32();
                    break;
                }

                case 34: {
                    if (newDateRange_ == null)
                    {
                        newDateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
                    }
                    input.ReadMessage(newDateRange_);
                    break;
                }

                case 40: {
                    NewRequestedQuantity = input.ReadUInt32();
                    break;
                }

                case 50: {
                    if (associatedLodgingReservation_ == null)
                    {
                        associatedLodgingReservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
                    }
                    input.ReadMessage(associatedLodgingReservation_);
                    break;
                }
                }
            }
        }
 public void MergeFrom(IncidentalItemAvailabilityResponse other)
 {
     if (other == null)
     {
         return;
     }
     if (other.NumberAvailable != 0)
     {
         NumberAvailable = other.NumberAvailable;
     }
     if (other.dateRange_ != null)
     {
         if (dateRange_ == null)
         {
             dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
         }
         DateRange.MergeFrom(other.DateRange);
     }
     if (other.incidentalItem_ != null)
     {
         if (incidentalItem_ == null)
         {
             incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         IncidentalItem.MergeFrom(other.IncidentalItem);
     }
 }
 public void MergeFrom(ItemHoldDropRequest other)
 {
     if (other == null)
     {
         return;
     }
     if (other.item_ != null)
     {
         if (item_ == null)
         {
             item_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         Item.MergeFrom(other.Item);
     }
     if (other.dateRange_ != null)
     {
         if (dateRange_ == null)
         {
             dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
         }
         DateRange.MergeFrom(other.DateRange);
     }
     if (other.associatedLodgingReservation_ != null)
     {
         if (associatedLodgingReservation_ == null)
         {
             associatedLodgingReservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
         }
         AssociatedLodgingReservation.MergeFrom(other.AssociatedLodgingReservation);
     }
     if (other.DropQuantity != 0)
     {
         DropQuantity = other.DropQuantity;
     }
 }
 public void MergeFrom(IncidentalsSnapshotResponseRecord other)
 {
     if (other == null)
     {
         return;
     }
     if (other.item_ != null)
     {
         if (item_ == null)
         {
             item_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         Item.MergeFrom(other.Item);
     }
     if (other.date_ != null)
     {
         if (date_ == null)
         {
             date_ = new global::HOLMS.Types.Primitive.PbLocalDate();
         }
         Date.MergeFrom(other.Date);
     }
     if (other.NumberAvailable != 0)
     {
         NumberAvailable = other.NumberAvailable;
     }
 }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    Description = input.ReadString();
                    break;
                }

                case 16: {
                    chargeCreditType_ = (global::HOLMS.Types.Folio.ChargeCreditType)input.ReadEnum();
                    break;
                }

                case 26: {
                    if (untaxedAmount_ == null)
                    {
                        untaxedAmount_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(untaxedAmount_);
                    break;
                }

                case 32: {
                    TaxExempt = input.ReadBool();
                    break;
                }

                case 42: {
                    if (incidentalItem_ == null)
                    {
                        incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(incidentalItem_);
                    break;
                }

                case 50: {
                    if (chargeOpsdate_ == null)
                    {
                        chargeOpsdate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
                    }
                    input.ReadMessage(chargeOpsdate_);
                    break;
                }
                }
            }
        }
Пример #7
0
 public void MergeFrom(IncidentalItemReservation other)
 {
     if (other == null)
     {
         return;
     }
     if (other.entityId_ != null)
     {
         if (entityId_ == null)
         {
             entityId_ = new global::HOLMS.Types.Booking.Indicators.IncidentalItemReservationIndicator();
         }
         EntityId.MergeFrom(other.EntityId);
     }
     if (other.reservation_ != null)
     {
         if (reservation_ == null)
         {
             reservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
         }
         Reservation.MergeFrom(other.Reservation);
     }
     if (other.dateRange_ != null)
     {
         if (dateRange_ == null)
         {
             dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
         }
         DateRange.MergeFrom(other.DateRange);
     }
     if (other.reservedItem_ != null)
     {
         if (reservedItem_ == null)
         {
             reservedItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         ReservedItem.MergeFrom(other.ReservedItem);
     }
     if (other.AmountReserved != 0)
     {
         AmountReserved = other.AmountReserved;
     }
     if (other.totalCost_ != null)
     {
         if (totalCost_ == null)
         {
             totalCost_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         TotalCost.MergeFrom(other.TotalCost);
     }
     if (other.IncidentalItemName.Length != 0)
     {
         IncidentalItemName = other.IncidentalItemName;
     }
 }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (entityId_ == null)
                    {
                        entityId_ = new global::HOLMS.Types.Booking.Indicators.IncidentalItemReservationIndicator();
                    }
                    input.ReadMessage(entityId_);
                    break;
                }

                case 16: {
                    IsForExistingIiReservation = input.ReadBool();
                    break;
                }

                case 26: {
                    if (dateRange_ == null)
                    {
                        dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
                    }
                    input.ReadMessage(dateRange_);
                    break;
                }

                case 34: {
                    if (reservedItem_ == null)
                    {
                        reservedItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(reservedItem_);
                    break;
                }

                case 40: {
                    QuantityHeldByExistingReservation = input.ReadUInt32();
                    break;
                }
                }
            }
        }
 public void MergeFrom(IncidentalItem other)
 {
     if (other == null)
     {
         return;
     }
     if (other.entityId_ != null)
     {
         if (entityId_ == null)
         {
             entityId_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         EntityId.MergeFrom(other.EntityId);
     }
     if (other.Description.Length != 0)
     {
         Description = other.Description;
     }
     if (other.QuanityOwned != 0)
     {
         QuanityOwned = other.QuanityOwned;
     }
     if (other.price_ != null)
     {
         if (price_ == null)
         {
             price_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         Price.MergeFrom(other.Price);
     }
     if (other.IncursTaxes != false)
     {
         IncursTaxes = other.IncursTaxes;
     }
     if (other.IncursFees != false)
     {
         IncursFees = other.IncursFees;
     }
     if (other.ChargeFrequency != 0)
     {
         ChargeFrequency = other.ChargeFrequency;
     }
     if (other.revenueAccount_ != null)
     {
         if (revenueAccount_ == null)
         {
             revenueAccount_ = new global::HOLMS.Types.Money.Accounting.AccountIndicator();
         }
         RevenueAccount.MergeFrom(other.RevenueAccount);
     }
 }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (opsdate_ == null)
                    {
                        opsdate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
                    }
                    input.ReadMessage(opsdate_);
                    break;
                }

                case 18: {
                    if (pretaxIncidentalPrice_ == null)
                    {
                        pretaxIncidentalPrice_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(pretaxIncidentalPrice_);
                    break;
                }

                case 26: {
                    taxEstimates_.AddEntriesFrom(input, _repeated_taxEstimates_codec);
                    break;
                }

                case 34: {
                    if (incidentalItem_ == null)
                    {
                        incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(incidentalItem_);
                    break;
                }
                }
            }
        }
 public void MergeFrom(RequestedChargeCreditPosting other)
 {
     if (other == null)
     {
         return;
     }
     if (other.Description.Length != 0)
     {
         Description = other.Description;
     }
     if (other.ChargeCreditType != 0)
     {
         ChargeCreditType = other.ChargeCreditType;
     }
     if (other.untaxedAmount_ != null)
     {
         if (untaxedAmount_ == null)
         {
             untaxedAmount_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         UntaxedAmount.MergeFrom(other.UntaxedAmount);
     }
     if (other.TaxExempt != false)
     {
         TaxExempt = other.TaxExempt;
     }
     if (other.incidentalItem_ != null)
     {
         if (incidentalItem_ == null)
         {
             incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         IncidentalItem.MergeFrom(other.IncidentalItem);
     }
     if (other.chargeOpsdate_ != null)
     {
         if (chargeOpsdate_ == null)
         {
             chargeOpsdate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
         }
         ChargeOpsdate.MergeFrom(other.ChargeOpsdate);
     }
 }
 public void MergeFrom(IncidentalItemAvailabilityQuery other)
 {
     if (other == null)
     {
         return;
     }
     if (other.entityId_ != null)
     {
         if (entityId_ == null)
         {
             entityId_ = new global::HOLMS.Types.Booking.Indicators.IncidentalItemReservationIndicator();
         }
         EntityId.MergeFrom(other.EntityId);
     }
     if (other.IsForExistingIiReservation != false)
     {
         IsForExistingIiReservation = other.IsForExistingIiReservation;
     }
     if (other.dateRange_ != null)
     {
         if (dateRange_ == null)
         {
             dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
         }
         DateRange.MergeFrom(other.DateRange);
     }
     if (other.reservedItem_ != null)
     {
         if (reservedItem_ == null)
         {
             reservedItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         ReservedItem.MergeFrom(other.ReservedItem);
     }
     if (other.QuantityHeldByExistingReservation != 0)
     {
         QuantityHeldByExistingReservation = other.QuantityHeldByExistingReservation;
     }
 }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 8: {
                    NumberAvailable = input.ReadInt32();
                    break;
                }

                case 18: {
                    if (dateRange_ == null)
                    {
                        dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
                    }
                    input.ReadMessage(dateRange_);
                    break;
                }

                case 26: {
                    if (incidentalItem_ == null)
                    {
                        incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(incidentalItem_);
                    break;
                }
                }
            }
        }
 public virtual global::HOLMS.Types.Supply.IncidentalItems.IncidentalItem GetById(global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator request, grpc::Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(GetById(request, new grpc::CallOptions(headers, deadline, cancellationToken)));
 }
 public void MergeFrom(ReservationNote other)
 {
     if (other == null)
     {
         return;
     }
     if (other.entityId_ != null)
     {
         if (entityId_ == null)
         {
             entityId_ = new global::HOLMS.Types.Booking.Indicators.ReservationNoteIndicator();
         }
         EntityId.MergeFrom(other.EntityId);
     }
     if (other.sourceNote_ != null)
     {
         if (sourceNote_ == null)
         {
             sourceNote_ = new global::HOLMS.Types.Operations.NoteRequests.NoteRequestIndicator();
         }
         SourceNote.MergeFrom(other.SourceNote);
     }
     if (other.Category != 0)
     {
         Category = other.Category;
     }
     if (other.AdditionalNote.Length != 0)
     {
         AdditionalNote = other.AdditionalNote;
     }
     if (other.IncludeOnConfirmation != false)
     {
         IncludeOnConfirmation = other.IncludeOnConfirmation;
     }
     if (other.lodgingReservation_ != null)
     {
         if (lodgingReservation_ == null)
         {
             lodgingReservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
         }
         LodgingReservation.MergeFrom(other.LodgingReservation);
     }
     if (other.SourceNoteSubject.Length != 0)
     {
         SourceNoteSubject = other.SourceNoteSubject;
     }
     if (other.IsFulfilled != false)
     {
         IsFulfilled = other.IsFulfilled;
     }
     if (other.PermanentOnGuestRecord != false)
     {
         PermanentOnGuestRecord = other.PermanentOnGuestRecord;
     }
     if (other.incidentalItemId_ != null)
     {
         if (incidentalItemId_ == null)
         {
             incidentalItemId_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         IncidentalItemId.MergeFrom(other.IncidentalItemId);
     }
     if (other.incStartDate_ != null)
     {
         if (incStartDate_ == null)
         {
             incStartDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
         }
         IncStartDate.MergeFrom(other.IncStartDate);
     }
     if (other.incEndDate_ != null)
     {
         if (incEndDate_ == null)
         {
             incEndDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
         }
         IncEndDate.MergeFrom(other.IncEndDate);
     }
 }
Пример #16
0
 public virtual AsyncUnaryCall <global::HOLMS.Types.Supply.IncidentalItems.IncidentalItem> GetByIdAsync(global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator request, CallOptions options)
 {
     return(CallInvoker.AsyncUnaryCall(__Method_GetById, null, options, request));
 }
Пример #17
0
 public virtual global::System.Threading.Tasks.Task <global::HOLMS.Types.Supply.IncidentalItems.IncidentalItem> GetById(global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator request, ServerCallContext context)
 {
     throw new RpcException(new Status(StatusCode.Unimplemented, ""));
 }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (amount_ == null)
                    {
                        amount_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(amount_);
                    break;
                }

                case 18: {
                    Narration = input.ReadString();
                    break;
                }

                case 24: {
                    chargeCreditType_ = (global::HOLMS.Types.Folio.ChargeCreditType)input.ReadEnum();
                    break;
                }

                case 34: {
                    if (effectiveForOpsdate_ == null)
                    {
                        effectiveForOpsdate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
                    }
                    input.ReadMessage(effectiveForOpsdate_);
                    break;
                }

                case 42: {
                    if (effectiveAtClock_ == null)
                    {
                        effectiveAtClock_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
                    }
                    input.ReadMessage(effectiveAtClock_);
                    break;
                }

                case 50: {
                    if (incidentalItem_ == null)
                    {
                        incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(incidentalItem_);
                    break;
                }

                case 58: {
                    if (incurredBy_ == null)
                    {
                        incurredBy_ = new global::HOLMS.Types.Folio.FolioIndicator();
                    }
                    input.ReadMessage(incurredBy_);
                    break;
                }

                case 64: {
                    issuanceSchedule_ = (global::HOLMS.Types.Folio.FolioAtomicChargeIssuanceSchedule)input.ReadEnum();
                    break;
                }

                case 74: {
                    if (enteredBy_ == null)
                    {
                        enteredBy_ = new global::HOLMS.Types.IAM.StaffMemberIndicator();
                    }
                    input.ReadMessage(enteredBy_);
                    break;
                }

                case 82: {
                    if (id_ == null)
                    {
                        id_ = new global::HOLMS.Types.Primitive.Uuid();
                    }
                    input.ReadMessage(id_);
                    break;
                }

                case 90: {
                    if (taxes_ == null)
                    {
                        taxes_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(taxes_);
                    break;
                }

                case 98: {
                    if (fees_ == null)
                    {
                        fees_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(fees_);
                    break;
                }

                case 106: {
                    currentTaxAssessments_.AddEntriesFrom(input, _repeated_currentTaxAssessments_codec);
                    break;
                }
                }
            }
        }
Пример #19
0
 public virtual AsyncUnaryCall <global::HOLMS.Types.Supply.IncidentalItems.IncidentalItem> GetByIdAsync(global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(GetByIdAsync(request, new CallOptions(headers, deadline, cancellationToken)));
 }
 public void MergeFrom(FolioAtomicCharge other)
 {
     if (other == null)
     {
         return;
     }
     if (other.amount_ != null)
     {
         if (amount_ == null)
         {
             amount_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         Amount.MergeFrom(other.Amount);
     }
     if (other.Narration.Length != 0)
     {
         Narration = other.Narration;
     }
     if (other.ChargeCreditType != 0)
     {
         ChargeCreditType = other.ChargeCreditType;
     }
     if (other.effectiveForOpsdate_ != null)
     {
         if (effectiveForOpsdate_ == null)
         {
             effectiveForOpsdate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
         }
         EffectiveForOpsdate.MergeFrom(other.EffectiveForOpsdate);
     }
     if (other.effectiveAtClock_ != null)
     {
         if (effectiveAtClock_ == null)
         {
             effectiveAtClock_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
         }
         EffectiveAtClock.MergeFrom(other.EffectiveAtClock);
     }
     if (other.incidentalItem_ != null)
     {
         if (incidentalItem_ == null)
         {
             incidentalItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
         }
         IncidentalItem.MergeFrom(other.IncidentalItem);
     }
     if (other.incurredBy_ != null)
     {
         if (incurredBy_ == null)
         {
             incurredBy_ = new global::HOLMS.Types.Folio.FolioIndicator();
         }
         IncurredBy.MergeFrom(other.IncurredBy);
     }
     if (other.IssuanceSchedule != 0)
     {
         IssuanceSchedule = other.IssuanceSchedule;
     }
     if (other.enteredBy_ != null)
     {
         if (enteredBy_ == null)
         {
             enteredBy_ = new global::HOLMS.Types.IAM.StaffMemberIndicator();
         }
         EnteredBy.MergeFrom(other.EnteredBy);
     }
     if (other.id_ != null)
     {
         if (id_ == null)
         {
             id_ = new global::HOLMS.Types.Primitive.Uuid();
         }
         Id.MergeFrom(other.Id);
     }
     if (other.taxes_ != null)
     {
         if (taxes_ == null)
         {
             taxes_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         Taxes.MergeFrom(other.Taxes);
     }
     if (other.fees_ != null)
     {
         if (fees_ == null)
         {
             fees_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
         }
         Fees.MergeFrom(other.Fees);
     }
     currentTaxAssessments_.Add(other.currentTaxAssessments_);
 }
 public virtual global::HOLMS.Types.Supply.IncidentalItems.IncidentalItem GetById(global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator request, grpc::CallOptions options)
 {
     return(CallInvoker.BlockingUnaryCall(__Method_GetById, null, options, request));
 }
Пример #22
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (entityId_ == null)
                    {
                        entityId_ = new global::HOLMS.Types.Booking.Indicators.IncidentalItemReservationIndicator();
                    }
                    input.ReadMessage(entityId_);
                    break;
                }

                case 18: {
                    if (reservation_ == null)
                    {
                        reservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
                    }
                    input.ReadMessage(reservation_);
                    break;
                }

                case 26: {
                    if (dateRange_ == null)
                    {
                        dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
                    }
                    input.ReadMessage(dateRange_);
                    break;
                }

                case 34: {
                    if (reservedItem_ == null)
                    {
                        reservedItem_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(reservedItem_);
                    break;
                }

                case 40: {
                    AmountReserved = input.ReadUInt32();
                    break;
                }

                case 50: {
                    if (totalCost_ == null)
                    {
                        totalCost_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(totalCost_);
                    break;
                }

                case 58: {
                    IncidentalItemName = input.ReadString();
                    break;
                }
                }
            }
        }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (entityId_ == null)
                    {
                        entityId_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(entityId_);
                    break;
                }

                case 18: {
                    Description = input.ReadString();
                    break;
                }

                case 24: {
                    QuanityOwned = input.ReadUInt32();
                    break;
                }

                case 34: {
                    if (price_ == null)
                    {
                        price_ = new global::HOLMS.Types.Primitive.MonetaryAmount();
                    }
                    input.ReadMessage(price_);
                    break;
                }

                case 40: {
                    IncursTaxes = input.ReadBool();
                    break;
                }

                case 48: {
                    IncursFees = input.ReadBool();
                    break;
                }

                case 56: {
                    chargeFrequency_ = (global::HOLMS.Types.Supply.IncidentalItems.ItemChargeFrequency)input.ReadEnum();
                    break;
                }

                case 66: {
                    if (revenueAccount_ == null)
                    {
                        revenueAccount_ = new global::HOLMS.Types.Money.Accounting.AccountIndicator();
                    }
                    input.ReadMessage(revenueAccount_);
                    break;
                }
                }
            }
        }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 10: {
                    if (entityId_ == null)
                    {
                        entityId_ = new global::HOLMS.Types.Booking.Indicators.ReservationNoteIndicator();
                    }
                    input.ReadMessage(entityId_);
                    break;
                }

                case 18: {
                    if (sourceNote_ == null)
                    {
                        sourceNote_ = new global::HOLMS.Types.Operations.NoteRequests.NoteRequestIndicator();
                    }
                    input.ReadMessage(sourceNote_);
                    break;
                }

                case 24: {
                    category_ = (global::HOLMS.Types.Operations.NoteRequests.NoteCategory)input.ReadEnum();
                    break;
                }

                case 34: {
                    AdditionalNote = input.ReadString();
                    break;
                }

                case 40: {
                    IncludeOnConfirmation = input.ReadBool();
                    break;
                }

                case 50: {
                    if (lodgingReservation_ == null)
                    {
                        lodgingReservation_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
                    }
                    input.ReadMessage(lodgingReservation_);
                    break;
                }

                case 58: {
                    SourceNoteSubject = input.ReadString();
                    break;
                }

                case 64: {
                    IsFulfilled = input.ReadBool();
                    break;
                }

                case 72: {
                    PermanentOnGuestRecord = input.ReadBool();
                    break;
                }

                case 82: {
                    if (incidentalItemId_ == null)
                    {
                        incidentalItemId_ = new global::HOLMS.Types.Supply.IncidentalItems.IncidentalItemIndicator();
                    }
                    input.ReadMessage(incidentalItemId_);
                    break;
                }

                case 90: {
                    if (incStartDate_ == null)
                    {
                        incStartDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
                    }
                    input.ReadMessage(incStartDate_);
                    break;
                }

                case 98: {
                    if (incEndDate_ == null)
                    {
                        incEndDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
                    }
                    input.ReadMessage(incEndDate_);
                    break;
                }
                }
            }
        }