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.IAM.TenancyIndicator();
                    }
                    input.ReadMessage(entityId_);
                    break;
                }

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

                case 24: {
                    DustCleanAfterDays = input.ReadInt32();
                    break;
                }

                case 32: {
                    MandatoryCleaningAfterInHouseDays = input.ReadInt32();
                    break;
                }

                case 40: {
                    MandatorySheetCleaningAfterInHouseDays = input.ReadInt32();
                    break;
                }

                case 50: {
                    properties_.AddEntriesFrom(input, _repeated_properties_codec);
                    break;
                }

                case 58: {
                    phoneCodes_.AddEntriesFrom(input, _repeated_phoneCodes_codec);
                    break;
                }

                case 66: {
                    if (reservationDefaults_ == null)
                    {
                        reservationDefaults_ = new global::HOLMS.Types.TenancyConfig.ReservationDefaults();
                    }
                    input.ReadMessage(reservationDefaults_);
                    break;
                }

                case 74: {
                    if (reservationStatusColors_ == null)
                    {
                        reservationStatusColors_ = new global::HOLMS.Types.TenancyConfig.ReservationStatusColors();
                    }
                    input.ReadMessage(reservationStatusColors_);
                    break;
                }

                case 82: {
                    if (roomStatusColors_ == null)
                    {
                        roomStatusColors_ = new global::HOLMS.Types.TenancyConfig.RoomStatusColors();
                    }
                    input.ReadMessage(roomStatusColors_);
                    break;
                }

                case 90: {
                    if (hKPhoneCodes_ == null)
                    {
                        hKPhoneCodes_ = new global::HOLMS.Types.TenancyConfig.HKPhoneCodes();
                    }
                    input.ReadMessage(hKPhoneCodes_);
                    break;
                }

                case 98: {
                    if (roomCallBillingRates_ == null)
                    {
                        roomCallBillingRates_ = new global::HOLMS.Types.TenancyConfig.RoomCallBillingRates();
                    }
                    input.ReadMessage(roomCallBillingRates_);
                    break;
                }

                case 106: {
                    if (channelManagerConfig_ == null)
                    {
                        channelManagerConfig_ = new global::HOLMS.Types.TenancyConfig.ChannelManagerConfig();
                    }
                    input.ReadMessage(channelManagerConfig_);
                    break;
                }

                case 114: {
                    DefaultAdminEmail = input.ReadString();
                    break;
                }

                case 122: {
                    PostmarkEmailSenderAddress = input.ReadString();
                    break;
                }

                case 130: {
                    PostmarkApiKey = input.ReadString();
                    break;
                }
                }
            }
        }
 public void MergeFrom(ReservationSummary other)
 {
     if (other == null)
     {
         return;
     }
     if (other.entityId_ != null)
     {
         if (entityId_ == null)
         {
             entityId_ = new global::HOLMS.Types.Booking.Indicators.ReservationIndicator();
         }
         EntityId.MergeFrom(other.EntityId);
     }
     if (other.BookingId.Length != 0)
     {
         BookingId = other.BookingId;
     }
     if (other.State != 0)
     {
         State = other.State;
     }
     if (other.guest_ != null)
     {
         if (guest_ == null)
         {
             guest_ = new global::HOLMS.Types.CRM.Guests.Guest();
         }
         Guest.MergeFrom(other.Guest);
     }
     if (other.dateRange_ != null)
     {
         if (dateRange_ == null)
         {
             dateRange_ = new global::HOLMS.Types.Primitive.PbInclusiveOpsdateRange();
         }
         DateRange.MergeFrom(other.DateRange);
     }
     if (other.roomType_ != null)
     {
         if (roomType_ == null)
         {
             roomType_ = new global::HOLMS.Types.Supply.RoomTypes.RoomType();
         }
         RoomType.MergeFrom(other.RoomType);
     }
     if (other.GuaranteeStatus != 0)
     {
         GuaranteeStatus = other.GuaranteeStatus;
     }
     if (other.tenancy_ != null)
     {
         if (tenancy_ == null)
         {
             tenancy_ = new global::HOLMS.Types.IAM.TenancyIndicator();
         }
         Tenancy.MergeFrom(other.Tenancy);
     }
     if (other.property_ != null)
     {
         if (property_ == null)
         {
             property_ = new global::HOLMS.Types.TenancyConfig.Indicators.PropertyIndicator();
         }
         Property.MergeFrom(other.Property);
     }
     if (other.Channel != 0)
     {
         Channel = other.Channel;
     }
     if (other.VehiclePlateInformation.Length != 0)
     {
         VehiclePlateInformation = other.VehiclePlateInformation;
     }
     if (other.CurrentOccupiedRoomNumber.Length != 0)
     {
         CurrentOccupiedRoomNumber = other.CurrentOccupiedRoomNumber;
     }
     if (other.currentOccupiedRoom_ != null)
     {
         if (currentOccupiedRoom_ == null)
         {
             currentOccupiedRoom_ = new global::HOLMS.Types.Operations.Rooms.RoomIndicator();
         }
         CurrentOccupiedRoom.MergeFrom(other.CurrentOccupiedRoom);
     }
     if (other.TerminalOccupiedRoomNumber.Length != 0)
     {
         TerminalOccupiedRoomNumber = other.TerminalOccupiedRoomNumber;
     }
     if (other.terminalOccupiedRoom_ != null)
     {
         if (terminalOccupiedRoom_ == null)
         {
             terminalOccupiedRoom_ = new global::HOLMS.Types.Operations.Rooms.RoomIndicator();
         }
         TerminalOccupiedRoom.MergeFrom(other.TerminalOccupiedRoom);
     }
     if (other.NumberAdults != 0)
     {
         NumberAdults = other.NumberAdults;
     }
     if (other.NumberChildren != 0)
     {
         NumberChildren = other.NumberChildren;
     }
     activeTags_.Add(other.activeTags_);
     if (other.cancellationPolicy_ != null)
     {
         if (cancellationPolicy_ == null)
         {
             cancellationPolicy_ = new global::HOLMS.Types.Booking.Indicators.CancellationPolicyIndicator();
         }
         CancellationPolicy.MergeFrom(other.CancellationPolicy);
     }
     if (other.hkTimePreference_ != null)
     {
         if (hkTimePreference_ == null)
         {
             hkTimePreference_ = new global::HOLMS.Types.Operations.Housekeeping.HousekeepingTime();
         }
         HkTimePreference.MergeFrom(other.HkTimePreference);
     }
     if (other.createdAt_ != null)
     {
         if (createdAt_ == null)
         {
             createdAt_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
         }
         CreatedAt.MergeFrom(other.CreatedAt);
     }
     if (other.OutstandingIssuedRoomKeys != 0)
     {
         OutstandingIssuedRoomKeys = other.OutstandingIssuedRoomKeys;
     }
     if (other.OptaRoomStayIndex != 0)
     {
         OptaRoomStayIndex = other.OptaRoomStayIndex;
     }
     if (other.ReservationIdFromChannel.Length != 0)
     {
         ReservationIdFromChannel = other.ReservationIdFromChannel;
     }
 }
 public void MergeFrom(Tenancy other)
 {
     if (other == null)
     {
         return;
     }
     if (other.entityId_ != null)
     {
         if (entityId_ == null)
         {
             entityId_ = new global::HOLMS.Types.IAM.TenancyIndicator();
         }
         EntityId.MergeFrom(other.EntityId);
     }
     if (other.TenancyName.Length != 0)
     {
         TenancyName = other.TenancyName;
     }
     if (other.DustCleanAfterDays != 0)
     {
         DustCleanAfterDays = other.DustCleanAfterDays;
     }
     if (other.MandatoryCleaningAfterInHouseDays != 0)
     {
         MandatoryCleaningAfterInHouseDays = other.MandatoryCleaningAfterInHouseDays;
     }
     if (other.MandatorySheetCleaningAfterInHouseDays != 0)
     {
         MandatorySheetCleaningAfterInHouseDays = other.MandatorySheetCleaningAfterInHouseDays;
     }
     properties_.Add(other.properties_);
     phoneCodes_.Add(other.phoneCodes_);
     if (other.reservationDefaults_ != null)
     {
         if (reservationDefaults_ == null)
         {
             reservationDefaults_ = new global::HOLMS.Types.TenancyConfig.ReservationDefaults();
         }
         ReservationDefaults.MergeFrom(other.ReservationDefaults);
     }
     if (other.reservationStatusColors_ != null)
     {
         if (reservationStatusColors_ == null)
         {
             reservationStatusColors_ = new global::HOLMS.Types.TenancyConfig.ReservationStatusColors();
         }
         ReservationStatusColors.MergeFrom(other.ReservationStatusColors);
     }
     if (other.roomStatusColors_ != null)
     {
         if (roomStatusColors_ == null)
         {
             roomStatusColors_ = new global::HOLMS.Types.TenancyConfig.RoomStatusColors();
         }
         RoomStatusColors.MergeFrom(other.RoomStatusColors);
     }
     if (other.hKPhoneCodes_ != null)
     {
         if (hKPhoneCodes_ == null)
         {
             hKPhoneCodes_ = new global::HOLMS.Types.TenancyConfig.HKPhoneCodes();
         }
         HKPhoneCodes.MergeFrom(other.HKPhoneCodes);
     }
     if (other.roomCallBillingRates_ != null)
     {
         if (roomCallBillingRates_ == null)
         {
             roomCallBillingRates_ = new global::HOLMS.Types.TenancyConfig.RoomCallBillingRates();
         }
         RoomCallBillingRates.MergeFrom(other.RoomCallBillingRates);
     }
     if (other.channelManagerConfig_ != null)
     {
         if (channelManagerConfig_ == null)
         {
             channelManagerConfig_ = new global::HOLMS.Types.TenancyConfig.ChannelManagerConfig();
         }
         ChannelManagerConfig.MergeFrom(other.ChannelManagerConfig);
     }
     if (other.DefaultAdminEmail.Length != 0)
     {
         DefaultAdminEmail = other.DefaultAdminEmail;
     }
     if (other.PostmarkEmailSenderAddress.Length != 0)
     {
         PostmarkEmailSenderAddress = other.PostmarkEmailSenderAddress;
     }
     if (other.PostmarkApiKey.Length != 0)
     {
         PostmarkApiKey = other.PostmarkApiKey;
     }
 }
        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.ReservationIndicator();
                    }
                    input.ReadMessage(entityId_);
                    break;
                }

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

                case 24: {
                    state_ = (global::HOLMS.Types.Booking.Reservations.ReservationState)input.ReadEnum();
                    break;
                }

                case 34: {
                    if (guest_ == null)
                    {
                        guest_ = new global::HOLMS.Types.CRM.Guests.Guest();
                    }
                    input.ReadMessage(guest_);
                    break;
                }

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

                case 50: {
                    if (roomType_ == null)
                    {
                        roomType_ = new global::HOLMS.Types.Supply.RoomTypes.RoomType();
                    }
                    input.ReadMessage(roomType_);
                    break;
                }

                case 56: {
                    guaranteeStatus_ = (global::HOLMS.Types.Booking.Reservations.ReservationGuaranteeStatus)input.ReadEnum();
                    break;
                }

                case 66: {
                    if (tenancy_ == null)
                    {
                        tenancy_ = new global::HOLMS.Types.IAM.TenancyIndicator();
                    }
                    input.ReadMessage(tenancy_);
                    break;
                }

                case 74: {
                    if (property_ == null)
                    {
                        property_ = new global::HOLMS.Types.TenancyConfig.Indicators.PropertyIndicator();
                    }
                    input.ReadMessage(property_);
                    break;
                }

                case 80: {
                    channel_ = (global::HOLMS.Types.Booking.Channels.Channel)input.ReadEnum();
                    break;
                }

                case 90: {
                    VehiclePlateInformation = input.ReadString();
                    break;
                }

                case 98: {
                    CurrentOccupiedRoomNumber = input.ReadString();
                    break;
                }

                case 106: {
                    if (currentOccupiedRoom_ == null)
                    {
                        currentOccupiedRoom_ = new global::HOLMS.Types.Operations.Rooms.RoomIndicator();
                    }
                    input.ReadMessage(currentOccupiedRoom_);
                    break;
                }

                case 114: {
                    TerminalOccupiedRoomNumber = input.ReadString();
                    break;
                }

                case 122: {
                    if (terminalOccupiedRoom_ == null)
                    {
                        terminalOccupiedRoom_ = new global::HOLMS.Types.Operations.Rooms.RoomIndicator();
                    }
                    input.ReadMessage(terminalOccupiedRoom_);
                    break;
                }

                case 128: {
                    NumberAdults = input.ReadInt32();
                    break;
                }

                case 136: {
                    NumberChildren = input.ReadInt32();
                    break;
                }

                case 146: {
                    activeTags_.AddEntriesFrom(input, _repeated_activeTags_codec);
                    break;
                }

                case 170: {
                    if (cancellationPolicy_ == null)
                    {
                        cancellationPolicy_ = new global::HOLMS.Types.Booking.Indicators.CancellationPolicyIndicator();
                    }
                    input.ReadMessage(cancellationPolicy_);
                    break;
                }

                case 178: {
                    if (hkTimePreference_ == null)
                    {
                        hkTimePreference_ = new global::HOLMS.Types.Operations.Housekeeping.HousekeepingTime();
                    }
                    input.ReadMessage(hkTimePreference_);
                    break;
                }

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

                case 192: {
                    OutstandingIssuedRoomKeys = input.ReadInt32();
                    break;
                }

                case 200: {
                    OptaRoomStayIndex = input.ReadInt32();
                    break;
                }

                case 210: {
                    ReservationIdFromChannel = input.ReadString();
                    break;
                }
                }
            }
        }