using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace HOLMS.Types.Booking.RPC {

  /// <summary>Holder for reflection information generated from booking/rpc/reservation_search_svc.proto</summary>
  public static partial class ReservationSearchSvcReflection {

    #region Descriptor
    /// <summary>File descriptor for booking/rpc/reservation_search_svc.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static ReservationSearchSvcReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Cihib29raW5nL3JwYy9yZXNlcnZhdGlvbl9zZWFyY2hfc3ZjLnByb3RvEhdo",
            "b2xtcy50eXBlcy5ib29raW5nLnJwYxouYm9va2luZy9pbmRpY2F0b3JzL3Jl",
            "c2VydmF0aW9uX2luZGljYXRvci5wcm90bxoaYm9va2luZy9xdWVyeV9maWx0",
            "ZXIucHJvdG8aLmJvb2tpbmcvcmVzZXJ2YXRpb25zL3Jlc2VydmF0aW9uX3N1",
            "bW1hcnkucHJvdG8aHXByaW1pdGl2ZS9wYl9sb2NhbF9kYXRlLnByb3RvGhtv",
            "cGVyYXRpb25zL3Jvb21zL3Jvb20ucHJvdG8aNmJvb2tpbmcvcmVzZXJ2YXRp",
            "b25zL3Jlc2VydmF0aW9uX21hbmFnZW1lbnRfaG9sZC5wcm90bxozYm9va2lu",
            "Zy9yZXNlcnZhdGlvbnMvcmVzZXJ2YXRpb25fc3VtbWFyeV9saXRlLnByb3Rv",
            "Ghtnb29nbGUvcHJvdG9idWYvZW1wdHkucHJvdG8inAEKNVJlc2VydmF0aW9u",
            "U2VhcmNoU3ZjR2V0RmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXF1ZXN0EjAK",
            "BmZpbHRlchgBIAEoDjIgLmhvbG1zLnR5cGVzLmJvb2tpbmcuUXVlcnlGaWx0",
            "ZXISGAoQaW5jbHVkZV9jYW5jZWxlZBgCIAEoCBIXCg9pbmNsdWRlX2xpbWl0",
            "ZWQYAyABKAgioAEKOVJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0RGF0ZUZpbHRl",
            "cmVkUmVzZXJ2YXRpb25MaXN0UmVxdWVzdBIwCgRkYXRlGAEgASgLMiIuaG9s",
            "bXMudHlwZXMucHJpbWl0aXZlLlBiTG9jYWxEYXRlEhgKEGluY2x1ZGVfY2Fu",
            "Y2VsZWQYAiABKAgSFwoPaW5jbHVkZV9saW1pdGVkGAMgASgIIrcBCjZSZXNl",
            "cnZhdGlvblNlYXJjaFN2Y0dldEZpbHRlcmVkUmVzZXJ2YXRpb25MaXN0UmVz",
            "cG9uc2USSgoMcmVzZXJ2YXRpb25zGAEgAygLMjQuaG9sbXMudHlwZXMuYm9v",
            "a2luZy5yZXNlcnZhdGlvbnMuUmVzZXJ2YXRpb25TdW1tYXJ5EjEKBXJvb21z",
            "GAIgAygLMiIuaG9sbXMudHlwZXMub3BlcmF0aW9ucy5yb29tcy5Sb29tIr8B",
            "CjpSZXNlcnZhdGlvblNlYXJjaFN2Y0dldEZpbHRlcmVkUmVzZXJ2YXRpb25M",
            "aXN0TGl0ZVJlc3BvbnNlEk4KDHJlc2VydmF0aW9ucxgBIAMoCzI4LmhvbG1z",
            "LnR5cGVzLmJvb2tpbmcucmVzZXJ2YXRpb25zLlJlc2VydmF0aW9uU3VtbWFy",
            "eUxpdGUSMQoFcm9vbXMYAiADKAsyIi5ob2xtcy50eXBlcy5vcGVyYXRpb25z",
            "LnJvb21zLlJvb20iQwotUmVzZXJ2YXRpb25TZWFyY2hTdmNTZWFyY2hSZXNl",
            "cnZhdGlvbnNSZXF1ZXN0EhIKCnNlYXJjaF9hcmcYASABKAki4AEKMVJlc2Vy",
            "dmF0aW9uU2VhcmNoU3ZjR2V0UmVzZXJ2YXRpb25TdW1tYXJ5UmVzcG9uc2US",
            "WAoGcmVzdWx0GAEgASgOMkguaG9sbXMudHlwZXMuYm9va2luZy5ycGMuUmVz",
            "ZXJ2YXRpb25TZWFyY2hTdmNHZXRSZXNlcnZhdGlvblN1bW1hcnlSZXN1bHQS",
            "UQoTcmVzZXJ2YXRpb25fc3VtbWFyeRgCIAEoCzI0LmhvbG1zLnR5cGVzLmJv",
            "b2tpbmcucmVzZXJ2YXRpb25zLlJlc2VydmF0aW9uU3VtbWFyeSJsCh5HZXRS",
            "ZXNlcnZhdGlvblN1bW1hcmllc1JlcXVlc3QSSgoMcmVzZXJ2YXRpb25zGAEg",
            "AygLMjQuaG9sbXMudHlwZXMuYm9va2luZy5pbmRpY2F0b3JzLlJlc2VydmF0",
            "aW9uSW5kaWNhdG9yIpsBCi5SZXNlcnZhdGlvblNlYXJjaFN2Y0dldEFzc29j",
            "aWF0ZWRIb2xkc1Jlc3BvbnNlEmkKIHJlc2VydmF0aW9uX3dpdGhfbWFuYWdl",
            "bWVudF9ob2xkGAEgASgLMj8uaG9sbXMudHlwZXMuYm9va2luZy5yZXNlcnZh",
            "dGlvbnMuUmVzZXJ2YXRpb25XaXRoTWFuYWdlbWVudEhvbGQisQEKJ1Jlc2Vy",
            "dmF0aW9uU2VhcmNoRHVyaW5nRGF0ZVJhbmdlUmVxdWVzdBI2CgpzdGFydF9k",
            "YXRlGAEgASgLMiIuaG9sbXMudHlwZXMucHJpbWl0aXZlLlBiTG9jYWxEYXRl",
            "EjQKCGVuZF9kYXRlGAIgASgLMiIuaG9sbXMudHlwZXMucHJpbWl0aXZlLlBi",
            "TG9jYWxEYXRlEhgKEGluY2x1ZGVfY2FuY2VsZWQYAyABKAgibQofU3luY1Nw",
            "ZWNpZmljUmVzZXJ2YXRpb25zUmVxdWVzdBJKCgxyZXNlcnZhdGlvbnMYASAD",
            "KAsyNC5ob2xtcy50eXBlcy5ib29raW5nLmluZGljYXRvcnMuUmVzZXJ2YXRp",
            "b25JbmRpY2F0b3IqtAEKL1Jlc2VydmF0aW9uU2VhcmNoU3ZjR2V0UmVzZXJ2",
            "YXRpb25TdW1tYXJ5UmVzdWx0EjwKOFJFU0VSVkFUSU9OX1NFQVJDSF9TVkNf",
            "R0VUX1JFU0VSVkFUSU9OX1NVTU1BUllfUkVTVUxUX09LEAASQwo/UkVTRVJW",
            "QVRJT05fU0VBUkNIX1NWQ19HRVRfUkVTRVJWQVRJT05fU1VNTUFSWV9SRVNV",
            "TFRfTk9UX0ZPVU5EEAEyqRcKFFJlc2VydmF0aW9uU2VhcmNoU3ZjEr8BChRH",
            "ZXRBbGxEdXJpbmdEYXRlTGl0ZRJSLmhvbG1zLnR5cGVzLmJvb2tpbmcucnBj",
            "LlJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0RGF0ZUZpbHRlcmVkUmVzZXJ2YXRp",
            "b25MaXN0UmVxdWVzdBpTLmhvbG1zLnR5cGVzLmJvb2tpbmcucnBjLlJlc2Vy",
            "dmF0aW9uU2VhcmNoU3ZjR2V0RmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RMaXRl",
            "UmVzcG9uc2USyAEKHUdldEFycml2YWxzQnlDYWxlbmRhckRhdGVMaXRlElIu",
            "aG9sbXMudHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25TZWFyY2hTdmNH",
            "ZXREYXRlRmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXF1ZXN0GlMuaG9sbXMu",
            "dHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25TZWFyY2hTdmNHZXRGaWx0",
            "ZXJlZFJlc2VydmF0aW9uTGlzdExpdGVSZXNwb25zZRLKAQofR2V0RGVwYXJ0",
            "dXJlc0J5Q2FsZW5kYXJEYXRlTGl0ZRJSLmhvbG1zLnR5cGVzLmJvb2tpbmcu",
            "cnBjLlJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0RGF0ZUZpbHRlcmVkUmVzZXJ2",
            "YXRpb25MaXN0UmVxdWVzdBpTLmhvbG1zLnR5cGVzLmJvb2tpbmcucnBjLlJl",
            "c2VydmF0aW9uU2VhcmNoU3ZjR2V0RmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RM",
            "aXRlUmVzcG9uc2USxQEKHkdldEZpbHRlcmVkUmVzZXJ2YXRpb25MaXN0TGl0",
            "ZRJOLmhvbG1zLnR5cGVzLmJvb2tpbmcucnBjLlJlc2VydmF0aW9uU2VhcmNo",
            "U3ZjR2V0RmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXF1ZXN0GlMuaG9sbXMu",
            "dHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25TZWFyY2hTdmNHZXRGaWx0",
            "ZXJlZFJlc2VydmF0aW9uTGlzdExpdGVSZXNwb25zZRK9AQoaR2V0RmlsdGVy",
            "ZWRSZXNlcnZhdGlvbkxpc3QSTi5ob2xtcy50eXBlcy5ib29raW5nLnJwYy5S",
            "ZXNlcnZhdGlvblNlYXJjaFN2Y0dldEZpbHRlcmVkUmVzZXJ2YXRpb25MaXN0",
            "UmVxdWVzdBpPLmhvbG1zLnR5cGVzLmJvb2tpbmcucnBjLlJlc2VydmF0aW9u",
            "U2VhcmNoU3ZjR2V0RmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXNwb25zZRLA",
            "AQoZR2V0QXJyaXZhbHNCeUNhbGVuZGFyRGF0ZRJSLmhvbG1zLnR5cGVzLmJv",
            "b2tpbmcucnBjLlJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0RGF0ZUZpbHRlcmVk",
            "UmVzZXJ2YXRpb25MaXN0UmVxdWVzdBpPLmhvbG1zLnR5cGVzLmJvb2tpbmcu",
            "cnBjLlJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0RmlsdGVyZWRSZXNlcnZhdGlv",
            "bkxpc3RSZXNwb25zZRLCAQobR2V0RGVwYXJ0dXJlc0J5Q2FsZW5kYXJEYXRl",
            "ElIuaG9sbXMudHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25TZWFyY2hT",
            "dmNHZXREYXRlRmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXF1ZXN0Gk8uaG9s",
            "bXMudHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25TZWFyY2hTdmNHZXRG",
            "aWx0ZXJlZFJlc2VydmF0aW9uTGlzdFJlc3BvbnNlErcBChBHZXROb1Nob3dz",
            "QnlEYXRlElIuaG9sbXMudHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25T",
            "ZWFyY2hTdmNHZXREYXRlRmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXF1ZXN0",
            "Gk8uaG9sbXMudHlwZXMuYm9va2luZy5ycGMuUmVzZXJ2YXRpb25TZWFyY2hT",
            "dmNHZXRGaWx0ZXJlZFJlc2VydmF0aW9uTGlzdFJlc3BvbnNlErkBChJHZXRT",
            "dGF5T3ZlcnNCeURhdGUSUi5ob2xtcy50eXBlcy5ib29raW5nLnJwYy5SZXNl",
            "cnZhdGlvblNlYXJjaFN2Y0dldERhdGVGaWx0ZXJlZFJlc2VydmF0aW9uTGlz",
            "dFJlcXVlc3QaTy5ob2xtcy50eXBlcy5ib29raW5nLnJwYy5SZXNlcnZhdGlv",
            "blNlYXJjaFN2Y0dldEZpbHRlcmVkUmVzZXJ2YXRpb25MaXN0UmVzcG9uc2US",
            "twEKEEdldEFsbER1cmluZ0RhdGUSUi5ob2xtcy50eXBlcy5ib29raW5nLnJw",
            "Yy5SZXNlcnZhdGlvblNlYXJjaFN2Y0dldERhdGVGaWx0ZXJlZFJlc2VydmF0",
            "aW9uTGlzdFJlcXVlc3QaTy5ob2xtcy50eXBlcy5ib29raW5nLnJwYy5SZXNl",
            "cnZhdGlvblNlYXJjaFN2Y0dldEZpbHRlcmVkUmVzZXJ2YXRpb25MaXN0UmVz",
            "cG9uc2USmQEKFUdldFJlc2VydmF0aW9uU3VtbWFyeRI0LmhvbG1zLnR5cGVz",
            "LmJvb2tpbmcuaW5kaWNhdG9ycy5SZXNlcnZhdGlvbkluZGljYXRvchpKLmhv",
            "bG1zLnR5cGVzLmJvb2tpbmcucnBjLlJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0",
            "UmVzZXJ2YXRpb25TdW1tYXJ5UmVzcG9uc2USowEKF0dldFJlc2VydmF0aW9u",
            "U3VtbWFyaWVzEjcuaG9sbXMudHlwZXMuYm9va2luZy5ycGMuR2V0UmVzZXJ2",
            "YXRpb25TdW1tYXJpZXNSZXF1ZXN0Gk8uaG9sbXMudHlwZXMuYm9va2luZy5y",
            "cGMuUmVzZXJ2YXRpb25TZWFyY2hTdmNHZXRGaWx0ZXJlZFJlc2VydmF0aW9u",
            "TGlzdFJlc3BvbnNlEq0BChJTZWFyY2hSZXNlcnZhdGlvbnMSRi5ob2xtcy50",
            "eXBlcy5ib29raW5nLnJwYy5SZXNlcnZhdGlvblNlYXJjaFN2Y1NlYXJjaFJl",
            "c2VydmF0aW9uc1JlcXVlc3QaTy5ob2xtcy50eXBlcy5ib29raW5nLnJwYy5S",
            "ZXNlcnZhdGlvblNlYXJjaFN2Y0dldEZpbHRlcmVkUmVzZXJ2YXRpb25MaXN0",
            "UmVzcG9uc2USnQEKHEdldEFzc29jaWF0ZWRNYW5hZ2VtZW50SG9sZHMSNC5o",
            "b2xtcy50eXBlcy5ib29raW5nLmluZGljYXRvcnMuUmVzZXJ2YXRpb25JbmRp",
            "Y2F0b3IaRy5ob2xtcy50eXBlcy5ib29raW5nLnJwYy5SZXNlcnZhdGlvblNl",
            "YXJjaFN2Y0dldEFzc29jaWF0ZWRIb2xkc1Jlc3BvbnNlEq8BChpHZXRSZXNl",
            "cnZhdGlvbnNJbkRhdGVSYW5nZRJALmhvbG1zLnR5cGVzLmJvb2tpbmcucnBj",
            "LlJlc2VydmF0aW9uU2VhcmNoRHVyaW5nRGF0ZVJhbmdlUmVxdWVzdBpPLmhv",
            "bG1zLnR5cGVzLmJvb2tpbmcucnBjLlJlc2VydmF0aW9uU2VhcmNoU3ZjR2V0",
            "RmlsdGVyZWRSZXNlcnZhdGlvbkxpc3RSZXNwb25zZRJFChNTeW5jQWxsUmVz",
            "ZXJ2YXRpb25zEhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5GhYuZ29vZ2xlLnBy",
            "b3RvYnVmLkVtcHR5EmwKGFN5bmNTcGVjaWZpY1Jlc2VydmF0aW9ucxI4Lmhv",
            "bG1zLnR5cGVzLmJvb2tpbmcucnBjLlN5bmNTcGVjaWZpY1Jlc2VydmF0aW9u",
            "c1JlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHlCGqoCF0hPTE1TLlR5",
            "cGVzLkJvb2tpbmcuUlBDYgZwcm90bzM="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { global::HOLMS.Types.Booking.Indicators.ReservationIndicatorReflection.Descriptor, global::HOLMS.Types.Booking.QueryFilterReflection.Descriptor, global::HOLMS.Types.Booking.Reservations.ReservationSummaryReflection.Descriptor, global::HOLMS.Types.Primitive.PbLocalDateReflection.Descriptor, global::HOLMS.Types.Operations.Rooms.RoomReflection.Descriptor, global::HOLMS.Types.Booking.Reservations.ReservationManagementHoldReflection.Descriptor, global::HOLMS.Types.Booking.Reservations.ReservationSummaryLiteReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, },
          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetReservationSummaryResult), }, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetFilteredReservationListRequest), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetFilteredReservationListRequest.Parser, new[]{ "Filter", "IncludeCanceled", "IncludeLimited" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetDateFilteredReservationListRequest), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetDateFilteredReservationListRequest.Parser, new[]{ "Date", "IncludeCanceled", "IncludeLimited" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetFilteredReservationListResponse), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetFilteredReservationListResponse.Parser, new[]{ "Reservations", "Rooms" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetFilteredReservationListLiteResponse), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetFilteredReservationListLiteResponse.Parser, new[]{ "Reservations", "Rooms" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcSearchReservationsRequest), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcSearchReservationsRequest.Parser, new[]{ "SearchArg" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetReservationSummaryResponse), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetReservationSummaryResponse.Parser, new[]{ "Result", "ReservationSummary" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.GetReservationSummariesRequest), global::HOLMS.Types.Booking.RPC.GetReservationSummariesRequest.Parser, new[]{ "Reservations" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetAssociatedHoldsResponse), global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetAssociatedHoldsResponse.Parser, new[]{ "ReservationWithManagementHold" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.ReservationSearchDuringDateRangeRequest), global::HOLMS.Types.Booking.RPC.ReservationSearchDuringDateRangeRequest.Parser, new[]{ "StartDate", "EndDate", "IncludeCanceled" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::HOLMS.Types.Booking.RPC.SyncSpecificReservationsRequest), global::HOLMS.Types.Booking.RPC.SyncSpecificReservationsRequest.Parser, new[]{ "Reservations" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Enums
  public enum ReservationSearchSvcGetReservationSummaryResult {
    [pbr::OriginalName("RESERVATION_SEARCH_SVC_GET_RESERVATION_SUMMARY_RESULT_OK")] Ok = 0,
    [pbr::OriginalName("RESERVATION_SEARCH_SVC_GET_RESERVATION_SUMMARY_RESULT_NOT_FOUND")] NotFound = 1,
  }

  #endregion

  #region Messages
  public sealed partial class ReservationSearchSvcGetFilteredReservationListRequest : pb::IMessage<ReservationSearchSvcGetFilteredReservationListRequest> {
    private static readonly pb::MessageParser<ReservationSearchSvcGetFilteredReservationListRequest> _parser = new pb::MessageParser<ReservationSearchSvcGetFilteredReservationListRequest>(() => new ReservationSearchSvcGetFilteredReservationListRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcGetFilteredReservationListRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListRequest(ReservationSearchSvcGetFilteredReservationListRequest other) : this() {
      filter_ = other.filter_;
      includeCanceled_ = other.includeCanceled_;
      includeLimited_ = other.includeLimited_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListRequest Clone() {
      return new ReservationSearchSvcGetFilteredReservationListRequest(this);
    }

    /// <summary>Field number for the "filter" field.</summary>
    public const int FilterFieldNumber = 1;
    private global::HOLMS.Types.Booking.QueryFilter filter_ = 0;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Booking.QueryFilter Filter {
      get { return filter_; }
      set {
        filter_ = value;
      }
    }

    /// <summary>Field number for the "include_canceled" field.</summary>
    public const int IncludeCanceledFieldNumber = 2;
    private bool includeCanceled_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool IncludeCanceled {
      get { return includeCanceled_; }
      set {
        includeCanceled_ = value;
      }
    }

    /// <summary>Field number for the "include_limited" field.</summary>
    public const int IncludeLimitedFieldNumber = 3;
    private bool includeLimited_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool IncludeLimited {
      get { return includeLimited_; }
      set {
        includeLimited_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcGetFilteredReservationListRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcGetFilteredReservationListRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Filter != other.Filter) return false;
      if (IncludeCanceled != other.IncludeCanceled) return false;
      if (IncludeLimited != other.IncludeLimited) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Filter != 0) hash ^= Filter.GetHashCode();
      if (IncludeCanceled != false) hash ^= IncludeCanceled.GetHashCode();
      if (IncludeLimited != false) hash ^= IncludeLimited.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Filter != 0) {
        output.WriteRawTag(8);
        output.WriteEnum((int) Filter);
      }
      if (IncludeCanceled != false) {
        output.WriteRawTag(16);
        output.WriteBool(IncludeCanceled);
      }
      if (IncludeLimited != false) {
        output.WriteRawTag(24);
        output.WriteBool(IncludeLimited);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Filter != 0) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Filter);
      }
      if (IncludeCanceled != false) {
        size += 1 + 1;
      }
      if (IncludeLimited != false) {
        size += 1 + 1;
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcGetFilteredReservationListRequest other) {
      if (other == null) {
        return;
      }
      if (other.Filter != 0) {
        Filter = other.Filter;
      }
      if (other.IncludeCanceled != false) {
        IncludeCanceled = other.IncludeCanceled;
      }
      if (other.IncludeLimited != false) {
        IncludeLimited = other.IncludeLimited;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            filter_ = (global::HOLMS.Types.Booking.QueryFilter) input.ReadEnum();
            break;
          }
          case 16: {
            IncludeCanceled = input.ReadBool();
            break;
          }
          case 24: {
            IncludeLimited = input.ReadBool();
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchSvcGetDateFilteredReservationListRequest : pb::IMessage<ReservationSearchSvcGetDateFilteredReservationListRequest> {
    private static readonly pb::MessageParser<ReservationSearchSvcGetDateFilteredReservationListRequest> _parser = new pb::MessageParser<ReservationSearchSvcGetDateFilteredReservationListRequest>(() => new ReservationSearchSvcGetDateFilteredReservationListRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcGetDateFilteredReservationListRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetDateFilteredReservationListRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetDateFilteredReservationListRequest(ReservationSearchSvcGetDateFilteredReservationListRequest other) : this() {
      Date = other.date_ != null ? other.Date.Clone() : null;
      includeCanceled_ = other.includeCanceled_;
      includeLimited_ = other.includeLimited_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetDateFilteredReservationListRequest Clone() {
      return new ReservationSearchSvcGetDateFilteredReservationListRequest(this);
    }

    /// <summary>Field number for the "date" field.</summary>
    public const int DateFieldNumber = 1;
    private global::HOLMS.Types.Primitive.PbLocalDate date_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Primitive.PbLocalDate Date {
      get { return date_; }
      set {
        date_ = value;
      }
    }

    /// <summary>Field number for the "include_canceled" field.</summary>
    public const int IncludeCanceledFieldNumber = 2;
    private bool includeCanceled_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool IncludeCanceled {
      get { return includeCanceled_; }
      set {
        includeCanceled_ = value;
      }
    }

    /// <summary>Field number for the "include_limited" field.</summary>
    public const int IncludeLimitedFieldNumber = 3;
    private bool includeLimited_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool IncludeLimited {
      get { return includeLimited_; }
      set {
        includeLimited_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcGetDateFilteredReservationListRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcGetDateFilteredReservationListRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!object.Equals(Date, other.Date)) return false;
      if (IncludeCanceled != other.IncludeCanceled) return false;
      if (IncludeLimited != other.IncludeLimited) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (date_ != null) hash ^= Date.GetHashCode();
      if (IncludeCanceled != false) hash ^= IncludeCanceled.GetHashCode();
      if (IncludeLimited != false) hash ^= IncludeLimited.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (date_ != null) {
        output.WriteRawTag(10);
        output.WriteMessage(Date);
      }
      if (IncludeCanceled != false) {
        output.WriteRawTag(16);
        output.WriteBool(IncludeCanceled);
      }
      if (IncludeLimited != false) {
        output.WriteRawTag(24);
        output.WriteBool(IncludeLimited);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (date_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Date);
      }
      if (IncludeCanceled != false) {
        size += 1 + 1;
      }
      if (IncludeLimited != false) {
        size += 1 + 1;
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcGetDateFilteredReservationListRequest other) {
      if (other == null) {
        return;
      }
      if (other.date_ != null) {
        if (date_ == null) {
          date_ = new global::HOLMS.Types.Primitive.PbLocalDate();
        }
        Date.MergeFrom(other.Date);
      }
      if (other.IncludeCanceled != false) {
        IncludeCanceled = other.IncludeCanceled;
      }
      if (other.IncludeLimited != false) {
        IncludeLimited = other.IncludeLimited;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            if (date_ == null) {
              date_ = new global::HOLMS.Types.Primitive.PbLocalDate();
            }
            input.ReadMessage(date_);
            break;
          }
          case 16: {
            IncludeCanceled = input.ReadBool();
            break;
          }
          case 24: {
            IncludeLimited = input.ReadBool();
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchSvcGetFilteredReservationListResponse : pb::IMessage<ReservationSearchSvcGetFilteredReservationListResponse> {
    private static readonly pb::MessageParser<ReservationSearchSvcGetFilteredReservationListResponse> _parser = new pb::MessageParser<ReservationSearchSvcGetFilteredReservationListResponse>(() => new ReservationSearchSvcGetFilteredReservationListResponse());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcGetFilteredReservationListResponse> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[2]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListResponse() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListResponse(ReservationSearchSvcGetFilteredReservationListResponse other) : this() {
      reservations_ = other.reservations_.Clone();
      rooms_ = other.rooms_.Clone();
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListResponse Clone() {
      return new ReservationSearchSvcGetFilteredReservationListResponse(this);
    }

    /// <summary>Field number for the "reservations" field.</summary>
    public const int ReservationsFieldNumber = 1;
    private static readonly pb::FieldCodec<global::HOLMS.Types.Booking.Reservations.ReservationSummary> _repeated_reservations_codec
        = pb::FieldCodec.ForMessage(10, global::HOLMS.Types.Booking.Reservations.ReservationSummary.Parser);
    private readonly pbc::RepeatedField<global::HOLMS.Types.Booking.Reservations.ReservationSummary> reservations_ = new pbc::RepeatedField<global::HOLMS.Types.Booking.Reservations.ReservationSummary>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::HOLMS.Types.Booking.Reservations.ReservationSummary> Reservations {
      get { return reservations_; }
    }

    /// <summary>Field number for the "rooms" field.</summary>
    public const int RoomsFieldNumber = 2;
    private static readonly pb::FieldCodec<global::HOLMS.Types.Operations.Rooms.Room> _repeated_rooms_codec
        = pb::FieldCodec.ForMessage(18, global::HOLMS.Types.Operations.Rooms.Room.Parser);
    private readonly pbc::RepeatedField<global::HOLMS.Types.Operations.Rooms.Room> rooms_ = new pbc::RepeatedField<global::HOLMS.Types.Operations.Rooms.Room>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::HOLMS.Types.Operations.Rooms.Room> Rooms {
      get { return rooms_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcGetFilteredReservationListResponse);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcGetFilteredReservationListResponse other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!reservations_.Equals(other.reservations_)) return false;
      if(!rooms_.Equals(other.rooms_)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= reservations_.GetHashCode();
      hash ^= rooms_.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      reservations_.WriteTo(output, _repeated_reservations_codec);
      rooms_.WriteTo(output, _repeated_rooms_codec);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += reservations_.CalculateSize(_repeated_reservations_codec);
      size += rooms_.CalculateSize(_repeated_rooms_codec);
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcGetFilteredReservationListResponse other) {
      if (other == null) {
        return;
      }
      reservations_.Add(other.reservations_);
      rooms_.Add(other.rooms_);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            reservations_.AddEntriesFrom(input, _repeated_reservations_codec);
            break;
          }
          case 18: {
            rooms_.AddEntriesFrom(input, _repeated_rooms_codec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchSvcGetFilteredReservationListLiteResponse : pb::IMessage<ReservationSearchSvcGetFilteredReservationListLiteResponse> {
    private static readonly pb::MessageParser<ReservationSearchSvcGetFilteredReservationListLiteResponse> _parser = new pb::MessageParser<ReservationSearchSvcGetFilteredReservationListLiteResponse>(() => new ReservationSearchSvcGetFilteredReservationListLiteResponse());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcGetFilteredReservationListLiteResponse> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[3]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListLiteResponse() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListLiteResponse(ReservationSearchSvcGetFilteredReservationListLiteResponse other) : this() {
      reservations_ = other.reservations_.Clone();
      rooms_ = other.rooms_.Clone();
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetFilteredReservationListLiteResponse Clone() {
      return new ReservationSearchSvcGetFilteredReservationListLiteResponse(this);
    }

    /// <summary>Field number for the "reservations" field.</summary>
    public const int ReservationsFieldNumber = 1;
    private static readonly pb::FieldCodec<global::HOLMS.Types.Booking.Reservations.ReservationSummaryLite> _repeated_reservations_codec
        = pb::FieldCodec.ForMessage(10, global::HOLMS.Types.Booking.Reservations.ReservationSummaryLite.Parser);
    private readonly pbc::RepeatedField<global::HOLMS.Types.Booking.Reservations.ReservationSummaryLite> reservations_ = new pbc::RepeatedField<global::HOLMS.Types.Booking.Reservations.ReservationSummaryLite>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::HOLMS.Types.Booking.Reservations.ReservationSummaryLite> Reservations {
      get { return reservations_; }
    }

    /// <summary>Field number for the "rooms" field.</summary>
    public const int RoomsFieldNumber = 2;
    private static readonly pb::FieldCodec<global::HOLMS.Types.Operations.Rooms.Room> _repeated_rooms_codec
        = pb::FieldCodec.ForMessage(18, global::HOLMS.Types.Operations.Rooms.Room.Parser);
    private readonly pbc::RepeatedField<global::HOLMS.Types.Operations.Rooms.Room> rooms_ = new pbc::RepeatedField<global::HOLMS.Types.Operations.Rooms.Room>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::HOLMS.Types.Operations.Rooms.Room> Rooms {
      get { return rooms_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcGetFilteredReservationListLiteResponse);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcGetFilteredReservationListLiteResponse other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!reservations_.Equals(other.reservations_)) return false;
      if(!rooms_.Equals(other.rooms_)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= reservations_.GetHashCode();
      hash ^= rooms_.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      reservations_.WriteTo(output, _repeated_reservations_codec);
      rooms_.WriteTo(output, _repeated_rooms_codec);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += reservations_.CalculateSize(_repeated_reservations_codec);
      size += rooms_.CalculateSize(_repeated_rooms_codec);
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcGetFilteredReservationListLiteResponse other) {
      if (other == null) {
        return;
      }
      reservations_.Add(other.reservations_);
      rooms_.Add(other.rooms_);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            reservations_.AddEntriesFrom(input, _repeated_reservations_codec);
            break;
          }
          case 18: {
            rooms_.AddEntriesFrom(input, _repeated_rooms_codec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchSvcSearchReservationsRequest : pb::IMessage<ReservationSearchSvcSearchReservationsRequest> {
    private static readonly pb::MessageParser<ReservationSearchSvcSearchReservationsRequest> _parser = new pb::MessageParser<ReservationSearchSvcSearchReservationsRequest>(() => new ReservationSearchSvcSearchReservationsRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcSearchReservationsRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[4]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcSearchReservationsRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcSearchReservationsRequest(ReservationSearchSvcSearchReservationsRequest other) : this() {
      searchArg_ = other.searchArg_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcSearchReservationsRequest Clone() {
      return new ReservationSearchSvcSearchReservationsRequest(this);
    }

    /// <summary>Field number for the "search_arg" field.</summary>
    public const int SearchArgFieldNumber = 1;
    private string searchArg_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string SearchArg {
      get { return searchArg_; }
      set {
        searchArg_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcSearchReservationsRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcSearchReservationsRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (SearchArg != other.SearchArg) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (SearchArg.Length != 0) hash ^= SearchArg.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (SearchArg.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(SearchArg);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (SearchArg.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(SearchArg);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcSearchReservationsRequest other) {
      if (other == null) {
        return;
      }
      if (other.SearchArg.Length != 0) {
        SearchArg = other.SearchArg;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            SearchArg = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchSvcGetReservationSummaryResponse : pb::IMessage<ReservationSearchSvcGetReservationSummaryResponse> {
    private static readonly pb::MessageParser<ReservationSearchSvcGetReservationSummaryResponse> _parser = new pb::MessageParser<ReservationSearchSvcGetReservationSummaryResponse>(() => new ReservationSearchSvcGetReservationSummaryResponse());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcGetReservationSummaryResponse> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[5]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetReservationSummaryResponse() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetReservationSummaryResponse(ReservationSearchSvcGetReservationSummaryResponse other) : this() {
      result_ = other.result_;
      ReservationSummary = other.reservationSummary_ != null ? other.ReservationSummary.Clone() : null;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetReservationSummaryResponse Clone() {
      return new ReservationSearchSvcGetReservationSummaryResponse(this);
    }

    /// <summary>Field number for the "result" field.</summary>
    public const int ResultFieldNumber = 1;
    private global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetReservationSummaryResult result_ = 0;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetReservationSummaryResult Result {
      get { return result_; }
      set {
        result_ = value;
      }
    }

    /// <summary>Field number for the "reservation_summary" field.</summary>
    public const int ReservationSummaryFieldNumber = 2;
    private global::HOLMS.Types.Booking.Reservations.ReservationSummary reservationSummary_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Booking.Reservations.ReservationSummary ReservationSummary {
      get { return reservationSummary_; }
      set {
        reservationSummary_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcGetReservationSummaryResponse);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcGetReservationSummaryResponse other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Result != other.Result) return false;
      if (!object.Equals(ReservationSummary, other.ReservationSummary)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Result != 0) hash ^= Result.GetHashCode();
      if (reservationSummary_ != null) hash ^= ReservationSummary.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Result != 0) {
        output.WriteRawTag(8);
        output.WriteEnum((int) Result);
      }
      if (reservationSummary_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(ReservationSummary);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Result != 0) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Result);
      }
      if (reservationSummary_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(ReservationSummary);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcGetReservationSummaryResponse other) {
      if (other == null) {
        return;
      }
      if (other.Result != 0) {
        Result = other.Result;
      }
      if (other.reservationSummary_ != null) {
        if (reservationSummary_ == null) {
          reservationSummary_ = new global::HOLMS.Types.Booking.Reservations.ReservationSummary();
        }
        ReservationSummary.MergeFrom(other.ReservationSummary);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            result_ = (global::HOLMS.Types.Booking.RPC.ReservationSearchSvcGetReservationSummaryResult) input.ReadEnum();
            break;
          }
          case 18: {
            if (reservationSummary_ == null) {
              reservationSummary_ = new global::HOLMS.Types.Booking.Reservations.ReservationSummary();
            }
            input.ReadMessage(reservationSummary_);
            break;
          }
        }
      }
    }

  }

  public sealed partial class GetReservationSummariesRequest : pb::IMessage<GetReservationSummariesRequest> {
    private static readonly pb::MessageParser<GetReservationSummariesRequest> _parser = new pb::MessageParser<GetReservationSummariesRequest>(() => new GetReservationSummariesRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<GetReservationSummariesRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[6]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public GetReservationSummariesRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public GetReservationSummariesRequest(GetReservationSummariesRequest other) : this() {
      reservations_ = other.reservations_.Clone();
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public GetReservationSummariesRequest Clone() {
      return new GetReservationSummariesRequest(this);
    }

    /// <summary>Field number for the "reservations" field.</summary>
    public const int ReservationsFieldNumber = 1;
    private static readonly pb::FieldCodec<global::HOLMS.Types.Booking.Indicators.ReservationIndicator> _repeated_reservations_codec
        = pb::FieldCodec.ForMessage(10, global::HOLMS.Types.Booking.Indicators.ReservationIndicator.Parser);
    private readonly pbc::RepeatedField<global::HOLMS.Types.Booking.Indicators.ReservationIndicator> reservations_ = new pbc::RepeatedField<global::HOLMS.Types.Booking.Indicators.ReservationIndicator>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::HOLMS.Types.Booking.Indicators.ReservationIndicator> Reservations {
      get { return reservations_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as GetReservationSummariesRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(GetReservationSummariesRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!reservations_.Equals(other.reservations_)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= reservations_.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      reservations_.WriteTo(output, _repeated_reservations_codec);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += reservations_.CalculateSize(_repeated_reservations_codec);
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(GetReservationSummariesRequest other) {
      if (other == null) {
        return;
      }
      reservations_.Add(other.reservations_);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            reservations_.AddEntriesFrom(input, _repeated_reservations_codec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchSvcGetAssociatedHoldsResponse : pb::IMessage<ReservationSearchSvcGetAssociatedHoldsResponse> {
    private static readonly pb::MessageParser<ReservationSearchSvcGetAssociatedHoldsResponse> _parser = new pb::MessageParser<ReservationSearchSvcGetAssociatedHoldsResponse>(() => new ReservationSearchSvcGetAssociatedHoldsResponse());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchSvcGetAssociatedHoldsResponse> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[7]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetAssociatedHoldsResponse() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetAssociatedHoldsResponse(ReservationSearchSvcGetAssociatedHoldsResponse other) : this() {
      ReservationWithManagementHold = other.reservationWithManagementHold_ != null ? other.ReservationWithManagementHold.Clone() : null;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchSvcGetAssociatedHoldsResponse Clone() {
      return new ReservationSearchSvcGetAssociatedHoldsResponse(this);
    }

    /// <summary>Field number for the "reservation_with_management_hold" field.</summary>
    public const int ReservationWithManagementHoldFieldNumber = 1;
    private global::HOLMS.Types.Booking.Reservations.ReservationWithManagementHold reservationWithManagementHold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Booking.Reservations.ReservationWithManagementHold ReservationWithManagementHold {
      get { return reservationWithManagementHold_; }
      set {
        reservationWithManagementHold_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchSvcGetAssociatedHoldsResponse);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchSvcGetAssociatedHoldsResponse other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!object.Equals(ReservationWithManagementHold, other.ReservationWithManagementHold)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (reservationWithManagementHold_ != null) hash ^= ReservationWithManagementHold.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (reservationWithManagementHold_ != null) {
        output.WriteRawTag(10);
        output.WriteMessage(ReservationWithManagementHold);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (reservationWithManagementHold_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(ReservationWithManagementHold);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchSvcGetAssociatedHoldsResponse other) {
      if (other == null) {
        return;
      }
      if (other.reservationWithManagementHold_ != null) {
        if (reservationWithManagementHold_ == null) {
          reservationWithManagementHold_ = new global::HOLMS.Types.Booking.Reservations.ReservationWithManagementHold();
        }
        ReservationWithManagementHold.MergeFrom(other.ReservationWithManagementHold);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            if (reservationWithManagementHold_ == null) {
              reservationWithManagementHold_ = new global::HOLMS.Types.Booking.Reservations.ReservationWithManagementHold();
            }
            input.ReadMessage(reservationWithManagementHold_);
            break;
          }
        }
      }
    }

  }

  public sealed partial class ReservationSearchDuringDateRangeRequest : pb::IMessage<ReservationSearchDuringDateRangeRequest> {
    private static readonly pb::MessageParser<ReservationSearchDuringDateRangeRequest> _parser = new pb::MessageParser<ReservationSearchDuringDateRangeRequest>(() => new ReservationSearchDuringDateRangeRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ReservationSearchDuringDateRangeRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[8]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchDuringDateRangeRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchDuringDateRangeRequest(ReservationSearchDuringDateRangeRequest other) : this() {
      StartDate = other.startDate_ != null ? other.StartDate.Clone() : null;
      EndDate = other.endDate_ != null ? other.EndDate.Clone() : null;
      includeCanceled_ = other.includeCanceled_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ReservationSearchDuringDateRangeRequest Clone() {
      return new ReservationSearchDuringDateRangeRequest(this);
    }

    /// <summary>Field number for the "start_date" field.</summary>
    public const int StartDateFieldNumber = 1;
    private global::HOLMS.Types.Primitive.PbLocalDate startDate_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Primitive.PbLocalDate StartDate {
      get { return startDate_; }
      set {
        startDate_ = value;
      }
    }

    /// <summary>Field number for the "end_date" field.</summary>
    public const int EndDateFieldNumber = 2;
    private global::HOLMS.Types.Primitive.PbLocalDate endDate_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::HOLMS.Types.Primitive.PbLocalDate EndDate {
      get { return endDate_; }
      set {
        endDate_ = value;
      }
    }

    /// <summary>Field number for the "include_canceled" field.</summary>
    public const int IncludeCanceledFieldNumber = 3;
    private bool includeCanceled_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool IncludeCanceled {
      get { return includeCanceled_; }
      set {
        includeCanceled_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ReservationSearchDuringDateRangeRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ReservationSearchDuringDateRangeRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!object.Equals(StartDate, other.StartDate)) return false;
      if (!object.Equals(EndDate, other.EndDate)) return false;
      if (IncludeCanceled != other.IncludeCanceled) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (startDate_ != null) hash ^= StartDate.GetHashCode();
      if (endDate_ != null) hash ^= EndDate.GetHashCode();
      if (IncludeCanceled != false) hash ^= IncludeCanceled.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (startDate_ != null) {
        output.WriteRawTag(10);
        output.WriteMessage(StartDate);
      }
      if (endDate_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(EndDate);
      }
      if (IncludeCanceled != false) {
        output.WriteRawTag(24);
        output.WriteBool(IncludeCanceled);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (startDate_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartDate);
      }
      if (endDate_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(EndDate);
      }
      if (IncludeCanceled != false) {
        size += 1 + 1;
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ReservationSearchDuringDateRangeRequest other) {
      if (other == null) {
        return;
      }
      if (other.startDate_ != null) {
        if (startDate_ == null) {
          startDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
        }
        StartDate.MergeFrom(other.StartDate);
      }
      if (other.endDate_ != null) {
        if (endDate_ == null) {
          endDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
        }
        EndDate.MergeFrom(other.EndDate);
      }
      if (other.IncludeCanceled != false) {
        IncludeCanceled = other.IncludeCanceled;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            if (startDate_ == null) {
              startDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
            }
            input.ReadMessage(startDate_);
            break;
          }
          case 18: {
            if (endDate_ == null) {
              endDate_ = new global::HOLMS.Types.Primitive.PbLocalDate();
            }
            input.ReadMessage(endDate_);
            break;
          }
          case 24: {
            IncludeCanceled = input.ReadBool();
            break;
          }
        }
      }
    }

  }

  public sealed partial class SyncSpecificReservationsRequest : pb::IMessage<SyncSpecificReservationsRequest> {
    private static readonly pb::MessageParser<SyncSpecificReservationsRequest> _parser = new pb::MessageParser<SyncSpecificReservationsRequest>(() => new SyncSpecificReservationsRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SyncSpecificReservationsRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::HOLMS.Types.Booking.RPC.ReservationSearchSvcReflection.Descriptor.MessageTypes[9]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SyncSpecificReservationsRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SyncSpecificReservationsRequest(SyncSpecificReservationsRequest other) : this() {
      reservations_ = other.reservations_.Clone();
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SyncSpecificReservationsRequest Clone() {
      return new SyncSpecificReservationsRequest(this);
    }

    /// <summary>Field number for the "reservations" field.</summary>
    public const int ReservationsFieldNumber = 1;
    private static readonly pb::FieldCodec<global::HOLMS.Types.Booking.Indicators.ReservationIndicator> _repeated_reservations_codec
        = pb::FieldCodec.ForMessage(10, global::HOLMS.Types.Booking.Indicators.ReservationIndicator.Parser);
    private readonly pbc::RepeatedField<global::HOLMS.Types.Booking.Indicators.ReservationIndicator> reservations_ = new pbc::RepeatedField<global::HOLMS.Types.Booking.Indicators.ReservationIndicator>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::HOLMS.Types.Booking.Indicators.ReservationIndicator> Reservations {
      get { return reservations_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SyncSpecificReservationsRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SyncSpecificReservationsRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!reservations_.Equals(other.reservations_)) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= reservations_.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      reservations_.WriteTo(output, _repeated_reservations_codec);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += reservations_.CalculateSize(_repeated_reservations_codec);
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SyncSpecificReservationsRequest other) {
      if (other == null) {
        return;
      }
      reservations_.Add(other.reservations_);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            reservations_.AddEntriesFrom(input, _repeated_reservations_codec);
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code
