From 8c58bae15c531aee2eca291d27e713d0dd92c58c Mon Sep 17 00:00:00 2001 From: Owl Bot Date: Tue, 3 Dec 2024 22:35:49 +0000 Subject: [PATCH] feat: add Network Connectivity Center APIs for PSC connection propagation through NCC feat: add Network Connectivity Center APIs for star topology feat: add Network Connectivity Center APIs for producer VPC spokes feat: add Network Connectivity Center APIs for dynamic route exchange feat: add Network Connectivity Center APIs for include export filters feat: add Network Connectivity Center APIs for include import ranges on hybrid spokes docs: update comment for `ListRoutes` method in service `HubService` to clarify that it lists routes in a route table docs: update comment for `ListRouteTables` method in service `HubService` to clarify that it lists route tables in a hub docs: update comment for field `location` in message `.google.cloud.networkconnectivity.v1.Route` to clarify that it's the origin location PiperOrigin-RevId: 702422268 Source-Link: https://github.com/googleapis/googleapis/commit/59254b411ac63bbb9bcd4a54cec10540ceaa5154 Source-Link: https://github.com/googleapis/googleapis-gen/commit/f199480d334002ada53c387fdb1175de3c550f7b Copy-Tag: eyJwIjoiYXBpcy9Hb29nbGUuQ2xvdWQuTmV0d29ya0Nvbm5lY3Rpdml0eS5WMS8uT3dsQm90LnlhbWwiLCJoIjoiZjE5OTQ4MGQzMzQwMDJhZGE1M2MzODdmZGIxMTc1ZGUzYzU1MGY3YiJ9 --- ...viceClient.QueryHubStatusAsyncSnippet.g.cs | 79 + ...eryHubStatusRequestObjectAsyncSnippet.g.cs | 85 + ...nt.QueryHubStatusRequestObjectSnippet.g.cs | 83 + ...eryHubStatusResourceNamesAsyncSnippet.g.cs | 79 + ...nt.QueryHubStatusResourceNamesSnippet.g.cs | 77 + ...ubServiceClient.QueryHubStatusSnippet.g.cs | 77 + ...ServiceClient.UpdateGroupAsyncSnippet.g.cs | 63 + ....UpdateGroupRequestObjectAsyncSnippet.g.cs | 67 + ...lient.UpdateGroupRequestObjectSnippet.g.cs | 66 + .../HubServiceClient.UpdateGroupSnippet.g.cs | 62 + ...a_google.cloud.networkconnectivity.v1.json | 519 + .../HubServiceClientSnippets.g.cs | 412 + .../Hub.g.cs | 8483 ++++++++++++----- .../HubGrpc.g.cs | 173 +- .../HubResourceNames.g.cs | 109 + .../HubServiceClient.g.cs | 444 +- .../gapic_metadata.json | 12 + 17 files changed, 8577 insertions(+), 2313 deletions(-) create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectSnippet.g.cs create mode 100644 apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupSnippet.g.cs diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusAsyncSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusAsyncSnippet.g.cs new file mode 100644 index 000000000000..b1ac9e4c824d --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusAsyncSnippet.g.cs @@ -0,0 +1,79 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_QueryHubStatus_async_flattened] + using Google.Api.Gax; + using Google.Cloud.NetworkConnectivity.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for QueryHubStatusAsync + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public async Task QueryHubStatusAsync() + { + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/global/hubs/[HUB]"; + // Make the request + PagedAsyncEnumerable response = hubServiceClient.QueryHubStatusAsync(name); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((HubStatusEntry item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((QueryHubStatusResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END networkconnectivity_v1_generated_HubService_QueryHubStatus_async_flattened] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectAsyncSnippet.g.cs new file mode 100644 index 000000000000..c9db64636a90 --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectAsyncSnippet.g.cs @@ -0,0 +1,85 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_QueryHubStatus_async] + using Google.Api.Gax; + using Google.Cloud.NetworkConnectivity.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for QueryHubStatusAsync + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public async Task QueryHubStatusRequestObjectAsync() + { + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + QueryHubStatusRequest request = new QueryHubStatusRequest + { + HubName = HubName.FromProjectHub("[PROJECT]", "[HUB]"), + Filter = "", + OrderBy = "", + GroupBy = "", + }; + // Make the request + PagedAsyncEnumerable response = hubServiceClient.QueryHubStatusAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((HubStatusEntry item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((QueryHubStatusResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END networkconnectivity_v1_generated_HubService_QueryHubStatus_async] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectSnippet.g.cs new file mode 100644 index 000000000000..83ef559e0c1a --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusRequestObjectSnippet.g.cs @@ -0,0 +1,83 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_QueryHubStatus_sync] + using Google.Api.Gax; + using Google.Cloud.NetworkConnectivity.V1; + using System; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for QueryHubStatus + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public void QueryHubStatusRequestObject() + { + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + QueryHubStatusRequest request = new QueryHubStatusRequest + { + HubName = HubName.FromProjectHub("[PROJECT]", "[HUB]"), + Filter = "", + OrderBy = "", + GroupBy = "", + }; + // Make the request + PagedEnumerable response = hubServiceClient.QueryHubStatus(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (HubStatusEntry item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (QueryHubStatusResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END networkconnectivity_v1_generated_HubService_QueryHubStatus_sync] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesAsyncSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesAsyncSnippet.g.cs new file mode 100644 index 000000000000..f1fa3f229acb --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesAsyncSnippet.g.cs @@ -0,0 +1,79 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_QueryHubStatus_async_flattened_resourceNames] + using Google.Api.Gax; + using Google.Cloud.NetworkConnectivity.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for QueryHubStatusAsync + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public async Task QueryHubStatusResourceNamesAsync() + { + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + HubName name = HubName.FromProjectHub("[PROJECT]", "[HUB]"); + // Make the request + PagedAsyncEnumerable response = hubServiceClient.QueryHubStatusAsync(name); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((HubStatusEntry item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((QueryHubStatusResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END networkconnectivity_v1_generated_HubService_QueryHubStatus_async_flattened_resourceNames] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesSnippet.g.cs new file mode 100644 index 000000000000..ecb5acbf1a2d --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusResourceNamesSnippet.g.cs @@ -0,0 +1,77 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_QueryHubStatus_sync_flattened_resourceNames] + using Google.Api.Gax; + using Google.Cloud.NetworkConnectivity.V1; + using System; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for QueryHubStatus + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public void QueryHubStatusResourceNames() + { + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + HubName name = HubName.FromProjectHub("[PROJECT]", "[HUB]"); + // Make the request + PagedEnumerable response = hubServiceClient.QueryHubStatus(name); + + // Iterate over all response items, lazily performing RPCs as required + foreach (HubStatusEntry item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (QueryHubStatusResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END networkconnectivity_v1_generated_HubService_QueryHubStatus_sync_flattened_resourceNames] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusSnippet.g.cs new file mode 100644 index 000000000000..2052507825d6 --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.QueryHubStatusSnippet.g.cs @@ -0,0 +1,77 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_QueryHubStatus_sync_flattened] + using Google.Api.Gax; + using Google.Cloud.NetworkConnectivity.V1; + using System; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for QueryHubStatus + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public void QueryHubStatus() + { + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/global/hubs/[HUB]"; + // Make the request + PagedEnumerable response = hubServiceClient.QueryHubStatus(name); + + // Iterate over all response items, lazily performing RPCs as required + foreach (HubStatusEntry item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (QueryHubStatusResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END networkconnectivity_v1_generated_HubService_QueryHubStatus_sync_flattened] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupAsyncSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupAsyncSnippet.g.cs new file mode 100644 index 000000000000..b8fc7b964937 --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupAsyncSnippet.g.cs @@ -0,0 +1,63 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_UpdateGroup_async_flattened] + using Google.Cloud.NetworkConnectivity.V1; + using Google.LongRunning; + using Google.Protobuf.WellKnownTypes; + using System.Threading.Tasks; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for UpdateGroupAsync + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public async Task UpdateGroupAsync() + { + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + Group group = new Group(); + FieldMask updateMask = new FieldMask(); + // Make the request + Operation response = await hubServiceClient.UpdateGroupAsync(group, updateMask); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await hubServiceClient.PollOnceUpdateGroupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + } + } + // [END networkconnectivity_v1_generated_HubService_UpdateGroup_async_flattened] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectAsyncSnippet.g.cs new file mode 100644 index 000000000000..931e4f8df409 --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectAsyncSnippet.g.cs @@ -0,0 +1,67 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_UpdateGroup_async] + using Google.Cloud.NetworkConnectivity.V1; + using Google.LongRunning; + using Google.Protobuf.WellKnownTypes; + using System.Threading.Tasks; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for UpdateGroupAsync + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public async Task UpdateGroupRequestObjectAsync() + { + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + UpdateGroupRequest request = new UpdateGroupRequest + { + UpdateMask = new FieldMask(), + Group = new Group(), + RequestId = "", + }; + // Make the request + Operation response = await hubServiceClient.UpdateGroupAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await hubServiceClient.PollOnceUpdateGroupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + } + } + // [END networkconnectivity_v1_generated_HubService_UpdateGroup_async] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectSnippet.g.cs new file mode 100644 index 000000000000..e64b81feb3a8 --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupRequestObjectSnippet.g.cs @@ -0,0 +1,66 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_UpdateGroup_sync] + using Google.Cloud.NetworkConnectivity.V1; + using Google.LongRunning; + using Google.Protobuf.WellKnownTypes; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for UpdateGroup + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public void UpdateGroupRequestObject() + { + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + UpdateGroupRequest request = new UpdateGroupRequest + { + UpdateMask = new FieldMask(), + Group = new Group(), + RequestId = "", + }; + // Make the request + Operation response = hubServiceClient.UpdateGroup(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = hubServiceClient.PollOnceUpdateGroup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + } + } + // [END networkconnectivity_v1_generated_HubService_UpdateGroup_sync] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupSnippet.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupSnippet.g.cs new file mode 100644 index 000000000000..6491ba6112f8 --- /dev/null +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/HubServiceClient.UpdateGroupSnippet.g.cs @@ -0,0 +1,62 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START networkconnectivity_v1_generated_HubService_UpdateGroup_sync_flattened] + using Google.Cloud.NetworkConnectivity.V1; + using Google.LongRunning; + using Google.Protobuf.WellKnownTypes; + + public sealed partial class GeneratedHubServiceClientSnippets + { + /// Snippet for UpdateGroup + /// + /// This snippet has been automatically generated and should be regarded as a code template only. + /// It will require modifications to work: + /// - It may require correct/in-range values for request initialization. + /// - It may require specifying regional endpoints when creating the service client as shown in + /// https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint. + /// + public void UpdateGroup() + { + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + Group group = new Group(); + FieldMask updateMask = new FieldMask(); + // Make the request + Operation response = hubServiceClient.UpdateGroup(group, updateMask); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = hubServiceClient.PollOnceUpdateGroup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + } + } + // [END networkconnectivity_v1_generated_HubService_UpdateGroup_sync_flattened] +} diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/snippet_metadata_google.cloud.networkconnectivity.v1.json b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/snippet_metadata_google.cloud.networkconnectivity.v1.json index db4fdd605648..51ec2c3394ef 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/snippet_metadata_google.cloud.networkconnectivity.v1.json +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.GeneratedSnippets/snippet_metadata_google.cloud.networkconnectivity.v1.json @@ -1741,6 +1741,325 @@ } ] }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_QueryHubStatus_sync", + "title": "QueryHubStatusRequestObject", + "description": "Snippet for QueryHubStatus", + "file": "HubServiceClient.QueryHubStatusRequestObjectSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "QueryHubStatus", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.QueryHubStatus", + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedEnumerable", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "QueryHubStatus", + "fullName": "google.cloud.networkconnectivity.v1.HubService.QueryHubStatus", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 81, + "type": "FULL" + }, + { + "start": 36, + "end": 79, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_QueryHubStatus_async", + "title": "QueryHubStatusRequestObjectAsync", + "description": "Snippet for QueryHubStatusAsync", + "file": "HubServiceClient.QueryHubStatusRequestObjectAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "QueryHubStatusAsync", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.QueryHubStatusAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedAsyncEnumerable", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "QueryHubStatus", + "fullName": "google.cloud.networkconnectivity.v1.HubService.QueryHubStatus", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 83, + "type": "FULL" + }, + { + "start": 38, + "end": 81, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_QueryHubStatus_sync_flattened", + "title": "QueryHubStatus", + "description": "Snippet for QueryHubStatus", + "file": "HubServiceClient.QueryHubStatusSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "QueryHubStatus", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.QueryHubStatus", + "parameters": [ + { + "type": "System.String", + "name": "name" + }, + { + "type": "System.String", + "name": "pageToken" + }, + { + "type": "System.Nullable[System.Int32]", + "name": "pageSize" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedEnumerable", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "QueryHubStatus", + "fullName": "google.cloud.networkconnectivity.v1.HubService.QueryHubStatus", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 75, + "type": "FULL" + }, + { + "start": 36, + "end": 73, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_QueryHubStatus_async_flattened", + "title": "QueryHubStatusAsync", + "description": "Snippet for QueryHubStatusAsync", + "file": "HubServiceClient.QueryHubStatusAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "QueryHubStatusAsync", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.QueryHubStatusAsync", + "async": true, + "parameters": [ + { + "type": "System.String", + "name": "name" + }, + { + "type": "System.String", + "name": "pageToken" + }, + { + "type": "System.Nullable[System.Int32]", + "name": "pageSize" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedAsyncEnumerable", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "QueryHubStatus", + "fullName": "google.cloud.networkconnectivity.v1.HubService.QueryHubStatus", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 77, + "type": "FULL" + }, + { + "start": 38, + "end": 75, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_QueryHubStatus_sync_flattened_resourceNames", + "title": "QueryHubStatusResourceNames", + "description": "Snippet for QueryHubStatus", + "file": "HubServiceClient.QueryHubStatusResourceNamesSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "QueryHubStatus", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.QueryHubStatus", + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.HubName", + "name": "name" + }, + { + "type": "System.String", + "name": "pageToken" + }, + { + "type": "System.Nullable[System.Int32]", + "name": "pageSize" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedEnumerable", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "QueryHubStatus", + "fullName": "google.cloud.networkconnectivity.v1.HubService.QueryHubStatus", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 75, + "type": "FULL" + }, + { + "start": 36, + "end": 73, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_QueryHubStatus_async_flattened_resourceNames", + "title": "QueryHubStatusResourceNamesAsync", + "description": "Snippet for QueryHubStatusAsync", + "file": "HubServiceClient.QueryHubStatusResourceNamesAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "QueryHubStatusAsync", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.QueryHubStatusAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.HubName", + "name": "name" + }, + { + "type": "System.String", + "name": "pageToken" + }, + { + "type": "System.Nullable[System.Int32]", + "name": "pageSize" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedAsyncEnumerable", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "QueryHubStatus", + "fullName": "google.cloud.networkconnectivity.v1.HubService.QueryHubStatus", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 77, + "type": "FULL" + }, + { + "start": 38, + "end": 75, + "type": "SHORT" + } + ] + }, { "regionTag": "networkconnectivity_v1_generated_HubService_ListSpokes_sync", "title": "ListSpokesRequestObject", @@ -5577,6 +5896,206 @@ } ] }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_UpdateGroup_sync", + "title": "UpdateGroupRequestObject", + "description": "Snippet for UpdateGroup", + "file": "HubServiceClient.UpdateGroupRequestObjectSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "UpdateGroup", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.UpdateGroup", + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.LongRunning.Operation", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "UpdateGroup", + "fullName": "google.cloud.networkconnectivity.v1.HubService.UpdateGroup", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 64, + "type": "FULL" + }, + { + "start": 36, + "end": 62, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_UpdateGroup_async", + "title": "UpdateGroupRequestObjectAsync", + "description": "Snippet for UpdateGroupAsync", + "file": "HubServiceClient.UpdateGroupRequestObjectAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "UpdateGroupAsync", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.UpdateGroupAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "System.Threading.Tasks.Task>", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "UpdateGroup", + "fullName": "google.cloud.networkconnectivity.v1.HubService.UpdateGroup", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 65, + "type": "FULL" + }, + { + "start": 37, + "end": 63, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_UpdateGroup_sync_flattened", + "title": "UpdateGroup", + "description": "Snippet for UpdateGroup", + "file": "HubServiceClient.UpdateGroupSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "UpdateGroup", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.UpdateGroup", + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.Group", + "name": "group" + }, + { + "type": "Google.Protobuf.WellKnownTypes.FieldMask", + "name": "updateMask" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.LongRunning.Operation", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "UpdateGroup", + "fullName": "google.cloud.networkconnectivity.v1.HubService.UpdateGroup", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 60, + "type": "FULL" + }, + { + "start": 36, + "end": 58, + "type": "SHORT" + } + ] + }, + { + "regionTag": "networkconnectivity_v1_generated_HubService_UpdateGroup_async_flattened", + "title": "UpdateGroupAsync", + "description": "Snippet for UpdateGroupAsync", + "file": "HubServiceClient.UpdateGroupAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "UpdateGroupAsync", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient.UpdateGroupAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.NetworkConnectivity.V1.Group", + "name": "group" + }, + { + "type": "Google.Protobuf.WellKnownTypes.FieldMask", + "name": "updateMask" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "System.Threading.Tasks.Task>", + "client": { + "shortName": "HubServiceClient", + "fullName": "Google.Cloud.NetworkConnectivity.V1.HubServiceClient" + }, + "method": { + "shortName": "UpdateGroup", + "fullName": "google.cloud.networkconnectivity.v1.HubService.UpdateGroup", + "service": { + "shortName": "HubService", + "fullName": "google.cloud.networkconnectivity.v1.HubService" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 61, + "type": "FULL" + }, + { + "start": 37, + "end": 59, + "type": "SHORT" + } + ] + }, { "regionTag": "networkconnectivity_v1_generated_PolicyBasedRoutingService_ListPolicyBasedRoutes_sync", "title": "ListPolicyBasedRoutesRequestObject", diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.Snippets/HubServiceClientSnippets.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.Snippets/HubServiceClientSnippets.g.cs index f155fcf242eb..2593c6604bd5 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.Snippets/HubServiceClientSnippets.g.cs +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1.Snippets/HubServiceClientSnippets.g.cs @@ -1191,6 +1191,288 @@ await response.AsRawResponses().ForEachAsync((ListHubSpokesResponse page) => // End snippet } + /// Snippet for QueryHubStatus + public void QueryHubStatusRequestObject() + { + // Snippet: QueryHubStatus(QueryHubStatusRequest, CallSettings) + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + QueryHubStatusRequest request = new QueryHubStatusRequest + { + HubName = HubName.FromProjectHub("[PROJECT]", "[HUB]"), + Filter = "", + OrderBy = "", + GroupBy = "", + }; + // Make the request + PagedEnumerable response = hubServiceClient.QueryHubStatus(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (HubStatusEntry item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (QueryHubStatusResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for QueryHubStatusAsync + public async Task QueryHubStatusRequestObjectAsync() + { + // Snippet: QueryHubStatusAsync(QueryHubStatusRequest, CallSettings) + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + QueryHubStatusRequest request = new QueryHubStatusRequest + { + HubName = HubName.FromProjectHub("[PROJECT]", "[HUB]"), + Filter = "", + OrderBy = "", + GroupBy = "", + }; + // Make the request + PagedAsyncEnumerable response = hubServiceClient.QueryHubStatusAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((HubStatusEntry item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((QueryHubStatusResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for QueryHubStatus + public void QueryHubStatus() + { + // Snippet: QueryHubStatus(string, string, int?, CallSettings) + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/global/hubs/[HUB]"; + // Make the request + PagedEnumerable response = hubServiceClient.QueryHubStatus(name); + + // Iterate over all response items, lazily performing RPCs as required + foreach (HubStatusEntry item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (QueryHubStatusResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for QueryHubStatusAsync + public async Task QueryHubStatusAsync() + { + // Snippet: QueryHubStatusAsync(string, string, int?, CallSettings) + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + string name = "projects/[PROJECT]/locations/global/hubs/[HUB]"; + // Make the request + PagedAsyncEnumerable response = hubServiceClient.QueryHubStatusAsync(name); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((HubStatusEntry item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((QueryHubStatusResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for QueryHubStatus + public void QueryHubStatusResourceNames() + { + // Snippet: QueryHubStatus(HubName, string, int?, CallSettings) + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + HubName name = HubName.FromProjectHub("[PROJECT]", "[HUB]"); + // Make the request + PagedEnumerable response = hubServiceClient.QueryHubStatus(name); + + // Iterate over all response items, lazily performing RPCs as required + foreach (HubStatusEntry item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (QueryHubStatusResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for QueryHubStatusAsync + public async Task QueryHubStatusResourceNamesAsync() + { + // Snippet: QueryHubStatusAsync(HubName, string, int?, CallSettings) + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + HubName name = HubName.FromProjectHub("[PROJECT]", "[HUB]"); + // Make the request + PagedAsyncEnumerable response = hubServiceClient.QueryHubStatusAsync(name); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((HubStatusEntry item) => + { + // Do something with each item + Console.WriteLine(item); + }); + + // Or iterate over pages (of server-defined size), performing one RPC per page + await response.AsRawResponses().ForEachAsync((QueryHubStatusResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (HubStatusEntry item in page) + { + // Do something with each item + Console.WriteLine(item); + } + }); + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (HubStatusEntry item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + /// Snippet for ListSpokes public void ListSpokesRequestObject() { @@ -3554,5 +3836,135 @@ await response.AsRawResponses().ForEachAsync((ListGroupsResponse page) => string nextPageToken = singlePage.NextPageToken; // End snippet } + + /// Snippet for UpdateGroup + public void UpdateGroupRequestObject() + { + // Snippet: UpdateGroup(UpdateGroupRequest, CallSettings) + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + UpdateGroupRequest request = new UpdateGroupRequest + { + UpdateMask = new FieldMask(), + Group = new Group(), + RequestId = "", + }; + // Make the request + Operation response = hubServiceClient.UpdateGroup(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = hubServiceClient.PollOnceUpdateGroup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for UpdateGroupAsync + public async Task UpdateGroupRequestObjectAsync() + { + // Snippet: UpdateGroupAsync(UpdateGroupRequest, CallSettings) + // Additional: UpdateGroupAsync(UpdateGroupRequest, CancellationToken) + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + UpdateGroupRequest request = new UpdateGroupRequest + { + UpdateMask = new FieldMask(), + Group = new Group(), + RequestId = "", + }; + // Make the request + Operation response = await hubServiceClient.UpdateGroupAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await hubServiceClient.PollOnceUpdateGroupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for UpdateGroup + public void UpdateGroup() + { + // Snippet: UpdateGroup(Group, FieldMask, CallSettings) + // Create client + HubServiceClient hubServiceClient = HubServiceClient.Create(); + // Initialize request argument(s) + Group group = new Group(); + FieldMask updateMask = new FieldMask(); + // Make the request + Operation response = hubServiceClient.UpdateGroup(group, updateMask); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = hubServiceClient.PollOnceUpdateGroup(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for UpdateGroupAsync + public async Task UpdateGroupAsync() + { + // Snippet: UpdateGroupAsync(Group, FieldMask, CallSettings) + // Additional: UpdateGroupAsync(Group, FieldMask, CancellationToken) + // Create client + HubServiceClient hubServiceClient = await HubServiceClient.CreateAsync(); + // Initialize request argument(s) + Group group = new Group(); + FieldMask updateMask = new FieldMask(); + // Make the request + Operation response = await hubServiceClient.UpdateGroupAsync(group, updateMask); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + Group result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await hubServiceClient.PollOnceUpdateGroupAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + Group retrievedResult = retrievedResponse.Result; + } + // End snippet + } } } diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/Hub.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/Hub.g.cs index e18eb6cfea93..b8e0288df8d0 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/Hub.g.cs +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/Hub.g.cs @@ -27,339 +27,421 @@ static HubReflection() { "Ci1nb29nbGUvY2xvdWQvbmV0d29ya2Nvbm5lY3Rpdml0eS92MS9odWIucHJv", "dG8SI2dvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxGhxnb29n", "bGUvYXBpL2Fubm90YXRpb25zLnByb3RvGhdnb29nbGUvYXBpL2NsaWVudC5w", - "cm90bxofZ29vZ2xlL2FwaS9maWVsZF9iZWhhdmlvci5wcm90bxoZZ29vZ2xl", - "L2FwaS9yZXNvdXJjZS5wcm90bxowZ29vZ2xlL2Nsb3VkL25ldHdvcmtjb25u", - "ZWN0aXZpdHkvdjEvY29tbW9uLnByb3RvGiNnb29nbGUvbG9uZ3J1bm5pbmcv", - "b3BlcmF0aW9ucy5wcm90bxobZ29vZ2xlL3Byb3RvYnVmL2VtcHR5LnByb3Rv", - "GiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxofZ29vZ2xlL3By", - "b3RvYnVmL3RpbWVzdGFtcC5wcm90byL0BAoDSHViEhEKBG5hbWUYASABKAlC", - "A+BBBRI0CgtjcmVhdGVfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5U", - "aW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgDIAEoCzIaLmdvb2dsZS5w", - "cm90b2J1Zi5UaW1lc3RhbXBCA+BBAxJECgZsYWJlbHMYBCADKAsyNC5nb29n", - "bGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5IdWIuTGFiZWxzRW50", - "cnkSEwoLZGVzY3JpcHRpb24YBSABKAkSFgoJdW5pcXVlX2lkGAggASgJQgPg", - "QQMSPgoFc3RhdGUYCSABKA4yKi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5l", - "Y3Rpdml0eS52MS5TdGF0ZUID4EEDEkUKDHJvdXRpbmdfdnBjcxgKIAMoCzIv", - "Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlJvdXRpbmdW", - "UEMSGQoMcm91dGVfdGFibGVzGAsgAygJQgPgQQMSTQoNc3Bva2Vfc3VtbWFy", - "eRgMIAEoCzIxLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYx", - "LlNwb2tlU3VtbWFyeUID4EEDGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEo", - "CRINCgV2YWx1ZRgCIAEoCToCOAE6W+pBWAombmV0d29ya2Nvbm5lY3Rpdml0", - "eS5nb29nbGVhcGlzLmNvbS9IdWISLnByb2plY3RzL3twcm9qZWN0fS9sb2Nh", - "dGlvbnMvZ2xvYmFsL2h1YnMve2h1Yn0ifwoKUm91dGluZ1ZQQxIwCgN1cmkY", - "ASABKAlCI/pBIAoeY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrEj8K", - "MnJlcXVpcmVkX2Zvcl9uZXdfc2l0ZV90b19zaXRlX2RhdGFfdHJhbnNmZXJf", - "c3Bva2VzGAIgASgIQgPgQQMiyAoKBVNwb2tlEhEKBG5hbWUYASABKAlCA+BB", - "BRI0CgtjcmVhdGVfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1l", - "c3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90", - "b2J1Zi5UaW1lc3RhbXBCA+BBAxJGCgZsYWJlbHMYBCADKAsyNi5nb29nbGUu", - "Y2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TcG9rZS5MYWJlbHNFbnRy", - "eRITCgtkZXNjcmlwdGlvbhgFIAEoCRI7CgNodWIYBiABKAlCLuBBBfpBKAom", - "bmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9IdWISPwoFZ3Jv", - "dXAYFyABKAlCMOBBAfpBKgoobmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVh", - "cGlzLmNvbS9Hcm91cBJRChJsaW5rZWRfdnBuX3R1bm5lbHMYESABKAsyNS5n", - "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaW5rZWRWcG5U", - "dW5uZWxzEmsKH2xpbmtlZF9pbnRlcmNvbm5lY3RfYXR0YWNobWVudHMYEiAB", - "KAsyQi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaW5r", - "ZWRJbnRlcmNvbm5lY3RBdHRhY2htZW50cxJuCiFsaW5rZWRfcm91dGVyX2Fw", - "cGxpYW5jZV9pbnN0YW5jZXMYEyABKAsyQy5nb29nbGUuY2xvdWQubmV0d29y", - "a2Nvbm5lY3Rpdml0eS52MS5MaW5rZWRSb3V0ZXJBcHBsaWFuY2VJbnN0YW5j", - "ZXMSVgoSbGlua2VkX3ZwY19uZXR3b3JrGBQgASgLMjUuZ29vZ2xlLmNsb3Vk", - "Lm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTGlua2VkVnBjTmV0d29ya0ID4EEB", - "EhYKCXVuaXF1ZV9pZBgLIAEoCUID4EEDEj4KBXN0YXRlGA8gASgOMiouZ29v", - "Z2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3RhdGVCA+BBAxJM", - "CgdyZWFzb25zGBUgAygLMjYuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0", - "aXZpdHkudjEuU3Bva2UuU3RhdGVSZWFzb25CA+BBAxJHCgpzcG9rZV90eXBl", - "GBYgASgOMi4uZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEu", - "U3Bva2VUeXBlQgPgQQMa1wEKC1N0YXRlUmVhc29uEkkKBGNvZGUYASABKA4y", - "Oy5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TcG9rZS5T", - "dGF0ZVJlYXNvbi5Db2RlEg8KB21lc3NhZ2UYAiABKAkSFAoMdXNlcl9kZXRh", - "aWxzGAMgASgJIlYKBENvZGUSFAoQQ09ERV9VTlNQRUNJRklFRBAAEhIKDlBF", - "TkRJTkdfUkVWSUVXEAESDAoIUkVKRUNURUQQAhIKCgZQQVVTRUQQAxIKCgZG", - "QUlMRUQQBBotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUY", - "AiABKAk6AjgBOmXqQWIKKG5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBp", - "cy5jb20vU3Bva2USNnByb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xv", - "Y2F0aW9ufS9zcG9rZXMve3Nwb2tlfSLsAwoKUm91dGVUYWJsZRIRCgRuYW1l", - "GAEgASgJQgPgQQUSNAoLY3JlYXRlX3RpbWUYAiABKAsyGi5nb29nbGUucHJv", - "dG9idWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYAyABKAsyGi5n", - "b29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSSwoGbGFiZWxzGAQgAygL", - "MjsuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuUm91dGVU", - "YWJsZS5MYWJlbHNFbnRyeRITCgtkZXNjcmlwdGlvbhgFIAEoCRIQCgN1aWQY", - "BiABKAlCA+BBAxI+CgVzdGF0ZRgHIAEoDjIqLmdvb2dsZS5jbG91ZC5uZXR3", - "b3JrY29ubmVjdGl2aXR5LnYxLlN0YXRlQgPgQQMaLQoLTGFiZWxzRW50cnkS", - "CwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ATp86kF5Ci1uZXR3b3Jr", - "Y29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL1JvdXRlVGFibGUSSHByb2pl", - "Y3RzL3twcm9qZWN0fS9sb2NhdGlvbnMvZ2xvYmFsL2h1YnMve2h1Yn0vcm91", - "dGVUYWJsZXMve3JvdXRlX3RhYmxlfSL+BQoFUm91dGUSEQoEbmFtZRgDIAEo", - "CUID4EEFEjQKC2NyZWF0ZV90aW1lGAQgASgLMhouZ29vZ2xlLnByb3RvYnVm", - "LlRpbWVzdGFtcEID4EEDEjQKC3VwZGF0ZV90aW1lGAUgASgLMhouZ29vZ2xl", - "LnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEhUKDWlwX2NpZHJfcmFuZ2UYASAB", - "KAkSQQoEdHlwZRgKIAEoDjIuLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", - "dGl2aXR5LnYxLlJvdXRlVHlwZUID4EEDElkKFG5leHRfaG9wX3ZwY19uZXR3", - "b3JrGAIgASgLMjYuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHku", - "djEuTmV4dEhvcFZwY05ldHdvcmtCA+BBBRJGCgZsYWJlbHMYBiADKAsyNi5n", - "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5Sb3V0ZS5MYWJl", - "bHNFbnRyeRITCgtkZXNjcmlwdGlvbhgHIAEoCRIQCgN1aWQYCCABKAlCA+BB", - "AxI+CgVzdGF0ZRgJIAEoDjIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", - "dGl2aXR5LnYxLlN0YXRlQgPgQQMSPwoFc3Bva2UYCyABKAlCMOBBBfpBKgoo", - "bmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9TcG9rZRIVCghs", - "b2NhdGlvbhgMIAEoCUID4EEDGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEo", - "CRINCgV2YWx1ZRgCIAEoCToCOAE6igHqQYYBCituZXR3b3JrY29ubmVjdGl2", - "aXR5Lmdvb2dsZWFwaXMuY29tL0h1YlJvdXRlEldwcm9qZWN0cy97cHJvamVj", - "dH0vbG9jYXRpb25zL2dsb2JhbC9odWJzL3todWJ9L3JvdXRlVGFibGVzL3ty", - "b3V0ZV90YWJsZX0vcm91dGVzL3tyb3V0ZX0i3AMKBUdyb3VwEhEKBG5hbWUY", - "ASABKAlCA+BBBRI0CgtjcmVhdGVfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90", - "b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgDIAEoCzIaLmdv", - "b2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxJLCgZsYWJlbHMYBCADKAsy", - "Ni5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5Hcm91cC5M", - "YWJlbHNFbnRyeUID4EEBEhgKC2Rlc2NyaXB0aW9uGAUgASgJQgPgQQESEAoD", - "dWlkGAYgASgJQgPgQQMSPgoFc3RhdGUYByABKA4yKi5nb29nbGUuY2xvdWQu", - "bmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TdGF0ZUID4EEDGi0KC0xhYmVsc0Vu", - "dHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAE6bOpBaQoobmV0", - "d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9Hcm91cBI9cHJvamVj", - "dHMve3Byb2plY3R9L2xvY2F0aW9ucy9nbG9iYWwvaHVicy97aHVifS9ncm91", - "cHMve2dyb3VwfSKVAQoPTGlzdEh1YnNSZXF1ZXN0EjkKBnBhcmVudBgBIAEo", - "CUIp4EEC+kEjCiFsb2NhdGlvbnMuZ29vZ2xlYXBpcy5jb20vTG9jYXRpb24S", - "EQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmls", - "dGVyGAQgASgJEhAKCG9yZGVyX2J5GAUgASgJIngKEExpc3RIdWJzUmVzcG9u", - "c2USNgoEaHVicxgBIAMoCzIoLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", - "dGl2aXR5LnYxLkh1YhIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkSEwoLdW5y", - "ZWFjaGFibGUYAyADKAkiTQoNR2V0SHViUmVxdWVzdBI8CgRuYW1lGAEgASgJ", - "Qi7gQQL6QSgKJm5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb20v", - "SHViIrcBChBDcmVhdGVIdWJSZXF1ZXN0EjkKBnBhcmVudBgBIAEoCUIp4EEC", - "+kEjCiFsb2NhdGlvbnMuZ29vZ2xlYXBpcy5jb20vTG9jYXRpb24SEwoGaHVi", - "X2lkGAIgASgJQgPgQQISOgoDaHViGAMgASgLMiguZ29vZ2xlLmNsb3VkLm5l", - "dHdvcmtjb25uZWN0aXZpdHkudjEuSHViQgPgQQISFwoKcmVxdWVzdF9pZBgE", - "IAEoCUID4EEBIp0BChBVcGRhdGVIdWJSZXF1ZXN0EjQKC3VwZGF0ZV9tYXNr", - "GAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFza0ID4EEBEjoKA2h1", - "YhgCIAEoCzIoLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYx", - "Lkh1YkID4EECEhcKCnJlcXVlc3RfaWQYAyABKAlCA+BBASJpChBEZWxldGVI", - "dWJSZXF1ZXN0EjwKBG5hbWUYASABKAlCLuBBAvpBKAombmV0d29ya2Nvbm5l", - "Y3Rpdml0eS5nb29nbGVhcGlzLmNvbS9IdWISFwoKcmVxdWVzdF9pZBgCIAEo", - "CUID4EEBIssCChRMaXN0SHViU3Bva2VzUmVxdWVzdBI8CgRuYW1lGAEgASgJ", - "Qi7gQQL6QSgKJm5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb20v", - "SHViEhcKD3Nwb2tlX2xvY2F0aW9ucxgCIAMoCRIRCglwYWdlX3NpemUYAyAB", - "KAUSEgoKcGFnZV90b2tlbhgEIAEoCRIOCgZmaWx0ZXIYBSABKAkSEAoIb3Jk", - "ZXJfYnkYBiABKAkSUQoEdmlldxgHIAEoDjJDLmdvb2dsZS5jbG91ZC5uZXR3", - "b3JrY29ubmVjdGl2aXR5LnYxLkxpc3RIdWJTcG9rZXNSZXF1ZXN0LlNwb2tl", - "VmlldyJACglTcG9rZVZpZXcSGgoWU1BPS0VfVklFV19VTlNQRUNJRklFRBAA", - "EgkKBUJBU0lDEAESDAoIREVUQUlMRUQQAiKBAQoVTGlzdEh1YlNwb2tlc1Jl", - "c3BvbnNlEjoKBnNwb2tlcxgBIAMoCzIqLmdvb2dsZS5jbG91ZC5uZXR3b3Jr", - "Y29ubmVjdGl2aXR5LnYxLlNwb2tlEhcKD25leHRfcGFnZV90b2tlbhgCIAEo", - "CRITCgt1bnJlYWNoYWJsZRgDIAMoCSKXAQoRTGlzdFNwb2tlc1JlcXVlc3QS", - "OQoGcGFyZW50GAEgASgJQingQQL6QSMKIWxvY2F0aW9ucy5nb29nbGVhcGlz", - "LmNvbS9Mb2NhdGlvbhIRCglwYWdlX3NpemUYAiABKAUSEgoKcGFnZV90b2tl", - "bhgDIAEoCRIOCgZmaWx0ZXIYBCABKAkSEAoIb3JkZXJfYnkYBSABKAkifgoS", - "TGlzdFNwb2tlc1Jlc3BvbnNlEjoKBnNwb2tlcxgBIAMoCzIqLmdvb2dsZS5j", - "bG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlEhcKD25leHRfcGFn", - "ZV90b2tlbhgCIAEoCRITCgt1bnJlYWNoYWJsZRgDIAMoCSJRCg9HZXRTcG9r", - "ZVJlcXVlc3QSPgoEbmFtZRgBIAEoCUIw4EEC+kEqCihuZXR3b3JrY29ubmVj", - "dGl2aXR5Lmdvb2dsZWFwaXMuY29tL1Nwb2tlIr8BChJDcmVhdGVTcG9rZVJl", - "cXVlc3QSOQoGcGFyZW50GAEgASgJQingQQL6QSMKIWxvY2F0aW9ucy5nb29n", - "bGVhcGlzLmNvbS9Mb2NhdGlvbhIVCghzcG9rZV9pZBgCIAEoCUID4EECEj4K", - "BXNwb2tlGAMgASgLMiouZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZp", - "dHkudjEuU3Bva2VCA+BBAhIXCgpyZXF1ZXN0X2lkGAQgASgJQgPgQQEiowEK", - "ElVwZGF0ZVNwb2tlUmVxdWVzdBI0Cgt1cGRhdGVfbWFzaxgBIAEoCzIaLmdv", - "b2dsZS5wcm90b2J1Zi5GaWVsZE1hc2tCA+BBARI+CgVzcG9rZRgCIAEoCzIq", - "Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlQgPg", - "QQISFwoKcmVxdWVzdF9pZBgDIAEoCUID4EEBIm0KEkRlbGV0ZVNwb2tlUmVx", - "dWVzdBI+CgRuYW1lGAEgASgJQjDgQQL6QSoKKG5ldHdvcmtjb25uZWN0aXZp", - "dHkuZ29vZ2xlYXBpcy5jb20vU3Bva2USFwoKcmVxdWVzdF9pZBgCIAEoCUID", - "4EEBIrMBChVBY2NlcHRIdWJTcG9rZVJlcXVlc3QSPAoEbmFtZRgBIAEoCUIu", - "4EEC+kEoCiZuZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL0h1", - "YhJDCglzcG9rZV91cmkYAiABKAlCMOBBAvpBKgoobmV0d29ya2Nvbm5lY3Rp", - "dml0eS5nb29nbGVhcGlzLmNvbS9TcG9rZRIXCgpyZXF1ZXN0X2lkGAMgASgJ", - "QgPgQQEiUwoWQWNjZXB0SHViU3Bva2VSZXNwb25zZRI5CgVzcG9rZRgBIAEo", - "CzIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tl", - "IskBChVSZWplY3RIdWJTcG9rZVJlcXVlc3QSPAoEbmFtZRgBIAEoCUIu4EEC", - "+kEoCiZuZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL0h1YhJD", - "CglzcG9rZV91cmkYAiABKAlCMOBBAvpBKgoobmV0d29ya2Nvbm5lY3Rpdml0", - "eS5nb29nbGVhcGlzLmNvbS9TcG9rZRIXCgpyZXF1ZXN0X2lkGAMgASgJQgPg", - "QQESFAoHZGV0YWlscxgEIAEoCUID4EEBIlMKFlJlamVjdEh1YlNwb2tlUmVz", - "cG9uc2USOQoFc3Bva2UYASABKAsyKi5nb29nbGUuY2xvdWQubmV0d29ya2Nv", - "bm5lY3Rpdml0eS52MS5TcG9rZSJbChRHZXRSb3V0ZVRhYmxlUmVxdWVzdBJD", - "CgRuYW1lGAEgASgJQjXgQQL6QS8KLW5ldHdvcmtjb25uZWN0aXZpdHkuZ29v", - "Z2xlYXBpcy5jb20vUm91dGVUYWJsZSJUCg9HZXRSb3V0ZVJlcXVlc3QSQQoE", - "bmFtZRgBIAEoCUIz4EEC+kEtCituZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2ds", - "ZWFwaXMuY29tL0h1YlJvdXRlIqMBChFMaXN0Um91dGVzUmVxdWVzdBJFCgZw", - "YXJlbnQYASABKAlCNeBBAvpBLwotbmV0d29ya2Nvbm5lY3Rpdml0eS5nb29n", - "bGVhcGlzLmNvbS9Sb3V0ZVRhYmxlEhEKCXBhZ2Vfc2l6ZRgCIAEoBRISCgpw", - "YWdlX3Rva2VuGAMgASgJEg4KBmZpbHRlchgEIAEoCRIQCghvcmRlcl9ieRgF", - "IAEoCSJ+ChJMaXN0Um91dGVzUmVzcG9uc2USOgoGcm91dGVzGAEgAygLMiou", - "Z29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuUm91dGUSFwoP", - "bmV4dF9wYWdlX3Rva2VuGAIgASgJEhMKC3VucmVhY2hhYmxlGAMgAygJIqEB", - "ChZMaXN0Um91dGVUYWJsZXNSZXF1ZXN0Ej4KBnBhcmVudBgBIAEoCUIu4EEC", - "+kEoCiZuZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL0h1YhIR", - "CglwYWdlX3NpemUYAiABKAUSEgoKcGFnZV90b2tlbhgDIAEoCRIOCgZmaWx0", - "ZXIYBCABKAkSEAoIb3JkZXJfYnkYBSABKAkijgEKF0xpc3RSb3V0ZVRhYmxl", - "c1Jlc3BvbnNlEkUKDHJvdXRlX3RhYmxlcxgBIAMoCzIvLmdvb2dsZS5jbG91", - "ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlJvdXRlVGFibGUSFwoPbmV4dF9w", - "YWdlX3Rva2VuGAIgASgJEhMKC3VucmVhY2hhYmxlGAMgAygJIpwBChFMaXN0", - "R3JvdXBzUmVxdWVzdBI+CgZwYXJlbnQYASABKAlCLuBBAvpBKAombmV0d29y", - "a2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9IdWISEQoJcGFnZV9zaXpl", - "GAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmlsdGVyGAQgASgJEhAK", - "CG9yZGVyX2J5GAUgASgJIn4KEkxpc3RHcm91cHNSZXNwb25zZRI6CgZncm91", - "cHMYASADKAsyKi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52", - "MS5Hcm91cBIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkSEwoLdW5yZWFjaGFi", - "bGUYAyADKAkiqAEKEExpbmtlZFZwblR1bm5lbHMSMwoEdXJpcxgBIAMoCUIl", - "+kEiCiBjb21wdXRlLmdvb2dsZWFwaXMuY29tL1ZwblR1bm5lbBIiChpzaXRl", - "X3RvX3NpdGVfZGF0YV90cmFuc2ZlchgCIAEoCBI7Cgt2cGNfbmV0d29yaxgD", - "IAEoCUIm4EED+kEgCh5jb21wdXRlLmdvb2dsZWFwaXMuY29tL05ldHdvcmsi", - "wgEKHUxpbmtlZEludGVyY29ubmVjdEF0dGFjaG1lbnRzEkAKBHVyaXMYASAD", - "KAlCMvpBLwotY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9JbnRlcmNvbm5lY3RB", - "dHRhY2htZW50EiIKGnNpdGVfdG9fc2l0ZV9kYXRhX3RyYW5zZmVyGAIgASgI", - "EjsKC3ZwY19uZXR3b3JrGAMgASgJQibgQQP6QSAKHmNvbXB1dGUuZ29vZ2xl", - "YXBpcy5jb20vTmV0d29yayLSAQoeTGlua2VkUm91dGVyQXBwbGlhbmNlSW5z", - "dGFuY2VzEk8KCWluc3RhbmNlcxgBIAMoCzI8Lmdvb2dsZS5jbG91ZC5uZXR3", - "b3JrY29ubmVjdGl2aXR5LnYxLlJvdXRlckFwcGxpYW5jZUluc3RhbmNlEiIK", - "GnNpdGVfdG9fc2l0ZV9kYXRhX3RyYW5zZmVyGAIgASgIEjsKC3ZwY19uZXR3", - "b3JrGAMgASgJQibgQQP6QSAKHmNvbXB1dGUuZ29vZ2xlYXBpcy5jb20vTmV0", - "d29yayJrChBMaW5rZWRWcGNOZXR3b3JrEjMKA3VyaRgBIAEoCUIm4EEC+kEg", - "Ch5jb21wdXRlLmdvb2dsZWFwaXMuY29tL05ldHdvcmsSIgoVZXhjbHVkZV9l", - "eHBvcnRfcmFuZ2VzGAIgAygJQgPgQQEibAoXUm91dGVyQXBwbGlhbmNlSW5z", - "dGFuY2USPQoPdmlydHVhbF9tYWNoaW5lGAEgASgJQiT6QSEKH2NvbXB1dGUu", - "Z29vZ2xlYXBpcy5jb20vSW5zdGFuY2USEgoKaXBfYWRkcmVzcxgDIAEoCSJj", - "ChBMb2NhdGlvbk1ldGFkYXRhEk8KEWxvY2F0aW9uX2ZlYXR1cmVzGAEgAygO", - "MjQuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTG9jYXRp", - "b25GZWF0dXJlIkUKEU5leHRIb3BWcGNOZXR3b3JrEjAKA3VyaRgBIAEoCUIj", - "+kEgCh5jb21wdXRlLmdvb2dsZWFwaXMuY29tL05ldHdvcmsipgUKDFNwb2tl", - "U3VtbWFyeRJgChFzcG9rZV90eXBlX2NvdW50cxgBIAMoCzJALmdvb2dsZS5j", - "bG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlU3VtbWFyeS5TcG9r", - "ZVR5cGVDb3VudEID4EEDEmIKEnNwb2tlX3N0YXRlX2NvdW50cxgCIAMoCzJB", - "Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlU3Vt", - "bWFyeS5TcG9rZVN0YXRlQ291bnRCA+BBAxJvChlzcG9rZV9zdGF0ZV9yZWFz", - "b25fY291bnRzGAMgAygLMkcuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0", - "aXZpdHkudjEuU3Bva2VTdW1tYXJ5LlNwb2tlU3RhdGVSZWFzb25Db3VudEID", - "4EEDGm0KDlNwb2tlVHlwZUNvdW50EkcKCnNwb2tlX3R5cGUYASABKA4yLi5n", - "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TcG9rZVR5cGVC", - "A+BBAxISCgVjb3VudBgCIAEoA0ID4EEDGmUKD1Nwb2tlU3RhdGVDb3VudBI+", - "CgVzdGF0ZRgBIAEoDjIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2", - "aXR5LnYxLlN0YXRlQgPgQQMSEgoFY291bnQYAiABKANCA+BBAxqIAQoVU3Bv", - "a2VTdGF0ZVJlYXNvbkNvdW50ElsKEXN0YXRlX3JlYXNvbl9jb2RlGAEgASgO", - "MjsuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3Bva2Uu", - "U3RhdGVSZWFzb24uQ29kZUID4EEDEhIKBWNvdW50GAIgASgDQgPgQQMiUQoP", - "R2V0R3JvdXBSZXF1ZXN0Ej4KBG5hbWUYASABKAlCMOBBAvpBKgoobmV0d29y", - "a2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9Hcm91cCpmCg9Mb2NhdGlv", - "bkZlYXR1cmUSIAocTE9DQVRJT05fRkVBVFVSRV9VTlNQRUNJRklFRBAAEhgK", - "FFNJVEVfVE9fQ0xPVURfU1BPS0VTEAESFwoTU0lURV9UT19TSVRFX1NQT0tF", - "UxACKlkKCVJvdXRlVHlwZRIaChZST1VURV9UWVBFX1VOU1BFQ0lGSUVEEAAS", - "FgoSVlBDX1BSSU1BUllfU1VCTkVUEAESGAoUVlBDX1NFQ09OREFSWV9TVUJO", - "RVQQAiqOAQoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIMCghDUkVB", - "VElORxABEgoKBkFDVElWRRACEgwKCERFTEVUSU5HEAMSDQoJQUNDRVBUSU5H", - "EAgSDQoJUkVKRUNUSU5HEAkSDAoIVVBEQVRJTkcQBhIMCghJTkFDVElWRRAH", - "EgwKCE9CU09MRVRFEAoqewoJU3Bva2VUeXBlEhoKFlNQT0tFX1RZUEVfVU5T", - "UEVDSUZJRUQQABIOCgpWUE5fVFVOTkVMEAESGwoXSU5URVJDT05ORUNUX0FU", - "VEFDSE1FTlQQAhIUChBST1VURVJfQVBQTElBTkNFEAMSDwoLVlBDX05FVFdP", - "UksQBDKYHwoKSHViU2VydmljZRK3AQoITGlzdEh1YnMSNC5nb29nbGUuY2xv", - "dWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaXN0SHVic1JlcXVlc3QaNS5n", - "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaXN0SHVic1Jl", - "c3BvbnNlIj7aQQZwYXJlbnSC0+STAi8SLS92MS97cGFyZW50PXByb2plY3Rz", - "LyovbG9jYXRpb25zL2dsb2JhbH0vaHVicxKkAQoGR2V0SHViEjIuZ29vZ2xl", - "LmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuR2V0SHViUmVxdWVzdBoo", - "Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkh1YiI82kEE", - "bmFtZYLT5JMCLxItL3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zL2ds", - "b2JhbC9odWJzLyp9EswBCglDcmVhdGVIdWISNS5nb29nbGUuY2xvdWQubmV0", - "d29ya2Nvbm5lY3Rpdml0eS52MS5DcmVhdGVIdWJSZXF1ZXN0Gh0uZ29vZ2xl", - "LmxvbmdydW5uaW5nLk9wZXJhdGlvbiJpykEYCgNIdWISEU9wZXJhdGlvbk1l", - "dGFkYXRh2kERcGFyZW50LGh1YixodWJfaWSC0+STAjQiLS92MS97cGFyZW50", - "PXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbH0vaHViczoDaHViEs4BCglV", - "cGRhdGVIdWISNS5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52", - "MS5VcGRhdGVIdWJSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9wZXJh", - "dGlvbiJrykEYCgNIdWISEU9wZXJhdGlvbk1ldGFkYXRh2kEPaHViLHVwZGF0", - "ZV9tYXNrgtPkkwI4MjEvdjEve2h1Yi5uYW1lPXByb2plY3RzLyovbG9jYXRp", - "b25zL2dsb2JhbC9odWJzLyp9OgNodWISzAEKCURlbGV0ZUh1YhI1Lmdvb2ds", - "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkRlbGV0ZUh1YlJlcXVl", - "c3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uImnKQSoKFWdvb2ds", - "ZS5wcm90b2J1Zi5FbXB0eRIRT3BlcmF0aW9uTWV0YWRhdGHaQQRuYW1lgtPk", - "kwIvKi0vdjEve25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvZ2xvYmFsL2h1", - "YnMvKn0SzwEKDUxpc3RIdWJTcG9rZXMSOS5nb29nbGUuY2xvdWQubmV0d29y", - "a2Nvbm5lY3Rpdml0eS52MS5MaXN0SHViU3Bva2VzUmVxdWVzdBo6Lmdvb2ds", - "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkxpc3RIdWJTcG9rZXNS", - "ZXNwb25zZSJH2kEEbmFtZYLT5JMCOhI4L3YxL3tuYW1lPXByb2plY3RzLyov", - "bG9jYXRpb25zL2dsb2JhbC9odWJzLyp9Omxpc3RTcG9rZXMSugEKCkxpc3RT", - "cG9rZXMSNi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5M", - "aXN0U3Bva2VzUmVxdWVzdBo3Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", - "dGl2aXR5LnYxLkxpc3RTcG9rZXNSZXNwb25zZSI72kEGcGFyZW50gtPkkwIs", - "EiovdjEve3BhcmVudD1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qfS9zcG9rZXMS", - "pwEKCEdldFNwb2tlEjQuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZp", - "dHkudjEuR2V0U3Bva2VSZXF1ZXN0GiouZ29vZ2xlLmNsb3VkLm5ldHdvcmtj", - "b25uZWN0aXZpdHkudjEuU3Bva2UiOdpBBG5hbWWC0+STAiwSKi92MS97bmFt", - "ZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL3Nwb2tlcy8qfRLVAQoLQ3JlYXRl", - "U3Bva2USNy5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5D", - "cmVhdGVTcG9rZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0", - "aW9uIm7KQRoKBVNwb2tlEhFPcGVyYXRpb25NZXRhZGF0YdpBFXBhcmVudCxz", - "cG9rZSxzcG9rZV9pZILT5JMCMyIqL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9s", - "b2NhdGlvbnMvKn0vc3Bva2VzOgVzcG9rZRLXAQoLVXBkYXRlU3Bva2USNy5n", - "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5VcGRhdGVTcG9r", - "ZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uInDKQRoK", - "BVNwb2tlEhFPcGVyYXRpb25NZXRhZGF0YdpBEXNwb2tlLHVwZGF0ZV9tYXNr", - "gtPkkwI5MjAvdjEve3Nwb2tlLm5hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMv", - "Ki9zcG9rZXMvKn06BXNwb2tlEvEBCg5SZWplY3RIdWJTcG9rZRI6Lmdvb2ds", - "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlJlamVjdEh1YlNwb2tl", - "UmVxdWVzdBodLmdvb2dsZS5sb25ncnVubmluZy5PcGVyYXRpb24igwHKQSsK", - "FlJlamVjdEh1YlNwb2tlUmVzcG9uc2USEU9wZXJhdGlvbk1ldGFkYXRh2kEO", - "bmFtZSxzcG9rZV91cmmC0+STAj4iOS92MS97bmFtZT1wcm9qZWN0cy8qL2xv", - "Y2F0aW9ucy9nbG9iYWwvaHVicy8qfTpyZWplY3RTcG9rZToBKhLxAQoOQWNj", - "ZXB0SHViU3Bva2USOi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0", - "eS52MS5BY2NlcHRIdWJTcG9rZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5p", - "bmcuT3BlcmF0aW9uIoMBykErChZBY2NlcHRIdWJTcG9rZVJlc3BvbnNlEhFP", - "cGVyYXRpb25NZXRhZGF0YdpBDm5hbWUsc3Bva2VfdXJpgtPkkwI+IjkvdjEv", - "e25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvZ2xvYmFsL2h1YnMvKn06YWNj", - "ZXB0U3Bva2U6ASoSzQEKC0RlbGV0ZVNwb2tlEjcuZ29vZ2xlLmNsb3VkLm5l", - "dHdvcmtjb25uZWN0aXZpdHkudjEuRGVsZXRlU3Bva2VSZXF1ZXN0Gh0uZ29v", - "Z2xlLmxvbmdydW5uaW5nLk9wZXJhdGlvbiJmykEqChVnb29nbGUucHJvdG9i", - "dWYuRW1wdHkSEU9wZXJhdGlvbk1ldGFkYXRh2kEEbmFtZYLT5JMCLCoqL3Yx", - "L3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zLyovc3Bva2VzLyp9EscBCg1H", - "ZXRSb3V0ZVRhYmxlEjkuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZp", - "dHkudjEuR2V0Um91dGVUYWJsZVJlcXVlc3QaLy5nb29nbGUuY2xvdWQubmV0", - "d29ya2Nvbm5lY3Rpdml0eS52MS5Sb3V0ZVRhYmxlIkraQQRuYW1lgtPkkwI9", - "EjsvdjEve25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvZ2xvYmFsL2h1YnMv", - "Ki9yb3V0ZVRhYmxlcy8qfRLBAQoIR2V0Um91dGUSNC5nb29nbGUuY2xvdWQu", - "bmV0d29ya2Nvbm5lY3Rpdml0eS52MS5HZXRSb3V0ZVJlcXVlc3QaKi5nb29n", - "bGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5Sb3V0ZSJT2kEEbmFt", - "ZYLT5JMCRhJEL3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zL2dsb2Jh", - "bC9odWJzLyovcm91dGVUYWJsZXMvKi9yb3V0ZXMvKn0S1AEKCkxpc3RSb3V0", - "ZXMSNi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaXN0", - "Um91dGVzUmVxdWVzdBo3Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2", - "aXR5LnYxLkxpc3RSb3V0ZXNSZXNwb25zZSJV2kEGcGFyZW50gtPkkwJGEkQv", - "djEve3BhcmVudD1wcm9qZWN0cy8qL2xvY2F0aW9ucy9nbG9iYWwvaHVicy8q", - "L3JvdXRlVGFibGVzLyp9L3JvdXRlcxLaAQoPTGlzdFJvdXRlVGFibGVzEjsu", - "Z29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTGlzdFJvdXRl", - "VGFibGVzUmVxdWVzdBo8Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2", - "aXR5LnYxLkxpc3RSb3V0ZVRhYmxlc1Jlc3BvbnNlIkzaQQZwYXJlbnSC0+ST", - "Aj0SOy92MS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbC9o", - "dWJzLyp9L3JvdXRlVGFibGVzErMBCghHZXRHcm91cBI0Lmdvb2dsZS5jbG91", - "ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkdldEdyb3VwUmVxdWVzdBoqLmdv", - "b2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkdyb3VwIkXaQQRu", - "YW1lgtPkkwI4EjYvdjEve25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvZ2xv", - "YmFsL2h1YnMvKi9ncm91cHMvKn0SxgEKCkxpc3RHcm91cHMSNi5nb29nbGUu", - "Y2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaXN0R3JvdXBzUmVxdWVz", - "dBo3Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkxpc3RH", - "cm91cHNSZXNwb25zZSJH2kEGcGFyZW50gtPkkwI4EjYvdjEve3BhcmVudD1w", - "cm9qZWN0cy8qL2xvY2F0aW9ucy9nbG9iYWwvaHVicy8qfS9ncm91cHMaVspB", - "Im5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb23SQS5odHRwczov", - "L3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQsIDCidj", - "b20uZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjFCCEh1YlBy", - "b3RvUAFaWWNsb3VkLmdvb2dsZS5jb20vZ28vbmV0d29ya2Nvbm5lY3Rpdml0", - "eS9hcGl2MS9uZXR3b3JrY29ubmVjdGl2aXR5cGI7bmV0d29ya2Nvbm5lY3Rp", - "dml0eXBiqgIjR29vZ2xlLkNsb3VkLk5ldHdvcmtDb25uZWN0aXZpdHkuVjHK", - "AiNHb29nbGVcQ2xvdWRcTmV0d29ya0Nvbm5lY3Rpdml0eVxWMeoCJkdvb2ds", - "ZTo6Q2xvdWQ6Ok5ldHdvcmtDb25uZWN0aXZpdHk6OlYx6kFgCiBjb21wdXRl", - "Lmdvb2dsZWFwaXMuY29tL1ZwblR1bm5lbBI8cHJvamVjdHMve3Byb2plY3R9", - "L3JlZ2lvbnMve3JlZ2lvbn0vdnBuVHVubmVscy97cmVzb3VyY2VfaWR96kFX", - "Ch9jb21wdXRlLmdvb2dsZWFwaXMuY29tL0luc3RhbmNlEjRwcm9qZWN0cy97", - "cHJvamVjdH0vem9uZXMve3pvbmV9L2luc3RhbmNlcy97aW5zdGFuY2V9YgZw", - "cm90bzM=")); + "cm90bxofZ29vZ2xlL2FwaS9maWVsZF9iZWhhdmlvci5wcm90bxobZ29vZ2xl", + "L2FwaS9maWVsZF9pbmZvLnByb3RvGhlnb29nbGUvYXBpL3Jlc291cmNlLnBy", + "b3RvGjBnb29nbGUvY2xvdWQvbmV0d29ya2Nvbm5lY3Rpdml0eS92MS9jb21t", + "b24ucHJvdG8aI2dvb2dsZS9sb25ncnVubmluZy9vcGVyYXRpb25zLnByb3Rv", + "Ghtnb29nbGUvcHJvdG9idWYvZW1wdHkucHJvdG8aIGdvb2dsZS9wcm90b2J1", + "Zi9maWVsZF9tYXNrLnByb3RvGh9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1w", + "LnByb3RvIr8GCgNIdWISEQoEbmFtZRgBIAEoCUID4EEFEjQKC2NyZWF0ZV90", + "aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEjQK", + "C3VwZGF0ZV90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFt", + "cEID4EEDEkQKBmxhYmVscxgEIAMoCzI0Lmdvb2dsZS5jbG91ZC5uZXR3b3Jr", + "Y29ubmVjdGl2aXR5LnYxLkh1Yi5MYWJlbHNFbnRyeRITCgtkZXNjcmlwdGlv", + "bhgFIAEoCRIWCgl1bmlxdWVfaWQYCCABKAlCA+BBAxI+CgVzdGF0ZRgJIAEo", + "DjIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlN0YXRl", + "QgPgQQMSRQoMcm91dGluZ192cGNzGAogAygLMi8uZ29vZ2xlLmNsb3VkLm5l", + "dHdvcmtjb25uZWN0aXZpdHkudjEuUm91dGluZ1ZQQxIZCgxyb3V0ZV90YWJs", + "ZXMYCyADKAlCA+BBAxJNCg1zcG9rZV9zdW1tYXJ5GAwgASgLMjEuZ29vZ2xl", + "LmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3Bva2VTdW1tYXJ5QgPg", + "QQMSSQoLcG9saWN5X21vZGUYDSABKA4yLy5nb29nbGUuY2xvdWQubmV0d29y", + "a2Nvbm5lY3Rpdml0eS52MS5Qb2xpY3lNb2RlQgPgQQESUQoPcHJlc2V0X3Rv", + "cG9sb2d5GA4gASgOMjMuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZp", + "dHkudjEuUHJlc2V0VG9wb2xvZ3lCA+BBARIcCgpleHBvcnRfcHNjGA8gASgI", + "QgPgQQFIAIgBARotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFs", + "dWUYAiABKAk6AjgBOlvqQVgKJm5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xl", + "YXBpcy5jb20vSHViEi5wcm9qZWN0cy97cHJvamVjdH0vbG9jYXRpb25zL2ds", + "b2JhbC9odWJzL3todWJ9Qg0KC19leHBvcnRfcHNjIn8KClJvdXRpbmdWUEMS", + "MAoDdXJpGAEgASgJQiP6QSAKHmNvbXB1dGUuZ29vZ2xlYXBpcy5jb20vTmV0", + "d29yaxI/CjJyZXF1aXJlZF9mb3JfbmV3X3NpdGVfdG9fc2l0ZV9kYXRhX3Ry", + "YW5zZmVyX3Nwb2tlcxgCIAEoCEID4EEDIrELCgVTcG9rZRIRCgRuYW1lGAEg", + "ASgJQgPgQQUSNAoLY3JlYXRlX3RpbWUYAiABKAsyGi5nb29nbGUucHJvdG9i", + "dWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYAyABKAsyGi5nb29n", + "bGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSRgoGbGFiZWxzGAQgAygLMjYu", + "Z29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3Bva2UuTGFi", + "ZWxzRW50cnkSEwoLZGVzY3JpcHRpb24YBSABKAkSOwoDaHViGAYgASgJQi7g", + "QQX6QSgKJm5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb20vSHVi", + "Ej8KBWdyb3VwGBcgASgJQjDgQQH6QSoKKG5ldHdvcmtjb25uZWN0aXZpdHku", + "Z29vZ2xlYXBpcy5jb20vR3JvdXASUQoSbGlua2VkX3Zwbl90dW5uZWxzGBEg", + "ASgLMjUuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTGlu", + "a2VkVnBuVHVubmVscxJrCh9saW5rZWRfaW50ZXJjb25uZWN0X2F0dGFjaG1l", + "bnRzGBIgASgLMkIuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHku", + "djEuTGlua2VkSW50ZXJjb25uZWN0QXR0YWNobWVudHMSbgohbGlua2VkX3Jv", + "dXRlcl9hcHBsaWFuY2VfaW5zdGFuY2VzGBMgASgLMkMuZ29vZ2xlLmNsb3Vk", + "Lm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTGlua2VkUm91dGVyQXBwbGlhbmNl", + "SW5zdGFuY2VzElYKEmxpbmtlZF92cGNfbmV0d29yaxgUIAEoCzI1Lmdvb2ds", + "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkxpbmtlZFZwY05ldHdv", + "cmtCA+BBARJnChtsaW5rZWRfcHJvZHVjZXJfdnBjX25ldHdvcmsYGiABKAsy", + "PS5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaW5rZWRQ", + "cm9kdWNlclZwY05ldHdvcmtCA+BBARIWCgl1bmlxdWVfaWQYCyABKAlCA+BB", + "AxI+CgVzdGF0ZRgPIAEoDjIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", + "dGl2aXR5LnYxLlN0YXRlQgPgQQMSTAoHcmVhc29ucxgVIAMoCzI2Lmdvb2ds", + "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlLlN0YXRlUmVh", + "c29uQgPgQQMSRwoKc3Bva2VfdHlwZRgWIAEoDjIuLmdvb2dsZS5jbG91ZC5u", + "ZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlVHlwZUID4EEDGtcBCgtTdGF0", + "ZVJlYXNvbhJJCgRjb2RlGAEgASgOMjsuZ29vZ2xlLmNsb3VkLm5ldHdvcmtj", + "b25uZWN0aXZpdHkudjEuU3Bva2UuU3RhdGVSZWFzb24uQ29kZRIPCgdtZXNz", + "YWdlGAIgASgJEhQKDHVzZXJfZGV0YWlscxgDIAEoCSJWCgRDb2RlEhQKEENP", + "REVfVU5TUEVDSUZJRUQQABISCg5QRU5ESU5HX1JFVklFVxABEgwKCFJFSkVD", + "VEVEEAISCgoGUEFVU0VEEAMSCgoGRkFJTEVEEAQaLQoLTGFiZWxzRW50cnkS", + "CwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ATpl6kFiCihuZXR3b3Jr", + "Y29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL1Nwb2tlEjZwcm9qZWN0cy97", + "cHJvamVjdH0vbG9jYXRpb25zL3tsb2NhdGlvbn0vc3Bva2VzL3tzcG9rZX0i", + "7AMKClJvdXRlVGFibGUSEQoEbmFtZRgBIAEoCUID4EEFEjQKC2NyZWF0ZV90", + "aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEjQK", + "C3VwZGF0ZV90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFt", + "cEID4EEDEksKBmxhYmVscxgEIAMoCzI7Lmdvb2dsZS5jbG91ZC5uZXR3b3Jr", + "Y29ubmVjdGl2aXR5LnYxLlJvdXRlVGFibGUuTGFiZWxzRW50cnkSEwoLZGVz", + "Y3JpcHRpb24YBSABKAkSEAoDdWlkGAYgASgJQgPgQQMSPgoFc3RhdGUYByAB", + "KA4yKi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TdGF0", + "ZUID4EEDGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgC", + "IAEoCToCOAE6fOpBeQotbmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlz", + "LmNvbS9Sb3V0ZVRhYmxlEkhwcm9qZWN0cy97cHJvamVjdH0vbG9jYXRpb25z", + "L2dsb2JhbC9odWJzL3todWJ9L3JvdXRlVGFibGVzL3tyb3V0ZV90YWJsZX0i", + "1wgKBVJvdXRlEhEKBG5hbWUYAyABKAlCA+BBBRI0CgtjcmVhdGVfdGltZRgE", + "IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRh", + "dGVfdGltZRgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BB", + "AxIVCg1pcF9jaWRyX3JhbmdlGAEgASgJEkEKBHR5cGUYCiABKA4yLi5nb29n", + "bGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5Sb3V0ZVR5cGVCA+BB", + "AxJZChRuZXh0X2hvcF92cGNfbmV0d29yaxgCIAEoCzI2Lmdvb2dsZS5jbG91", + "ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLk5leHRIb3BWcGNOZXR3b3JrQgPg", + "QQUSRgoGbGFiZWxzGAYgAygLMjYuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25u", + "ZWN0aXZpdHkudjEuUm91dGUuTGFiZWxzRW50cnkSEwoLZGVzY3JpcHRpb24Y", + "ByABKAkSEAoDdWlkGAggASgJQgPgQQMSPgoFc3RhdGUYCSABKA4yKi5nb29n", + "bGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TdGF0ZUID4EEDEj8K", + "BXNwb2tlGAsgASgJQjDgQQX6QSoKKG5ldHdvcmtjb25uZWN0aXZpdHkuZ29v", + "Z2xlYXBpcy5jb20vU3Bva2USFQoIbG9jYXRpb24YDCABKAlCA+BBAxIVCghw", + "cmlvcml0eRgNIAEoA0ID4EEDElcKE25leHRfaG9wX3Zwbl90dW5uZWwYDiAB", + "KAsyNS5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5OZXh0", + "SG9wVlBOVHVubmVsQgPgQQUSdAoibmV4dF9ob3Bfcm91dGVyX2FwcGxpYW5j", + "ZV9pbnN0YW5jZRgPIAEoCzJDLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", + "dGl2aXR5LnYxLk5leHRIb3BSb3V0ZXJBcHBsaWFuY2VJbnN0YW5jZUID4EEF", + "EnEKIG5leHRfaG9wX2ludGVyY29ubmVjdF9hdHRhY2htZW50GBAgASgLMkIu", + "Z29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTmV4dEhvcElu", + "dGVyY29ubmVjdEF0dGFjaG1lbnRCA+BBBRotCgtMYWJlbHNFbnRyeRILCgNr", + "ZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBOooB6kGGAQorbmV0d29ya2Nv", + "bm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9IdWJSb3V0ZRJXcHJvamVjdHMv", + "e3Byb2plY3R9L2xvY2F0aW9ucy9nbG9iYWwvaHVicy97aHVifS9yb3V0ZVRh", + "Ymxlcy97cm91dGVfdGFibGV9L3JvdXRlcy97cm91dGV9IsEECgVHcm91cBIR", + "CgRuYW1lGAEgASgJQgPgQQUSNAoLY3JlYXRlX3RpbWUYAiABKAsyGi5nb29n", + "bGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYAyAB", + "KAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSSwoGbGFiZWxz", + "GAQgAygLMjYuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEu", + "R3JvdXAuTGFiZWxzRW50cnlCA+BBARIYCgtkZXNjcmlwdGlvbhgFIAEoCUID", + "4EEBEhAKA3VpZBgGIAEoCUID4EEDEj4KBXN0YXRlGAcgASgOMiouZ29vZ2xl", + "LmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3RhdGVCA+BBAxJJCgth", + "dXRvX2FjY2VwdBgIIAEoCzIvLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", + "dGl2aXR5LnYxLkF1dG9BY2NlcHRCA+BBARIYCgtyb3V0ZV90YWJsZRgJIAEo", + "CUID4EEDGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgC", + "IAEoCToCOAE6bOpBaQoobmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlz", + "LmNvbS9Hcm91cBI9cHJvamVjdHMve3Byb2plY3R9L2xvY2F0aW9ucy9nbG9i", + "YWwvaHVicy97aHVifS9ncm91cHMve2dyb3VwfSIqCgpBdXRvQWNjZXB0EhwK", + "FGF1dG9fYWNjZXB0X3Byb2plY3RzGAEgAygJIpUBCg9MaXN0SHVic1JlcXVl", + "c3QSOQoGcGFyZW50GAEgASgJQingQQL6QSMKIWxvY2F0aW9ucy5nb29nbGVh", + "cGlzLmNvbS9Mb2NhdGlvbhIRCglwYWdlX3NpemUYAiABKAUSEgoKcGFnZV90", + "b2tlbhgDIAEoCRIOCgZmaWx0ZXIYBCABKAkSEAoIb3JkZXJfYnkYBSABKAki", + "eAoQTGlzdEh1YnNSZXNwb25zZRI2CgRodWJzGAEgAygLMiguZ29vZ2xlLmNs", + "b3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuSHViEhcKD25leHRfcGFnZV90", + "b2tlbhgCIAEoCRITCgt1bnJlYWNoYWJsZRgDIAMoCSJNCg1HZXRIdWJSZXF1", + "ZXN0EjwKBG5hbWUYASABKAlCLuBBAvpBKAombmV0d29ya2Nvbm5lY3Rpdml0", + "eS5nb29nbGVhcGlzLmNvbS9IdWIitwEKEENyZWF0ZUh1YlJlcXVlc3QSOQoG", + "cGFyZW50GAEgASgJQingQQL6QSMKIWxvY2F0aW9ucy5nb29nbGVhcGlzLmNv", + "bS9Mb2NhdGlvbhITCgZodWJfaWQYAiABKAlCA+BBAhI6CgNodWIYAyABKAsy", + "KC5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5IdWJCA+BB", + "AhIXCgpyZXF1ZXN0X2lkGAQgASgJQgPgQQEinQEKEFVwZGF0ZUh1YlJlcXVl", + "c3QSNAoLdXBkYXRlX21hc2sYASABKAsyGi5nb29nbGUucHJvdG9idWYuRmll", + "bGRNYXNrQgPgQQESOgoDaHViGAIgASgLMiguZ29vZ2xlLmNsb3VkLm5ldHdv", + "cmtjb25uZWN0aXZpdHkudjEuSHViQgPgQQISFwoKcmVxdWVzdF9pZBgDIAEo", + "CUID4EEBImkKEERlbGV0ZUh1YlJlcXVlc3QSPAoEbmFtZRgBIAEoCUIu4EEC", + "+kEoCiZuZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL0h1YhIX", + "CgpyZXF1ZXN0X2lkGAIgASgJQgPgQQEiywIKFExpc3RIdWJTcG9rZXNSZXF1", + "ZXN0EjwKBG5hbWUYASABKAlCLuBBAvpBKAombmV0d29ya2Nvbm5lY3Rpdml0", + "eS5nb29nbGVhcGlzLmNvbS9IdWISFwoPc3Bva2VfbG9jYXRpb25zGAIgAygJ", + "EhEKCXBhZ2Vfc2l6ZRgDIAEoBRISCgpwYWdlX3Rva2VuGAQgASgJEg4KBmZp", + "bHRlchgFIAEoCRIQCghvcmRlcl9ieRgGIAEoCRJRCgR2aWV3GAcgASgOMkMu", + "Z29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTGlzdEh1YlNw", + "b2tlc1JlcXVlc3QuU3Bva2VWaWV3IkAKCVNwb2tlVmlldxIaChZTUE9LRV9W", + "SUVXX1VOU1BFQ0lGSUVEEAASCQoFQkFTSUMQARIMCghERVRBSUxFRBACIoEB", + "ChVMaXN0SHViU3Bva2VzUmVzcG9uc2USOgoGc3Bva2VzGAEgAygLMiouZ29v", + "Z2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3Bva2USFwoPbmV4", + "dF9wYWdlX3Rva2VuGAIgASgJEhMKC3VucmVhY2hhYmxlGAMgAygJIskBChVR", + "dWVyeUh1YlN0YXR1c1JlcXVlc3QSPAoEbmFtZRgBIAEoCUIu4EEC+kEoCiZu", + "ZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL0h1YhIWCglwYWdl", + "X3NpemUYAiABKAVCA+BBARIXCgpwYWdlX3Rva2VuGAMgASgJQgPgQQESEwoG", + "ZmlsdGVyGAQgASgJQgPgQQESFQoIb3JkZXJfYnkYBSABKAlCA+BBARIVCghn", + "cm91cF9ieRgGIAEoCUID4EEBIoIBChZRdWVyeUh1YlN0YXR1c1Jlc3BvbnNl", + "Ek8KEmh1Yl9zdGF0dXNfZW50cmllcxgBIAMoCzIzLmdvb2dsZS5jbG91ZC5u", + "ZXR3b3JrY29ubmVjdGl2aXR5LnYxLkh1YlN0YXR1c0VudHJ5EhcKD25leHRf", + "cGFnZV90b2tlbhgCIAEoCSKMAQoOSHViU3RhdHVzRW50cnkSDQoFY291bnQY", + "ASABKAUSEAoIZ3JvdXBfYnkYAiABKAkSWQoWcHNjX3Byb3BhZ2F0aW9uX3N0", + "YXR1cxgDIAEoCzI5Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5", + "LnYxLlBzY1Byb3BhZ2F0aW9uU3RhdHVzItIDChRQc2NQcm9wYWdhdGlvblN0", + "YXR1cxIUCgxzb3VyY2Vfc3Bva2UYASABKAkSFAoMc291cmNlX2dyb3VwGAIg", + "ASgJEh4KFnNvdXJjZV9mb3J3YXJkaW5nX3J1bGUYAyABKAkSFAoMdGFyZ2V0", + "X3Nwb2tlGAQgASgJEhQKDHRhcmdldF9ncm91cBgFIAEoCRJMCgRjb2RlGAYg", + "ASgOMj4uZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuUHNj", + "UHJvcGFnYXRpb25TdGF0dXMuQ29kZRIPCgdtZXNzYWdlGAcgASgJIuIBCgRD", + "b2RlEhQKEENPREVfVU5TUEVDSUZJRUQQABIJCgVSRUFEWRABEg8KC1BST1BB", + "R0FUSU5HEAISNwozRVJST1JfUFJPRFVDRVJfUFJPUEFHQVRFRF9DT05ORUNU", + "SU9OX0xJTUlUX0VYQ0VFREVEEAMSKQolRVJST1JfUFJPRFVDRVJfTkFUX0lQ", + "X1NQQUNFX0VYSEFVU1RFRBAEEiEKHUVSUk9SX1BST0RVQ0VSX1FVT1RBX0VY", + "Q0VFREVEEAUSIQodRVJST1JfQ09OU1VNRVJfUVVPVEFfRVhDRUVERUQQBiKX", + "AQoRTGlzdFNwb2tlc1JlcXVlc3QSOQoGcGFyZW50GAEgASgJQingQQL6QSMK", + "IWxvY2F0aW9ucy5nb29nbGVhcGlzLmNvbS9Mb2NhdGlvbhIRCglwYWdlX3Np", + "emUYAiABKAUSEgoKcGFnZV90b2tlbhgDIAEoCRIOCgZmaWx0ZXIYBCABKAkS", + "EAoIb3JkZXJfYnkYBSABKAkifgoSTGlzdFNwb2tlc1Jlc3BvbnNlEjoKBnNw", + "b2tlcxgBIAMoCzIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5", + "LnYxLlNwb2tlEhcKD25leHRfcGFnZV90b2tlbhgCIAEoCRITCgt1bnJlYWNo", + "YWJsZRgDIAMoCSJRCg9HZXRTcG9rZVJlcXVlc3QSPgoEbmFtZRgBIAEoCUIw", + "4EEC+kEqCihuZXR3b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL1Nw", + "b2tlIr8BChJDcmVhdGVTcG9rZVJlcXVlc3QSOQoGcGFyZW50GAEgASgJQing", + "QQL6QSMKIWxvY2F0aW9ucy5nb29nbGVhcGlzLmNvbS9Mb2NhdGlvbhIVCghz", + "cG9rZV9pZBgCIAEoCUID4EECEj4KBXNwb2tlGAMgASgLMiouZ29vZ2xlLmNs", + "b3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3Bva2VCA+BBAhIXCgpyZXF1", + "ZXN0X2lkGAQgASgJQgPgQQEiowEKElVwZGF0ZVNwb2tlUmVxdWVzdBI0Cgt1", + "cGRhdGVfbWFzaxgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE1hc2tC", + "A+BBARI+CgVzcG9rZRgCIAEoCzIqLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29u", + "bmVjdGl2aXR5LnYxLlNwb2tlQgPgQQISFwoKcmVxdWVzdF9pZBgDIAEoCUID", + "4EEBIm0KEkRlbGV0ZVNwb2tlUmVxdWVzdBI+CgRuYW1lGAEgASgJQjDgQQL6", + "QSoKKG5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb20vU3Bva2US", + "FwoKcmVxdWVzdF9pZBgCIAEoCUID4EEBIrMBChVBY2NlcHRIdWJTcG9rZVJl", + "cXVlc3QSPAoEbmFtZRgBIAEoCUIu4EEC+kEoCiZuZXR3b3JrY29ubmVjdGl2", + "aXR5Lmdvb2dsZWFwaXMuY29tL0h1YhJDCglzcG9rZV91cmkYAiABKAlCMOBB", + "AvpBKgoobmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9TcG9r", + "ZRIXCgpyZXF1ZXN0X2lkGAMgASgJQgPgQQEiUwoWQWNjZXB0SHViU3Bva2VS", + "ZXNwb25zZRI5CgVzcG9rZRgBIAEoCzIqLmdvb2dsZS5jbG91ZC5uZXR3b3Jr", + "Y29ubmVjdGl2aXR5LnYxLlNwb2tlIskBChVSZWplY3RIdWJTcG9rZVJlcXVl", + "c3QSPAoEbmFtZRgBIAEoCUIu4EEC+kEoCiZuZXR3b3JrY29ubmVjdGl2aXR5", + "Lmdvb2dsZWFwaXMuY29tL0h1YhJDCglzcG9rZV91cmkYAiABKAlCMOBBAvpB", + "KgoobmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9TcG9rZRIX", + "CgpyZXF1ZXN0X2lkGAMgASgJQgPgQQESFAoHZGV0YWlscxgEIAEoCUID4EEB", + "IlMKFlJlamVjdEh1YlNwb2tlUmVzcG9uc2USOQoFc3Bva2UYASABKAsyKi5n", + "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TcG9rZSJbChRH", + "ZXRSb3V0ZVRhYmxlUmVxdWVzdBJDCgRuYW1lGAEgASgJQjXgQQL6QS8KLW5l", + "dHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb20vUm91dGVUYWJsZSJU", + "Cg9HZXRSb3V0ZVJlcXVlc3QSQQoEbmFtZRgBIAEoCUIz4EEC+kEtCituZXR3", + "b3JrY29ubmVjdGl2aXR5Lmdvb2dsZWFwaXMuY29tL0h1YlJvdXRlIqMBChFM", + "aXN0Um91dGVzUmVxdWVzdBJFCgZwYXJlbnQYASABKAlCNeBBAvpBLwotbmV0", + "d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9Sb3V0ZVRhYmxlEhEK", + "CXBhZ2Vfc2l6ZRgCIAEoBRISCgpwYWdlX3Rva2VuGAMgASgJEg4KBmZpbHRl", + "chgEIAEoCRIQCghvcmRlcl9ieRgFIAEoCSJ+ChJMaXN0Um91dGVzUmVzcG9u", + "c2USOgoGcm91dGVzGAEgAygLMiouZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25u", + "ZWN0aXZpdHkudjEuUm91dGUSFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJEhMK", + "C3VucmVhY2hhYmxlGAMgAygJIqEBChZMaXN0Um91dGVUYWJsZXNSZXF1ZXN0", + "Ej4KBnBhcmVudBgBIAEoCUIu4EEC+kEoCiZuZXR3b3JrY29ubmVjdGl2aXR5", + "Lmdvb2dsZWFwaXMuY29tL0h1YhIRCglwYWdlX3NpemUYAiABKAUSEgoKcGFn", + "ZV90b2tlbhgDIAEoCRIOCgZmaWx0ZXIYBCABKAkSEAoIb3JkZXJfYnkYBSAB", + "KAkijgEKF0xpc3RSb3V0ZVRhYmxlc1Jlc3BvbnNlEkUKDHJvdXRlX3RhYmxl", + "cxgBIAMoCzIvLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYx", + "LlJvdXRlVGFibGUSFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJEhMKC3VucmVh", + "Y2hhYmxlGAMgAygJIpwBChFMaXN0R3JvdXBzUmVxdWVzdBI+CgZwYXJlbnQY", + "ASABKAlCLuBBAvpBKAombmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlz", + "LmNvbS9IdWISEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyAB", + "KAkSDgoGZmlsdGVyGAQgASgJEhAKCG9yZGVyX2J5GAUgASgJIn4KEkxpc3RH", + "cm91cHNSZXNwb25zZRI6CgZncm91cHMYASADKAsyKi5nb29nbGUuY2xvdWQu", + "bmV0d29ya2Nvbm5lY3Rpdml0eS52MS5Hcm91cBIXCg9uZXh0X3BhZ2VfdG9r", + "ZW4YAiABKAkSEwoLdW5yZWFjaGFibGUYAyADKAkizAEKEExpbmtlZFZwblR1", + "bm5lbHMSMwoEdXJpcxgBIAMoCUIl+kEiCiBjb21wdXRlLmdvb2dsZWFwaXMu", + "Y29tL1ZwblR1bm5lbBIiChpzaXRlX3RvX3NpdGVfZGF0YV90cmFuc2ZlchgC", + "IAEoCBI7Cgt2cGNfbmV0d29yaxgDIAEoCUIm4EED+kEgCh5jb21wdXRlLmdv", + "b2dsZWFwaXMuY29tL05ldHdvcmsSIgoVaW5jbHVkZV9pbXBvcnRfcmFuZ2Vz", + "GAUgAygJQgPgQQEi5gEKHUxpbmtlZEludGVyY29ubmVjdEF0dGFjaG1lbnRz", + "EkAKBHVyaXMYASADKAlCMvpBLwotY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9J", + "bnRlcmNvbm5lY3RBdHRhY2htZW50EiIKGnNpdGVfdG9fc2l0ZV9kYXRhX3Ry", + "YW5zZmVyGAIgASgIEjsKC3ZwY19uZXR3b3JrGAMgASgJQibgQQP6QSAKHmNv", + "bXB1dGUuZ29vZ2xlYXBpcy5jb20vTmV0d29yaxIiChVpbmNsdWRlX2ltcG9y", + "dF9yYW5nZXMYBSADKAlCA+BBASL2AQoeTGlua2VkUm91dGVyQXBwbGlhbmNl", + "SW5zdGFuY2VzEk8KCWluc3RhbmNlcxgBIAMoCzI8Lmdvb2dsZS5jbG91ZC5u", + "ZXR3b3JrY29ubmVjdGl2aXR5LnYxLlJvdXRlckFwcGxpYW5jZUluc3RhbmNl", + "EiIKGnNpdGVfdG9fc2l0ZV9kYXRhX3RyYW5zZmVyGAIgASgIEjsKC3ZwY19u", + "ZXR3b3JrGAMgASgJQibgQQP6QSAKHmNvbXB1dGUuZ29vZ2xlYXBpcy5jb20v", + "TmV0d29yaxIiChVpbmNsdWRlX2ltcG9ydF9yYW5nZXMYBSADKAlCA+BBASLe", + "AQoQTGlua2VkVnBjTmV0d29yaxIzCgN1cmkYASABKAlCJuBBAvpBIAoeY29t", + "cHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrEiIKFWV4Y2x1ZGVfZXhwb3J0", + "X3JhbmdlcxgCIAMoCUID4EEBEiIKFWluY2x1ZGVfZXhwb3J0X3JhbmdlcxgD", + "IAMoCUID4EEBEk0KE3Byb2R1Y2VyX3ZwY19zcG9rZXMYBCADKAlCMOBBA/pB", + "KgoobmV0d29ya2Nvbm5lY3Rpdml0eS5nb29nbGVhcGlzLmNvbS9TcG9rZSLJ", + "AgoYTGlua2VkUHJvZHVjZXJWcGNOZXR3b3JrEjcKB25ldHdvcmsYASABKAlC", + "JuBBBfpBIAoeY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrElQKGnNl", + "cnZpY2VfY29uc3VtZXJfdnBjX3Nwb2tlGAYgASgJQjDgQQP6QSoKKG5ldHdv", + "cmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb20vU3Bva2USFAoHcGVlcmlu", + "ZxgCIAEoCUID4EEFEkAKEHByb2R1Y2VyX25ldHdvcmsYBSABKAlCJuBBA/pB", + "IAoeY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrEiIKFWV4Y2x1ZGVf", + "ZXhwb3J0X3JhbmdlcxgDIAMoCUID4EEBEiIKFWluY2x1ZGVfZXhwb3J0X3Jh", + "bmdlcxgEIAMoCUID4EEBImwKF1JvdXRlckFwcGxpYW5jZUluc3RhbmNlEj0K", + "D3ZpcnR1YWxfbWFjaGluZRgBIAEoCUIk+kEhCh9jb21wdXRlLmdvb2dsZWFw", + "aXMuY29tL0luc3RhbmNlEhIKCmlwX2FkZHJlc3MYAyABKAkiYwoQTG9jYXRp", + "b25NZXRhZGF0YRJPChFsb2NhdGlvbl9mZWF0dXJlcxgBIAMoDjI0Lmdvb2ds", + "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkxvY2F0aW9uRmVhdHVy", + "ZSJFChFOZXh0SG9wVnBjTmV0d29yaxIwCgN1cmkYASABKAlCI/pBIAoeY29t", + "cHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrIqQBChBOZXh0SG9wVlBOVHVu", + "bmVsEjIKA3VyaRgBIAEoCUIl+kEiCiBjb21wdXRlLmdvb2dsZWFwaXMuY29t", + "L1ZwblR1bm5lbBI4Cgt2cGNfbmV0d29yaxgCIAEoCUIj+kEgCh5jb21wdXRl", + "Lmdvb2dsZWFwaXMuY29tL05ldHdvcmsSIgoac2l0ZV90b19zaXRlX2RhdGFf", + "dHJhbnNmZXIYAyABKAgisQEKHk5leHRIb3BSb3V0ZXJBcHBsaWFuY2VJbnN0", + "YW5jZRIxCgN1cmkYASABKAlCJPpBIQofY29tcHV0ZS5nb29nbGVhcGlzLmNv", + "bS9JbnN0YW5jZRI4Cgt2cGNfbmV0d29yaxgCIAEoCUIj+kEgCh5jb21wdXRl", + "Lmdvb2dsZWFwaXMuY29tL05ldHdvcmsSIgoac2l0ZV90b19zaXRlX2RhdGFf", + "dHJhbnNmZXIYAyABKAgivgEKHU5leHRIb3BJbnRlcmNvbm5lY3RBdHRhY2ht", + "ZW50Ej8KA3VyaRgBIAEoCUIy+kEvCi1jb21wdXRlLmdvb2dsZWFwaXMuY29t", + "L0ludGVyY29ubmVjdEF0dGFjaG1lbnQSOAoLdnBjX25ldHdvcmsYAiABKAlC", + "I/pBIAoeY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3JrEiIKGnNpdGVf", + "dG9fc2l0ZV9kYXRhX3RyYW5zZmVyGAMgASgIIqYFCgxTcG9rZVN1bW1hcnkS", + "YAoRc3Bva2VfdHlwZV9jb3VudHMYASADKAsyQC5nb29nbGUuY2xvdWQubmV0", + "d29ya2Nvbm5lY3Rpdml0eS52MS5TcG9rZVN1bW1hcnkuU3Bva2VUeXBlQ291", + "bnRCA+BBAxJiChJzcG9rZV9zdGF0ZV9jb3VudHMYAiADKAsyQS5nb29nbGUu", + "Y2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5TcG9rZVN1bW1hcnkuU3Bv", + "a2VTdGF0ZUNvdW50QgPgQQMSbwoZc3Bva2Vfc3RhdGVfcmVhc29uX2NvdW50", + "cxgDIAMoCzJHLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYx", + "LlNwb2tlU3VtbWFyeS5TcG9rZVN0YXRlUmVhc29uQ291bnRCA+BBAxptCg5T", + "cG9rZVR5cGVDb3VudBJHCgpzcG9rZV90eXBlGAEgASgOMi4uZ29vZ2xlLmNs", + "b3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuU3Bva2VUeXBlQgPgQQMSEgoF", + "Y291bnQYAiABKANCA+BBAxplCg9TcG9rZVN0YXRlQ291bnQSPgoFc3RhdGUY", + "ASABKA4yKi5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5T", + "dGF0ZUID4EEDEhIKBWNvdW50GAIgASgDQgPgQQMaiAEKFVNwb2tlU3RhdGVS", + "ZWFzb25Db3VudBJbChFzdGF0ZV9yZWFzb25fY29kZRgBIAEoDjI7Lmdvb2ds", + "ZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlLlN0YXRlUmVh", + "c29uLkNvZGVCA+BBAxISCgVjb3VudBgCIAEoA0ID4EEDIlEKD0dldEdyb3Vw", + "UmVxdWVzdBI+CgRuYW1lGAEgASgJQjDgQQL6QSoKKG5ldHdvcmtjb25uZWN0", + "aXZpdHkuZ29vZ2xlYXBpcy5jb20vR3JvdXAiowEKElVwZGF0ZUdyb3VwUmVx", + "dWVzdBI0Cgt1cGRhdGVfbWFzaxgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5G", + "aWVsZE1hc2tCA+BBARI+CgVncm91cBgCIAEoCzIqLmdvb2dsZS5jbG91ZC5u", + "ZXR3b3JrY29ubmVjdGl2aXR5LnYxLkdyb3VwQgPgQQISFwoKcmVxdWVzdF9p", + "ZBgDIAEoCUID4EEBKmYKD0xvY2F0aW9uRmVhdHVyZRIgChxMT0NBVElPTl9G", + "RUFUVVJFX1VOU1BFQ0lGSUVEEAASGAoUU0lURV9UT19DTE9VRF9TUE9LRVMQ", + "ARIXChNTSVRFX1RPX1NJVEVfU1BPS0VTEAIqbAoJUm91dGVUeXBlEhoKFlJP", + "VVRFX1RZUEVfVU5TUEVDSUZJRUQQABIWChJWUENfUFJJTUFSWV9TVUJORVQQ", + "ARIYChRWUENfU0VDT05EQVJZX1NVQk5FVBACEhEKDURZTkFNSUNfUk9VVEUQ", + "AyqOAQoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIMCghDUkVBVElO", + "RxABEgoKBkFDVElWRRACEgwKCERFTEVUSU5HEAMSDQoJQUNDRVBUSU5HEAgS", + "DQoJUkVKRUNUSU5HEAkSDAoIVVBEQVRJTkcQBhIMCghJTkFDVElWRRAHEgwK", + "CE9CU09MRVRFEAoqlQEKCVNwb2tlVHlwZRIaChZTUE9LRV9UWVBFX1VOU1BF", + "Q0lGSUVEEAASDgoKVlBOX1RVTk5FTBABEhsKF0lOVEVSQ09OTkVDVF9BVFRB", + "Q0hNRU5UEAISFAoQUk9VVEVSX0FQUExJQU5DRRADEg8KC1ZQQ19ORVRXT1JL", + "EAQSGAoUUFJPRFVDRVJfVlBDX05FVFdPUksQByo1CgpQb2xpY3lNb2RlEhsK", + "F1BPTElDWV9NT0RFX1VOU1BFQ0lGSUVEEAASCgoGUFJFU0VUEAEqRQoOUHJl", + "c2V0VG9wb2xvZ3kSHwobUFJFU0VUX1RPUE9MT0dZX1VOU1BFQ0lGSUVEEAAS", + "CAoETUVTSBACEggKBFNUQVIQAzLUIgoKSHViU2VydmljZRK3AQoITGlzdEh1", + "YnMSNC5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaXN0", + "SHVic1JlcXVlc3QaNS5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0", + "eS52MS5MaXN0SHVic1Jlc3BvbnNlIj7aQQZwYXJlbnSC0+STAi8SLS92MS97", + "cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbH0vaHVicxKkAQoG", + "R2V0SHViEjIuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEu", + "R2V0SHViUmVxdWVzdBooLmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2", + "aXR5LnYxLkh1YiI82kEEbmFtZYLT5JMCLxItL3YxL3tuYW1lPXByb2plY3Rz", + "LyovbG9jYXRpb25zL2dsb2JhbC9odWJzLyp9EswBCglDcmVhdGVIdWISNS5n", + "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5DcmVhdGVIdWJS", + "ZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9wZXJhdGlvbiJpykEYCgNI", + "dWISEU9wZXJhdGlvbk1ldGFkYXRh2kERcGFyZW50LGh1YixodWJfaWSC0+ST", + "AjQiLS92MS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbH0v", + "aHViczoDaHViEs4BCglVcGRhdGVIdWISNS5nb29nbGUuY2xvdWQubmV0d29y", + "a2Nvbm5lY3Rpdml0eS52MS5VcGRhdGVIdWJSZXF1ZXN0Gh0uZ29vZ2xlLmxv", + "bmdydW5uaW5nLk9wZXJhdGlvbiJrykEYCgNIdWISEU9wZXJhdGlvbk1ldGFk", + "YXRh2kEPaHViLHVwZGF0ZV9tYXNrgtPkkwI4MjEvdjEve2h1Yi5uYW1lPXBy", + "b2plY3RzLyovbG9jYXRpb25zL2dsb2JhbC9odWJzLyp9OgNodWISzAEKCURl", + "bGV0ZUh1YhI1Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYx", + "LkRlbGV0ZUh1YlJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0", + "aW9uImnKQSoKFWdvb2dsZS5wcm90b2J1Zi5FbXB0eRIRT3BlcmF0aW9uTWV0", + "YWRhdGHaQQRuYW1lgtPkkwIvKi0vdjEve25hbWU9cHJvamVjdHMvKi9sb2Nh", + "dGlvbnMvZ2xvYmFsL2h1YnMvKn0SzwEKDUxpc3RIdWJTcG9rZXMSOS5nb29n", + "bGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5MaXN0SHViU3Bva2Vz", + "UmVxdWVzdBo6Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYx", + "Lkxpc3RIdWJTcG9rZXNSZXNwb25zZSJH2kEEbmFtZYLT5JMCOhI4L3YxL3tu", + "YW1lPXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbC9odWJzLyp9Omxpc3RT", + "cG9rZXMS0wEKDlF1ZXJ5SHViU3RhdHVzEjouZ29vZ2xlLmNsb3VkLm5ldHdv", + "cmtjb25uZWN0aXZpdHkudjEuUXVlcnlIdWJTdGF0dXNSZXF1ZXN0GjsuZ29v", + "Z2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuUXVlcnlIdWJTdGF0", + "dXNSZXNwb25zZSJI2kEEbmFtZYLT5JMCOxI5L3YxL3tuYW1lPXByb2plY3Rz", + "LyovbG9jYXRpb25zL2dsb2JhbC9odWJzLyp9OnF1ZXJ5U3RhdHVzEroBCgpM", + "aXN0U3Bva2VzEjYuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHku", + "djEuTGlzdFNwb2tlc1JlcXVlc3QaNy5nb29nbGUuY2xvdWQubmV0d29ya2Nv", + "bm5lY3Rpdml0eS52MS5MaXN0U3Bva2VzUmVzcG9uc2UiO9pBBnBhcmVudILT", + "5JMCLBIqL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9sb2NhdGlvbnMvKn0vc3Bv", + "a2VzEqcBCghHZXRTcG9rZRI0Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", + "dGl2aXR5LnYxLkdldFNwb2tlUmVxdWVzdBoqLmdvb2dsZS5jbG91ZC5uZXR3", + "b3JrY29ubmVjdGl2aXR5LnYxLlNwb2tlIjnaQQRuYW1lgtPkkwIsEiovdjEv", + "e25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9zcG9rZXMvKn0S1QEKC0Ny", + "ZWF0ZVNwb2tlEjcuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHku", + "djEuQ3JlYXRlU3Bva2VSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9w", + "ZXJhdGlvbiJuykEaCgVTcG9rZRIRT3BlcmF0aW9uTWV0YWRhdGHaQRVwYXJl", + "bnQsc3Bva2Usc3Bva2VfaWSC0+STAjMiKi92MS97cGFyZW50PXByb2plY3Rz", + "LyovbG9jYXRpb25zLyp9L3Nwb2tlczoFc3Bva2US1wEKC1VwZGF0ZVNwb2tl", + "EjcuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuVXBkYXRl", + "U3Bva2VSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdydW5uaW5nLk9wZXJhdGlvbiJw", + "ykEaCgVTcG9rZRIRT3BlcmF0aW9uTWV0YWRhdGHaQRFzcG9rZSx1cGRhdGVf", + "bWFza4LT5JMCOTIwL3YxL3tzcG9rZS5uYW1lPXByb2plY3RzLyovbG9jYXRp", + "b25zLyovc3Bva2VzLyp9OgVzcG9rZRLxAQoOUmVqZWN0SHViU3Bva2USOi5n", + "b29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5SZWplY3RIdWJT", + "cG9rZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5pbmcuT3BlcmF0aW9uIoMB", + "ykErChZSZWplY3RIdWJTcG9rZVJlc3BvbnNlEhFPcGVyYXRpb25NZXRhZGF0", + "YdpBDm5hbWUsc3Bva2VfdXJpgtPkkwI+IjkvdjEve25hbWU9cHJvamVjdHMv", + "Ki9sb2NhdGlvbnMvZ2xvYmFsL2h1YnMvKn06cmVqZWN0U3Bva2U6ASoS8QEK", + "DkFjY2VwdEh1YlNwb2tlEjouZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0", + "aXZpdHkudjEuQWNjZXB0SHViU3Bva2VSZXF1ZXN0Gh0uZ29vZ2xlLmxvbmdy", + "dW5uaW5nLk9wZXJhdGlvbiKDAcpBKwoWQWNjZXB0SHViU3Bva2VSZXNwb25z", + "ZRIRT3BlcmF0aW9uTWV0YWRhdGHaQQ5uYW1lLHNwb2tlX3VyaYLT5JMCPiI5", + "L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbC9odWJzLyp9", + "OmFjY2VwdFNwb2tlOgEqEs0BCgtEZWxldGVTcG9rZRI3Lmdvb2dsZS5jbG91", + "ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkRlbGV0ZVNwb2tlUmVxdWVzdBod", + "Lmdvb2dsZS5sb25ncnVubmluZy5PcGVyYXRpb24iZspBKgoVZ29vZ2xlLnBy", + "b3RvYnVmLkVtcHR5EhFPcGVyYXRpb25NZXRhZGF0YdpBBG5hbWWC0+STAiwq", + "Ki92MS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL3Nwb2tlcy8qfRLH", + "AQoNR2V0Um91dGVUYWJsZRI5Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", + "dGl2aXR5LnYxLkdldFJvdXRlVGFibGVSZXF1ZXN0Gi8uZ29vZ2xlLmNsb3Vk", + "Lm5ldHdvcmtjb25uZWN0aXZpdHkudjEuUm91dGVUYWJsZSJK2kEEbmFtZYLT", + "5JMCPRI7L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zL2dsb2JhbC9o", + "dWJzLyovcm91dGVUYWJsZXMvKn0SwQEKCEdldFJvdXRlEjQuZ29vZ2xlLmNs", + "b3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuR2V0Um91dGVSZXF1ZXN0Giou", + "Z29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuUm91dGUiU9pB", + "BG5hbWWC0+STAkYSRC92MS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy9n", + "bG9iYWwvaHVicy8qL3JvdXRlVGFibGVzLyovcm91dGVzLyp9EtQBCgpMaXN0", + "Um91dGVzEjYuZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEu", + "TGlzdFJvdXRlc1JlcXVlc3QaNy5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5l", + "Y3Rpdml0eS52MS5MaXN0Um91dGVzUmVzcG9uc2UiVdpBBnBhcmVudILT5JMC", + "RhJEL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9sb2NhdGlvbnMvZ2xvYmFsL2h1", + "YnMvKi9yb3V0ZVRhYmxlcy8qfS9yb3V0ZXMS2gEKD0xpc3RSb3V0ZVRhYmxl", + "cxI7Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVjdGl2aXR5LnYxLkxpc3RS", + "b3V0ZVRhYmxlc1JlcXVlc3QaPC5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5l", + "Y3Rpdml0eS52MS5MaXN0Um91dGVUYWJsZXNSZXNwb25zZSJM2kEGcGFyZW50", + "gtPkkwI9EjsvdjEve3BhcmVudD1wcm9qZWN0cy8qL2xvY2F0aW9ucy9nbG9i", + "YWwvaHVicy8qfS9yb3V0ZVRhYmxlcxKzAQoIR2V0R3JvdXASNC5nb29nbGUu", + "Y2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5HZXRHcm91cFJlcXVlc3Qa", + "Ki5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5Hcm91cCJF", + "2kEEbmFtZYLT5JMCOBI2L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25z", + "L2dsb2JhbC9odWJzLyovZ3JvdXBzLyp9EsYBCgpMaXN0R3JvdXBzEjYuZ29v", + "Z2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHkudjEuTGlzdEdyb3Vwc1Jl", + "cXVlc3QaNy5nb29nbGUuY2xvdWQubmV0d29ya2Nvbm5lY3Rpdml0eS52MS5M", + "aXN0R3JvdXBzUmVzcG9uc2UiR9pBBnBhcmVudILT5JMCOBI2L3YxL3twYXJl", + "bnQ9cHJvamVjdHMvKi9sb2NhdGlvbnMvZ2xvYmFsL2h1YnMvKn0vZ3JvdXBz", + "EuMBCgtVcGRhdGVHcm91cBI3Lmdvb2dsZS5jbG91ZC5uZXR3b3JrY29ubmVj", + "dGl2aXR5LnYxLlVwZGF0ZUdyb3VwUmVxdWVzdBodLmdvb2dsZS5sb25ncnVu", + "bmluZy5PcGVyYXRpb24ifMpBGgoFR3JvdXASEU9wZXJhdGlvbk1ldGFkYXRh", + "2kERZ3JvdXAsdXBkYXRlX21hc2uC0+STAkUyPC92MS97Z3JvdXAubmFtZT1w", + "cm9qZWN0cy8qL2xvY2F0aW9ucy9nbG9iYWwvaHVicy8qL2dyb3Vwcy8qfToF", + "Z3JvdXAaVspBIm5ldHdvcmtjb25uZWN0aXZpdHkuZ29vZ2xlYXBpcy5jb23S", + "QS5odHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRm", + "b3JtQsIDCidjb20uZ29vZ2xlLmNsb3VkLm5ldHdvcmtjb25uZWN0aXZpdHku", + "djFCCEh1YlByb3RvUAFaWWNsb3VkLmdvb2dsZS5jb20vZ28vbmV0d29ya2Nv", + "bm5lY3Rpdml0eS9hcGl2MS9uZXR3b3JrY29ubmVjdGl2aXR5cGI7bmV0d29y", + "a2Nvbm5lY3Rpdml0eXBiqgIjR29vZ2xlLkNsb3VkLk5ldHdvcmtDb25uZWN0", + "aXZpdHkuVjHKAiNHb29nbGVcQ2xvdWRcTmV0d29ya0Nvbm5lY3Rpdml0eVxW", + "MeoCJkdvb2dsZTo6Q2xvdWQ6Ok5ldHdvcmtDb25uZWN0aXZpdHk6OlYx6kFg", + "CiBjb21wdXRlLmdvb2dsZWFwaXMuY29tL1ZwblR1bm5lbBI8cHJvamVjdHMv", + "e3Byb2plY3R9L3JlZ2lvbnMve3JlZ2lvbn0vdnBuVHVubmVscy97cmVzb3Vy", + "Y2VfaWR96kFXCh9jb21wdXRlLmdvb2dsZWFwaXMuY29tL0luc3RhbmNlEjRw", + "cm9qZWN0cy97cHJvamVjdH0vem9uZXMve3pvbmV9L2luc3RhbmNlcy97aW5z", + "dGFuY2V9YgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.NetworkConnectivity.V1.CommonReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, - new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.NetworkConnectivity.V1.LocationFeature), typeof(global::Google.Cloud.NetworkConnectivity.V1.RouteType), typeof(global::Google.Cloud.NetworkConnectivity.V1.State), typeof(global::Google.Cloud.NetworkConnectivity.V1.SpokeType), }, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Hub), global::Google.Cloud.NetworkConnectivity.V1.Hub.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "UniqueId", "State", "RoutingVpcs", "RouteTables", "SpokeSummary" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.FieldInfoReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.NetworkConnectivity.V1.CommonReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.NetworkConnectivity.V1.LocationFeature), typeof(global::Google.Cloud.NetworkConnectivity.V1.RouteType), typeof(global::Google.Cloud.NetworkConnectivity.V1.State), typeof(global::Google.Cloud.NetworkConnectivity.V1.SpokeType), typeof(global::Google.Cloud.NetworkConnectivity.V1.PolicyMode), typeof(global::Google.Cloud.NetworkConnectivity.V1.PresetTopology), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Hub), global::Google.Cloud.NetworkConnectivity.V1.Hub.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "UniqueId", "State", "RoutingVpcs", "RouteTables", "SpokeSummary", "PolicyMode", "PresetTopology", "ExportPsc" }, new[]{ "ExportPsc" }, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.RoutingVPC), global::Google.Cloud.NetworkConnectivity.V1.RoutingVPC.Parser, new[]{ "Uri", "RequiredForNewSiteToSiteDataTransferSpokes" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Spoke), global::Google.Cloud.NetworkConnectivity.V1.Spoke.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "Hub", "Group", "LinkedVpnTunnels", "LinkedInterconnectAttachments", "LinkedRouterApplianceInstances", "LinkedVpcNetwork", "UniqueId", "State", "Reasons", "SpokeType" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason), global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Parser, new[]{ "Code", "Message", "UserDetails" }, null, new[]{ typeof(global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code) }, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Spoke), global::Google.Cloud.NetworkConnectivity.V1.Spoke.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "Hub", "Group", "LinkedVpnTunnels", "LinkedInterconnectAttachments", "LinkedRouterApplianceInstances", "LinkedVpcNetwork", "LinkedProducerVpcNetwork", "UniqueId", "State", "Reasons", "SpokeType" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason), global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Parser, new[]{ "Code", "Message", "UserDetails" }, null, new[]{ typeof(global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code) }, null, null), null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.RouteTable), global::Google.Cloud.NetworkConnectivity.V1.RouteTable.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "Uid", "State" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Route), global::Google.Cloud.NetworkConnectivity.V1.Route.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "IpCidrRange", "Type", "NextHopVpcNetwork", "Labels", "Description", "Uid", "State", "Spoke", "Location" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Group), global::Google.Cloud.NetworkConnectivity.V1.Group.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "Uid", "State" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Route), global::Google.Cloud.NetworkConnectivity.V1.Route.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "IpCidrRange", "Type", "NextHopVpcNetwork", "Labels", "Description", "Uid", "State", "Spoke", "Location", "Priority", "NextHopVpnTunnel", "NextHopRouterApplianceInstance", "NextHopInterconnectAttachment" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.Group), global::Google.Cloud.NetworkConnectivity.V1.Group.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "Description", "Uid", "State", "AutoAccept", "RouteTable" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.AutoAccept), global::Google.Cloud.NetworkConnectivity.V1.AutoAccept.Parser, new[]{ "AutoAcceptProjects" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListHubsRequest), global::Google.Cloud.NetworkConnectivity.V1.ListHubsRequest.Parser, new[]{ "Parent", "PageSize", "PageToken", "Filter", "OrderBy" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListHubsResponse), global::Google.Cloud.NetworkConnectivity.V1.ListHubsResponse.Parser, new[]{ "Hubs", "NextPageToken", "Unreachable" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.GetHubRequest), global::Google.Cloud.NetworkConnectivity.V1.GetHubRequest.Parser, new[]{ "Name" }, null, null, null, null), @@ -368,6 +450,10 @@ static HubReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.DeleteHubRequest), global::Google.Cloud.NetworkConnectivity.V1.DeleteHubRequest.Parser, new[]{ "Name", "RequestId" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListHubSpokesRequest), global::Google.Cloud.NetworkConnectivity.V1.ListHubSpokesRequest.Parser, new[]{ "Name", "SpokeLocations", "PageSize", "PageToken", "Filter", "OrderBy", "View" }, null, new[]{ typeof(global::Google.Cloud.NetworkConnectivity.V1.ListHubSpokesRequest.Types.SpokeView) }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListHubSpokesResponse), global::Google.Cloud.NetworkConnectivity.V1.ListHubSpokesResponse.Parser, new[]{ "Spokes", "NextPageToken", "Unreachable" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest), global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest.Parser, new[]{ "Name", "PageSize", "PageToken", "Filter", "OrderBy", "GroupBy" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusResponse), global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusResponse.Parser, new[]{ "HubStatusEntries", "NextPageToken" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.HubStatusEntry), global::Google.Cloud.NetworkConnectivity.V1.HubStatusEntry.Parser, new[]{ "Count", "GroupBy", "PscPropagationStatus" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus), global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Parser, new[]{ "SourceSpoke", "SourceGroup", "SourceForwardingRule", "TargetSpoke", "TargetGroup", "Code", "Message" }, null, new[]{ typeof(global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code) }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListSpokesRequest), global::Google.Cloud.NetworkConnectivity.V1.ListSpokesRequest.Parser, new[]{ "Parent", "PageSize", "PageToken", "Filter", "OrderBy" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListSpokesResponse), global::Google.Cloud.NetworkConnectivity.V1.ListSpokesResponse.Parser, new[]{ "Spokes", "NextPageToken", "Unreachable" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.GetSpokeRequest), global::Google.Cloud.NetworkConnectivity.V1.GetSpokeRequest.Parser, new[]{ "Name" }, null, null, null, null), @@ -386,17 +472,22 @@ static HubReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListRouteTablesResponse), global::Google.Cloud.NetworkConnectivity.V1.ListRouteTablesResponse.Parser, new[]{ "RouteTables", "NextPageToken", "Unreachable" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListGroupsRequest), global::Google.Cloud.NetworkConnectivity.V1.ListGroupsRequest.Parser, new[]{ "Parent", "PageSize", "PageToken", "Filter", "OrderBy" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.ListGroupsResponse), global::Google.Cloud.NetworkConnectivity.V1.ListGroupsResponse.Parser, new[]{ "Groups", "NextPageToken", "Unreachable" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedVpnTunnels), global::Google.Cloud.NetworkConnectivity.V1.LinkedVpnTunnels.Parser, new[]{ "Uris", "SiteToSiteDataTransfer", "VpcNetwork" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedInterconnectAttachments), global::Google.Cloud.NetworkConnectivity.V1.LinkedInterconnectAttachments.Parser, new[]{ "Uris", "SiteToSiteDataTransfer", "VpcNetwork" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedRouterApplianceInstances), global::Google.Cloud.NetworkConnectivity.V1.LinkedRouterApplianceInstances.Parser, new[]{ "Instances", "SiteToSiteDataTransfer", "VpcNetwork" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedVpcNetwork), global::Google.Cloud.NetworkConnectivity.V1.LinkedVpcNetwork.Parser, new[]{ "Uri", "ExcludeExportRanges" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedVpnTunnels), global::Google.Cloud.NetworkConnectivity.V1.LinkedVpnTunnels.Parser, new[]{ "Uris", "SiteToSiteDataTransfer", "VpcNetwork", "IncludeImportRanges" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedInterconnectAttachments), global::Google.Cloud.NetworkConnectivity.V1.LinkedInterconnectAttachments.Parser, new[]{ "Uris", "SiteToSiteDataTransfer", "VpcNetwork", "IncludeImportRanges" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedRouterApplianceInstances), global::Google.Cloud.NetworkConnectivity.V1.LinkedRouterApplianceInstances.Parser, new[]{ "Instances", "SiteToSiteDataTransfer", "VpcNetwork", "IncludeImportRanges" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedVpcNetwork), global::Google.Cloud.NetworkConnectivity.V1.LinkedVpcNetwork.Parser, new[]{ "Uri", "ExcludeExportRanges", "IncludeExportRanges", "ProducerVpcSpokes" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork), global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork.Parser, new[]{ "Network", "ServiceConsumerVpcSpoke", "Peering", "ProducerNetwork", "ExcludeExportRanges", "IncludeExportRanges" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.RouterApplianceInstance), global::Google.Cloud.NetworkConnectivity.V1.RouterApplianceInstance.Parser, new[]{ "VirtualMachine", "IpAddress" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.LocationMetadata), global::Google.Cloud.NetworkConnectivity.V1.LocationMetadata.Parser, new[]{ "LocationFeatures" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.NextHopVpcNetwork), global::Google.Cloud.NetworkConnectivity.V1.NextHopVpcNetwork.Parser, new[]{ "Uri" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel), global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel.Parser, new[]{ "Uri", "VpcNetwork", "SiteToSiteDataTransfer" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance), global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance.Parser, new[]{ "Uri", "VpcNetwork", "SiteToSiteDataTransfer" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment), global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment.Parser, new[]{ "Uri", "VpcNetwork", "SiteToSiteDataTransfer" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary), global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Parser, new[]{ "SpokeTypeCounts", "SpokeStateCounts", "SpokeStateReasonCounts" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeTypeCount), global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeTypeCount.Parser, new[]{ "SpokeType", "Count" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateCount), global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateCount.Parser, new[]{ "State", "Count" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateReasonCount), global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateReasonCount.Parser, new[]{ "StateReasonCode", "Count" }, null, null, null, null)}), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.GetGroupRequest), global::Google.Cloud.NetworkConnectivity.V1.GetGroupRequest.Parser, new[]{ "Name" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.GetGroupRequest), global::Google.Cloud.NetworkConnectivity.V1.GetGroupRequest.Parser, new[]{ "Name" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest), global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest.Parser, new[]{ "UpdateMask", "Group", "RequestId" }, null, null, null, null) })); } #endregion @@ -439,6 +530,12 @@ public enum RouteType { /// VPC network's subnet. /// [pbr::OriginalName("VPC_SECONDARY_SUBNET")] VpcSecondarySubnet = 2, + /// + /// The route leads to a destination in a dynamic route. Dynamic routes are + /// derived from Border Gateway Protocol (BGP) advertisements received from an + /// NCC hybrid spoke. + /// + [pbr::OriginalName("DYNAMIC_ROUTE")] DynamicRoute = 3, } /// @@ -510,6 +607,47 @@ public enum SpokeType { /// Spokes associated with VPC networks. /// [pbr::OriginalName("VPC_NETWORK")] VpcNetwork = 4, + /// + /// Spokes that are backed by a producer VPC network. + /// + [pbr::OriginalName("PRODUCER_VPC_NETWORK")] ProducerVpcNetwork = 7, + } + + /// + /// This enum controls the policy mode used in a hub. + /// + public enum PolicyMode { + /// + /// Policy mode is unspecified. It defaults to PRESET + /// with preset_topology = MESH. + /// + [pbr::OriginalName("POLICY_MODE_UNSPECIFIED")] Unspecified = 0, + /// + /// Hub uses one of the preset topologies. + /// + [pbr::OriginalName("PRESET")] Preset = 1, + } + + /// + /// The list of available preset topologies. + /// + public enum PresetTopology { + /// + /// Preset topology is unspecified. When policy_mode = PRESET, + /// it defaults to MESH. + /// + [pbr::OriginalName("PRESET_TOPOLOGY_UNSPECIFIED")] Unspecified = 0, + /// + /// Mesh topology is implemented. Group `default` is automatically created. + /// All spokes in the hub are added to group `default`. + /// + [pbr::OriginalName("MESH")] Mesh = 2, + /// + /// Star topology is implemented. Two groups, `center` and `edge`, are + /// automatically created along with hub creation. Spokes have to join one of + /// the groups during creation. + /// + [pbr::OriginalName("STAR")] Star = 3, } #endregion @@ -531,6 +669,7 @@ public sealed partial class Hub : pb::IMessage { private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Hub()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pb::MessageParser Parser { get { return _parser; } } @@ -558,6 +697,7 @@ public Hub() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public Hub(Hub other) : this() { + _hasBits0 = other._hasBits0; name_ = other.name_; createTime_ = other.createTime_ != null ? other.createTime_.Clone() : null; updateTime_ = other.updateTime_ != null ? other.updateTime_.Clone() : null; @@ -568,6 +708,9 @@ public Hub(Hub other) : this() { routingVpcs_ = other.routingVpcs_.Clone(); routeTables_ = other.routeTables_.Clone(); spokeSummary_ = other.spokeSummary_ != null ? other.spokeSummary_.Clone() : null; + policyMode_ = other.policyMode_; + presetTopology_ = other.presetTopology_; + exportPsc_ = other.exportPsc_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -742,6 +885,75 @@ public string UniqueId { } } + /// Field number for the "policy_mode" field. + public const int PolicyModeFieldNumber = 13; + private global::Google.Cloud.NetworkConnectivity.V1.PolicyMode policyMode_ = global::Google.Cloud.NetworkConnectivity.V1.PolicyMode.Unspecified; + /// + /// Optional. The policy mode of this hub. This field can be either + /// PRESET or CUSTOM. If unspecified, the + /// policy_mode defaults to PRESET. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.PolicyMode PolicyMode { + get { return policyMode_; } + set { + policyMode_ = value; + } + } + + /// Field number for the "preset_topology" field. + public const int PresetTopologyFieldNumber = 14; + private global::Google.Cloud.NetworkConnectivity.V1.PresetTopology presetTopology_ = global::Google.Cloud.NetworkConnectivity.V1.PresetTopology.Unspecified; + /// + /// Optional. The topology implemented in this hub. Currently, this field is + /// only used when policy_mode = PRESET. The available preset topologies are + /// MESH and STAR. If preset_topology is unspecified and policy_mode = PRESET, + /// the preset_topology defaults to MESH. When policy_mode = CUSTOM, + /// the preset_topology is set to PRESET_TOPOLOGY_UNSPECIFIED. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.PresetTopology PresetTopology { + get { return presetTopology_; } + set { + presetTopology_ = value; + } + } + + /// Field number for the "export_psc" field. + public const int ExportPscFieldNumber = 15; + private readonly static bool ExportPscDefaultValue = false; + + private bool exportPsc_; + /// + /// Optional. Whether Private Service Connect transitivity is enabled for the + /// hub. If true, Private Service Connect endpoints in VPC spokes attached to + /// the hub are made accessible to other VPC spokes attached to the hub. + /// The default value is false. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool ExportPsc { + get { if ((_hasBits0 & 1) != 0) { return exportPsc_; } else { return ExportPscDefaultValue; } } + set { + _hasBits0 |= 1; + exportPsc_ = value; + } + } + /// Gets whether the "export_psc" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasExportPsc { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "export_psc" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearExportPsc() { + _hasBits0 &= ~1; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -767,6 +979,9 @@ public bool Equals(Hub other) { if(!routingVpcs_.Equals(other.routingVpcs_)) return false; if(!routeTables_.Equals(other.routeTables_)) return false; if (!object.Equals(SpokeSummary, other.SpokeSummary)) return false; + if (PolicyMode != other.PolicyMode) return false; + if (PresetTopology != other.PresetTopology) return false; + if (ExportPsc != other.ExportPsc) return false; return Equals(_unknownFields, other._unknownFields); } @@ -784,6 +999,9 @@ public override int GetHashCode() { hash ^= routingVpcs_.GetHashCode(); hash ^= routeTables_.GetHashCode(); if (spokeSummary_ != null) hash ^= SpokeSummary.GetHashCode(); + if (PolicyMode != global::Google.Cloud.NetworkConnectivity.V1.PolicyMode.Unspecified) hash ^= PolicyMode.GetHashCode(); + if (PresetTopology != global::Google.Cloud.NetworkConnectivity.V1.PresetTopology.Unspecified) hash ^= PresetTopology.GetHashCode(); + if (HasExportPsc) hash ^= ExportPsc.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -833,6 +1051,18 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(98); output.WriteMessage(SpokeSummary); } + if (PolicyMode != global::Google.Cloud.NetworkConnectivity.V1.PolicyMode.Unspecified) { + output.WriteRawTag(104); + output.WriteEnum((int) PolicyMode); + } + if (PresetTopology != global::Google.Cloud.NetworkConnectivity.V1.PresetTopology.Unspecified) { + output.WriteRawTag(112); + output.WriteEnum((int) PresetTopology); + } + if (HasExportPsc) { + output.WriteRawTag(120); + output.WriteBool(ExportPsc); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -874,6 +1104,18 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(98); output.WriteMessage(SpokeSummary); } + if (PolicyMode != global::Google.Cloud.NetworkConnectivity.V1.PolicyMode.Unspecified) { + output.WriteRawTag(104); + output.WriteEnum((int) PolicyMode); + } + if (PresetTopology != global::Google.Cloud.NetworkConnectivity.V1.PresetTopology.Unspecified) { + output.WriteRawTag(112); + output.WriteEnum((int) PresetTopology); + } + if (HasExportPsc) { + output.WriteRawTag(120); + output.WriteBool(ExportPsc); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -908,6 +1150,15 @@ public int CalculateSize() { if (spokeSummary_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(SpokeSummary); } + if (PolicyMode != global::Google.Cloud.NetworkConnectivity.V1.PolicyMode.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) PolicyMode); + } + if (PresetTopology != global::Google.Cloud.NetworkConnectivity.V1.PresetTopology.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) PresetTopology); + } + if (HasExportPsc) { + size += 1 + 1; + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -953,6 +1204,15 @@ public void MergeFrom(Hub other) { } SpokeSummary.MergeFrom(other.SpokeSummary); } + if (other.PolicyMode != global::Google.Cloud.NetworkConnectivity.V1.PolicyMode.Unspecified) { + PolicyMode = other.PolicyMode; + } + if (other.PresetTopology != global::Google.Cloud.NetworkConnectivity.V1.PresetTopology.Unspecified) { + PresetTopology = other.PresetTopology; + } + if (other.HasExportPsc) { + ExportPsc = other.ExportPsc; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -1017,6 +1277,18 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(SpokeSummary); break; } + case 104: { + PolicyMode = (global::Google.Cloud.NetworkConnectivity.V1.PolicyMode) input.ReadEnum(); + break; + } + case 112: { + PresetTopology = (global::Google.Cloud.NetworkConnectivity.V1.PresetTopology) input.ReadEnum(); + break; + } + case 120: { + ExportPsc = input.ReadBool(); + break; + } } } #endif @@ -1081,6 +1353,18 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(SpokeSummary); break; } + case 104: { + PolicyMode = (global::Google.Cloud.NetworkConnectivity.V1.PolicyMode) input.ReadEnum(); + break; + } + case 112: { + PresetTopology = (global::Google.Cloud.NetworkConnectivity.V1.PresetTopology) input.ReadEnum(); + break; + } + case 120: { + ExportPsc = input.ReadBool(); + break; + } } } } @@ -1387,6 +1671,7 @@ public Spoke(Spoke other) : this() { linkedInterconnectAttachments_ = other.linkedInterconnectAttachments_ != null ? other.linkedInterconnectAttachments_.Clone() : null; linkedRouterApplianceInstances_ = other.linkedRouterApplianceInstances_ != null ? other.linkedRouterApplianceInstances_.Clone() : null; linkedVpcNetwork_ = other.linkedVpcNetwork_ != null ? other.linkedVpcNetwork_.Clone() : null; + linkedProducerVpcNetwork_ = other.linkedProducerVpcNetwork_ != null ? other.linkedProducerVpcNetwork_.Clone() : null; uniqueId_ = other.uniqueId_; state_ = other.state_; reasons_ = other.reasons_.Clone(); @@ -1568,6 +1853,21 @@ public string Group { } } + /// Field number for the "linked_producer_vpc_network" field. + public const int LinkedProducerVpcNetworkFieldNumber = 26; + private global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork linkedProducerVpcNetwork_; + /// + /// Optional. The linked producer VPC that is associated with the spoke. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork LinkedProducerVpcNetwork { + get { return linkedProducerVpcNetwork_; } + set { + linkedProducerVpcNetwork_ = value; + } + } + /// Field number for the "unique_id" field. public const int UniqueIdFieldNumber = 11; private string uniqueId_ = ""; @@ -1656,6 +1956,7 @@ public bool Equals(Spoke other) { if (!object.Equals(LinkedInterconnectAttachments, other.LinkedInterconnectAttachments)) return false; if (!object.Equals(LinkedRouterApplianceInstances, other.LinkedRouterApplianceInstances)) return false; if (!object.Equals(LinkedVpcNetwork, other.LinkedVpcNetwork)) return false; + if (!object.Equals(LinkedProducerVpcNetwork, other.LinkedProducerVpcNetwork)) return false; if (UniqueId != other.UniqueId) return false; if (State != other.State) return false; if(!reasons_.Equals(other.reasons_)) return false; @@ -1678,6 +1979,7 @@ public override int GetHashCode() { if (linkedInterconnectAttachments_ != null) hash ^= LinkedInterconnectAttachments.GetHashCode(); if (linkedRouterApplianceInstances_ != null) hash ^= LinkedRouterApplianceInstances.GetHashCode(); if (linkedVpcNetwork_ != null) hash ^= LinkedVpcNetwork.GetHashCode(); + if (linkedProducerVpcNetwork_ != null) hash ^= LinkedProducerVpcNetwork.GetHashCode(); if (UniqueId.Length != 0) hash ^= UniqueId.GetHashCode(); if (State != global::Google.Cloud.NetworkConnectivity.V1.State.Unspecified) hash ^= State.GetHashCode(); hash ^= reasons_.GetHashCode(); @@ -1754,6 +2056,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(186, 1); output.WriteString(Group); } + if (linkedProducerVpcNetwork_ != null) { + output.WriteRawTag(210, 1); + output.WriteMessage(LinkedProducerVpcNetwork); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -1818,6 +2124,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(186, 1); output.WriteString(Group); } + if (linkedProducerVpcNetwork_ != null) { + output.WriteRawTag(210, 1); + output.WriteMessage(LinkedProducerVpcNetwork); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -1859,6 +2169,9 @@ public int CalculateSize() { if (linkedVpcNetwork_ != null) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinkedVpcNetwork); } + if (linkedProducerVpcNetwork_ != null) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinkedProducerVpcNetwork); + } if (UniqueId.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(UniqueId); } @@ -1930,6 +2243,12 @@ public void MergeFrom(Spoke other) { } LinkedVpcNetwork.MergeFrom(other.LinkedVpcNetwork); } + if (other.linkedProducerVpcNetwork_ != null) { + if (linkedProducerVpcNetwork_ == null) { + LinkedProducerVpcNetwork = new global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork(); + } + LinkedProducerVpcNetwork.MergeFrom(other.LinkedProducerVpcNetwork); + } if (other.UniqueId.Length != 0) { UniqueId = other.UniqueId; } @@ -2033,6 +2352,13 @@ public void MergeFrom(pb::CodedInputStream input) { Group = input.ReadString(); break; } + case 210: { + if (linkedProducerVpcNetwork_ == null) { + LinkedProducerVpcNetwork = new global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork(); + } + input.ReadMessage(LinkedProducerVpcNetwork); + break; + } } } #endif @@ -2126,6 +2452,13 @@ public void MergeFrom(pb::CodedInputStream input) { Group = input.ReadString(); break; } + case 210: { + if (linkedProducerVpcNetwork_ == null) { + LinkedProducerVpcNetwork = new global::Google.Cloud.NetworkConnectivity.V1.LinkedProducerVpcNetwork(); + } + input.ReadMessage(LinkedProducerVpcNetwork); + break; + } } } } @@ -2950,6 +3283,10 @@ public Route(Route other) : this() { state_ = other.state_; spoke_ = other.spoke_; location_ = other.location_; + priority_ = other.priority_; + nextHopVpnTunnel_ = other.nextHopVpnTunnel_ != null ? other.nextHopVpnTunnel_.Clone() : null; + nextHopRouterApplianceInstance_ = other.nextHopRouterApplianceInstance_ != null ? other.nextHopRouterApplianceInstance_.Clone() : null; + nextHopInterconnectAttachment_ = other.nextHopInterconnectAttachment_ != null ? other.nextHopInterconnectAttachment_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -3136,7 +3473,7 @@ public string Spoke { public const int LocationFieldNumber = 12; private string location_ = ""; /// - /// Output only. The location of the route. + /// Output only. The origin location of the route. /// Uses the following form: "projects/{project}/locations/{location}" /// Example: projects/1234/locations/us-central1 /// @@ -3149,6 +3486,69 @@ public string Location { } } + /// Field number for the "priority" field. + public const int PriorityFieldNumber = 13; + private long priority_; + /// + /// Output only. The priority of this route. Priority is used to break ties in + /// cases where a destination matches more than one route. In these cases the + /// route with the lowest-numbered priority value wins. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Priority { + get { return priority_; } + set { + priority_ = value; + } + } + + /// Field number for the "next_hop_vpn_tunnel" field. + public const int NextHopVpnTunnelFieldNumber = 14; + private global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel nextHopVpnTunnel_; + /// + /// Immutable. The next-hop VPN tunnel for packets on this route. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel NextHopVpnTunnel { + get { return nextHopVpnTunnel_; } + set { + nextHopVpnTunnel_ = value; + } + } + + /// Field number for the "next_hop_router_appliance_instance" field. + public const int NextHopRouterApplianceInstanceFieldNumber = 15; + private global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance nextHopRouterApplianceInstance_; + /// + /// Immutable. The next-hop Router appliance instance for packets on this + /// route. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance NextHopRouterApplianceInstance { + get { return nextHopRouterApplianceInstance_; } + set { + nextHopRouterApplianceInstance_ = value; + } + } + + /// Field number for the "next_hop_interconnect_attachment" field. + public const int NextHopInterconnectAttachmentFieldNumber = 16; + private global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment nextHopInterconnectAttachment_; + /// + /// Immutable. The next-hop VLAN attachment for packets on this route. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment NextHopInterconnectAttachment { + get { return nextHopInterconnectAttachment_; } + set { + nextHopInterconnectAttachment_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -3176,6 +3576,10 @@ public bool Equals(Route other) { if (State != other.State) return false; if (Spoke != other.Spoke) return false; if (Location != other.Location) return false; + if (Priority != other.Priority) return false; + if (!object.Equals(NextHopVpnTunnel, other.NextHopVpnTunnel)) return false; + if (!object.Equals(NextHopRouterApplianceInstance, other.NextHopRouterApplianceInstance)) return false; + if (!object.Equals(NextHopInterconnectAttachment, other.NextHopInterconnectAttachment)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -3195,6 +3599,10 @@ public override int GetHashCode() { if (State != global::Google.Cloud.NetworkConnectivity.V1.State.Unspecified) hash ^= State.GetHashCode(); if (Spoke.Length != 0) hash ^= Spoke.GetHashCode(); if (Location.Length != 0) hash ^= Location.GetHashCode(); + if (Priority != 0L) hash ^= Priority.GetHashCode(); + if (nextHopVpnTunnel_ != null) hash ^= NextHopVpnTunnel.GetHashCode(); + if (nextHopRouterApplianceInstance_ != null) hash ^= NextHopRouterApplianceInstance.GetHashCode(); + if (nextHopInterconnectAttachment_ != null) hash ^= NextHopInterconnectAttachment.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -3258,6 +3666,22 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(98); output.WriteString(Location); } + if (Priority != 0L) { + output.WriteRawTag(104); + output.WriteInt64(Priority); + } + if (nextHopVpnTunnel_ != null) { + output.WriteRawTag(114); + output.WriteMessage(NextHopVpnTunnel); + } + if (nextHopRouterApplianceInstance_ != null) { + output.WriteRawTag(122); + output.WriteMessage(NextHopRouterApplianceInstance); + } + if (nextHopInterconnectAttachment_ != null) { + output.WriteRawTag(130, 1); + output.WriteMessage(NextHopInterconnectAttachment); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -3313,6 +3737,22 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(98); output.WriteString(Location); } + if (Priority != 0L) { + output.WriteRawTag(104); + output.WriteInt64(Priority); + } + if (nextHopVpnTunnel_ != null) { + output.WriteRawTag(114); + output.WriteMessage(NextHopVpnTunnel); + } + if (nextHopRouterApplianceInstance_ != null) { + output.WriteRawTag(122); + output.WriteMessage(NextHopRouterApplianceInstance); + } + if (nextHopInterconnectAttachment_ != null) { + output.WriteRawTag(130, 1); + output.WriteMessage(NextHopInterconnectAttachment); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -3357,6 +3797,18 @@ public int CalculateSize() { if (Location.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Location); } + if (Priority != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Priority); + } + if (nextHopVpnTunnel_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NextHopVpnTunnel); + } + if (nextHopRouterApplianceInstance_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NextHopRouterApplianceInstance); + } + if (nextHopInterconnectAttachment_ != null) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(NextHopInterconnectAttachment); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -3412,6 +3864,27 @@ public void MergeFrom(Route other) { if (other.Location.Length != 0) { Location = other.Location; } + if (other.Priority != 0L) { + Priority = other.Priority; + } + if (other.nextHopVpnTunnel_ != null) { + if (nextHopVpnTunnel_ == null) { + NextHopVpnTunnel = new global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel(); + } + NextHopVpnTunnel.MergeFrom(other.NextHopVpnTunnel); + } + if (other.nextHopRouterApplianceInstance_ != null) { + if (nextHopRouterApplianceInstance_ == null) { + NextHopRouterApplianceInstance = new global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance(); + } + NextHopRouterApplianceInstance.MergeFrom(other.NextHopRouterApplianceInstance); + } + if (other.nextHopInterconnectAttachment_ != null) { + if (nextHopInterconnectAttachment_ == null) { + NextHopInterconnectAttachment = new global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment(); + } + NextHopInterconnectAttachment.MergeFrom(other.NextHopInterconnectAttachment); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -3484,6 +3957,31 @@ public void MergeFrom(pb::CodedInputStream input) { Location = input.ReadString(); break; } + case 104: { + Priority = input.ReadInt64(); + break; + } + case 114: { + if (nextHopVpnTunnel_ == null) { + NextHopVpnTunnel = new global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel(); + } + input.ReadMessage(NextHopVpnTunnel); + break; + } + case 122: { + if (nextHopRouterApplianceInstance_ == null) { + NextHopRouterApplianceInstance = new global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance(); + } + input.ReadMessage(NextHopRouterApplianceInstance); + break; + } + case 130: { + if (nextHopInterconnectAttachment_ == null) { + NextHopInterconnectAttachment = new global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment(); + } + input.ReadMessage(NextHopInterconnectAttachment); + break; + } } } #endif @@ -3556,6 +4054,31 @@ public void MergeFrom(pb::CodedInputStream input) { Location = input.ReadString(); break; } + case 104: { + Priority = input.ReadInt64(); + break; + } + case 114: { + if (nextHopVpnTunnel_ == null) { + NextHopVpnTunnel = new global::Google.Cloud.NetworkConnectivity.V1.NextHopVPNTunnel(); + } + input.ReadMessage(NextHopVpnTunnel); + break; + } + case 122: { + if (nextHopRouterApplianceInstance_ == null) { + NextHopRouterApplianceInstance = new global::Google.Cloud.NetworkConnectivity.V1.NextHopRouterApplianceInstance(); + } + input.ReadMessage(NextHopRouterApplianceInstance); + break; + } + case 130: { + if (nextHopInterconnectAttachment_ == null) { + NextHopInterconnectAttachment = new global::Google.Cloud.NetworkConnectivity.V1.NextHopInterconnectAttachment(); + } + input.ReadMessage(NextHopInterconnectAttachment); + break; + } } } } @@ -3608,6 +4131,8 @@ public Group(Group other) : this() { description_ = other.description_; uid_ = other.uid_; state_ = other.state_; + autoAccept_ = other.autoAccept_ != null ? other.autoAccept_.Clone() : null; + routeTable_ = other.routeTable_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -3728,6 +4253,38 @@ public string Uid { } } + /// Field number for the "auto_accept" field. + public const int AutoAcceptFieldNumber = 8; + private global::Google.Cloud.NetworkConnectivity.V1.AutoAccept autoAccept_; + /// + /// Optional. The auto-accept setting for this group. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.AutoAccept AutoAccept { + get { return autoAccept_; } + set { + autoAccept_ = value; + } + } + + /// Field number for the "route_table" field. + public const int RouteTableFieldNumber = 9; + private string routeTable_ = ""; + /// + /// Output only. The name of the route table that corresponds to this group. + /// They use the following form: + /// `projects/{project_number}/locations/global/hubs/{hub_id}/routeTables/{route_table_id}` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RouteTable { + get { return routeTable_; } + set { + routeTable_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -3750,6 +4307,8 @@ public bool Equals(Group other) { if (Description != other.Description) return false; if (Uid != other.Uid) return false; if (State != other.State) return false; + if (!object.Equals(AutoAccept, other.AutoAccept)) return false; + if (RouteTable != other.RouteTable) return false; return Equals(_unknownFields, other._unknownFields); } @@ -3764,6 +4323,8 @@ public override int GetHashCode() { if (Description.Length != 0) hash ^= Description.GetHashCode(); if (Uid.Length != 0) hash ^= Uid.GetHashCode(); if (State != global::Google.Cloud.NetworkConnectivity.V1.State.Unspecified) hash ^= State.GetHashCode(); + if (autoAccept_ != null) hash ^= AutoAccept.GetHashCode(); + if (RouteTable.Length != 0) hash ^= RouteTable.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -3807,6 +4368,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(56); output.WriteEnum((int) State); } + if (autoAccept_ != null) { + output.WriteRawTag(66); + output.WriteMessage(AutoAccept); + } + if (RouteTable.Length != 0) { + output.WriteRawTag(74); + output.WriteString(RouteTable); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -3842,6 +4411,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(56); output.WriteEnum((int) State); } + if (autoAccept_ != null) { + output.WriteRawTag(66); + output.WriteMessage(AutoAccept); + } + if (RouteTable.Length != 0) { + output.WriteRawTag(74); + output.WriteString(RouteTable); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -3871,6 +4448,12 @@ public int CalculateSize() { if (State != global::Google.Cloud.NetworkConnectivity.V1.State.Unspecified) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); } + if (autoAccept_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(AutoAccept); + } + if (RouteTable.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RouteTable); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -3908,6 +4491,15 @@ public void MergeFrom(Group other) { if (other.State != global::Google.Cloud.NetworkConnectivity.V1.State.Unspecified) { State = other.State; } + if (other.autoAccept_ != null) { + if (autoAccept_ == null) { + AutoAccept = new global::Google.Cloud.NetworkConnectivity.V1.AutoAccept(); + } + AutoAccept.MergeFrom(other.AutoAccept); + } + if (other.RouteTable.Length != 0) { + RouteTable = other.RouteTable; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -3957,6 +4549,17 @@ public void MergeFrom(pb::CodedInputStream input) { State = (global::Google.Cloud.NetworkConnectivity.V1.State) input.ReadEnum(); break; } + case 66: { + if (autoAccept_ == null) { + AutoAccept = new global::Google.Cloud.NetworkConnectivity.V1.AutoAccept(); + } + input.ReadMessage(AutoAccept); + break; + } + case 74: { + RouteTable = input.ReadString(); + break; + } } } #endif @@ -4006,6 +4609,17 @@ public void MergeFrom(pb::CodedInputStream input) { State = (global::Google.Cloud.NetworkConnectivity.V1.State) input.ReadEnum(); break; } + case 66: { + if (autoAccept_ == null) { + AutoAccept = new global::Google.Cloud.NetworkConnectivity.V1.AutoAccept(); + } + input.ReadMessage(AutoAccept); + break; + } + case 74: { + RouteTable = input.ReadString(); + break; + } } } } @@ -4014,21 +4628,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Request for - /// [HubService.ListHubs][google.cloud.networkconnectivity.v1.HubService.ListHubs] - /// method. + /// The auto-accept setting for a group controls whether + /// proposed spokes are automatically attached to the hub. If auto-accept is + /// enabled, the spoke immediately is attached to the hub and becomes part of the + /// group. In this case, the new spoke is in the ACTIVE state. + /// If auto-accept is disabled, the spoke goes to the INACTIVE + /// state, and it must be reviewed and accepted by a hub + /// administrator. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListHubsRequest : pb::IMessage + public sealed partial class AutoAccept : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListHubsRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AutoAccept()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -4044,7 +4662,7 @@ public sealed partial class ListHubsRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListHubsRequest() { + public AutoAccept() { OnConstruction(); } @@ -4052,56 +4670,245 @@ public ListHubsRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListHubsRequest(ListHubsRequest other) : this() { - parent_ = other.parent_; - pageSize_ = other.pageSize_; - pageToken_ = other.pageToken_; - filter_ = other.filter_; - orderBy_ = other.orderBy_; + public AutoAccept(AutoAccept other) : this() { + autoAcceptProjects_ = other.autoAcceptProjects_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListHubsRequest Clone() { - return new ListHubsRequest(this); + public AutoAccept Clone() { + return new AutoAccept(this); } - /// Field number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; + /// Field number for the "auto_accept_projects" field. + public const int AutoAcceptProjectsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_autoAcceptProjects_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField autoAcceptProjects_ = new pbc::RepeatedField(); /// - /// Required. The parent resource's name. + /// A list of project ids or project numbers for which you want + /// to enable auto-accept. The auto-accept setting is applied to + /// spokes being created or updated in these projects. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Parent { - get { return parent_; } - set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public pbc::RepeatedField AutoAcceptProjects { + get { return autoAcceptProjects_; } } - /// Field number for the "page_size" field. - public const int PageSizeFieldNumber = 2; - private int pageSize_; - /// - /// The maximum number of results per page to return. - /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public int PageSize { - get { return pageSize_; } - set { - pageSize_ = value; - } + public override bool Equals(object other) { + return Equals(other as AutoAccept); } - /// Field number for the "page_token" field. - public const int PageTokenFieldNumber = 3; - private string pageToken_ = ""; - /// - /// The page token. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AutoAccept other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!autoAcceptProjects_.Equals(other.autoAcceptProjects_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= autoAcceptProjects_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + autoAcceptProjects_.WriteTo(output, _repeated_autoAcceptProjects_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + autoAcceptProjects_.WriteTo(ref output, _repeated_autoAcceptProjects_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += autoAcceptProjects_.CalculateSize(_repeated_autoAcceptProjects_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AutoAccept other) { + if (other == null) { + return; + } + autoAcceptProjects_.Add(other.autoAcceptProjects_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + autoAcceptProjects_.AddEntriesFrom(input, _repeated_autoAcceptProjects_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + autoAcceptProjects_.AddEntriesFrom(ref input, _repeated_autoAcceptProjects_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Request for + /// [HubService.ListHubs][google.cloud.networkconnectivity.v1.HubService.ListHubs] + /// method. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ListHubsRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListHubsRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListHubsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListHubsRequest(ListHubsRequest other) : this() { + parent_ = other.parent_; + pageSize_ = other.pageSize_; + pageToken_ = other.pageToken_; + filter_ = other.filter_; + orderBy_ = other.orderBy_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListHubsRequest Clone() { + return new ListHubsRequest(this); + } + + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; + /// + /// Required. The parent resource's name. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; + /// + /// The maximum number of results per page to return. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int PageSize { + get { return pageSize_; } + set { + pageSize_ = value; + } + } + + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; + /// + /// The page token. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -4391,7 +5198,7 @@ public sealed partial class ListHubsResponse : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[7]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[8]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4649,7 +5456,7 @@ public sealed partial class GetHubRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[8]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[9]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4847,7 +5654,7 @@ public sealed partial class CreateHubRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[9]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[10]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5187,7 +5994,7 @@ public sealed partial class UpdateHubRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[10]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[11]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5499,7 +6306,7 @@ public sealed partial class DeleteHubRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[11]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[12]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5749,7 +6556,7 @@ public sealed partial class ListHubSpokesRequest : pb::IMessage /// The request for - /// [HubService.ListSpokes][google.cloud.networkconnectivity.v1.HubService.ListSpokes]. + /// [HubService.QueryHubStatus][google.cloud.networkconnectivity.v1.HubService.QueryHubStatus]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListSpokesRequest : pb::IMessage + public sealed partial class QueryHubStatusRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListSpokesRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new QueryHubStatusRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[14]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[15]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6484,7 +7291,7 @@ public sealed partial class ListSpokesRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListSpokesRequest() { + public QueryHubStatusRequest() { OnConstruction(); } @@ -6492,33 +7299,34 @@ public ListSpokesRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListSpokesRequest(ListSpokesRequest other) : this() { - parent_ = other.parent_; + public QueryHubStatusRequest(QueryHubStatusRequest other) : this() { + name_ = other.name_; pageSize_ = other.pageSize_; pageToken_ = other.pageToken_; filter_ = other.filter_; orderBy_ = other.orderBy_; + groupBy_ = other.groupBy_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListSpokesRequest Clone() { - return new ListSpokesRequest(this); + public QueryHubStatusRequest Clone() { + return new QueryHubStatusRequest(this); } - /// Field number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// Required. The parent resource. + /// Required. The name of the hub. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Parent { - get { return parent_; } + public string Name { + get { return name_; } set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } @@ -6526,7 +7334,7 @@ public string Parent { public const int PageSizeFieldNumber = 2; private int pageSize_; /// - /// The maximum number of results to return per page. + /// Optional. The maximum number of results to return per page. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -6541,7 +7349,7 @@ public int PageSize { public const int PageTokenFieldNumber = 3; private string pageToken_ = ""; /// - /// The page token. + /// Optional. The page token. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -6556,7 +7364,15 @@ public string PageToken { public const int FilterFieldNumber = 4; private string filter_ = ""; /// - /// An expression that filters the list of results. + /// Optional. An expression that filters the list of results. + /// The filter can be used to filter the results by the following fields: + /// * `psc_propagation_status.source_spoke` + /// * `psc_propagation_status.source_group` + /// * `psc_propagation_status.source_forwarding_rule` + /// * `psc_propagation_status.target_spoke` + /// * `psc_propagation_status.target_group` + /// * `psc_propagation_status.code` + /// * `psc_propagation_status.message` /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -6571,7 +7387,16 @@ public string Filter { public const int OrderByFieldNumber = 5; private string orderBy_ = ""; /// - /// Sort the results by a certain order. + /// Optional. Sort the results in ascending order by the specified fields. + /// A comma-separated list of any of these fields: + /// * `psc_propagation_status.source_spoke` + /// * `psc_propagation_status.source_group` + /// * `psc_propagation_status.source_forwarding_rule` + /// * `psc_propagation_status.target_spoke` + /// * `psc_propagation_status.target_group` + /// * `psc_propagation_status.code` + /// If `group_by` is set, the value of the `order_by` field must be the + /// same as or a subset of the `group_by` field. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -6582,26 +7407,49 @@ public string OrderBy { } } + /// Field number for the "group_by" field. + public const int GroupByFieldNumber = 6; + private string groupBy_ = ""; + /// + /// Optional. Aggregate the results by the specified fields. + /// A comma-separated list of any of these fields: + /// * `psc_propagation_status.source_spoke` + /// * `psc_propagation_status.source_group` + /// * `psc_propagation_status.source_forwarding_rule` + /// * `psc_propagation_status.target_spoke` + /// * `psc_propagation_status.target_group` + /// * `psc_propagation_status.code` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string GroupBy { + get { return groupBy_; } + set { + groupBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListSpokesRequest); + return Equals(other as QueryHubStatusRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListSpokesRequest other) { + public bool Equals(QueryHubStatusRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Parent != other.Parent) return false; + if (Name != other.Name) return false; if (PageSize != other.PageSize) return false; if (PageToken != other.PageToken) return false; if (Filter != other.Filter) return false; if (OrderBy != other.OrderBy) return false; + if (GroupBy != other.GroupBy) return false; return Equals(_unknownFields, other._unknownFields); } @@ -6609,11 +7457,12 @@ public bool Equals(ListSpokesRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); if (PageSize != 0) hash ^= PageSize.GetHashCode(); if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); if (Filter.Length != 0) hash ^= Filter.GetHashCode(); if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); + if (GroupBy.Length != 0) hash ^= GroupBy.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -6632,9 +7481,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Parent.Length != 0) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); + output.WriteString(Name); } if (PageSize != 0) { output.WriteRawTag(16); @@ -6652,6 +7501,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(42); output.WriteString(OrderBy); } + if (GroupBy.Length != 0) { + output.WriteRawTag(50); + output.WriteString(GroupBy); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -6662,9 +7515,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Parent.Length != 0) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); + output.WriteString(Name); } if (PageSize != 0) { output.WriteRawTag(16); @@ -6682,6 +7535,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(42); output.WriteString(OrderBy); } + if (GroupBy.Length != 0) { + output.WriteRawTag(50); + output.WriteString(GroupBy); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -6692,8 +7549,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Parent.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } if (PageSize != 0) { size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); @@ -6707,6 +7564,9 @@ public int CalculateSize() { if (OrderBy.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); } + if (GroupBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(GroupBy); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -6715,12 +7575,12 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListSpokesRequest other) { + public void MergeFrom(QueryHubStatusRequest other) { if (other == null) { return; } - if (other.Parent.Length != 0) { - Parent = other.Parent; + if (other.Name.Length != 0) { + Name = other.Name; } if (other.PageSize != 0) { PageSize = other.PageSize; @@ -6734,6 +7594,9 @@ public void MergeFrom(ListSpokesRequest other) { if (other.OrderBy.Length != 0) { OrderBy = other.OrderBy; } + if (other.GroupBy.Length != 0) { + GroupBy = other.GroupBy; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -6750,7 +7613,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Parent = input.ReadString(); + Name = input.ReadString(); break; } case 16: { @@ -6769,6 +7632,10 @@ public void MergeFrom(pb::CodedInputStream input) { OrderBy = input.ReadString(); break; } + case 50: { + GroupBy = input.ReadString(); + break; + } } } #endif @@ -6785,7 +7652,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Parent = input.ReadString(); + Name = input.ReadString(); break; } case 16: { @@ -6804,6 +7671,10 @@ public void MergeFrom(pb::CodedInputStream input) { OrderBy = input.ReadString(); break; } + case 50: { + GroupBy = input.ReadString(); + break; + } } } } @@ -6813,24 +7684,24 @@ public void MergeFrom(pb::CodedInputStream input) { /// /// The response for - /// [HubService.ListSpokes][google.cloud.networkconnectivity.v1.HubService.ListSpokes]. + /// [HubService.QueryHubStatus][google.cloud.networkconnectivity.v1.HubService.QueryHubStatus]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListSpokesResponse : pb::IMessage + public sealed partial class QueryHubStatusResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListSpokesResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new QueryHubStatusResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[15]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[16]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6841,7 +7712,7 @@ public sealed partial class ListSpokesResponse : pb::IMessageField number for the "spokes" field. - public const int SpokesFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_spokes_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.Spoke.Parser); - private readonly pbc::RepeatedField spokes_ = new pbc::RepeatedField(); + /// Field number for the "hub_status_entries" field. + public const int HubStatusEntriesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_hubStatusEntries_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.HubStatusEntry.Parser); + private readonly pbc::RepeatedField hubStatusEntries_ = new pbc::RepeatedField(); /// - /// The requested spokes. + /// The list of hub status. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Spokes { - get { return spokes_; } + public pbc::RepeatedField HubStatusEntries { + get { return hubStatusEntries_; } } /// Field number for the "next_page_token" field. @@ -6893,38 +7763,23 @@ public string NextPageToken { } } - /// Field number for the "unreachable" field. - public const int UnreachableFieldNumber = 3; - private static readonly pb::FieldCodec _repeated_unreachable_codec - = pb::FieldCodec.ForString(26); - private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); - /// - /// Locations that could not be reached. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Unreachable { - get { return unreachable_; } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListSpokesResponse); + return Equals(other as QueryHubStatusResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListSpokesResponse other) { + public bool Equals(QueryHubStatusResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!spokes_.Equals(other.spokes_)) return false; + if(!hubStatusEntries_.Equals(other.hubStatusEntries_)) return false; if (NextPageToken != other.NextPageToken) return false; - if(!unreachable_.Equals(other.unreachable_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -6932,9 +7787,8 @@ public bool Equals(ListSpokesResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= spokes_.GetHashCode(); + hash ^= hubStatusEntries_.GetHashCode(); if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); - hash ^= unreachable_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -6953,12 +7807,11 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - spokes_.WriteTo(output, _repeated_spokes_codec); + hubStatusEntries_.WriteTo(output, _repeated_hubStatusEntries_codec); if (NextPageToken.Length != 0) { output.WriteRawTag(18); output.WriteString(NextPageToken); } - unreachable_.WriteTo(output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -6969,12 +7822,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - spokes_.WriteTo(ref output, _repeated_spokes_codec); + hubStatusEntries_.WriteTo(ref output, _repeated_hubStatusEntries_codec); if (NextPageToken.Length != 0) { output.WriteRawTag(18); output.WriteString(NextPageToken); } - unreachable_.WriteTo(ref output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -6985,11 +7837,10 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += spokes_.CalculateSize(_repeated_spokes_codec); + size += hubStatusEntries_.CalculateSize(_repeated_hubStatusEntries_codec); if (NextPageToken.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); } - size += unreachable_.CalculateSize(_repeated_unreachable_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -6998,15 +7849,14 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListSpokesResponse other) { + public void MergeFrom(QueryHubStatusResponse other) { if (other == null) { return; } - spokes_.Add(other.spokes_); + hubStatusEntries_.Add(other.hubStatusEntries_); if (other.NextPageToken.Length != 0) { NextPageToken = other.NextPageToken; } - unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7023,17 +7873,13 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - spokes_.AddEntriesFrom(input, _repeated_spokes_codec); + hubStatusEntries_.AddEntriesFrom(input, _repeated_hubStatusEntries_codec); break; } case 18: { NextPageToken = input.ReadString(); break; } - case 26: { - unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); - break; - } } } #endif @@ -7050,17 +7896,13 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - spokes_.AddEntriesFrom(ref input, _repeated_spokes_codec); + hubStatusEntries_.AddEntriesFrom(ref input, _repeated_hubStatusEntries_codec); break; } case 18: { NextPageToken = input.ReadString(); break; } - case 26: { - unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); - break; - } } } } @@ -7069,25 +7911,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The request for - /// [HubService.GetSpoke][google.cloud.networkconnectivity.v1.HubService.GetSpoke]. + /// A hub status entry represents the status of a set of propagated Private + /// Service Connect connections grouped by certain fields. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class GetSpokeRequest : pb::IMessage + public sealed partial class HubStatusEntry : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetSpokeRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new HubStatusEntry()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[16]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[17]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7098,7 +7940,7 @@ public sealed partial class GetSpokeRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetSpokeRequest() { + public HubStatusEntry() { OnConstruction(); } @@ -7106,48 +7948,85 @@ public GetSpokeRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetSpokeRequest(GetSpokeRequest other) : this() { - name_ = other.name_; + public HubStatusEntry(HubStatusEntry other) : this() { + count_ = other.count_; + groupBy_ = other.groupBy_; + pscPropagationStatus_ = other.pscPropagationStatus_ != null ? other.pscPropagationStatus_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetSpokeRequest Clone() { - return new GetSpokeRequest(this); + public HubStatusEntry Clone() { + return new HubStatusEntry(this); } - /// Field number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "count" field. + public const int CountFieldNumber = 1; + private int count_; /// - /// Required. The name of the spoke resource. + /// The number of propagated Private Service Connect connections with this + /// status. If the `group_by` field was not set in the request message, the + /// value of this field is 1. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Name { - get { return name_; } + public int Count { + get { return count_; } set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + count_ = value; + } + } + + /// Field number for the "group_by" field. + public const int GroupByFieldNumber = 2; + private string groupBy_ = ""; + /// + /// The fields that this entry is grouped by. This has the same value as the + /// `group_by` field in the request message. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string GroupBy { + get { return groupBy_; } + set { + groupBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "psc_propagation_status" field. + public const int PscPropagationStatusFieldNumber = 3; + private global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus pscPropagationStatus_; + /// + /// The Private Service Connect propagation status. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus PscPropagationStatus { + get { return pscPropagationStatus_; } + set { + pscPropagationStatus_ = value; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as GetSpokeRequest); + return Equals(other as HubStatusEntry); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(GetSpokeRequest other) { + public bool Equals(HubStatusEntry other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; + if (Count != other.Count) return false; + if (GroupBy != other.GroupBy) return false; + if (!object.Equals(PscPropagationStatus, other.PscPropagationStatus)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7155,7 +8034,9 @@ public bool Equals(GetSpokeRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Count != 0) hash ^= Count.GetHashCode(); + if (GroupBy.Length != 0) hash ^= GroupBy.GetHashCode(); + if (pscPropagationStatus_ != null) hash ^= PscPropagationStatus.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7174,9 +8055,17 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Name); + if (Count != 0) { + output.WriteRawTag(8); + output.WriteInt32(Count); + } + if (GroupBy.Length != 0) { + output.WriteRawTag(18); + output.WriteString(GroupBy); + } + if (pscPropagationStatus_ != null) { + output.WriteRawTag(26); + output.WriteMessage(PscPropagationStatus); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -7188,9 +8077,17 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Name); + if (Count != 0) { + output.WriteRawTag(8); + output.WriteInt32(Count); + } + if (GroupBy.Length != 0) { + output.WriteRawTag(18); + output.WriteString(GroupBy); + } + if (pscPropagationStatus_ != null) { + output.WriteRawTag(26); + output.WriteMessage(PscPropagationStatus); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -7202,8 +8099,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + if (Count != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Count); + } + if (GroupBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(GroupBy); + } + if (pscPropagationStatus_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(PscPropagationStatus); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -7213,12 +8116,21 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(GetSpokeRequest other) { + public void MergeFrom(HubStatusEntry other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; + if (other.Count != 0) { + Count = other.Count; + } + if (other.GroupBy.Length != 0) { + GroupBy = other.GroupBy; + } + if (other.pscPropagationStatus_ != null) { + if (pscPropagationStatus_ == null) { + PscPropagationStatus = new global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus(); + } + PscPropagationStatus.MergeFrom(other.PscPropagationStatus); } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7235,8 +8147,19 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: { - Name = input.ReadString(); + case 8: { + Count = input.ReadInt32(); + break; + } + case 18: { + GroupBy = input.ReadString(); + break; + } + case 26: { + if (pscPropagationStatus_ == null) { + PscPropagationStatus = new global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus(); + } + input.ReadMessage(PscPropagationStatus); break; } } @@ -7254,8 +8177,19 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: { - Name = input.ReadString(); + case 8: { + Count = input.ReadInt32(); + break; + } + case 18: { + GroupBy = input.ReadString(); + break; + } + case 26: { + if (pscPropagationStatus_ == null) { + PscPropagationStatus = new global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus(); + } + input.ReadMessage(PscPropagationStatus); break; } } @@ -7266,25 +8200,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The request for - /// [HubService.CreateSpoke][google.cloud.networkconnectivity.v1.HubService.CreateSpoke]. + /// The status of one or more propagated Private Service Connect connections in a + /// hub. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class CreateSpokeRequest : pb::IMessage + public sealed partial class PscPropagationStatus : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateSpokeRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PscPropagationStatus()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[17]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[18]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7295,7 +8229,7 @@ public sealed partial class CreateSpokeRequest : pb::IMessageField number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; + /// Field number for the "source_spoke" field. + public const int SourceSpokeFieldNumber = 1; + private string sourceSpoke_ = ""; /// - /// Required. The parent resource. + /// The name of the spoke that the source forwarding rule belongs to. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Parent { - get { return parent_; } + public string SourceSpoke { + get { return sourceSpoke_; } set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + sourceSpoke_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "spoke_id" field. - public const int SpokeIdFieldNumber = 2; - private string spokeId_ = ""; + /// Field number for the "source_group" field. + public const int SourceGroupFieldNumber = 2; + private string sourceGroup_ = ""; /// - /// Required. Unique id for the spoke to create. + /// The name of the group that the source spoke belongs to. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string SpokeId { - get { return spokeId_; } + public string SourceGroup { + get { return sourceGroup_; } set { - spokeId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + sourceGroup_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "spoke" field. - public const int SpokeFieldNumber = 3; - private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; + /// Field number for the "source_forwarding_rule" field. + public const int SourceForwardingRuleFieldNumber = 3; + private string sourceForwardingRule_ = ""; /// - /// Required. The initial values for a new spoke. + /// The name of the forwarding rule exported to the hub. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::Google.Cloud.NetworkConnectivity.V1.Spoke Spoke { - get { return spoke_; } + public string SourceForwardingRule { + get { return sourceForwardingRule_; } set { - spoke_ = value; + sourceForwardingRule_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 4; - private string requestId_ = ""; + /// Field number for the "target_spoke" field. + public const int TargetSpokeFieldNumber = 4; + private string targetSpoke_ = ""; /// - /// Optional. A request ID to identify requests. Specify a unique request ID so - /// that if you must retry your request, the server knows to ignore the request - /// if it has already been completed. The server guarantees that a request - /// doesn't result in creation of duplicate commitments for at least 60 - /// minutes. - /// - /// For example, consider a situation where you make an initial request and - /// the request times out. If you make the request again with the same request - /// ID, the server can check to see whether the original operation - /// was received. If it was, the server ignores the second request. This - /// behavior prevents clients from mistakenly creating duplicate commitments. - /// - /// The request ID must be a valid UUID, with the exception that zero UUID is - /// not supported (00000000-0000-0000-0000-000000000000). + /// The name of the spoke that the source forwarding rule propagates to. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string RequestId { - get { return requestId_; } + public string TargetSpoke { + get { return targetSpoke_; } set { - requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + targetSpoke_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "target_group" field. + public const int TargetGroupFieldNumber = 5; + private string targetGroup_ = ""; + /// + /// The name of the group that the target spoke belongs to. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TargetGroup { + get { return targetGroup_; } + set { + targetGroup_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "code" field. + public const int CodeFieldNumber = 6; + private global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code code_ = global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code.Unspecified; + /// + /// The propagation status. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code Code { + get { return code_; } + set { + code_ = value; + } + } + + /// Field number for the "message" field. + public const int MessageFieldNumber = 7; + private string message_ = ""; + /// + /// The human-readable summary of the Private Service Connect connection + /// propagation status. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Message { + get { return message_; } + set { + message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as CreateSpokeRequest); + return Equals(other as PscPropagationStatus); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(CreateSpokeRequest other) { + public bool Equals(PscPropagationStatus other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Parent != other.Parent) return false; - if (SpokeId != other.SpokeId) return false; - if (!object.Equals(Spoke, other.Spoke)) return false; - if (RequestId != other.RequestId) return false; + if (SourceSpoke != other.SourceSpoke) return false; + if (SourceGroup != other.SourceGroup) return false; + if (SourceForwardingRule != other.SourceForwardingRule) return false; + if (TargetSpoke != other.TargetSpoke) return false; + if (TargetGroup != other.TargetGroup) return false; + if (Code != other.Code) return false; + if (Message != other.Message) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7416,10 +8389,13 @@ public bool Equals(CreateSpokeRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Parent.Length != 0) hash ^= Parent.GetHashCode(); - if (SpokeId.Length != 0) hash ^= SpokeId.GetHashCode(); - if (spoke_ != null) hash ^= Spoke.GetHashCode(); - if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (SourceSpoke.Length != 0) hash ^= SourceSpoke.GetHashCode(); + if (SourceGroup.Length != 0) hash ^= SourceGroup.GetHashCode(); + if (SourceForwardingRule.Length != 0) hash ^= SourceForwardingRule.GetHashCode(); + if (TargetSpoke.Length != 0) hash ^= TargetSpoke.GetHashCode(); + if (TargetGroup.Length != 0) hash ^= TargetGroup.GetHashCode(); + if (Code != global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code.Unspecified) hash ^= Code.GetHashCode(); + if (Message.Length != 0) hash ^= Message.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7438,21 +8414,33 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Parent.Length != 0) { + if (SourceSpoke.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); + output.WriteString(SourceSpoke); } - if (SpokeId.Length != 0) { + if (SourceGroup.Length != 0) { output.WriteRawTag(18); - output.WriteString(SpokeId); + output.WriteString(SourceGroup); } - if (spoke_ != null) { + if (SourceForwardingRule.Length != 0) { output.WriteRawTag(26); - output.WriteMessage(Spoke); + output.WriteString(SourceForwardingRule); } - if (RequestId.Length != 0) { + if (TargetSpoke.Length != 0) { output.WriteRawTag(34); - output.WriteString(RequestId); + output.WriteString(TargetSpoke); + } + if (TargetGroup.Length != 0) { + output.WriteRawTag(42); + output.WriteString(TargetGroup); + } + if (Code != global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code.Unspecified) { + output.WriteRawTag(48); + output.WriteEnum((int) Code); + } + if (Message.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Message); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -7464,21 +8452,33 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Parent.Length != 0) { + if (SourceSpoke.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); + output.WriteString(SourceSpoke); } - if (SpokeId.Length != 0) { + if (SourceGroup.Length != 0) { output.WriteRawTag(18); - output.WriteString(SpokeId); + output.WriteString(SourceGroup); } - if (spoke_ != null) { + if (SourceForwardingRule.Length != 0) { output.WriteRawTag(26); - output.WriteMessage(Spoke); + output.WriteString(SourceForwardingRule); } - if (RequestId.Length != 0) { + if (TargetSpoke.Length != 0) { output.WriteRawTag(34); - output.WriteString(RequestId); + output.WriteString(TargetSpoke); + } + if (TargetGroup.Length != 0) { + output.WriteRawTag(42); + output.WriteString(TargetGroup); + } + if (Code != global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code.Unspecified) { + output.WriteRawTag(48); + output.WriteEnum((int) Code); + } + if (Message.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Message); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -7490,17 +8490,26 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Parent.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + if (SourceSpoke.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceSpoke); } - if (SpokeId.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(SpokeId); + if (SourceGroup.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceGroup); } - if (spoke_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); + if (SourceForwardingRule.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceForwardingRule); } - if (RequestId.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + if (TargetSpoke.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TargetSpoke); + } + if (TargetGroup.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TargetGroup); + } + if (Code != global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Code); + } + if (Message.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Message); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -7510,24 +8519,30 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(CreateSpokeRequest other) { + public void MergeFrom(PscPropagationStatus other) { if (other == null) { return; } - if (other.Parent.Length != 0) { - Parent = other.Parent; + if (other.SourceSpoke.Length != 0) { + SourceSpoke = other.SourceSpoke; } - if (other.SpokeId.Length != 0) { - SpokeId = other.SpokeId; + if (other.SourceGroup.Length != 0) { + SourceGroup = other.SourceGroup; } - if (other.spoke_ != null) { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - Spoke.MergeFrom(other.Spoke); + if (other.SourceForwardingRule.Length != 0) { + SourceForwardingRule = other.SourceForwardingRule; } - if (other.RequestId.Length != 0) { - RequestId = other.RequestId; + if (other.TargetSpoke.Length != 0) { + TargetSpoke = other.TargetSpoke; + } + if (other.TargetGroup.Length != 0) { + TargetGroup = other.TargetGroup; + } + if (other.Code != global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code.Unspecified) { + Code = other.Code; + } + if (other.Message.Length != 0) { + Message = other.Message; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7545,22 +8560,31 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Parent = input.ReadString(); + SourceSpoke = input.ReadString(); break; } case 18: { - SpokeId = input.ReadString(); + SourceGroup = input.ReadString(); break; } case 26: { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - input.ReadMessage(Spoke); + SourceForwardingRule = input.ReadString(); break; } case 34: { - RequestId = input.ReadString(); + TargetSpoke = input.ReadString(); + break; + } + case 42: { + TargetGroup = input.ReadString(); + break; + } + case 48: { + Code = (global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code) input.ReadEnum(); + break; + } + case 58: { + Message = input.ReadString(); break; } } @@ -7579,22 +8603,31 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Parent = input.ReadString(); + SourceSpoke = input.ReadString(); break; } case 18: { - SpokeId = input.ReadString(); + SourceGroup = input.ReadString(); break; } case 26: { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - input.ReadMessage(Spoke); + SourceForwardingRule = input.ReadString(); break; } case 34: { - RequestId = input.ReadString(); + TargetSpoke = input.ReadString(); + break; + } + case 42: { + TargetGroup = input.ReadString(); + break; + } + case 48: { + Code = (global::Google.Cloud.NetworkConnectivity.V1.PscPropagationStatus.Types.Code) input.ReadEnum(); + break; + } + case 58: { + Message = input.ReadString(); break; } } @@ -7602,29 +8635,81 @@ public void MergeFrom(pb::CodedInputStream input) { } #endif + #region Nested types + /// Container for nested types declared in the PscPropagationStatus message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// The Code enum represents the state of the Private Service Connect + /// propagation. + /// + public enum Code { + /// + /// The code is unspecified. + /// + [pbr::OriginalName("CODE_UNSPECIFIED")] Unspecified = 0, + /// + /// The propagated Private Service Connect connection is ready. + /// + [pbr::OriginalName("READY")] Ready = 1, + /// + /// The Private Service Connect connection is propagating. This is a + /// transient state. + /// + [pbr::OriginalName("PROPAGATING")] Propagating = 2, + /// + /// The Private Service Connect connection propagation failed because the VPC + /// network or the project of the target spoke has exceeded the connection + /// limit set by the producer. + /// + [pbr::OriginalName("ERROR_PRODUCER_PROPAGATED_CONNECTION_LIMIT_EXCEEDED")] ErrorProducerPropagatedConnectionLimitExceeded = 3, + /// + /// The Private Service Connect connection propagation failed because the NAT + /// IP subnet space has been exhausted. It is equivalent to the `Needs + /// attention` status of the Private Service Connect connection. See + /// https://cloud.google.com/vpc/docs/about-accessing-vpc-hosted-services-endpoints#connection-statuses. + /// + [pbr::OriginalName("ERROR_PRODUCER_NAT_IP_SPACE_EXHAUSTED")] ErrorProducerNatIpSpaceExhausted = 4, + /// + /// The Private Service Connect connection propagation failed because the + /// `PSC_ILB_CONSUMER_FORWARDING_RULES_PER_PRODUCER_NETWORK` quota in the + /// producer VPC network has been exceeded. + /// + [pbr::OriginalName("ERROR_PRODUCER_QUOTA_EXCEEDED")] ErrorProducerQuotaExceeded = 5, + /// + /// The Private Service Connect connection propagation failed because the + /// `PSC_PROPAGATED_CONNECTIONS_PER_VPC_NETWORK` quota in the consumer + /// VPC network has been exceeded. + /// + [pbr::OriginalName("ERROR_CONSUMER_QUOTA_EXCEEDED")] ErrorConsumerQuotaExceeded = 6, + } + + } + #endregion + } /// - /// Request for - /// [HubService.UpdateSpoke][google.cloud.networkconnectivity.v1.HubService.UpdateSpoke] - /// method. + /// The request for + /// [HubService.ListSpokes][google.cloud.networkconnectivity.v1.HubService.ListSpokes]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class UpdateSpokeRequest : pb::IMessage + public sealed partial class ListSpokesRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateSpokeRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListSpokesRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[18]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[19]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7635,7 +8720,7 @@ public sealed partial class UpdateSpokeRequest : pb::IMessageField number for the "update_mask" field. - public const int UpdateMaskFieldNumber = 1; - private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; /// - /// Optional. In the case of an update to an existing spoke, field mask is used - /// to specify the fields to be overwritten. The fields specified in the - /// update_mask are relative to the resource, not the full request. A field is - /// overwritten if it is in the mask. If the user does not provide a mask, then - /// all fields are overwritten. + /// Required. The parent resource. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { - get { return updateMask_; } + public string Parent { + get { return parent_; } set { - updateMask_ = value; + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "spoke" field. - public const int SpokeFieldNumber = 2; - private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; /// - /// Required. The state that the spoke should be in after the update. + /// The maximum number of results to return per page. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::Google.Cloud.NetworkConnectivity.V1.Spoke Spoke { - get { return spoke_; } + public int PageSize { + get { return pageSize_; } set { - spoke_ = value; + pageSize_ = value; } } - /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 3; - private string requestId_ = ""; + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; /// - /// Optional. A request ID to identify requests. Specify a unique request ID so - /// that if you must retry your request, the server knows to ignore the request - /// if it has already been completed. The server guarantees that a request - /// doesn't result in creation of duplicate commitments for at least 60 - /// minutes. - /// - /// For example, consider a situation where you make an initial request and - /// the request times out. If you make the request again with the same request - /// ID, the server can check to see whether the original operation - /// was received. If it was, the server ignores the second request. This - /// behavior prevents clients from mistakenly creating duplicate commitments. - /// - /// The request ID must be a valid UUID, with the exception that zero UUID is - /// not supported (00000000-0000-0000-0000-000000000000). + /// The page token. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string RequestId { - get { return requestId_; } + public string PageToken { + get { return pageToken_; } set { - requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 4; + private string filter_ = ""; + /// + /// An expression that filters the list of results. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Filter { + get { return filter_; } + set { + filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "order_by" field. + public const int OrderByFieldNumber = 5; + private string orderBy_ = ""; + /// + /// Sort the results by a certain order. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OrderBy { + get { return orderBy_; } + set { + orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as UpdateSpokeRequest); + return Equals(other as ListSpokesRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(UpdateSpokeRequest other) { + public bool Equals(ListSpokesRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(UpdateMask, other.UpdateMask)) return false; - if (!object.Equals(Spoke, other.Spoke)) return false; - if (RequestId != other.RequestId) return false; + if (Parent != other.Parent) return false; + if (PageSize != other.PageSize) return false; + if (PageToken != other.PageToken) return false; + if (Filter != other.Filter) return false; + if (OrderBy != other.OrderBy) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7743,9 +8845,11 @@ public bool Equals(UpdateSpokeRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); - if (spoke_ != null) hash ^= Spoke.GetHashCode(); - if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); + if (Filter.Length != 0) hash ^= Filter.GetHashCode(); + if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7764,17 +8868,25 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (updateMask_ != null) { + if (Parent.Length != 0) { output.WriteRawTag(10); - output.WriteMessage(UpdateMask); + output.WriteString(Parent); } - if (spoke_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Spoke); + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); } - if (RequestId.Length != 0) { + if (PageToken.Length != 0) { output.WriteRawTag(26); - output.WriteString(RequestId); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -7786,17 +8898,25 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (updateMask_ != null) { + if (Parent.Length != 0) { output.WriteRawTag(10); - output.WriteMessage(UpdateMask); + output.WriteString(Parent); } - if (spoke_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Spoke); + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); } - if (RequestId.Length != 0) { + if (PageToken.Length != 0) { output.WriteRawTag(26); - output.WriteString(RequestId); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -7808,14 +8928,20 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (updateMask_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateMask); + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); } - if (spoke_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); } - if (RequestId.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + if (PageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); + } + if (Filter.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Filter); + } + if (OrderBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -7825,24 +8951,24 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(UpdateSpokeRequest other) { + public void MergeFrom(ListSpokesRequest other) { if (other == null) { return; } - if (other.updateMask_ != null) { - if (updateMask_ == null) { - UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); - } - UpdateMask.MergeFrom(other.UpdateMask); + if (other.Parent.Length != 0) { + Parent = other.Parent; } - if (other.spoke_ != null) { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - Spoke.MergeFrom(other.Spoke); + if (other.PageSize != 0) { + PageSize = other.PageSize; } - if (other.RequestId.Length != 0) { - RequestId = other.RequestId; + if (other.PageToken.Length != 0) { + PageToken = other.PageToken; + } + if (other.Filter.Length != 0) { + Filter = other.Filter; + } + if (other.OrderBy.Length != 0) { + OrderBy = other.OrderBy; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7860,21 +8986,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - if (updateMask_ == null) { - UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); - } - input.ReadMessage(UpdateMask); + Parent = input.ReadString(); break; } - case 18: { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - input.ReadMessage(Spoke); + case 16: { + PageSize = input.ReadInt32(); break; } case 26: { - RequestId = input.ReadString(); + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); break; } } @@ -7893,21 +9021,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - if (updateMask_ == null) { - UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); - } - input.ReadMessage(UpdateMask); + Parent = input.ReadString(); break; } - case 18: { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - input.ReadMessage(Spoke); + case 16: { + PageSize = input.ReadInt32(); break; } case 26: { - RequestId = input.ReadString(); + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); break; } } @@ -7918,25 +9048,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The request for - /// [HubService.DeleteSpoke][google.cloud.networkconnectivity.v1.HubService.DeleteSpoke]. + /// The response for + /// [HubService.ListSpokes][google.cloud.networkconnectivity.v1.HubService.ListSpokes]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class DeleteSpokeRequest : pb::IMessage + public sealed partial class ListSpokesResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeleteSpokeRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListSpokesResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[19]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[20]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7947,7 +9077,7 @@ public sealed partial class DeleteSpokeRequest : pb::IMessageField number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "spokes" field. + public const int SpokesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_spokes_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.Spoke.Parser); + private readonly pbc::RepeatedField spokes_ = new pbc::RepeatedField(); /// - /// Required. The name of the spoke to delete. + /// The requested spokes. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Name { - get { return name_; } - set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public pbc::RepeatedField Spokes { + get { return spokes_; } } - /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 2; - private string requestId_ = ""; + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; /// - /// Optional. A request ID to identify requests. Specify a unique request ID so - /// that if you must retry your request, the server knows to ignore the request - /// if it has already been completed. The server guarantees that a request - /// doesn't result in creation of duplicate commitments for at least 60 - /// minutes. - /// - /// For example, consider a situation where you make an initial request and - /// the request times out. If you make the request again with the same request - /// ID, the server can check to see whether the original operation - /// was received. If it was, the server ignores the second request. This - /// behavior prevents clients from mistakenly creating duplicate commitments. - /// - /// The request ID must be a valid UUID, with the exception that zero UUID is - /// not supported (00000000-0000-0000-0000-000000000000). + /// The token for the next page of the response. To see more results, + /// use this value as the page_token for your next request. If this value + /// is empty, there are no more results. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string RequestId { - get { return requestId_; } + public string NextPageToken { + get { return nextPageToken_; } set { - requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } + /// Field number for the "unreachable" field. + public const int UnreachableFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_unreachable_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); + /// + /// Locations that could not be reached. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Unreachable { + get { return unreachable_; } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as DeleteSpokeRequest); + return Equals(other as ListSpokesResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(DeleteSpokeRequest other) { + public bool Equals(ListSpokesResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; - if (RequestId != other.RequestId) return false; + if(!spokes_.Equals(other.spokes_)) return false; + if (NextPageToken != other.NextPageToken) return false; + if(!unreachable_.Equals(other.unreachable_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8034,8 +9168,9 @@ public bool Equals(DeleteSpokeRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); - if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + hash ^= spokes_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + hash ^= unreachable_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8054,14 +9189,12 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Name); - } - if (RequestId.Length != 0) { + spokes_.WriteTo(output, _repeated_spokes_codec); + if (NextPageToken.Length != 0) { output.WriteRawTag(18); - output.WriteString(RequestId); + output.WriteString(NextPageToken); } + unreachable_.WriteTo(output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8072,14 +9205,12 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Name); - } - if (RequestId.Length != 0) { + spokes_.WriteTo(ref output, _repeated_spokes_codec); + if (NextPageToken.Length != 0) { output.WriteRawTag(18); - output.WriteString(RequestId); + output.WriteString(NextPageToken); } + unreachable_.WriteTo(ref output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8090,12 +9221,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); - } - if (RequestId.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + size += spokes_.CalculateSize(_repeated_spokes_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); } + size += unreachable_.CalculateSize(_repeated_unreachable_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8104,16 +9234,15 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(DeleteSpokeRequest other) { + public void MergeFrom(ListSpokesResponse other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; - } - if (other.RequestId.Length != 0) { - RequestId = other.RequestId; + spokes_.Add(other.spokes_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; } + unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8130,11 +9259,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Name = input.ReadString(); + spokes_.AddEntriesFrom(input, _repeated_spokes_codec); break; } case 18: { - RequestId = input.ReadString(); + NextPageToken = input.ReadString(); + break; + } + case 26: { + unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); break; } } @@ -8153,11 +9286,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Name = input.ReadString(); + spokes_.AddEntriesFrom(ref input, _repeated_spokes_codec); break; } case 18: { - RequestId = input.ReadString(); + NextPageToken = input.ReadString(); + break; + } + case 26: { + unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); break; } } @@ -8169,24 +9306,24 @@ public void MergeFrom(pb::CodedInputStream input) { /// /// The request for - /// [HubService.AcceptHubSpoke][google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke]. + /// [HubService.GetSpoke][google.cloud.networkconnectivity.v1.HubService.GetSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AcceptHubSpokeRequest : pb::IMessage + public sealed partial class GetSpokeRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AcceptHubSpokeRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetSpokeRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[20]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[21]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8197,7 +9334,7 @@ public sealed partial class AcceptHubSpokeRequest : pb::IMessageField number for the "name" field. public const int NameFieldNumber = 1; private string name_ = ""; /// - /// Required. The name of the hub into which to accept the spoke. + /// Required. The name of the spoke resource. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -8233,58 +9368,15 @@ public string Name { } } - /// Field number for the "spoke_uri" field. - public const int SpokeUriFieldNumber = 2; - private string spokeUri_ = ""; - /// - /// Required. The URI of the spoke to accept into the hub. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string SpokeUri { - get { return spokeUri_; } - set { - spokeUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - /// Field number for the "request_id" field. - public const int RequestIdFieldNumber = 3; - private string requestId_ = ""; - /// - /// Optional. A request ID to identify requests. Specify a unique request ID so - /// that if you must retry your request, the server knows to ignore the request - /// if it has already been completed. The server guarantees that a request - /// doesn't result in creation of duplicate commitments for at least 60 - /// minutes. - /// - /// For example, consider a situation where you make an initial request and - /// the request times out. If you make the request again with the same request - /// ID, the server can check to see whether the original operation - /// was received. If it was, the server ignores the second request. This - /// behavior prevents clients from mistakenly creating duplicate commitments. - /// - /// The request ID must be a valid UUID, with the exception that zero UUID is - /// not supported (00000000-0000-0000-0000-000000000000). - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string RequestId { - get { return requestId_; } - set { - requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AcceptHubSpokeRequest); + return Equals(other as GetSpokeRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AcceptHubSpokeRequest other) { + public bool Equals(GetSpokeRequest other) { if (ReferenceEquals(other, null)) { return false; } @@ -8292,8 +9384,6 @@ public bool Equals(AcceptHubSpokeRequest other) { return true; } if (Name != other.Name) return false; - if (SpokeUri != other.SpokeUri) return false; - if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8302,8 +9392,6 @@ public bool Equals(AcceptHubSpokeRequest other) { public override int GetHashCode() { int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); - if (SpokeUri.Length != 0) hash ^= SpokeUri.GetHashCode(); - if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8326,14 +9414,6 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(Name); } - if (SpokeUri.Length != 0) { - output.WriteRawTag(18); - output.WriteString(SpokeUri); - } - if (RequestId.Length != 0) { - output.WriteRawTag(26); - output.WriteString(RequestId); - } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8348,14 +9428,6 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(Name); } - if (SpokeUri.Length != 0) { - output.WriteRawTag(18); - output.WriteString(SpokeUri); - } - if (RequestId.Length != 0) { - output.WriteRawTag(26); - output.WriteString(RequestId); - } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8369,12 +9441,6 @@ public int CalculateSize() { if (Name.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } - if (SpokeUri.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(SpokeUri); - } - if (RequestId.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); - } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8383,19 +9449,13 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AcceptHubSpokeRequest other) { + public void MergeFrom(GetSpokeRequest other) { if (other == null) { return; } if (other.Name.Length != 0) { Name = other.Name; } - if (other.SpokeUri.Length != 0) { - SpokeUri = other.SpokeUri; - } - if (other.RequestId.Length != 0) { - RequestId = other.RequestId; - } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8415,14 +9475,6 @@ public void MergeFrom(pb::CodedInputStream input) { Name = input.ReadString(); break; } - case 18: { - SpokeUri = input.ReadString(); - break; - } - case 26: { - RequestId = input.ReadString(); - break; - } } } #endif @@ -8442,14 +9494,6 @@ public void MergeFrom(pb::CodedInputStream input) { Name = input.ReadString(); break; } - case 18: { - SpokeUri = input.ReadString(); - break; - } - case 26: { - RequestId = input.ReadString(); - break; - } } } } @@ -8458,25 +9502,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The response for - /// [HubService.AcceptHubSpoke][google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke]. + /// The request for + /// [HubService.CreateSpoke][google.cloud.networkconnectivity.v1.HubService.CreateSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AcceptHubSpokeResponse : pb::IMessage + public sealed partial class CreateSpokeRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AcceptHubSpokeResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateSpokeRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[21]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[22]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8487,7 +9531,7 @@ public sealed partial class AcceptHubSpokeResponse : pb::IMessageField number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; + /// + /// Required. The parent resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "spoke_id" field. + public const int SpokeIdFieldNumber = 2; + private string spokeId_ = ""; + /// + /// Required. Unique id for the spoke to create. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SpokeId { + get { return spokeId_; } + set { + spokeId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } } /// Field number for the "spoke" field. - public const int SpokeFieldNumber = 1; + public const int SpokeFieldNumber = 3; private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; /// - /// The spoke that was operated on. + /// Required. The initial values for a new spoke. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -8521,22 +9598,53 @@ public AcceptHubSpokeResponse Clone() { } } + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 4; + private string requestId_ = ""; + /// + /// Optional. A request ID to identify requests. Specify a unique request ID so + /// that if you must retry your request, the server knows to ignore the request + /// if it has already been completed. The server guarantees that a request + /// doesn't result in creation of duplicate commitments for at least 60 + /// minutes. + /// + /// For example, consider a situation where you make an initial request and + /// the request times out. If you make the request again with the same request + /// ID, the server can check to see whether the original operation + /// was received. If it was, the server ignores the second request. This + /// behavior prevents clients from mistakenly creating duplicate commitments. + /// + /// The request ID must be a valid UUID, with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AcceptHubSpokeResponse); + return Equals(other as CreateSpokeRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AcceptHubSpokeResponse other) { + public bool Equals(CreateSpokeRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } + if (Parent != other.Parent) return false; + if (SpokeId != other.SpokeId) return false; if (!object.Equals(Spoke, other.Spoke)) return false; + if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8544,7 +9652,10 @@ public bool Equals(AcceptHubSpokeResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (SpokeId.Length != 0) hash ^= SpokeId.GetHashCode(); if (spoke_ != null) hash ^= Spoke.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8563,10 +9674,22 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (spoke_ != null) { + if (Parent.Length != 0) { output.WriteRawTag(10); + output.WriteString(Parent); + } + if (SpokeId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpokeId); + } + if (spoke_ != null) { + output.WriteRawTag(26); output.WriteMessage(Spoke); } + if (RequestId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(RequestId); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8577,10 +9700,22 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (spoke_ != null) { + if (Parent.Length != 0) { output.WriteRawTag(10); + output.WriteString(Parent); + } + if (SpokeId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpokeId); + } + if (spoke_ != null) { + output.WriteRawTag(26); output.WriteMessage(Spoke); } + if (RequestId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(RequestId); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8591,9 +9726,18 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + } + if (SpokeId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SpokeId); + } if (spoke_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8602,16 +9746,25 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AcceptHubSpokeResponse other) { + public void MergeFrom(CreateSpokeRequest other) { if (other == null) { return; } + if (other.Parent.Length != 0) { + Parent = other.Parent; + } + if (other.SpokeId.Length != 0) { + SpokeId = other.SpokeId; + } if (other.spoke_ != null) { if (spoke_ == null) { Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); } Spoke.MergeFrom(other.Spoke); } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8628,12 +9781,24 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { + Parent = input.ReadString(); + break; + } + case 18: { + SpokeId = input.ReadString(); + break; + } + case 26: { if (spoke_ == null) { Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); } input.ReadMessage(Spoke); break; } + case 34: { + RequestId = input.ReadString(); + break; + } } } #endif @@ -8650,12 +9815,24 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { + Parent = input.ReadString(); + break; + } + case 18: { + SpokeId = input.ReadString(); + break; + } + case 26: { if (spoke_ == null) { Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); } input.ReadMessage(Spoke); break; } + case 34: { + RequestId = input.ReadString(); + break; + } } } } @@ -8664,25 +9841,26 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The request for - /// [HubService.RejectHubSpoke][google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke]. + /// Request for + /// [HubService.UpdateSpoke][google.cloud.networkconnectivity.v1.HubService.UpdateSpoke] + /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class RejectHubSpokeRequest : pb::IMessage + public sealed partial class UpdateSpokeRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RejectHubSpokeRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateSpokeRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[22]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[23]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8693,7 +9871,7 @@ public sealed partial class RejectHubSpokeRequest : pb::IMessageField number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "update_mask" field. + public const int UpdateMaskFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; /// - /// Required. The name of the hub from which to reject the spoke. + /// Optional. In the case of an update to an existing spoke, field mask is used + /// to specify the fields to be overwritten. The fields specified in the + /// update_mask are relative to the resource, not the full request. A field is + /// overwritten if it is in the mask. If the user does not provide a mask, then + /// all fields are overwritten. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Name { - get { return name_; } + public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { + get { return updateMask_; } set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + updateMask_ = value; } } - /// Field number for the "spoke_uri" field. - public const int SpokeUriFieldNumber = 2; - private string spokeUri_ = ""; + /// Field number for the "spoke" field. + public const int SpokeFieldNumber = 2; + private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; /// - /// Required. The URI of the spoke to reject from the hub. + /// Required. The state that the spoke should be in after the update. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string SpokeUri { - get { return spokeUri_; } + public global::Google.Cloud.NetworkConnectivity.V1.Spoke Spoke { + get { return spoke_; } set { - spokeUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + spoke_ = value; } } @@ -8773,40 +9954,24 @@ public string RequestId { } } - /// Field number for the "details" field. - public const int DetailsFieldNumber = 4; - private string details_ = ""; - /// - /// Optional. Additional information provided by the hub administrator. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Details { - get { return details_; } - set { - details_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as RejectHubSpokeRequest); + return Equals(other as UpdateSpokeRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(RejectHubSpokeRequest other) { + public bool Equals(UpdateSpokeRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; - if (SpokeUri != other.SpokeUri) return false; + if (!object.Equals(UpdateMask, other.UpdateMask)) return false; + if (!object.Equals(Spoke, other.Spoke)) return false; if (RequestId != other.RequestId) return false; - if (Details != other.Details) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8814,10 +9979,9 @@ public bool Equals(RejectHubSpokeRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); - if (SpokeUri.Length != 0) hash ^= SpokeUri.GetHashCode(); + if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); + if (spoke_ != null) hash ^= Spoke.GetHashCode(); if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); - if (Details.Length != 0) hash ^= Details.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8836,22 +10000,18 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { + if (updateMask_ != null) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteMessage(UpdateMask); } - if (SpokeUri.Length != 0) { + if (spoke_ != null) { output.WriteRawTag(18); - output.WriteString(SpokeUri); + output.WriteMessage(Spoke); } if (RequestId.Length != 0) { output.WriteRawTag(26); output.WriteString(RequestId); } - if (Details.Length != 0) { - output.WriteRawTag(34); - output.WriteString(Details); - } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8862,22 +10022,18 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { + if (updateMask_ != null) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteMessage(UpdateMask); } - if (SpokeUri.Length != 0) { + if (spoke_ != null) { output.WriteRawTag(18); - output.WriteString(SpokeUri); + output.WriteMessage(Spoke); } if (RequestId.Length != 0) { output.WriteRawTag(26); output.WriteString(RequestId); } - if (Details.Length != 0) { - output.WriteRawTag(34); - output.WriteString(Details); - } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8888,18 +10044,15 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + if (updateMask_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateMask); } - if (SpokeUri.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(SpokeUri); + if (spoke_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); } if (RequestId.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); } - if (Details.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Details); - } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8908,22 +10061,25 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(RejectHubSpokeRequest other) { + public void MergeFrom(UpdateSpokeRequest other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; + if (other.updateMask_ != null) { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + UpdateMask.MergeFrom(other.UpdateMask); } - if (other.SpokeUri.Length != 0) { - SpokeUri = other.SpokeUri; + if (other.spoke_ != null) { + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + Spoke.MergeFrom(other.Spoke); } if (other.RequestId.Length != 0) { RequestId = other.RequestId; } - if (other.Details.Length != 0) { - Details = other.Details; - } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8940,21 +10096,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Name = input.ReadString(); + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); break; } case 18: { - SpokeUri = input.ReadString(); + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + input.ReadMessage(Spoke); break; } case 26: { RequestId = input.ReadString(); break; } - case 34: { - Details = input.ReadString(); - break; - } } } #endif @@ -8971,21 +10129,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Name = input.ReadString(); + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); break; } case 18: { - SpokeUri = input.ReadString(); + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + input.ReadMessage(Spoke); break; } case 26: { RequestId = input.ReadString(); break; } - case 34: { - Details = input.ReadString(); - break; - } } } } @@ -8994,25 +10154,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The response for - /// [HubService.RejectHubSpoke][google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke]. + /// The request for + /// [HubService.DeleteSpoke][google.cloud.networkconnectivity.v1.HubService.DeleteSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class RejectHubSpokeResponse : pb::IMessage + public sealed partial class DeleteSpokeRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RejectHubSpokeResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeleteSpokeRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[23]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[24]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9023,7 +10183,7 @@ public sealed partial class RejectHubSpokeResponse : pb::IMessageField number for the "spoke" field. - public const int SpokeFieldNumber = 1; - private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// The spoke that was operated on. + /// Required. The name of the spoke to delete. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::Google.Cloud.NetworkConnectivity.V1.Spoke Spoke { - get { return spoke_; } + public string Name { + get { return name_; } set { - spoke_ = value; + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 2; + private string requestId_ = ""; + /// + /// Optional. A request ID to identify requests. Specify a unique request ID so + /// that if you must retry your request, the server knows to ignore the request + /// if it has already been completed. The server guarantees that a request + /// doesn't result in creation of duplicate commitments for at least 60 + /// minutes. + /// + /// For example, consider a situation where you make an initial request and + /// the request times out. If you make the request again with the same request + /// ID, the server can check to see whether the original operation + /// was received. If it was, the server ignores the second request. This + /// behavior prevents clients from mistakenly creating duplicate commitments. + /// + /// The request ID must be a valid UUID, with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as RejectHubSpokeResponse); + return Equals(other as DeleteSpokeRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(RejectHubSpokeResponse other) { + public bool Equals(DeleteSpokeRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Spoke, other.Spoke)) return false; + if (Name != other.Name) return false; + if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } @@ -9080,7 +10270,8 @@ public bool Equals(RejectHubSpokeResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (spoke_ != null) hash ^= Spoke.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -9099,9 +10290,13 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (spoke_ != null) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteMessage(Spoke); + output.WriteString(Name); + } + if (RequestId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(RequestId); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -9113,9 +10308,13 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (spoke_ != null) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteMessage(Spoke); + output.WriteString(Name); + } + if (RequestId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(RequestId); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -9127,8 +10326,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (spoke_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -9138,15 +10340,15 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(RejectHubSpokeResponse other) { + public void MergeFrom(DeleteSpokeRequest other) { if (other == null) { return; } - if (other.spoke_ != null) { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - Spoke.MergeFrom(other.Spoke); + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9164,10 +10366,11 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - input.ReadMessage(Spoke); + Name = input.ReadString(); + break; + } + case 18: { + RequestId = input.ReadString(); break; } } @@ -9186,10 +10389,11 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - if (spoke_ == null) { - Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); - } - input.ReadMessage(Spoke); + Name = input.ReadString(); + break; + } + case 18: { + RequestId = input.ReadString(); break; } } @@ -9201,24 +10405,24 @@ public void MergeFrom(pb::CodedInputStream input) { /// /// The request for - /// [HubService.GetRouteTable][google.cloud.networkconnectivity.v1.HubService.GetRouteTable]. + /// [HubService.AcceptHubSpoke][google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class GetRouteTableRequest : pb::IMessage + public sealed partial class AcceptHubSpokeRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetRouteTableRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AcceptHubSpokeRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[24]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[25]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9229,7 +10433,7 @@ public sealed partial class GetRouteTableRequest : pb::IMessageField number for the "name" field. public const int NameFieldNumber = 1; private string name_ = ""; /// - /// Required. The name of the route table resource. + /// Required. The name of the hub into which to accept the spoke. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -9263,15 +10469,58 @@ public string Name { } } + /// Field number for the "spoke_uri" field. + public const int SpokeUriFieldNumber = 2; + private string spokeUri_ = ""; + /// + /// Required. The URI of the spoke to accept into the hub. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SpokeUri { + get { return spokeUri_; } + set { + spokeUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 3; + private string requestId_ = ""; + /// + /// Optional. A request ID to identify requests. Specify a unique request ID so + /// that if you must retry your request, the server knows to ignore the request + /// if it has already been completed. The server guarantees that a request + /// doesn't result in creation of duplicate commitments for at least 60 + /// minutes. + /// + /// For example, consider a situation where you make an initial request and + /// the request times out. If you make the request again with the same request + /// ID, the server can check to see whether the original operation + /// was received. If it was, the server ignores the second request. This + /// behavior prevents clients from mistakenly creating duplicate commitments. + /// + /// The request ID must be a valid UUID, with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as GetRouteTableRequest); + return Equals(other as AcceptHubSpokeRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(GetRouteTableRequest other) { + public bool Equals(AcceptHubSpokeRequest other) { if (ReferenceEquals(other, null)) { return false; } @@ -9279,6 +10528,8 @@ public bool Equals(GetRouteTableRequest other) { return true; } if (Name != other.Name) return false; + if (SpokeUri != other.SpokeUri) return false; + if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } @@ -9287,6 +10538,8 @@ public bool Equals(GetRouteTableRequest other) { public override int GetHashCode() { int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (SpokeUri.Length != 0) hash ^= SpokeUri.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -9309,6 +10562,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(Name); } + if (SpokeUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpokeUri); + } + if (RequestId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RequestId); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -9323,6 +10584,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(Name); } + if (SpokeUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpokeUri); + } + if (RequestId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RequestId); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -9336,6 +10605,12 @@ public int CalculateSize() { if (Name.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } + if (SpokeUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SpokeUri); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -9344,13 +10619,19 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(GetRouteTableRequest other) { + public void MergeFrom(AcceptHubSpokeRequest other) { if (other == null) { return; } if (other.Name.Length != 0) { Name = other.Name; } + if (other.SpokeUri.Length != 0) { + SpokeUri = other.SpokeUri; + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9370,6 +10651,14 @@ public void MergeFrom(pb::CodedInputStream input) { Name = input.ReadString(); break; } + case 18: { + SpokeUri = input.ReadString(); + break; + } + case 26: { + RequestId = input.ReadString(); + break; + } } } #endif @@ -9389,6 +10678,14 @@ public void MergeFrom(pb::CodedInputStream input) { Name = input.ReadString(); break; } + case 18: { + SpokeUri = input.ReadString(); + break; + } + case 26: { + RequestId = input.ReadString(); + break; + } } } } @@ -9397,25 +10694,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// The request for - /// [HubService.GetRoute][google.cloud.networkconnectivity.v1.HubService.GetRoute]. + /// The response for + /// [HubService.AcceptHubSpoke][google.cloud.networkconnectivity.v1.HubService.AcceptHubSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class GetRouteRequest : pb::IMessage + public sealed partial class AcceptHubSpokeResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetRouteRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AcceptHubSpokeResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[25]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[26]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9426,7 +10723,7 @@ public sealed partial class GetRouteRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetRouteRequest() { + public AcceptHubSpokeResponse() { OnConstruction(); } @@ -9434,48 +10731,48 @@ public GetRouteRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetRouteRequest(GetRouteRequest other) : this() { - name_ = other.name_; + public AcceptHubSpokeResponse(AcceptHubSpokeResponse other) : this() { + spoke_ = other.spoke_ != null ? other.spoke_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetRouteRequest Clone() { - return new GetRouteRequest(this); + public AcceptHubSpokeResponse Clone() { + return new AcceptHubSpokeResponse(this); } - /// Field number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "spoke" field. + public const int SpokeFieldNumber = 1; + private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; /// - /// Required. The name of the route resource. + /// The spoke that was operated on. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Name { - get { return name_; } + public global::Google.Cloud.NetworkConnectivity.V1.Spoke Spoke { + get { return spoke_; } set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + spoke_ = value; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as GetRouteRequest); + return Equals(other as AcceptHubSpokeResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(GetRouteRequest other) { + public bool Equals(AcceptHubSpokeResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; + if (!object.Equals(Spoke, other.Spoke)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -9483,7 +10780,7 @@ public bool Equals(GetRouteRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (spoke_ != null) hash ^= Spoke.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -9502,9 +10799,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { + if (spoke_ != null) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteMessage(Spoke); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -9516,9 +10813,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { + if (spoke_ != null) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteMessage(Spoke); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -9530,8 +10827,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + if (spoke_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -9541,12 +10838,15 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(GetRouteRequest other) { + public void MergeFrom(AcceptHubSpokeResponse other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; + if (other.spoke_ != null) { + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + Spoke.MergeFrom(other.Spoke); } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9564,7 +10864,10 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Name = input.ReadString(); + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + input.ReadMessage(Spoke); break; } } @@ -9583,7 +10886,10 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Name = input.ReadString(); + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + input.ReadMessage(Spoke); break; } } @@ -9594,26 +10900,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Request for - /// [HubService.ListRoutes][google.cloud.networkconnectivity.v1.HubService.ListRoutes] - /// method. + /// The request for + /// [HubService.RejectHubSpoke][google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListRoutesRequest : pb::IMessage + public sealed partial class RejectHubSpokeRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRoutesRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RejectHubSpokeRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[26]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[27]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9624,7 +10929,7 @@ public sealed partial class ListRoutesRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListRoutesRequest() { + public RejectHubSpokeRequest() { OnConstruction(); } @@ -9632,116 +10937,112 @@ public ListRoutesRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListRoutesRequest(ListRoutesRequest other) : this() { - parent_ = other.parent_; - pageSize_ = other.pageSize_; - pageToken_ = other.pageToken_; - filter_ = other.filter_; - orderBy_ = other.orderBy_; + public RejectHubSpokeRequest(RejectHubSpokeRequest other) : this() { + name_ = other.name_; + spokeUri_ = other.spokeUri_; + requestId_ = other.requestId_; + details_ = other.details_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListRoutesRequest Clone() { - return new ListRoutesRequest(this); - } - - /// Field number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; - /// - /// Required. The parent resource's name. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Parent { - get { return parent_; } - set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public RejectHubSpokeRequest Clone() { + return new RejectHubSpokeRequest(this); } - /// Field number for the "page_size" field. - public const int PageSizeFieldNumber = 2; - private int pageSize_; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// The maximum number of results to return per page. + /// Required. The name of the hub from which to reject the spoke. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public int PageSize { - get { return pageSize_; } + public string Name { + get { return name_; } set { - pageSize_ = value; + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "page_token" field. - public const int PageTokenFieldNumber = 3; - private string pageToken_ = ""; + /// Field number for the "spoke_uri" field. + public const int SpokeUriFieldNumber = 2; + private string spokeUri_ = ""; /// - /// The page token. + /// Required. The URI of the spoke to reject from the hub. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string PageToken { - get { return pageToken_; } + public string SpokeUri { + get { return spokeUri_; } set { - pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + spokeUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "filter" field. - public const int FilterFieldNumber = 4; - private string filter_ = ""; + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 3; + private string requestId_ = ""; /// - /// An expression that filters the list of results. + /// Optional. A request ID to identify requests. Specify a unique request ID so + /// that if you must retry your request, the server knows to ignore the request + /// if it has already been completed. The server guarantees that a request + /// doesn't result in creation of duplicate commitments for at least 60 + /// minutes. + /// + /// For example, consider a situation where you make an initial request and + /// the request times out. If you make the request again with the same request + /// ID, the server can check to see whether the original operation + /// was received. If it was, the server ignores the second request. This + /// behavior prevents clients from mistakenly creating duplicate commitments. + /// + /// The request ID must be a valid UUID, with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Filter { - get { return filter_; } + public string RequestId { + get { return requestId_; } set { - filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "order_by" field. - public const int OrderByFieldNumber = 5; - private string orderBy_ = ""; + /// Field number for the "details" field. + public const int DetailsFieldNumber = 4; + private string details_ = ""; /// - /// Sort the results by a certain order. + /// Optional. Additional information provided by the hub administrator. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string OrderBy { - get { return orderBy_; } + public string Details { + get { return details_; } set { - orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + details_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListRoutesRequest); + return Equals(other as RejectHubSpokeRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListRoutesRequest other) { + public bool Equals(RejectHubSpokeRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Parent != other.Parent) return false; - if (PageSize != other.PageSize) return false; - if (PageToken != other.PageToken) return false; - if (Filter != other.Filter) return false; - if (OrderBy != other.OrderBy) return false; + if (Name != other.Name) return false; + if (SpokeUri != other.SpokeUri) return false; + if (RequestId != other.RequestId) return false; + if (Details != other.Details) return false; return Equals(_unknownFields, other._unknownFields); } @@ -9749,11 +11050,10 @@ public bool Equals(ListRoutesRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Parent.Length != 0) hash ^= Parent.GetHashCode(); - if (PageSize != 0) hash ^= PageSize.GetHashCode(); - if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); - if (Filter.Length != 0) hash ^= Filter.GetHashCode(); - if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (SpokeUri.Length != 0) hash ^= SpokeUri.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); + if (Details.Length != 0) hash ^= Details.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -9772,25 +11072,21 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Parent.Length != 0) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); + output.WriteString(Name); } - if (PageSize != 0) { - output.WriteRawTag(16); - output.WriteInt32(PageSize); + if (SpokeUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpokeUri); } - if (PageToken.Length != 0) { + if (RequestId.Length != 0) { output.WriteRawTag(26); - output.WriteString(PageToken); + output.WriteString(RequestId); } - if (Filter.Length != 0) { + if (Details.Length != 0) { output.WriteRawTag(34); - output.WriteString(Filter); - } - if (OrderBy.Length != 0) { - output.WriteRawTag(42); - output.WriteString(OrderBy); + output.WriteString(Details); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -9802,25 +11098,21 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Parent.Length != 0) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); + output.WriteString(Name); } - if (PageSize != 0) { - output.WriteRawTag(16); - output.WriteInt32(PageSize); + if (SpokeUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpokeUri); } - if (PageToken.Length != 0) { + if (RequestId.Length != 0) { output.WriteRawTag(26); - output.WriteString(PageToken); + output.WriteString(RequestId); } - if (Filter.Length != 0) { + if (Details.Length != 0) { output.WriteRawTag(34); - output.WriteString(Filter); - } - if (OrderBy.Length != 0) { - output.WriteRawTag(42); - output.WriteString(OrderBy); + output.WriteString(Details); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -9832,20 +11124,17 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Parent.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); - } - if (PageSize != 0) { - size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } - if (PageToken.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); + if (SpokeUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SpokeUri); } - if (Filter.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Filter); + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); } - if (OrderBy.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); + if (Details.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Details); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -9855,24 +11144,21 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListRoutesRequest other) { + public void MergeFrom(RejectHubSpokeRequest other) { if (other == null) { return; } - if (other.Parent.Length != 0) { - Parent = other.Parent; - } - if (other.PageSize != 0) { - PageSize = other.PageSize; + if (other.Name.Length != 0) { + Name = other.Name; } - if (other.PageToken.Length != 0) { - PageToken = other.PageToken; + if (other.SpokeUri.Length != 0) { + SpokeUri = other.SpokeUri; } - if (other.Filter.Length != 0) { - Filter = other.Filter; + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; } - if (other.OrderBy.Length != 0) { - OrderBy = other.OrderBy; + if (other.Details.Length != 0) { + Details = other.Details; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9890,23 +11176,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Parent = input.ReadString(); + Name = input.ReadString(); break; } - case 16: { - PageSize = input.ReadInt32(); + case 18: { + SpokeUri = input.ReadString(); break; } case 26: { - PageToken = input.ReadString(); + RequestId = input.ReadString(); break; } case 34: { - Filter = input.ReadString(); - break; - } - case 42: { - OrderBy = input.ReadString(); + Details = input.ReadString(); break; } } @@ -9925,23 +11207,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Parent = input.ReadString(); + Name = input.ReadString(); break; } - case 16: { - PageSize = input.ReadInt32(); + case 18: { + SpokeUri = input.ReadString(); break; } case 26: { - PageToken = input.ReadString(); + RequestId = input.ReadString(); break; } case 34: { - Filter = input.ReadString(); - break; - } - case 42: { - OrderBy = input.ReadString(); + Details = input.ReadString(); break; } } @@ -9952,26 +11230,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Response for - /// [HubService.ListRoutes][google.cloud.networkconnectivity.v1.HubService.ListRoutes] - /// method. + /// The response for + /// [HubService.RejectHubSpoke][google.cloud.networkconnectivity.v1.HubService.RejectHubSpoke]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListRoutesResponse : pb::IMessage + public sealed partial class RejectHubSpokeResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRoutesResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RejectHubSpokeResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[27]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[28]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9982,7 +11259,7 @@ public sealed partial class ListRoutesResponse : pb::IMessageField number for the "routes" field. - public const int RoutesFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_routes_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.Route.Parser); - private readonly pbc::RepeatedField routes_ = new pbc::RepeatedField(); - /// - /// The requested routes. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Routes { - get { return routes_; } + public RejectHubSpokeResponse Clone() { + return new RejectHubSpokeResponse(this); } - /// Field number for the "next_page_token" field. - public const int NextPageTokenFieldNumber = 2; - private string nextPageToken_ = ""; + /// Field number for the "spoke" field. + public const int SpokeFieldNumber = 1; + private global::Google.Cloud.NetworkConnectivity.V1.Spoke spoke_; /// - /// The token for the next page of the response. To see more results, - /// use this value as the page_token for your next request. If this value - /// is empty, there are no more results. + /// The spoke that was operated on. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string NextPageToken { - get { return nextPageToken_; } + public global::Google.Cloud.NetworkConnectivity.V1.Spoke Spoke { + get { return spoke_; } set { - nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + spoke_ = value; } } - /// Field number for the "unreachable" field. - public const int UnreachableFieldNumber = 3; - private static readonly pb::FieldCodec _repeated_unreachable_codec - = pb::FieldCodec.ForString(26); - private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); - /// - /// RouteTables that could not be reached. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Unreachable { - get { return unreachable_; } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListRoutesResponse); + return Equals(other as RejectHubSpokeResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListRoutesResponse other) { + public bool Equals(RejectHubSpokeResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!routes_.Equals(other.routes_)) return false; - if (NextPageToken != other.NextPageToken) return false; - if(!unreachable_.Equals(other.unreachable_)) return false; + if (!object.Equals(Spoke, other.Spoke)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -10073,9 +11316,7 @@ public bool Equals(ListRoutesResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= routes_.GetHashCode(); - if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); - hash ^= unreachable_.GetHashCode(); + if (spoke_ != null) hash ^= Spoke.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -10094,12 +11335,10 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - routes_.WriteTo(output, _repeated_routes_codec); - if (NextPageToken.Length != 0) { - output.WriteRawTag(18); - output.WriteString(NextPageToken); + if (spoke_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Spoke); } - unreachable_.WriteTo(output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -10110,12 +11349,10 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - routes_.WriteTo(ref output, _repeated_routes_codec); - if (NextPageToken.Length != 0) { - output.WriteRawTag(18); - output.WriteString(NextPageToken); + if (spoke_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Spoke); } - unreachable_.WriteTo(ref output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -10126,11 +11363,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += routes_.CalculateSize(_repeated_routes_codec); - if (NextPageToken.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); + if (spoke_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Spoke); } - size += unreachable_.CalculateSize(_repeated_unreachable_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -10139,15 +11374,16 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListRoutesResponse other) { + public void MergeFrom(RejectHubSpokeResponse other) { if (other == null) { return; } - routes_.Add(other.routes_); - if (other.NextPageToken.Length != 0) { - NextPageToken = other.NextPageToken; + if (other.spoke_ != null) { + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + Spoke.MergeFrom(other.Spoke); } - unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -10164,15 +11400,10 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - routes_.AddEntriesFrom(input, _repeated_routes_codec); - break; - } - case 18: { - NextPageToken = input.ReadString(); - break; - } - case 26: { - unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + input.ReadMessage(Spoke); break; } } @@ -10191,15 +11422,10 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - routes_.AddEntriesFrom(ref input, _repeated_routes_codec); - break; - } - case 18: { - NextPageToken = input.ReadString(); - break; - } - case 26: { - unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); + if (spoke_ == null) { + Spoke = new global::Google.Cloud.NetworkConnectivity.V1.Spoke(); + } + input.ReadMessage(Spoke); break; } } @@ -10210,26 +11436,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Request for - /// [HubService.ListRouteTables][google.cloud.networkconnectivity.v1.HubService.ListRouteTables] - /// method. + /// The request for + /// [HubService.GetRouteTable][google.cloud.networkconnectivity.v1.HubService.GetRouteTable]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListRouteTablesRequest : pb::IMessage + public sealed partial class GetRouteTableRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRouteTablesRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetRouteTableRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[28]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[29]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10240,7 +11465,7 @@ public sealed partial class ListRouteTablesRequest : pb::IMessageField number for the "parent" field. - public const int ParentFieldNumber = 1; - private string parent_ = ""; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// Required. The parent resource's name. + /// Required. The name of the route table resource. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Parent { - get { return parent_; } + public string Name { + get { return name_; } set { - parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "page_size" field. - public const int PageSizeFieldNumber = 2; - private int pageSize_; - /// - /// The maximum number of results to return per page. - /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public int PageSize { - get { return pageSize_; } - set { - pageSize_ = value; - } + public override bool Equals(object other) { + return Equals(other as GetRouteTableRequest); } - /// Field number for the "page_token" field. - public const int PageTokenFieldNumber = 3; - private string pageToken_ = ""; - /// - /// The page token. - /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string PageToken { - get { return pageToken_; } - set { - pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + public bool Equals(GetRouteTableRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; } + if (Name != other.Name) return false; + return Equals(_unknownFields, other._unknownFields); } - /// Field number for the "filter" field. - public const int FilterFieldNumber = 4; - private string filter_ = ""; - /// - /// An expression that filters the list of results. - /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Filter { - get { return filter_; } - set { - filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); } - } - - /// Field number for the "order_by" field. - public const int OrderByFieldNumber = 5; - private string orderBy_ = ""; - /// - /// Sort the results by a certain order. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string OrderBy { - get { return orderBy_; } - set { - orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public override bool Equals(object other) { - return Equals(other as ListRouteTablesRequest); - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListRouteTablesRequest other) { - if (ReferenceEquals(other, null)) { - return false; - } - if (ReferenceEquals(other, this)) { - return true; - } - if (Parent != other.Parent) return false; - if (PageSize != other.PageSize) return false; - if (PageToken != other.PageToken) return false; - if (Filter != other.Filter) return false; - if (OrderBy != other.OrderBy) return false; - return Equals(_unknownFields, other._unknownFields); - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public override int GetHashCode() { - int hash = 1; - if (Parent.Length != 0) hash ^= Parent.GetHashCode(); - if (PageSize != 0) hash ^= PageSize.GetHashCode(); - if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); - if (Filter.Length != 0) hash ^= Filter.GetHashCode(); - if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); - if (_unknownFields != null) { - hash ^= _unknownFields.GetHashCode(); - } - return hash; + return hash; } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10388,25 +11541,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Parent.Length != 0) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); - } - if (PageSize != 0) { - output.WriteRawTag(16); - output.WriteInt32(PageSize); - } - if (PageToken.Length != 0) { - output.WriteRawTag(26); - output.WriteString(PageToken); - } - if (Filter.Length != 0) { - output.WriteRawTag(34); - output.WriteString(Filter); - } - if (OrderBy.Length != 0) { - output.WriteRawTag(42); - output.WriteString(OrderBy); + output.WriteString(Name); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -10418,25 +11555,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Parent.Length != 0) { + if (Name.Length != 0) { output.WriteRawTag(10); - output.WriteString(Parent); - } - if (PageSize != 0) { - output.WriteRawTag(16); - output.WriteInt32(PageSize); - } - if (PageToken.Length != 0) { - output.WriteRawTag(26); - output.WriteString(PageToken); - } - if (Filter.Length != 0) { - output.WriteRawTag(34); - output.WriteString(Filter); - } - if (OrderBy.Length != 0) { - output.WriteRawTag(42); - output.WriteString(OrderBy); + output.WriteString(Name); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -10448,20 +11569,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Parent.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); - } - if (PageSize != 0) { - size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); - } - if (PageToken.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); - } - if (Filter.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Filter); - } - if (OrderBy.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -10471,24 +11580,12 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListRouteTablesRequest other) { + public void MergeFrom(GetRouteTableRequest other) { if (other == null) { return; } - if (other.Parent.Length != 0) { - Parent = other.Parent; - } - if (other.PageSize != 0) { - PageSize = other.PageSize; - } - if (other.PageToken.Length != 0) { - PageToken = other.PageToken; - } - if (other.Filter.Length != 0) { - Filter = other.Filter; - } - if (other.OrderBy.Length != 0) { - OrderBy = other.OrderBy; + if (other.Name.Length != 0) { + Name = other.Name; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -10506,23 +11603,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Parent = input.ReadString(); - break; - } - case 16: { - PageSize = input.ReadInt32(); - break; - } - case 26: { - PageToken = input.ReadString(); - break; - } - case 34: { - Filter = input.ReadString(); - break; - } - case 42: { - OrderBy = input.ReadString(); + Name = input.ReadString(); break; } } @@ -10541,23 +11622,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Parent = input.ReadString(); - break; - } - case 16: { - PageSize = input.ReadInt32(); - break; - } - case 26: { - PageToken = input.ReadString(); - break; - } - case 34: { - Filter = input.ReadString(); - break; - } - case 42: { - OrderBy = input.ReadString(); + Name = input.ReadString(); break; } } @@ -10568,26 +11633,25 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Response for - /// [HubService.ListRouteTables][google.cloud.networkconnectivity.v1.HubService.ListRouteTables] - /// method. + /// The request for + /// [HubService.GetRoute][google.cloud.networkconnectivity.v1.HubService.GetRoute]. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListRouteTablesResponse : pb::IMessage + public sealed partial class GetRouteRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRouteTablesResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetRouteRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[29]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[30]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10598,7 +11662,7 @@ public sealed partial class ListRouteTablesResponse : pb::IMessageField number for the "route_tables" field. - public const int RouteTablesFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_routeTables_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.RouteTable.Parser); - private readonly pbc::RepeatedField routeTables_ = new pbc::RepeatedField(); - /// - /// The requested route tables. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField RouteTables { - get { return routeTables_; } + public GetRouteRequest Clone() { + return new GetRouteRequest(this); } - /// Field number for the "next_page_token" field. - public const int NextPageTokenFieldNumber = 2; - private string nextPageToken_ = ""; + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; /// - /// The token for the next page of the response. To see more results, - /// use this value as the page_token for your next request. If this value - /// is empty, there are no more results. + /// Required. The name of the route resource. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string NextPageToken { - get { return nextPageToken_; } + public string Name { + get { return name_; } set { - nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "unreachable" field. - public const int UnreachableFieldNumber = 3; - private static readonly pb::FieldCodec _repeated_unreachable_codec - = pb::FieldCodec.ForString(26); - private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); - /// - /// Hubs that could not be reached. - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Unreachable { - get { return unreachable_; } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListRouteTablesResponse); + return Equals(other as GetRouteRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListRouteTablesResponse other) { + public bool Equals(GetRouteRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!routeTables_.Equals(other.routeTables_)) return false; - if (NextPageToken != other.NextPageToken) return false; - if(!unreachable_.Equals(other.unreachable_)) return false; + if (Name != other.Name) return false; return Equals(_unknownFields, other._unknownFields); } @@ -10689,9 +11719,7 @@ public bool Equals(ListRouteTablesResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= routeTables_.GetHashCode(); - if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); - hash ^= unreachable_.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -10710,12 +11738,10 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - routeTables_.WriteTo(output, _repeated_routeTables_codec); - if (NextPageToken.Length != 0) { - output.WriteRawTag(18); - output.WriteString(NextPageToken); + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); } - unreachable_.WriteTo(output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -10726,12 +11752,10 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - routeTables_.WriteTo(ref output, _repeated_routeTables_codec); - if (NextPageToken.Length != 0) { - output.WriteRawTag(18); - output.WriteString(NextPageToken); + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); } - unreachable_.WriteTo(ref output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -10742,11 +11766,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += routeTables_.CalculateSize(_repeated_routeTables_codec); - if (NextPageToken.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); } - size += unreachable_.CalculateSize(_repeated_unreachable_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -10755,15 +11777,13 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListRouteTablesResponse other) { + public void MergeFrom(GetRouteRequest other) { if (other == null) { return; } - routeTables_.Add(other.routeTables_); - if (other.NextPageToken.Length != 0) { - NextPageToken = other.NextPageToken; + if (other.Name.Length != 0) { + Name = other.Name; } - unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -10780,15 +11800,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - routeTables_.AddEntriesFrom(input, _repeated_routeTables_codec); - break; - } - case 18: { - NextPageToken = input.ReadString(); - break; - } - case 26: { - unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); + Name = input.ReadString(); break; } } @@ -10807,15 +11819,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - routeTables_.AddEntriesFrom(ref input, _repeated_routeTables_codec); - break; - } - case 18: { - NextPageToken = input.ReadString(); - break; - } - case 26: { - unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); + Name = input.ReadString(); break; } } @@ -10827,25 +11831,25 @@ public void MergeFrom(pb::CodedInputStream input) { /// /// Request for - /// [HubService.ListGroups][google.cloud.networkconnectivity.v1.HubService.ListGroups] + /// [HubService.ListRoutes][google.cloud.networkconnectivity.v1.HubService.ListRoutes] /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListGroupsRequest : pb::IMessage + public sealed partial class ListRoutesRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListGroupsRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRoutesRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[30]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[31]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10856,7 +11860,7 @@ public sealed partial class ListGroupsRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListGroupsRequest() { + public ListRoutesRequest() { OnConstruction(); } @@ -10864,7 +11868,7 @@ public ListGroupsRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListGroupsRequest(ListGroupsRequest other) : this() { + public ListRoutesRequest(ListRoutesRequest other) : this() { parent_ = other.parent_; pageSize_ = other.pageSize_; pageToken_ = other.pageToken_; @@ -10875,8 +11879,8 @@ public ListGroupsRequest(ListGroupsRequest other) : this() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ListGroupsRequest Clone() { - return new ListGroupsRequest(this); + public ListRoutesRequest Clone() { + return new ListRoutesRequest(this); } /// Field number for the "parent" field. @@ -10957,12 +11961,12 @@ public string OrderBy { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListGroupsRequest); + return Equals(other as ListRoutesRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListGroupsRequest other) { + public bool Equals(ListRoutesRequest other) { if (ReferenceEquals(other, null)) { return false; } @@ -11087,7 +12091,7 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListGroupsRequest other) { + public void MergeFrom(ListRoutesRequest other) { if (other == null) { return; } @@ -11185,25 +12189,25 @@ public void MergeFrom(pb::CodedInputStream input) { /// /// Response for - /// [HubService.ListGroups][google.cloud.networkconnectivity.v1.HubService.ListGroups] + /// [HubService.ListRoutes][google.cloud.networkconnectivity.v1.HubService.ListRoutes] /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class ListGroupsResponse : pb::IMessage + public sealed partial class ListRoutesResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListGroupsResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRoutesResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[31]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[32]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11214,7 +12218,7 @@ public sealed partial class ListGroupsResponse : pb::IMessageField number for the "groups" field. - public const int GroupsFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_groups_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.Group.Parser); - private readonly pbc::RepeatedField groups_ = new pbc::RepeatedField(); + /// Field number for the "routes" field. + public const int RoutesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_routes_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.Route.Parser); + private readonly pbc::RepeatedField routes_ = new pbc::RepeatedField(); /// - /// The requested groups. + /// The requested routes. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Groups { - get { return groups_; } + public pbc::RepeatedField Routes { + get { return routes_; } } /// Field number for the "next_page_token" field. @@ -11272,7 +12276,7 @@ public string NextPageToken { = pb::FieldCodec.ForString(26); private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); /// - /// Hubs that could not be reached. + /// RouteTables that could not be reached. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -11283,19 +12287,19 @@ public string NextPageToken { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as ListGroupsResponse); + return Equals(other as ListRoutesResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(ListGroupsResponse other) { + public bool Equals(ListRoutesResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!groups_.Equals(other.groups_)) return false; + if(!routes_.Equals(other.routes_)) return false; if (NextPageToken != other.NextPageToken) return false; if(!unreachable_.Equals(other.unreachable_)) return false; return Equals(_unknownFields, other._unknownFields); @@ -11305,7 +12309,7 @@ public bool Equals(ListGroupsResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= groups_.GetHashCode(); + hash ^= routes_.GetHashCode(); if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); hash ^= unreachable_.GetHashCode(); if (_unknownFields != null) { @@ -11326,7 +12330,7 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - groups_.WriteTo(output, _repeated_groups_codec); + routes_.WriteTo(output, _repeated_routes_codec); if (NextPageToken.Length != 0) { output.WriteRawTag(18); output.WriteString(NextPageToken); @@ -11342,7 +12346,7 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - groups_.WriteTo(ref output, _repeated_groups_codec); + routes_.WriteTo(ref output, _repeated_routes_codec); if (NextPageToken.Length != 0) { output.WriteRawTag(18); output.WriteString(NextPageToken); @@ -11358,7 +12362,7 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += groups_.CalculateSize(_repeated_groups_codec); + size += routes_.CalculateSize(_repeated_routes_codec); if (NextPageToken.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); } @@ -11371,11 +12375,11 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(ListGroupsResponse other) { + public void MergeFrom(ListRoutesResponse other) { if (other == null) { return; } - groups_.Add(other.groups_); + routes_.Add(other.routes_); if (other.NextPageToken.Length != 0) { NextPageToken = other.NextPageToken; } @@ -11396,7 +12400,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - groups_.AddEntriesFrom(input, _repeated_groups_codec); + routes_.AddEntriesFrom(input, _repeated_routes_codec); break; } case 18: { @@ -11423,7 +12427,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - groups_.AddEntriesFrom(ref input, _repeated_groups_codec); + routes_.AddEntriesFrom(ref input, _repeated_routes_codec); break; } case 18: { @@ -11442,27 +12446,26 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// A collection of Cloud VPN tunnel resources. These resources should be - /// redundant HA VPN tunnels that all advertise the same prefixes to Google - /// Cloud. Alternatively, in a passive/active configuration, all tunnels - /// should be capable of advertising the same prefixes. + /// Request for + /// [HubService.ListRouteTables][google.cloud.networkconnectivity.v1.HubService.ListRouteTables] + /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class LinkedVpnTunnels : pb::IMessage + public sealed partial class ListRouteTablesRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedVpnTunnels()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRouteTablesRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[32]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[33]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11473,7 +12476,7 @@ public sealed partial class LinkedVpnTunnels : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LinkedVpnTunnels() { + public ListRouteTablesRequest() { OnConstruction(); } @@ -11481,83 +12484,116 @@ public LinkedVpnTunnels() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LinkedVpnTunnels(LinkedVpnTunnels other) : this() { - uris_ = other.uris_.Clone(); - siteToSiteDataTransfer_ = other.siteToSiteDataTransfer_; - vpcNetwork_ = other.vpcNetwork_; + public ListRouteTablesRequest(ListRouteTablesRequest other) : this() { + parent_ = other.parent_; + pageSize_ = other.pageSize_; + pageToken_ = other.pageToken_; + filter_ = other.filter_; + orderBy_ = other.orderBy_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LinkedVpnTunnels Clone() { - return new LinkedVpnTunnels(this); + public ListRouteTablesRequest Clone() { + return new ListRouteTablesRequest(this); } - /// Field number for the "uris" field. - public const int UrisFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_uris_codec - = pb::FieldCodec.ForString(10); - private readonly pbc::RepeatedField uris_ = new pbc::RepeatedField(); + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; /// - /// The URIs of linked VPN tunnel resources. + /// Required. The parent resource's name. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Uris { - get { return uris_; } + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } } - /// Field number for the "site_to_site_data_transfer" field. - public const int SiteToSiteDataTransferFieldNumber = 2; - private bool siteToSiteDataTransfer_; + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; /// - /// A value that controls whether site-to-site data transfer is enabled for - /// these resources. Data transfer is available only in [supported - /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// The maximum number of results to return per page. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool SiteToSiteDataTransfer { - get { return siteToSiteDataTransfer_; } + public int PageSize { + get { return pageSize_; } set { - siteToSiteDataTransfer_ = value; + pageSize_ = value; } } - /// Field number for the "vpc_network" field. - public const int VpcNetworkFieldNumber = 3; - private string vpcNetwork_ = ""; + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; /// - /// Output only. The VPC network where these VPN tunnels are located. + /// The page token. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string VpcNetwork { - get { return vpcNetwork_; } + public string PageToken { + get { return pageToken_; } set { - vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 4; + private string filter_ = ""; + /// + /// An expression that filters the list of results. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Filter { + get { return filter_; } + set { + filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "order_by" field. + public const int OrderByFieldNumber = 5; + private string orderBy_ = ""; + /// + /// Sort the results by a certain order. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OrderBy { + get { return orderBy_; } + set { + orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as LinkedVpnTunnels); + return Equals(other as ListRouteTablesRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(LinkedVpnTunnels other) { + public bool Equals(ListRouteTablesRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!uris_.Equals(other.uris_)) return false; - if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; - if (VpcNetwork != other.VpcNetwork) return false; + if (Parent != other.Parent) return false; + if (PageSize != other.PageSize) return false; + if (PageToken != other.PageToken) return false; + if (Filter != other.Filter) return false; + if (OrderBy != other.OrderBy) return false; return Equals(_unknownFields, other._unknownFields); } @@ -11565,9 +12601,11 @@ public bool Equals(LinkedVpnTunnels other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= uris_.GetHashCode(); - if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); - if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); + if (Filter.Length != 0) hash ^= Filter.GetHashCode(); + if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -11586,14 +12624,25 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - uris_.WriteTo(output, _repeated_uris_codec); - if (SiteToSiteDataTransfer != false) { - output.WriteRawTag(16); - output.WriteBool(SiteToSiteDataTransfer); - } - if (VpcNetwork.Length != 0) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); + } + if (PageToken.Length != 0) { output.WriteRawTag(26); - output.WriteString(VpcNetwork); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -11605,14 +12654,25 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - uris_.WriteTo(ref output, _repeated_uris_codec); - if (SiteToSiteDataTransfer != false) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (PageSize != 0) { output.WriteRawTag(16); - output.WriteBool(SiteToSiteDataTransfer); + output.WriteInt32(PageSize); } - if (VpcNetwork.Length != 0) { + if (PageToken.Length != 0) { output.WriteRawTag(26); - output.WriteString(VpcNetwork); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -11624,12 +12684,20 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += uris_.CalculateSize(_repeated_uris_codec); - if (SiteToSiteDataTransfer != false) { - size += 1 + 1; + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); } - if (VpcNetwork.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + } + if (PageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); + } + if (Filter.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Filter); + } + if (OrderBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -11639,16 +12707,24 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(LinkedVpnTunnels other) { + public void MergeFrom(ListRouteTablesRequest other) { if (other == null) { return; } - uris_.Add(other.uris_); - if (other.SiteToSiteDataTransfer != false) { - SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + if (other.Parent.Length != 0) { + Parent = other.Parent; } - if (other.VpcNetwork.Length != 0) { - VpcNetwork = other.VpcNetwork; + if (other.PageSize != 0) { + PageSize = other.PageSize; + } + if (other.PageToken.Length != 0) { + PageToken = other.PageToken; + } + if (other.Filter.Length != 0) { + Filter = other.Filter; + } + if (other.OrderBy.Length != 0) { + OrderBy = other.OrderBy; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -11666,15 +12742,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - uris_.AddEntriesFrom(input, _repeated_uris_codec); + Parent = input.ReadString(); break; } case 16: { - SiteToSiteDataTransfer = input.ReadBool(); + PageSize = input.ReadInt32(); break; } case 26: { - VpcNetwork = input.ReadString(); + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); break; } } @@ -11693,15 +12777,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - uris_.AddEntriesFrom(ref input, _repeated_uris_codec); + Parent = input.ReadString(); break; } case 16: { - SiteToSiteDataTransfer = input.ReadBool(); + PageSize = input.ReadInt32(); break; } case 26: { - VpcNetwork = input.ReadString(); + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); break; } } @@ -11712,27 +12804,26 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// A collection of VLAN attachment resources. These resources should - /// be redundant attachments that all advertise the same prefixes to Google - /// Cloud. Alternatively, in active/passive configurations, all attachments - /// should be capable of advertising the same prefixes. + /// Response for + /// [HubService.ListRouteTables][google.cloud.networkconnectivity.v1.HubService.ListRouteTables] + /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class LinkedInterconnectAttachments : pb::IMessage + public sealed partial class ListRouteTablesResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedInterconnectAttachments()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListRouteTablesResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[33]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[34]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11743,7 +12834,7 @@ public sealed partial class LinkedInterconnectAttachments : pb::IMessageField number for the "uris" field. - public const int UrisFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_uris_codec - = pb::FieldCodec.ForString(10); - private readonly pbc::RepeatedField uris_ = new pbc::RepeatedField(); + /// Field number for the "route_tables" field. + public const int RouteTablesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_routeTables_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.RouteTable.Parser); + private readonly pbc::RepeatedField routeTables_ = new pbc::RepeatedField(); /// - /// The URIs of linked interconnect attachment resources + /// The requested route tables. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Uris { - get { return uris_; } + public pbc::RepeatedField RouteTables { + get { return routeTables_; } } - /// Field number for the "site_to_site_data_transfer" field. - public const int SiteToSiteDataTransferFieldNumber = 2; - private bool siteToSiteDataTransfer_; + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; /// - /// A value that controls whether site-to-site data transfer is enabled for - /// these resources. Data transfer is available only in [supported - /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// The token for the next page of the response. To see more results, + /// use this value as the page_token for your next request. If this value + /// is empty, there are no more results. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool SiteToSiteDataTransfer { - get { return siteToSiteDataTransfer_; } + public string NextPageToken { + get { return nextPageToken_; } set { - siteToSiteDataTransfer_ = value; + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "vpc_network" field. - public const int VpcNetworkFieldNumber = 3; - private string vpcNetwork_ = ""; + /// Field number for the "unreachable" field. + public const int UnreachableFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_unreachable_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); /// - /// Output only. The VPC network where these VLAN attachments are located. + /// Hubs that could not be reached. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string VpcNetwork { - get { return vpcNetwork_; } - set { - vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public pbc::RepeatedField Unreachable { + get { return unreachable_; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as LinkedInterconnectAttachments); + return Equals(other as ListRouteTablesResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(LinkedInterconnectAttachments other) { + public bool Equals(ListRouteTablesResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!uris_.Equals(other.uris_)) return false; - if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; - if (VpcNetwork != other.VpcNetwork) return false; + if(!routeTables_.Equals(other.routeTables_)) return false; + if (NextPageToken != other.NextPageToken) return false; + if(!unreachable_.Equals(other.unreachable_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -11835,9 +12925,9 @@ public bool Equals(LinkedInterconnectAttachments other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= uris_.GetHashCode(); - if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); - if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + hash ^= routeTables_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + hash ^= unreachable_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -11856,15 +12946,12 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - uris_.WriteTo(output, _repeated_uris_codec); - if (SiteToSiteDataTransfer != false) { - output.WriteRawTag(16); - output.WriteBool(SiteToSiteDataTransfer); - } - if (VpcNetwork.Length != 0) { - output.WriteRawTag(26); - output.WriteString(VpcNetwork); + routeTables_.WriteTo(output, _repeated_routeTables_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); } + unreachable_.WriteTo(output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -11875,15 +12962,12 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - uris_.WriteTo(ref output, _repeated_uris_codec); - if (SiteToSiteDataTransfer != false) { - output.WriteRawTag(16); - output.WriteBool(SiteToSiteDataTransfer); - } - if (VpcNetwork.Length != 0) { - output.WriteRawTag(26); - output.WriteString(VpcNetwork); + routeTables_.WriteTo(ref output, _repeated_routeTables_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); } + unreachable_.WriteTo(ref output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -11894,13 +12978,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += uris_.CalculateSize(_repeated_uris_codec); - if (SiteToSiteDataTransfer != false) { - size += 1 + 1; - } - if (VpcNetwork.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + size += routeTables_.CalculateSize(_repeated_routeTables_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); } + size += unreachable_.CalculateSize(_repeated_unreachable_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -11909,17 +12991,15 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(LinkedInterconnectAttachments other) { + public void MergeFrom(ListRouteTablesResponse other) { if (other == null) { return; } - uris_.Add(other.uris_); - if (other.SiteToSiteDataTransfer != false) { - SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; - } - if (other.VpcNetwork.Length != 0) { - VpcNetwork = other.VpcNetwork; + routeTables_.Add(other.routeTables_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; } + unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -11936,15 +13016,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - uris_.AddEntriesFrom(input, _repeated_uris_codec); + routeTables_.AddEntriesFrom(input, _repeated_routeTables_codec); break; } - case 16: { - SiteToSiteDataTransfer = input.ReadBool(); + case 18: { + NextPageToken = input.ReadString(); break; } case 26: { - VpcNetwork = input.ReadString(); + unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); break; } } @@ -11963,15 +13043,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - uris_.AddEntriesFrom(ref input, _repeated_uris_codec); + routeTables_.AddEntriesFrom(ref input, _repeated_routeTables_codec); break; } - case 16: { - SiteToSiteDataTransfer = input.ReadBool(); + case 18: { + NextPageToken = input.ReadString(); break; } case 26: { - VpcNetwork = input.ReadString(); + unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); break; } } @@ -11982,27 +13062,26 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// A collection of router appliance instances. If you configure multiple router - /// appliance instances to receive data from the same set of sites outside of - /// Google Cloud, we recommend that you associate those instances with the same - /// spoke. + /// Request for + /// [HubService.ListGroups][google.cloud.networkconnectivity.v1.HubService.ListGroups] + /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class LinkedRouterApplianceInstances : pb::IMessage + public sealed partial class ListGroupsRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedRouterApplianceInstances()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListGroupsRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[34]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[35]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -12013,7 +13092,7 @@ public sealed partial class LinkedRouterApplianceInstances : pb::IMessageField number for the "instances" field. - public const int InstancesFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_instances_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.RouterApplianceInstance.Parser); - private readonly pbc::RepeatedField instances_ = new pbc::RepeatedField(); + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; /// - /// The list of router appliance instances. + /// Required. The parent resource's name. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField Instances { - get { return instances_; } + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } } - /// Field number for the "site_to_site_data_transfer" field. - public const int SiteToSiteDataTransferFieldNumber = 2; - private bool siteToSiteDataTransfer_; + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; /// - /// A value that controls whether site-to-site data transfer is enabled for - /// these resources. Data transfer is available only in [supported - /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// The maximum number of results to return per page. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool SiteToSiteDataTransfer { - get { return siteToSiteDataTransfer_; } + public int PageSize { + get { return pageSize_; } set { - siteToSiteDataTransfer_ = value; + pageSize_ = value; } } - /// Field number for the "vpc_network" field. - public const int VpcNetworkFieldNumber = 3; - private string vpcNetwork_ = ""; + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; /// - /// Output only. The VPC network where these router appliance instances are - /// located. + /// The page token. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string VpcNetwork { - get { return vpcNetwork_; } + public string PageToken { + get { return pageToken_; } set { - vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 4; + private string filter_ = ""; + /// + /// An expression that filters the list of results. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Filter { + get { return filter_; } + set { + filter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "order_by" field. + public const int OrderByFieldNumber = 5; + private string orderBy_ = ""; + /// + /// Sort the results by a certain order. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OrderBy { + get { return orderBy_; } + set { + orderBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as LinkedRouterApplianceInstances); + return Equals(other as ListGroupsRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(LinkedRouterApplianceInstances other) { + public bool Equals(ListGroupsRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!instances_.Equals(other.instances_)) return false; - if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; - if (VpcNetwork != other.VpcNetwork) return false; + if (Parent != other.Parent) return false; + if (PageSize != other.PageSize) return false; + if (PageToken != other.PageToken) return false; + if (Filter != other.Filter) return false; + if (OrderBy != other.OrderBy) return false; return Equals(_unknownFields, other._unknownFields); } @@ -12106,9 +13217,11 @@ public bool Equals(LinkedRouterApplianceInstances other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= instances_.GetHashCode(); - if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); - if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); + if (Filter.Length != 0) hash ^= Filter.GetHashCode(); + if (OrderBy.Length != 0) hash ^= OrderBy.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -12127,14 +13240,25 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - instances_.WriteTo(output, _repeated_instances_codec); - if (SiteToSiteDataTransfer != false) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (PageSize != 0) { output.WriteRawTag(16); - output.WriteBool(SiteToSiteDataTransfer); + output.WriteInt32(PageSize); } - if (VpcNetwork.Length != 0) { + if (PageToken.Length != 0) { output.WriteRawTag(26); - output.WriteString(VpcNetwork); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -12146,14 +13270,25 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - instances_.WriteTo(ref output, _repeated_instances_codec); - if (SiteToSiteDataTransfer != false) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (PageSize != 0) { output.WriteRawTag(16); - output.WriteBool(SiteToSiteDataTransfer); + output.WriteInt32(PageSize); } - if (VpcNetwork.Length != 0) { + if (PageToken.Length != 0) { output.WriteRawTag(26); - output.WriteString(VpcNetwork); + output.WriteString(PageToken); + } + if (Filter.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Filter); + } + if (OrderBy.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OrderBy); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -12165,12 +13300,20 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += instances_.CalculateSize(_repeated_instances_codec); - if (SiteToSiteDataTransfer != false) { - size += 1 + 1; + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); } - if (VpcNetwork.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + } + if (PageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); + } + if (Filter.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Filter); + } + if (OrderBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OrderBy); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -12180,16 +13323,24 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(LinkedRouterApplianceInstances other) { + public void MergeFrom(ListGroupsRequest other) { if (other == null) { return; } - instances_.Add(other.instances_); - if (other.SiteToSiteDataTransfer != false) { - SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + if (other.Parent.Length != 0) { + Parent = other.Parent; } - if (other.VpcNetwork.Length != 0) { - VpcNetwork = other.VpcNetwork; + if (other.PageSize != 0) { + PageSize = other.PageSize; + } + if (other.PageToken.Length != 0) { + PageToken = other.PageToken; + } + if (other.Filter.Length != 0) { + Filter = other.Filter; + } + if (other.OrderBy.Length != 0) { + OrderBy = other.OrderBy; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -12207,15 +13358,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - instances_.AddEntriesFrom(input, _repeated_instances_codec); + Parent = input.ReadString(); break; } case 16: { - SiteToSiteDataTransfer = input.ReadBool(); + PageSize = input.ReadInt32(); break; } case 26: { - VpcNetwork = input.ReadString(); + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); break; } } @@ -12234,15 +13393,23 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - instances_.AddEntriesFrom(ref input, _repeated_instances_codec); + Parent = input.ReadString(); break; } case 16: { - SiteToSiteDataTransfer = input.ReadBool(); + PageSize = input.ReadInt32(); break; } case 26: { - VpcNetwork = input.ReadString(); + PageToken = input.ReadString(); + break; + } + case 34: { + Filter = input.ReadString(); + break; + } + case 42: { + OrderBy = input.ReadString(); break; } } @@ -12253,24 +13420,26 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// An existing VPC network. + /// Response for + /// [HubService.ListGroups][google.cloud.networkconnectivity.v1.HubService.ListGroups] + /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class LinkedVpcNetwork : pb::IMessage + public sealed partial class ListGroupsResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedVpcNetwork()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListGroupsResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[35]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[36]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -12281,7 +13450,7 @@ public sealed partial class LinkedVpcNetwork : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LinkedVpcNetwork() { + public ListGroupsResponse() { OnConstruction(); } @@ -12289,64 +13458,82 @@ public LinkedVpcNetwork() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LinkedVpcNetwork(LinkedVpcNetwork other) : this() { - uri_ = other.uri_; - excludeExportRanges_ = other.excludeExportRanges_.Clone(); + public ListGroupsResponse(ListGroupsResponse other) : this() { + groups_ = other.groups_.Clone(); + nextPageToken_ = other.nextPageToken_; + unreachable_ = other.unreachable_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LinkedVpcNetwork Clone() { - return new LinkedVpcNetwork(this); + public ListGroupsResponse Clone() { + return new ListGroupsResponse(this); } - /// Field number for the "uri" field. - public const int UriFieldNumber = 1; - private string uri_ = ""; + /// Field number for the "groups" field. + public const int GroupsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_groups_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.Group.Parser); + private readonly pbc::RepeatedField groups_ = new pbc::RepeatedField(); /// - /// Required. The URI of the VPC network resource. + /// The requested groups. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Uri { - get { return uri_; } + public pbc::RepeatedField Groups { + get { return groups_; } + } + + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; + /// + /// The token for the next page of the response. To see more results, + /// use this value as the page_token for your next request. If this value + /// is empty, there are no more results. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string NextPageToken { + get { return nextPageToken_; } set { - uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - /// Field number for the "exclude_export_ranges" field. - public const int ExcludeExportRangesFieldNumber = 2; - private static readonly pb::FieldCodec _repeated_excludeExportRanges_codec - = pb::FieldCodec.ForString(18); - private readonly pbc::RepeatedField excludeExportRanges_ = new pbc::RepeatedField(); + /// Field number for the "unreachable" field. + public const int UnreachableFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_unreachable_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField unreachable_ = new pbc::RepeatedField(); /// - /// Optional. IP ranges encompassing the subnets to be excluded from peering. + /// Hubs that could not be reached. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField ExcludeExportRanges { - get { return excludeExportRanges_; } + public pbc::RepeatedField Unreachable { + get { return unreachable_; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as LinkedVpcNetwork); + return Equals(other as ListGroupsResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(LinkedVpcNetwork other) { + public bool Equals(ListGroupsResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Uri != other.Uri) return false; - if(!excludeExportRanges_.Equals(other.excludeExportRanges_)) return false; + if(!groups_.Equals(other.groups_)) return false; + if (NextPageToken != other.NextPageToken) return false; + if(!unreachable_.Equals(other.unreachable_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -12354,8 +13541,9 @@ public bool Equals(LinkedVpcNetwork other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Uri.Length != 0) hash ^= Uri.GetHashCode(); - hash ^= excludeExportRanges_.GetHashCode(); + hash ^= groups_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + hash ^= unreachable_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -12374,11 +13562,12 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Uri.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Uri); + groups_.WriteTo(output, _repeated_groups_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); } - excludeExportRanges_.WriteTo(output, _repeated_excludeExportRanges_codec); + unreachable_.WriteTo(output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -12389,11 +13578,12 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Uri.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Uri); + groups_.WriteTo(ref output, _repeated_groups_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); } - excludeExportRanges_.WriteTo(ref output, _repeated_excludeExportRanges_codec); + unreachable_.WriteTo(ref output, _repeated_unreachable_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -12404,10 +13594,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Uri.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + size += groups_.CalculateSize(_repeated_groups_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); } - size += excludeExportRanges_.CalculateSize(_repeated_excludeExportRanges_codec); + size += unreachable_.CalculateSize(_repeated_unreachable_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -12416,14 +13607,15 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(LinkedVpcNetwork other) { + public void MergeFrom(ListGroupsResponse other) { if (other == null) { return; } - if (other.Uri.Length != 0) { - Uri = other.Uri; + groups_.Add(other.groups_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; } - excludeExportRanges_.Add(other.excludeExportRanges_); + unreachable_.Add(other.unreachable_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -12440,11 +13632,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Uri = input.ReadString(); + groups_.AddEntriesFrom(input, _repeated_groups_codec); break; } case 18: { - excludeExportRanges_.AddEntriesFrom(input, _repeated_excludeExportRanges_codec); + NextPageToken = input.ReadString(); + break; + } + case 26: { + unreachable_.AddEntriesFrom(input, _repeated_unreachable_codec); break; } } @@ -12463,11 +13659,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Uri = input.ReadString(); + groups_.AddEntriesFrom(ref input, _repeated_groups_codec); break; } case 18: { - excludeExportRanges_.AddEntriesFrom(ref input, _repeated_excludeExportRanges_codec); + NextPageToken = input.ReadString(); + break; + } + case 26: { + unreachable_.AddEntriesFrom(ref input, _repeated_unreachable_codec); break; } } @@ -12478,27 +13678,27 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// A router appliance instance is a Compute Engine virtual machine (VM) instance - /// that acts as a BGP speaker. A router appliance instance is specified by the - /// URI of the VM and the internal IP address of one of the VM's network - /// interfaces. + /// A collection of Cloud VPN tunnel resources. These resources should be + /// redundant HA VPN tunnels that all advertise the same prefixes to Google + /// Cloud. Alternatively, in a passive/active configuration, all tunnels + /// should be capable of advertising the same prefixes. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class RouterApplianceInstance : pb::IMessage + public sealed partial class LinkedVpnTunnels : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouterApplianceInstance()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedVpnTunnels()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[36]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[37]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -12509,7 +13709,7 @@ public sealed partial class RouterApplianceInstance : pb::IMessageField number for the "virtual_machine" field. - public const int VirtualMachineFieldNumber = 1; - private string virtualMachine_ = ""; + /// Field number for the "uris" field. + public const int UrisFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_uris_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField uris_ = new pbc::RepeatedField(); /// - /// The URI of the VM. + /// The URIs of linked VPN tunnel resources. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string VirtualMachine { - get { return virtualMachine_; } + public pbc::RepeatedField Uris { + get { return uris_; } + } + + /// Field number for the "site_to_site_data_transfer" field. + public const int SiteToSiteDataTransferFieldNumber = 2; + private bool siteToSiteDataTransfer_; + /// + /// A value that controls whether site-to-site data transfer is enabled for + /// these resources. Data transfer is available only in [supported + /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool SiteToSiteDataTransfer { + get { return siteToSiteDataTransfer_; } set { - virtualMachine_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + siteToSiteDataTransfer_ = value; } } - /// Field number for the "ip_address" field. - public const int IpAddressFieldNumber = 3; - private string ipAddress_ = ""; + /// Field number for the "vpc_network" field. + public const int VpcNetworkFieldNumber = 3; + private string vpcNetwork_ = ""; /// - /// The IP address on the VM to use for peering. + /// Output only. The VPC network where these VPN tunnels are located. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string IpAddress { - get { return ipAddress_; } + public string VpcNetwork { + get { return vpcNetwork_; } set { - ipAddress_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } + /// Field number for the "include_import_ranges" field. + public const int IncludeImportRangesFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_includeImportRanges_codec + = pb::FieldCodec.ForString(42); + private readonly pbc::RepeatedField includeImportRanges_ = new pbc::RepeatedField(); + /// + /// Optional. IP ranges allowed to be included during import from hub (does not + /// control transit connectivity). The only allowed value for now is + /// "ALL_IPV4_RANGES". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField IncludeImportRanges { + get { return includeImportRanges_; } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as RouterApplianceInstance); + return Equals(other as LinkedVpnTunnels); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(RouterApplianceInstance other) { + public bool Equals(LinkedVpnTunnels other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (VirtualMachine != other.VirtualMachine) return false; - if (IpAddress != other.IpAddress) return false; + if(!uris_.Equals(other.uris_)) return false; + if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; + if (VpcNetwork != other.VpcNetwork) return false; + if(!includeImportRanges_.Equals(other.includeImportRanges_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -12583,8 +13819,10 @@ public bool Equals(RouterApplianceInstance other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (VirtualMachine.Length != 0) hash ^= VirtualMachine.GetHashCode(); - if (IpAddress.Length != 0) hash ^= IpAddress.GetHashCode(); + hash ^= uris_.GetHashCode(); + if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); + if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + hash ^= includeImportRanges_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -12603,14 +13841,16 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (VirtualMachine.Length != 0) { - output.WriteRawTag(10); - output.WriteString(VirtualMachine); + uris_.WriteTo(output, _repeated_uris_codec); + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(16); + output.WriteBool(SiteToSiteDataTransfer); } - if (IpAddress.Length != 0) { + if (VpcNetwork.Length != 0) { output.WriteRawTag(26); - output.WriteString(IpAddress); + output.WriteString(VpcNetwork); } + includeImportRanges_.WriteTo(output, _repeated_includeImportRanges_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -12621,14 +13861,16 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (VirtualMachine.Length != 0) { - output.WriteRawTag(10); - output.WriteString(VirtualMachine); + uris_.WriteTo(ref output, _repeated_uris_codec); + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(16); + output.WriteBool(SiteToSiteDataTransfer); } - if (IpAddress.Length != 0) { + if (VpcNetwork.Length != 0) { output.WriteRawTag(26); - output.WriteString(IpAddress); + output.WriteString(VpcNetwork); } + includeImportRanges_.WriteTo(ref output, _repeated_includeImportRanges_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -12639,12 +13881,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (VirtualMachine.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(VirtualMachine); + size += uris_.CalculateSize(_repeated_uris_codec); + if (SiteToSiteDataTransfer != false) { + size += 1 + 1; } - if (IpAddress.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(IpAddress); + if (VpcNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); } + size += includeImportRanges_.CalculateSize(_repeated_includeImportRanges_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -12653,16 +13897,18 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(RouterApplianceInstance other) { + public void MergeFrom(LinkedVpnTunnels other) { if (other == null) { return; } - if (other.VirtualMachine.Length != 0) { - VirtualMachine = other.VirtualMachine; - } - if (other.IpAddress.Length != 0) { - IpAddress = other.IpAddress; + uris_.Add(other.uris_); + if (other.SiteToSiteDataTransfer != false) { + SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; } + if (other.VpcNetwork.Length != 0) { + VpcNetwork = other.VpcNetwork; + } + includeImportRanges_.Add(other.includeImportRanges_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -12679,11 +13925,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - VirtualMachine = input.ReadString(); + uris_.AddEntriesFrom(input, _repeated_uris_codec); + break; + } + case 16: { + SiteToSiteDataTransfer = input.ReadBool(); break; } case 26: { - IpAddress = input.ReadString(); + VpcNetwork = input.ReadString(); + break; + } + case 42: { + includeImportRanges_.AddEntriesFrom(input, _repeated_includeImportRanges_codec); break; } } @@ -12702,11 +13956,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - VirtualMachine = input.ReadString(); + uris_.AddEntriesFrom(ref input, _repeated_uris_codec); + break; + } + case 16: { + SiteToSiteDataTransfer = input.ReadBool(); break; } case 26: { - IpAddress = input.ReadString(); + VpcNetwork = input.ReadString(); + break; + } + case 42: { + includeImportRanges_.AddEntriesFrom(ref input, _repeated_includeImportRanges_codec); break; } } @@ -12717,24 +13979,27 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Metadata about locations + /// A collection of VLAN attachment resources. These resources should + /// be redundant attachments that all advertise the same prefixes to Google + /// Cloud. Alternatively, in active/passive configurations, all attachments + /// should be capable of advertising the same prefixes. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class LocationMetadata : pb::IMessage + public sealed partial class LinkedInterconnectAttachments : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LocationMetadata()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedInterconnectAttachments()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[37]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[38]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -12745,7 +14010,7 @@ public sealed partial class LocationMetadata : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LocationMetadata() { + public LinkedInterconnectAttachments() { OnConstruction(); } @@ -12753,47 +14018,101 @@ public LocationMetadata() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LocationMetadata(LocationMetadata other) : this() { - locationFeatures_ = other.locationFeatures_.Clone(); + public LinkedInterconnectAttachments(LinkedInterconnectAttachments other) : this() { + uris_ = other.uris_.Clone(); + siteToSiteDataTransfer_ = other.siteToSiteDataTransfer_; + vpcNetwork_ = other.vpcNetwork_; + includeImportRanges_ = other.includeImportRanges_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public LocationMetadata Clone() { - return new LocationMetadata(this); + public LinkedInterconnectAttachments Clone() { + return new LinkedInterconnectAttachments(this); } - /// Field number for the "location_features" field. - public const int LocationFeaturesFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_locationFeatures_codec - = pb::FieldCodec.ForEnum(10, x => (int) x, x => (global::Google.Cloud.NetworkConnectivity.V1.LocationFeature) x); - private readonly pbc::RepeatedField locationFeatures_ = new pbc::RepeatedField(); + /// Field number for the "uris" field. + public const int UrisFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_uris_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField uris_ = new pbc::RepeatedField(); /// - /// List of supported features + /// The URIs of linked interconnect attachment resources /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField LocationFeatures { - get { return locationFeatures_; } + public pbc::RepeatedField Uris { + get { return uris_; } + } + + /// Field number for the "site_to_site_data_transfer" field. + public const int SiteToSiteDataTransferFieldNumber = 2; + private bool siteToSiteDataTransfer_; + /// + /// A value that controls whether site-to-site data transfer is enabled for + /// these resources. Data transfer is available only in [supported + /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool SiteToSiteDataTransfer { + get { return siteToSiteDataTransfer_; } + set { + siteToSiteDataTransfer_ = value; + } + } + + /// Field number for the "vpc_network" field. + public const int VpcNetworkFieldNumber = 3; + private string vpcNetwork_ = ""; + /// + /// Output only. The VPC network where these VLAN attachments are located. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string VpcNetwork { + get { return vpcNetwork_; } + set { + vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "include_import_ranges" field. + public const int IncludeImportRangesFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_includeImportRanges_codec + = pb::FieldCodec.ForString(42); + private readonly pbc::RepeatedField includeImportRanges_ = new pbc::RepeatedField(); + /// + /// Optional. IP ranges allowed to be included during import from hub (does not + /// control transit connectivity). The only allowed value for now is + /// "ALL_IPV4_RANGES". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField IncludeImportRanges { + get { return includeImportRanges_; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as LocationMetadata); + return Equals(other as LinkedInterconnectAttachments); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(LocationMetadata other) { + public bool Equals(LinkedInterconnectAttachments other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!locationFeatures_.Equals(other.locationFeatures_)) return false; + if(!uris_.Equals(other.uris_)) return false; + if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; + if (VpcNetwork != other.VpcNetwork) return false; + if(!includeImportRanges_.Equals(other.includeImportRanges_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -12801,7 +14120,10 @@ public bool Equals(LocationMetadata other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= locationFeatures_.GetHashCode(); + hash ^= uris_.GetHashCode(); + if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); + if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + hash ^= includeImportRanges_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -12820,7 +14142,16 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - locationFeatures_.WriteTo(output, _repeated_locationFeatures_codec); + uris_.WriteTo(output, _repeated_uris_codec); + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(16); + output.WriteBool(SiteToSiteDataTransfer); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(26); + output.WriteString(VpcNetwork); + } + includeImportRanges_.WriteTo(output, _repeated_includeImportRanges_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -12831,7 +14162,16 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - locationFeatures_.WriteTo(ref output, _repeated_locationFeatures_codec); + uris_.WriteTo(ref output, _repeated_uris_codec); + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(16); + output.WriteBool(SiteToSiteDataTransfer); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(26); + output.WriteString(VpcNetwork); + } + includeImportRanges_.WriteTo(ref output, _repeated_includeImportRanges_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -12842,7 +14182,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += locationFeatures_.CalculateSize(_repeated_locationFeatures_codec); + size += uris_.CalculateSize(_repeated_uris_codec); + if (SiteToSiteDataTransfer != false) { + size += 1 + 1; + } + if (VpcNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + } + size += includeImportRanges_.CalculateSize(_repeated_includeImportRanges_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -12851,11 +14198,18 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(LocationMetadata other) { + public void MergeFrom(LinkedInterconnectAttachments other) { if (other == null) { return; } - locationFeatures_.Add(other.locationFeatures_); + uris_.Add(other.uris_); + if (other.SiteToSiteDataTransfer != false) { + SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + } + if (other.VpcNetwork.Length != 0) { + VpcNetwork = other.VpcNetwork; + } + includeImportRanges_.Add(other.includeImportRanges_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -12871,9 +14225,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: - case 8: { - locationFeatures_.AddEntriesFrom(input, _repeated_locationFeatures_codec); + case 10: { + uris_.AddEntriesFrom(input, _repeated_uris_codec); + break; + } + case 16: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + case 26: { + VpcNetwork = input.ReadString(); + break; + } + case 42: { + includeImportRanges_.AddEntriesFrom(input, _repeated_includeImportRanges_codec); break; } } @@ -12891,9 +14256,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: - case 8: { - locationFeatures_.AddEntriesFrom(ref input, _repeated_locationFeatures_codec); + case 10: { + uris_.AddEntriesFrom(ref input, _repeated_uris_codec); + break; + } + case 16: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + case 26: { + VpcNetwork = input.ReadString(); + break; + } + case 42: { + includeImportRanges_.AddEntriesFrom(ref input, _repeated_includeImportRanges_codec); break; } } @@ -12903,22 +14279,28 @@ public void MergeFrom(pb::CodedInputStream input) { } + /// + /// A collection of router appliance instances. If you configure multiple router + /// appliance instances to receive data from the same set of sites outside of + /// Google Cloud, we recommend that you associate those instances with the same + /// spoke. + /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class NextHopVpcNetwork : pb::IMessage + public sealed partial class LinkedRouterApplianceInstances : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NextHopVpcNetwork()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedRouterApplianceInstances()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[38]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[39]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -12929,7 +14311,7 @@ public sealed partial class NextHopVpcNetwork : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public NextHopVpcNetwork() { + public LinkedRouterApplianceInstances() { OnConstruction(); } @@ -12937,48 +14319,102 @@ public NextHopVpcNetwork() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public NextHopVpcNetwork(NextHopVpcNetwork other) : this() { - uri_ = other.uri_; + public LinkedRouterApplianceInstances(LinkedRouterApplianceInstances other) : this() { + instances_ = other.instances_.Clone(); + siteToSiteDataTransfer_ = other.siteToSiteDataTransfer_; + vpcNetwork_ = other.vpcNetwork_; + includeImportRanges_ = other.includeImportRanges_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public NextHopVpcNetwork Clone() { - return new NextHopVpcNetwork(this); + public LinkedRouterApplianceInstances Clone() { + return new LinkedRouterApplianceInstances(this); } - /// Field number for the "uri" field. - public const int UriFieldNumber = 1; - private string uri_ = ""; + /// Field number for the "instances" field. + public const int InstancesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_instances_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.RouterApplianceInstance.Parser); + private readonly pbc::RepeatedField instances_ = new pbc::RepeatedField(); /// - /// The URI of the VPC network resource + /// The list of router appliance instances. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Uri { - get { return uri_; } - set { - uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } + public pbc::RepeatedField Instances { + get { return instances_; } } + /// Field number for the "site_to_site_data_transfer" field. + public const int SiteToSiteDataTransferFieldNumber = 2; + private bool siteToSiteDataTransfer_; + /// + /// A value that controls whether site-to-site data transfer is enabled for + /// these resources. Data transfer is available only in [supported + /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public override bool Equals(object other) { - return Equals(other as NextHopVpcNetwork); + public bool SiteToSiteDataTransfer { + get { return siteToSiteDataTransfer_; } + set { + siteToSiteDataTransfer_ = value; + } } + /// Field number for the "vpc_network" field. + public const int VpcNetworkFieldNumber = 3; + private string vpcNetwork_ = ""; + /// + /// Output only. The VPC network where these router appliance instances are + /// located. + /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(NextHopVpcNetwork other) { + public string VpcNetwork { + get { return vpcNetwork_; } + set { + vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "include_import_ranges" field. + public const int IncludeImportRangesFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_includeImportRanges_codec + = pb::FieldCodec.ForString(42); + private readonly pbc::RepeatedField includeImportRanges_ = new pbc::RepeatedField(); + /// + /// Optional. IP ranges allowed to be included during import from hub (does not + /// control transit connectivity). The only allowed value for now is + /// "ALL_IPV4_RANGES". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField IncludeImportRanges { + get { return includeImportRanges_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LinkedRouterApplianceInstances); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LinkedRouterApplianceInstances other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Uri != other.Uri) return false; + if(!instances_.Equals(other.instances_)) return false; + if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; + if (VpcNetwork != other.VpcNetwork) return false; + if(!includeImportRanges_.Equals(other.includeImportRanges_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -12986,7 +14422,10 @@ public bool Equals(NextHopVpcNetwork other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Uri.Length != 0) hash ^= Uri.GetHashCode(); + hash ^= instances_.GetHashCode(); + if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); + if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + hash ^= includeImportRanges_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -13005,10 +14444,16 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Uri.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Uri); + instances_.WriteTo(output, _repeated_instances_codec); + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(16); + output.WriteBool(SiteToSiteDataTransfer); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(26); + output.WriteString(VpcNetwork); } + includeImportRanges_.WriteTo(output, _repeated_includeImportRanges_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -13019,10 +14464,16 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Uri.Length != 0) { - output.WriteRawTag(10); - output.WriteString(Uri); + instances_.WriteTo(ref output, _repeated_instances_codec); + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(16); + output.WriteBool(SiteToSiteDataTransfer); } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(26); + output.WriteString(VpcNetwork); + } + includeImportRanges_.WriteTo(ref output, _repeated_includeImportRanges_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -13033,9 +14484,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Uri.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + size += instances_.CalculateSize(_repeated_instances_codec); + if (SiteToSiteDataTransfer != false) { + size += 1 + 1; + } + if (VpcNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); } + size += includeImportRanges_.CalculateSize(_repeated_includeImportRanges_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -13044,13 +14500,18 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(NextHopVpcNetwork other) { + public void MergeFrom(LinkedRouterApplianceInstances other) { if (other == null) { return; } - if (other.Uri.Length != 0) { - Uri = other.Uri; + instances_.Add(other.instances_); + if (other.SiteToSiteDataTransfer != false) { + SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + } + if (other.VpcNetwork.Length != 0) { + VpcNetwork = other.VpcNetwork; } + includeImportRanges_.Add(other.includeImportRanges_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -13067,7 +14528,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Uri = input.ReadString(); + instances_.AddEntriesFrom(input, _repeated_instances_codec); + break; + } + case 16: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + case 26: { + VpcNetwork = input.ReadString(); + break; + } + case 42: { + includeImportRanges_.AddEntriesFrom(input, _repeated_includeImportRanges_codec); break; } } @@ -13086,7 +14559,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Uri = input.ReadString(); + instances_.AddEntriesFrom(ref input, _repeated_instances_codec); + break; + } + case 16: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + case 26: { + VpcNetwork = input.ReadString(); + break; + } + case 42: { + includeImportRanges_.AddEntriesFrom(ref input, _repeated_includeImportRanges_codec); break; } } @@ -13097,28 +14582,24 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// Summarizes information about the spokes associated with a hub. - /// The summary includes a count of spokes according to type - /// and according to state. If any spokes are inactive, - /// the summary also lists the reasons they are inactive, - /// including a count for each reason. + /// An existing VPC network. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class SpokeSummary : pb::IMessage + public sealed partial class LinkedVpcNetwork : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SpokeSummary()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedVpcNetwork()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[39]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[40]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -13129,7 +14610,7 @@ public sealed partial class SpokeSummary : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public SpokeSummary() { + public LinkedVpcNetwork() { OnConstruction(); } @@ -13137,82 +14618,98 @@ public SpokeSummary() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public SpokeSummary(SpokeSummary other) : this() { - spokeTypeCounts_ = other.spokeTypeCounts_.Clone(); - spokeStateCounts_ = other.spokeStateCounts_.Clone(); - spokeStateReasonCounts_ = other.spokeStateReasonCounts_.Clone(); + public LinkedVpcNetwork(LinkedVpcNetwork other) : this() { + uri_ = other.uri_; + excludeExportRanges_ = other.excludeExportRanges_.Clone(); + includeExportRanges_ = other.includeExportRanges_.Clone(); + producerVpcSpokes_ = other.producerVpcSpokes_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public SpokeSummary Clone() { - return new SpokeSummary(this); + public LinkedVpcNetwork Clone() { + return new LinkedVpcNetwork(this); } - /// Field number for the "spoke_type_counts" field. - public const int SpokeTypeCountsFieldNumber = 1; - private static readonly pb::FieldCodec _repeated_spokeTypeCounts_codec - = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeTypeCount.Parser); - private readonly pbc::RepeatedField spokeTypeCounts_ = new pbc::RepeatedField(); + /// Field number for the "uri" field. + public const int UriFieldNumber = 1; + private string uri_ = ""; /// - /// Output only. Counts the number of spokes of each type that are - /// associated with a specific hub. + /// Required. The URI of the VPC network resource. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField SpokeTypeCounts { - get { return spokeTypeCounts_; } + public string Uri { + get { return uri_; } + set { + uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } } - /// Field number for the "spoke_state_counts" field. - public const int SpokeStateCountsFieldNumber = 2; - private static readonly pb::FieldCodec _repeated_spokeStateCounts_codec - = pb::FieldCodec.ForMessage(18, global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateCount.Parser); - private readonly pbc::RepeatedField spokeStateCounts_ = new pbc::RepeatedField(); + /// Field number for the "exclude_export_ranges" field. + public const int ExcludeExportRangesFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_excludeExportRanges_codec + = pb::FieldCodec.ForString(18); + private readonly pbc::RepeatedField excludeExportRanges_ = new pbc::RepeatedField(); /// - /// Output only. Counts the number of spokes that are in each state - /// and associated with a given hub. + /// Optional. IP ranges encompassing the subnets to be excluded from peering. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField SpokeStateCounts { - get { return spokeStateCounts_; } + public pbc::RepeatedField ExcludeExportRanges { + get { return excludeExportRanges_; } } - /// Field number for the "spoke_state_reason_counts" field. - public const int SpokeStateReasonCountsFieldNumber = 3; - private static readonly pb::FieldCodec _repeated_spokeStateReasonCounts_codec - = pb::FieldCodec.ForMessage(26, global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateReasonCount.Parser); - private readonly pbc::RepeatedField spokeStateReasonCounts_ = new pbc::RepeatedField(); + /// Field number for the "include_export_ranges" field. + public const int IncludeExportRangesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_includeExportRanges_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField includeExportRanges_ = new pbc::RepeatedField(); /// - /// Output only. Counts the number of spokes that are inactive for each - /// possible reason and associated with a given hub. + /// Optional. IP ranges allowed to be included from peering. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public pbc::RepeatedField SpokeStateReasonCounts { - get { return spokeStateReasonCounts_; } + public pbc::RepeatedField IncludeExportRanges { + get { return includeExportRanges_; } + } + + /// Field number for the "producer_vpc_spokes" field. + public const int ProducerVpcSpokesFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_producerVpcSpokes_codec + = pb::FieldCodec.ForString(34); + private readonly pbc::RepeatedField producerVpcSpokes_ = new pbc::RepeatedField(); + /// + /// Output only. The list of Producer VPC spokes that this VPC spoke is a + /// service consumer VPC spoke for. These producer VPCs are connected through + /// VPC peering to this spoke's backing VPC network. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField ProducerVpcSpokes { + get { return producerVpcSpokes_; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as SpokeSummary); + return Equals(other as LinkedVpcNetwork); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(SpokeSummary other) { + public bool Equals(LinkedVpcNetwork other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if(!spokeTypeCounts_.Equals(other.spokeTypeCounts_)) return false; - if(!spokeStateCounts_.Equals(other.spokeStateCounts_)) return false; - if(!spokeStateReasonCounts_.Equals(other.spokeStateReasonCounts_)) return false; + if (Uri != other.Uri) return false; + if(!excludeExportRanges_.Equals(other.excludeExportRanges_)) return false; + if(!includeExportRanges_.Equals(other.includeExportRanges_)) return false; + if(!producerVpcSpokes_.Equals(other.producerVpcSpokes_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -13220,9 +14717,10 @@ public bool Equals(SpokeSummary other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - hash ^= spokeTypeCounts_.GetHashCode(); - hash ^= spokeStateCounts_.GetHashCode(); - hash ^= spokeStateReasonCounts_.GetHashCode(); + if (Uri.Length != 0) hash ^= Uri.GetHashCode(); + hash ^= excludeExportRanges_.GetHashCode(); + hash ^= includeExportRanges_.GetHashCode(); + hash ^= producerVpcSpokes_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -13241,9 +14739,13 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - spokeTypeCounts_.WriteTo(output, _repeated_spokeTypeCounts_codec); - spokeStateCounts_.WriteTo(output, _repeated_spokeStateCounts_codec); - spokeStateReasonCounts_.WriteTo(output, _repeated_spokeStateReasonCounts_codec); + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + excludeExportRanges_.WriteTo(output, _repeated_excludeExportRanges_codec); + includeExportRanges_.WriteTo(output, _repeated_includeExportRanges_codec); + producerVpcSpokes_.WriteTo(output, _repeated_producerVpcSpokes_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -13254,9 +14756,13 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - spokeTypeCounts_.WriteTo(ref output, _repeated_spokeTypeCounts_codec); - spokeStateCounts_.WriteTo(ref output, _repeated_spokeStateCounts_codec); - spokeStateReasonCounts_.WriteTo(ref output, _repeated_spokeStateReasonCounts_codec); + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + excludeExportRanges_.WriteTo(ref output, _repeated_excludeExportRanges_codec); + includeExportRanges_.WriteTo(ref output, _repeated_includeExportRanges_codec); + producerVpcSpokes_.WriteTo(ref output, _repeated_producerVpcSpokes_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -13267,9 +14773,12 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - size += spokeTypeCounts_.CalculateSize(_repeated_spokeTypeCounts_codec); - size += spokeStateCounts_.CalculateSize(_repeated_spokeStateCounts_codec); - size += spokeStateReasonCounts_.CalculateSize(_repeated_spokeStateReasonCounts_codec); + if (Uri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + } + size += excludeExportRanges_.CalculateSize(_repeated_excludeExportRanges_codec); + size += includeExportRanges_.CalculateSize(_repeated_includeExportRanges_codec); + size += producerVpcSpokes_.CalculateSize(_repeated_producerVpcSpokes_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -13278,13 +14787,16 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(SpokeSummary other) { + public void MergeFrom(LinkedVpcNetwork other) { if (other == null) { return; } - spokeTypeCounts_.Add(other.spokeTypeCounts_); - spokeStateCounts_.Add(other.spokeStateCounts_); - spokeStateReasonCounts_.Add(other.spokeStateReasonCounts_); + if (other.Uri.Length != 0) { + Uri = other.Uri; + } + excludeExportRanges_.Add(other.excludeExportRanges_); + includeExportRanges_.Add(other.includeExportRanges_); + producerVpcSpokes_.Add(other.producerVpcSpokes_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -13301,15 +14813,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - spokeTypeCounts_.AddEntriesFrom(input, _repeated_spokeTypeCounts_codec); + Uri = input.ReadString(); break; } case 18: { - spokeStateCounts_.AddEntriesFrom(input, _repeated_spokeStateCounts_codec); + excludeExportRanges_.AddEntriesFrom(input, _repeated_excludeExportRanges_codec); break; } case 26: { - spokeStateReasonCounts_.AddEntriesFrom(input, _repeated_spokeStateReasonCounts_codec); + includeExportRanges_.AddEntriesFrom(input, _repeated_includeExportRanges_codec); + break; + } + case 34: { + producerVpcSpokes_.AddEntriesFrom(input, _repeated_producerVpcSpokes_codec); break; } } @@ -13328,15 +14844,19 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - spokeTypeCounts_.AddEntriesFrom(ref input, _repeated_spokeTypeCounts_codec); + Uri = input.ReadString(); break; } case 18: { - spokeStateCounts_.AddEntriesFrom(ref input, _repeated_spokeStateCounts_codec); + excludeExportRanges_.AddEntriesFrom(ref input, _repeated_excludeExportRanges_codec); break; } case 26: { - spokeStateReasonCounts_.AddEntriesFrom(ref input, _repeated_spokeStateReasonCounts_codec); + includeExportRanges_.AddEntriesFrom(ref input, _repeated_includeExportRanges_codec); + break; + } + case 34: { + producerVpcSpokes_.AddEntriesFrom(ref input, _repeated_producerVpcSpokes_codec); break; } } @@ -13344,20 +14864,2098 @@ public void MergeFrom(pb::CodedInputStream input) { } #endif - #region Nested types - /// Container for nested types declared in the SpokeSummary message type. + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LinkedProducerVpcNetwork : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LinkedProducerVpcNetwork()); + private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static partial class Types { - /// - /// The number of spokes of a given type that are associated - /// with a specific hub. The type indicates what kind of - /// resource is associated with the spoke. - /// - [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class SpokeTypeCount : pb::IMessage - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - , pb::IBufferMessage + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[41]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LinkedProducerVpcNetwork() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LinkedProducerVpcNetwork(LinkedProducerVpcNetwork other) : this() { + network_ = other.network_; + serviceConsumerVpcSpoke_ = other.serviceConsumerVpcSpoke_; + peering_ = other.peering_; + producerNetwork_ = other.producerNetwork_; + excludeExportRanges_ = other.excludeExportRanges_.Clone(); + includeExportRanges_ = other.includeExportRanges_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LinkedProducerVpcNetwork Clone() { + return new LinkedProducerVpcNetwork(this); + } + + /// Field number for the "network" field. + public const int NetworkFieldNumber = 1; + private string network_ = ""; + /// + /// Immutable. The URI of the Service Consumer VPC that the Producer VPC is + /// peered with. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Network { + get { return network_; } + set { + network_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "service_consumer_vpc_spoke" field. + public const int ServiceConsumerVpcSpokeFieldNumber = 6; + private string serviceConsumerVpcSpoke_ = ""; + /// + /// Output only. The Service Consumer Network spoke. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ServiceConsumerVpcSpoke { + get { return serviceConsumerVpcSpoke_; } + set { + serviceConsumerVpcSpoke_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "peering" field. + public const int PeeringFieldNumber = 2; + private string peering_ = ""; + /// + /// Immutable. The name of the VPC peering between the Service Consumer VPC and + /// the Producer VPC (defined in the Tenant project) which is added to the NCC + /// hub. This peering must be in ACTIVE state. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Peering { + get { return peering_; } + set { + peering_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "producer_network" field. + public const int ProducerNetworkFieldNumber = 5; + private string producerNetwork_ = ""; + /// + /// Output only. The URI of the Producer VPC. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ProducerNetwork { + get { return producerNetwork_; } + set { + producerNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "exclude_export_ranges" field. + public const int ExcludeExportRangesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_excludeExportRanges_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField excludeExportRanges_ = new pbc::RepeatedField(); + /// + /// Optional. IP ranges encompassing the subnets to be excluded from peering. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField ExcludeExportRanges { + get { return excludeExportRanges_; } + } + + /// Field number for the "include_export_ranges" field. + public const int IncludeExportRangesFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_includeExportRanges_codec + = pb::FieldCodec.ForString(34); + private readonly pbc::RepeatedField includeExportRanges_ = new pbc::RepeatedField(); + /// + /// Optional. IP ranges allowed to be included from peering. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField IncludeExportRanges { + get { return includeExportRanges_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LinkedProducerVpcNetwork); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LinkedProducerVpcNetwork other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Network != other.Network) return false; + if (ServiceConsumerVpcSpoke != other.ServiceConsumerVpcSpoke) return false; + if (Peering != other.Peering) return false; + if (ProducerNetwork != other.ProducerNetwork) return false; + if(!excludeExportRanges_.Equals(other.excludeExportRanges_)) return false; + if(!includeExportRanges_.Equals(other.includeExportRanges_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Network.Length != 0) hash ^= Network.GetHashCode(); + if (ServiceConsumerVpcSpoke.Length != 0) hash ^= ServiceConsumerVpcSpoke.GetHashCode(); + if (Peering.Length != 0) hash ^= Peering.GetHashCode(); + if (ProducerNetwork.Length != 0) hash ^= ProducerNetwork.GetHashCode(); + hash ^= excludeExportRanges_.GetHashCode(); + hash ^= includeExportRanges_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Network.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Network); + } + if (Peering.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Peering); + } + excludeExportRanges_.WriteTo(output, _repeated_excludeExportRanges_codec); + includeExportRanges_.WriteTo(output, _repeated_includeExportRanges_codec); + if (ProducerNetwork.Length != 0) { + output.WriteRawTag(42); + output.WriteString(ProducerNetwork); + } + if (ServiceConsumerVpcSpoke.Length != 0) { + output.WriteRawTag(50); + output.WriteString(ServiceConsumerVpcSpoke); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Network.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Network); + } + if (Peering.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Peering); + } + excludeExportRanges_.WriteTo(ref output, _repeated_excludeExportRanges_codec); + includeExportRanges_.WriteTo(ref output, _repeated_includeExportRanges_codec); + if (ProducerNetwork.Length != 0) { + output.WriteRawTag(42); + output.WriteString(ProducerNetwork); + } + if (ServiceConsumerVpcSpoke.Length != 0) { + output.WriteRawTag(50); + output.WriteString(ServiceConsumerVpcSpoke); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Network.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Network); + } + if (ServiceConsumerVpcSpoke.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceConsumerVpcSpoke); + } + if (Peering.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Peering); + } + if (ProducerNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ProducerNetwork); + } + size += excludeExportRanges_.CalculateSize(_repeated_excludeExportRanges_codec); + size += includeExportRanges_.CalculateSize(_repeated_includeExportRanges_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LinkedProducerVpcNetwork other) { + if (other == null) { + return; + } + if (other.Network.Length != 0) { + Network = other.Network; + } + if (other.ServiceConsumerVpcSpoke.Length != 0) { + ServiceConsumerVpcSpoke = other.ServiceConsumerVpcSpoke; + } + if (other.Peering.Length != 0) { + Peering = other.Peering; + } + if (other.ProducerNetwork.Length != 0) { + ProducerNetwork = other.ProducerNetwork; + } + excludeExportRanges_.Add(other.excludeExportRanges_); + includeExportRanges_.Add(other.includeExportRanges_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Network = input.ReadString(); + break; + } + case 18: { + Peering = input.ReadString(); + break; + } + case 26: { + excludeExportRanges_.AddEntriesFrom(input, _repeated_excludeExportRanges_codec); + break; + } + case 34: { + includeExportRanges_.AddEntriesFrom(input, _repeated_includeExportRanges_codec); + break; + } + case 42: { + ProducerNetwork = input.ReadString(); + break; + } + case 50: { + ServiceConsumerVpcSpoke = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Network = input.ReadString(); + break; + } + case 18: { + Peering = input.ReadString(); + break; + } + case 26: { + excludeExportRanges_.AddEntriesFrom(ref input, _repeated_excludeExportRanges_codec); + break; + } + case 34: { + includeExportRanges_.AddEntriesFrom(ref input, _repeated_includeExportRanges_codec); + break; + } + case 42: { + ProducerNetwork = input.ReadString(); + break; + } + case 50: { + ServiceConsumerVpcSpoke = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// A router appliance instance is a Compute Engine virtual machine (VM) instance + /// that acts as a BGP speaker. A router appliance instance is specified by the + /// URI of the VM and the internal IP address of one of the VM's network + /// interfaces. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouterApplianceInstance : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouterApplianceInstance()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[42]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouterApplianceInstance() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouterApplianceInstance(RouterApplianceInstance other) : this() { + virtualMachine_ = other.virtualMachine_; + ipAddress_ = other.ipAddress_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouterApplianceInstance Clone() { + return new RouterApplianceInstance(this); + } + + /// Field number for the "virtual_machine" field. + public const int VirtualMachineFieldNumber = 1; + private string virtualMachine_ = ""; + /// + /// The URI of the VM. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string VirtualMachine { + get { return virtualMachine_; } + set { + virtualMachine_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "ip_address" field. + public const int IpAddressFieldNumber = 3; + private string ipAddress_ = ""; + /// + /// The IP address on the VM to use for peering. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string IpAddress { + get { return ipAddress_; } + set { + ipAddress_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouterApplianceInstance); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouterApplianceInstance other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (VirtualMachine != other.VirtualMachine) return false; + if (IpAddress != other.IpAddress) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (VirtualMachine.Length != 0) hash ^= VirtualMachine.GetHashCode(); + if (IpAddress.Length != 0) hash ^= IpAddress.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (VirtualMachine.Length != 0) { + output.WriteRawTag(10); + output.WriteString(VirtualMachine); + } + if (IpAddress.Length != 0) { + output.WriteRawTag(26); + output.WriteString(IpAddress); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (VirtualMachine.Length != 0) { + output.WriteRawTag(10); + output.WriteString(VirtualMachine); + } + if (IpAddress.Length != 0) { + output.WriteRawTag(26); + output.WriteString(IpAddress); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (VirtualMachine.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VirtualMachine); + } + if (IpAddress.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(IpAddress); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouterApplianceInstance other) { + if (other == null) { + return; + } + if (other.VirtualMachine.Length != 0) { + VirtualMachine = other.VirtualMachine; + } + if (other.IpAddress.Length != 0) { + IpAddress = other.IpAddress; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + VirtualMachine = input.ReadString(); + break; + } + case 26: { + IpAddress = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + VirtualMachine = input.ReadString(); + break; + } + case 26: { + IpAddress = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Metadata about locations + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LocationMetadata : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LocationMetadata()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[43]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LocationMetadata() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LocationMetadata(LocationMetadata other) : this() { + locationFeatures_ = other.locationFeatures_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LocationMetadata Clone() { + return new LocationMetadata(this); + } + + /// Field number for the "location_features" field. + public const int LocationFeaturesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_locationFeatures_codec + = pb::FieldCodec.ForEnum(10, x => (int) x, x => (global::Google.Cloud.NetworkConnectivity.V1.LocationFeature) x); + private readonly pbc::RepeatedField locationFeatures_ = new pbc::RepeatedField(); + /// + /// List of supported features + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField LocationFeatures { + get { return locationFeatures_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LocationMetadata); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LocationMetadata other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!locationFeatures_.Equals(other.locationFeatures_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= locationFeatures_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + locationFeatures_.WriteTo(output, _repeated_locationFeatures_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + locationFeatures_.WriteTo(ref output, _repeated_locationFeatures_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += locationFeatures_.CalculateSize(_repeated_locationFeatures_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LocationMetadata other) { + if (other == null) { + return; + } + locationFeatures_.Add(other.locationFeatures_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: + case 8: { + locationFeatures_.AddEntriesFrom(input, _repeated_locationFeatures_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: + case 8: { + locationFeatures_.AddEntriesFrom(ref input, _repeated_locationFeatures_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NextHopVpcNetwork : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NextHopVpcNetwork()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[44]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopVpcNetwork() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopVpcNetwork(NextHopVpcNetwork other) : this() { + uri_ = other.uri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopVpcNetwork Clone() { + return new NextHopVpcNetwork(this); + } + + /// Field number for the "uri" field. + public const int UriFieldNumber = 1; + private string uri_ = ""; + /// + /// The URI of the VPC network resource + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Uri { + get { return uri_; } + set { + uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NextHopVpcNetwork); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NextHopVpcNetwork other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Uri != other.Uri) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Uri.Length != 0) hash ^= Uri.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Uri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NextHopVpcNetwork other) { + if (other == null) { + return; + } + if (other.Uri.Length != 0) { + Uri = other.Uri; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// A route next hop that leads to a VPN tunnel resource. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NextHopVPNTunnel : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NextHopVPNTunnel()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[45]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopVPNTunnel() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopVPNTunnel(NextHopVPNTunnel other) : this() { + uri_ = other.uri_; + vpcNetwork_ = other.vpcNetwork_; + siteToSiteDataTransfer_ = other.siteToSiteDataTransfer_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopVPNTunnel Clone() { + return new NextHopVPNTunnel(this); + } + + /// Field number for the "uri" field. + public const int UriFieldNumber = 1; + private string uri_ = ""; + /// + /// The URI of the VPN tunnel resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Uri { + get { return uri_; } + set { + uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "vpc_network" field. + public const int VpcNetworkFieldNumber = 2; + private string vpcNetwork_ = ""; + /// + /// The VPC network where this VPN tunnel is located. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string VpcNetwork { + get { return vpcNetwork_; } + set { + vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_to_site_data_transfer" field. + public const int SiteToSiteDataTransferFieldNumber = 3; + private bool siteToSiteDataTransfer_; + /// + /// Indicates whether site-to-site data transfer is allowed for this VPN tunnel + /// resource. Data transfer is available only in [supported + /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool SiteToSiteDataTransfer { + get { return siteToSiteDataTransfer_; } + set { + siteToSiteDataTransfer_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NextHopVPNTunnel); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NextHopVPNTunnel other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Uri != other.Uri) return false; + if (VpcNetwork != other.VpcNetwork) return false; + if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Uri.Length != 0) hash ^= Uri.GetHashCode(); + if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(18); + output.WriteString(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(24); + output.WriteBool(SiteToSiteDataTransfer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(18); + output.WriteString(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(24); + output.WriteBool(SiteToSiteDataTransfer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Uri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + } + if (VpcNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NextHopVPNTunnel other) { + if (other == null) { + return; + } + if (other.Uri.Length != 0) { + Uri = other.Uri; + } + if (other.VpcNetwork.Length != 0) { + VpcNetwork = other.VpcNetwork; + } + if (other.SiteToSiteDataTransfer != false) { + SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + case 18: { + VpcNetwork = input.ReadString(); + break; + } + case 24: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + case 18: { + VpcNetwork = input.ReadString(); + break; + } + case 24: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// A route next hop that leads to a Router appliance instance. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NextHopRouterApplianceInstance : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NextHopRouterApplianceInstance()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[46]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopRouterApplianceInstance() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopRouterApplianceInstance(NextHopRouterApplianceInstance other) : this() { + uri_ = other.uri_; + vpcNetwork_ = other.vpcNetwork_; + siteToSiteDataTransfer_ = other.siteToSiteDataTransfer_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopRouterApplianceInstance Clone() { + return new NextHopRouterApplianceInstance(this); + } + + /// Field number for the "uri" field. + public const int UriFieldNumber = 1; + private string uri_ = ""; + /// + /// The URI of the Router appliance instance. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Uri { + get { return uri_; } + set { + uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "vpc_network" field. + public const int VpcNetworkFieldNumber = 2; + private string vpcNetwork_ = ""; + /// + /// The VPC network where this VM is located. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string VpcNetwork { + get { return vpcNetwork_; } + set { + vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_to_site_data_transfer" field. + public const int SiteToSiteDataTransferFieldNumber = 3; + private bool siteToSiteDataTransfer_; + /// + /// Indicates whether site-to-site data transfer is allowed for this Router + /// appliance instance resource. Data transfer is available only in [supported + /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool SiteToSiteDataTransfer { + get { return siteToSiteDataTransfer_; } + set { + siteToSiteDataTransfer_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NextHopRouterApplianceInstance); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NextHopRouterApplianceInstance other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Uri != other.Uri) return false; + if (VpcNetwork != other.VpcNetwork) return false; + if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Uri.Length != 0) hash ^= Uri.GetHashCode(); + if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(18); + output.WriteString(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(24); + output.WriteBool(SiteToSiteDataTransfer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(18); + output.WriteString(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(24); + output.WriteBool(SiteToSiteDataTransfer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Uri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + } + if (VpcNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NextHopRouterApplianceInstance other) { + if (other == null) { + return; + } + if (other.Uri.Length != 0) { + Uri = other.Uri; + } + if (other.VpcNetwork.Length != 0) { + VpcNetwork = other.VpcNetwork; + } + if (other.SiteToSiteDataTransfer != false) { + SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + case 18: { + VpcNetwork = input.ReadString(); + break; + } + case 24: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + case 18: { + VpcNetwork = input.ReadString(); + break; + } + case 24: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// A route next hop that leads to an interconnect attachment resource. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NextHopInterconnectAttachment : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NextHopInterconnectAttachment()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[47]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopInterconnectAttachment() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopInterconnectAttachment(NextHopInterconnectAttachment other) : this() { + uri_ = other.uri_; + vpcNetwork_ = other.vpcNetwork_; + siteToSiteDataTransfer_ = other.siteToSiteDataTransfer_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NextHopInterconnectAttachment Clone() { + return new NextHopInterconnectAttachment(this); + } + + /// Field number for the "uri" field. + public const int UriFieldNumber = 1; + private string uri_ = ""; + /// + /// The URI of the interconnect attachment resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Uri { + get { return uri_; } + set { + uri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "vpc_network" field. + public const int VpcNetworkFieldNumber = 2; + private string vpcNetwork_ = ""; + /// + /// The VPC network where this interconnect attachment is located. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string VpcNetwork { + get { return vpcNetwork_; } + set { + vpcNetwork_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_to_site_data_transfer" field. + public const int SiteToSiteDataTransferFieldNumber = 3; + private bool siteToSiteDataTransfer_; + /// + /// Indicates whether site-to-site data transfer is allowed for this + /// interconnect attachment resource. Data transfer is available only in + /// [supported + /// locations](https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/locations). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool SiteToSiteDataTransfer { + get { return siteToSiteDataTransfer_; } + set { + siteToSiteDataTransfer_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NextHopInterconnectAttachment); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NextHopInterconnectAttachment other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Uri != other.Uri) return false; + if (VpcNetwork != other.VpcNetwork) return false; + if (SiteToSiteDataTransfer != other.SiteToSiteDataTransfer) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Uri.Length != 0) hash ^= Uri.GetHashCode(); + if (VpcNetwork.Length != 0) hash ^= VpcNetwork.GetHashCode(); + if (SiteToSiteDataTransfer != false) hash ^= SiteToSiteDataTransfer.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(18); + output.WriteString(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(24); + output.WriteBool(SiteToSiteDataTransfer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Uri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Uri); + } + if (VpcNetwork.Length != 0) { + output.WriteRawTag(18); + output.WriteString(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + output.WriteRawTag(24); + output.WriteBool(SiteToSiteDataTransfer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Uri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Uri); + } + if (VpcNetwork.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VpcNetwork); + } + if (SiteToSiteDataTransfer != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NextHopInterconnectAttachment other) { + if (other == null) { + return; + } + if (other.Uri.Length != 0) { + Uri = other.Uri; + } + if (other.VpcNetwork.Length != 0) { + VpcNetwork = other.VpcNetwork; + } + if (other.SiteToSiteDataTransfer != false) { + SiteToSiteDataTransfer = other.SiteToSiteDataTransfer; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + case 18: { + VpcNetwork = input.ReadString(); + break; + } + case 24: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Uri = input.ReadString(); + break; + } + case 18: { + VpcNetwork = input.ReadString(); + break; + } + case 24: { + SiteToSiteDataTransfer = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// Summarizes information about the spokes associated with a hub. + /// The summary includes a count of spokes according to type + /// and according to state. If any spokes are inactive, + /// the summary also lists the reasons they are inactive, + /// including a count for each reason. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SpokeSummary : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SpokeSummary()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[48]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SpokeSummary() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SpokeSummary(SpokeSummary other) : this() { + spokeTypeCounts_ = other.spokeTypeCounts_.Clone(); + spokeStateCounts_ = other.spokeStateCounts_.Clone(); + spokeStateReasonCounts_ = other.spokeStateReasonCounts_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SpokeSummary Clone() { + return new SpokeSummary(this); + } + + /// Field number for the "spoke_type_counts" field. + public const int SpokeTypeCountsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_spokeTypeCounts_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeTypeCount.Parser); + private readonly pbc::RepeatedField spokeTypeCounts_ = new pbc::RepeatedField(); + /// + /// Output only. Counts the number of spokes of each type that are + /// associated with a specific hub. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField SpokeTypeCounts { + get { return spokeTypeCounts_; } + } + + /// Field number for the "spoke_state_counts" field. + public const int SpokeStateCountsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_spokeStateCounts_codec + = pb::FieldCodec.ForMessage(18, global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateCount.Parser); + private readonly pbc::RepeatedField spokeStateCounts_ = new pbc::RepeatedField(); + /// + /// Output only. Counts the number of spokes that are in each state + /// and associated with a given hub. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField SpokeStateCounts { + get { return spokeStateCounts_; } + } + + /// Field number for the "spoke_state_reason_counts" field. + public const int SpokeStateReasonCountsFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_spokeStateReasonCounts_codec + = pb::FieldCodec.ForMessage(26, global::Google.Cloud.NetworkConnectivity.V1.SpokeSummary.Types.SpokeStateReasonCount.Parser); + private readonly pbc::RepeatedField spokeStateReasonCounts_ = new pbc::RepeatedField(); + /// + /// Output only. Counts the number of spokes that are inactive for each + /// possible reason and associated with a given hub. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField SpokeStateReasonCounts { + get { return spokeStateReasonCounts_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SpokeSummary); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SpokeSummary other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!spokeTypeCounts_.Equals(other.spokeTypeCounts_)) return false; + if(!spokeStateCounts_.Equals(other.spokeStateCounts_)) return false; + if(!spokeStateReasonCounts_.Equals(other.spokeStateReasonCounts_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= spokeTypeCounts_.GetHashCode(); + hash ^= spokeStateCounts_.GetHashCode(); + hash ^= spokeStateReasonCounts_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + spokeTypeCounts_.WriteTo(output, _repeated_spokeTypeCounts_codec); + spokeStateCounts_.WriteTo(output, _repeated_spokeStateCounts_codec); + spokeStateReasonCounts_.WriteTo(output, _repeated_spokeStateReasonCounts_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + spokeTypeCounts_.WriteTo(ref output, _repeated_spokeTypeCounts_codec); + spokeStateCounts_.WriteTo(ref output, _repeated_spokeStateCounts_codec); + spokeStateReasonCounts_.WriteTo(ref output, _repeated_spokeStateReasonCounts_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += spokeTypeCounts_.CalculateSize(_repeated_spokeTypeCounts_codec); + size += spokeStateCounts_.CalculateSize(_repeated_spokeStateCounts_codec); + size += spokeStateReasonCounts_.CalculateSize(_repeated_spokeStateReasonCounts_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SpokeSummary other) { + if (other == null) { + return; + } + spokeTypeCounts_.Add(other.spokeTypeCounts_); + spokeStateCounts_.Add(other.spokeStateCounts_); + spokeStateReasonCounts_.Add(other.spokeStateReasonCounts_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + spokeTypeCounts_.AddEntriesFrom(input, _repeated_spokeTypeCounts_codec); + break; + } + case 18: { + spokeStateCounts_.AddEntriesFrom(input, _repeated_spokeStateCounts_codec); + break; + } + case 26: { + spokeStateReasonCounts_.AddEntriesFrom(input, _repeated_spokeStateReasonCounts_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + spokeTypeCounts_.AddEntriesFrom(ref input, _repeated_spokeTypeCounts_codec); + break; + } + case 18: { + spokeStateCounts_.AddEntriesFrom(ref input, _repeated_spokeStateCounts_codec); + break; + } + case 26: { + spokeStateReasonCounts_.AddEntriesFrom(ref input, _repeated_spokeStateReasonCounts_codec); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the SpokeSummary message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// The number of spokes of a given type that are associated + /// with a specific hub. The type indicates what kind of + /// resource is associated with the spoke. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SpokeTypeCount : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage #endif { private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SpokeTypeCount()); @@ -13998,96 +17596,294 @@ public int CalculateSize() { return size; } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(SpokeStateReasonCount other) { - if (other == null) { - return; - } - if (other.StateReasonCode != global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code.Unspecified) { - StateReasonCode = other.StateReasonCode; - } - if (other.Count != 0L) { - Count = other.Count; - } - _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SpokeStateReasonCount other) { + if (other == null) { + return; + } + if (other.StateReasonCode != global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code.Unspecified) { + StateReasonCode = other.StateReasonCode; + } + if (other.Count != 0L) { + Count = other.Count; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + StateReasonCode = (global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code) input.ReadEnum(); + break; + } + case 16: { + Count = input.ReadInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + StateReasonCode = (global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code) input.ReadEnum(); + break; + } + case 16: { + Count = input.ReadInt64(); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + /// + /// The request for + /// [HubService.GetGroup][google.cloud.networkconnectivity.v1.HubService.GetGroup]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class GetGroupRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetGroupRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[49]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetGroupRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetGroupRequest(GetGroupRequest other) : this() { + name_ = other.name_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetGroupRequest Clone() { + return new GetGroupRequest(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Required. The name of the route table resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as GetGroupRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(GetGroupRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(GetGroupRequest other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(pb::CodedInputStream input) { - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - input.ReadRawMessage(this); - #else - uint tag; - while ((tag = input.ReadTag()) != 0) { - switch(tag) { - default: - _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); - break; - case 8: { - StateReasonCode = (global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code) input.ReadEnum(); - break; - } - case 16: { - Count = input.ReadInt64(); - break; - } - } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; } - #endif } + } + #endif + } - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { - uint tag; - while ((tag = input.ReadTag()) != 0) { - switch(tag) { - default: - _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); - break; - case 8: { - StateReasonCode = (global::Google.Cloud.NetworkConnectivity.V1.Spoke.Types.StateReason.Types.Code) input.ReadEnum(); - break; - } - case 16: { - Count = input.ReadInt64(); - break; - } - } + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; } } - #endif - } - } - #endregion + #endif } /// - /// The request for - /// [HubService.GetGroup][google.cloud.networkconnectivity.v1.HubService.GetGroup]. + /// Request for + /// [HubService.UpdateGroup][google.cloud.networkconnectivity.v1.HubService.UpdateGroup] + /// method. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class GetGroupRequest : pb::IMessage + public sealed partial class UpdateGroupRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetGroupRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateGroupRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[40]; } + get { return global::Google.Cloud.NetworkConnectivity.V1.HubReflection.Descriptor.MessageTypes[50]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -14098,7 +17894,7 @@ public sealed partial class GetGroupRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetGroupRequest() { + public UpdateGroupRequest() { OnConstruction(); } @@ -14106,48 +17902,99 @@ public GetGroupRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetGroupRequest(GetGroupRequest other) : this() { - name_ = other.name_; + public UpdateGroupRequest(UpdateGroupRequest other) : this() { + updateMask_ = other.updateMask_ != null ? other.updateMask_.Clone() : null; + group_ = other.group_ != null ? other.group_.Clone() : null; + requestId_ = other.requestId_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public GetGroupRequest Clone() { - return new GetGroupRequest(this); + public UpdateGroupRequest Clone() { + return new UpdateGroupRequest(this); } - /// Field number for the "name" field. - public const int NameFieldNumber = 1; - private string name_ = ""; + /// Field number for the "update_mask" field. + public const int UpdateMaskFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; /// - /// Required. The name of the route table resource. + /// Optional. In the case of an update to an existing group, field mask is used + /// to specify the fields to be overwritten. The fields specified in the + /// update_mask are relative to the resource, not the full request. A field is + /// overwritten if it is in the mask. If the user does not provide a mask, then + /// all fields are overwritten. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Name { - get { return name_; } + public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { + get { return updateMask_; } set { - name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + updateMask_ = value; + } + } + + /// Field number for the "group" field. + public const int GroupFieldNumber = 2; + private global::Google.Cloud.NetworkConnectivity.V1.Group group_; + /// + /// Required. The state that the group should be in after the update. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetworkConnectivity.V1.Group Group { + get { return group_; } + set { + group_ = value; + } + } + + /// Field number for the "request_id" field. + public const int RequestIdFieldNumber = 3; + private string requestId_ = ""; + /// + /// Optional. A request ID to identify requests. Specify a unique request ID so + /// that if you must retry your request, the server knows to ignore the request + /// if it has already been completed. The server guarantees that a request + /// doesn't result in creation of duplicate commitments for at least 60 + /// minutes. + /// + /// For example, consider a situation where you make an initial request and + /// the request times out. If you make the request again with the same request + /// ID, the server can check to see whether the original operation + /// was received. If it was, the server ignores the second request. This + /// behavior prevents clients from mistakenly creating duplicate commitments. + /// + /// The request ID must be a valid UUID, with the exception that zero UUID is + /// not supported (00000000-0000-0000-0000-000000000000). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RequestId { + get { return requestId_; } + set { + requestId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as GetGroupRequest); + return Equals(other as UpdateGroupRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(GetGroupRequest other) { + public bool Equals(UpdateGroupRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Name != other.Name) return false; + if (!object.Equals(UpdateMask, other.UpdateMask)) return false; + if (!object.Equals(Group, other.Group)) return false; + if (RequestId != other.RequestId) return false; return Equals(_unknownFields, other._unknownFields); } @@ -14155,7 +18002,9 @@ public bool Equals(GetGroupRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); + if (group_ != null) hash ^= Group.GetHashCode(); + if (RequestId.Length != 0) hash ^= RequestId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -14174,9 +18023,17 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Name.Length != 0) { + if (updateMask_ != null) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteMessage(UpdateMask); + } + if (group_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Group); + } + if (RequestId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RequestId); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -14188,9 +18045,17 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Name.Length != 0) { + if (updateMask_ != null) { output.WriteRawTag(10); - output.WriteString(Name); + output.WriteMessage(UpdateMask); + } + if (group_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Group); + } + if (RequestId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RequestId); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -14202,8 +18067,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (Name.Length != 0) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + if (updateMask_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateMask); + } + if (group_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Group); + } + if (RequestId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RequestId); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -14213,12 +18084,24 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(GetGroupRequest other) { + public void MergeFrom(UpdateGroupRequest other) { if (other == null) { return; } - if (other.Name.Length != 0) { - Name = other.Name; + if (other.updateMask_ != null) { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + UpdateMask.MergeFrom(other.UpdateMask); + } + if (other.group_ != null) { + if (group_ == null) { + Group = new global::Google.Cloud.NetworkConnectivity.V1.Group(); + } + Group.MergeFrom(other.Group); + } + if (other.RequestId.Length != 0) { + RequestId = other.RequestId; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -14236,7 +18119,21 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Name = input.ReadString(); + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); + break; + } + case 18: { + if (group_ == null) { + Group = new global::Google.Cloud.NetworkConnectivity.V1.Group(); + } + input.ReadMessage(Group); + break; + } + case 26: { + RequestId = input.ReadString(); break; } } @@ -14255,7 +18152,21 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Name = input.ReadString(); + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); + break; + } + case 18: { + if (group_ == null) { + Group = new global::Google.Cloud.NetworkConnectivity.V1.Group(); + } + input.ReadMessage(Group); + break; + } + case 26: { + RequestId = input.ReadString(); break; } } diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubGrpc.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubGrpc.g.cs index e57035e599e6..e6544b0c3538 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubGrpc.g.cs +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubGrpc.g.cs @@ -86,6 +86,10 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_ListHubSpokesResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.ListHubSpokesResponse.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_QueryHubStatusRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_QueryHubStatusResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_ListSpokesRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.ListSpokesRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_ListSpokesResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.ListSpokesResponse.Parser)); @@ -127,6 +131,8 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_ListGroupsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.ListGroupsRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_ListGroupsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.ListGroupsResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_networkconnectivity_v1_UpdateGroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Method __Method_ListHubs = new grpc::Method( @@ -176,6 +182,14 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl __Marshaller_google_cloud_networkconnectivity_v1_ListHubSpokesRequest, __Marshaller_google_cloud_networkconnectivity_v1_ListHubSpokesResponse); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_QueryHubStatus = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "QueryHubStatus", + __Marshaller_google_cloud_networkconnectivity_v1_QueryHubStatusRequest, + __Marshaller_google_cloud_networkconnectivity_v1_QueryHubStatusResponse); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Method __Method_ListSpokes = new grpc::Method( grpc::MethodType.Unary, @@ -280,6 +294,14 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl __Marshaller_google_cloud_networkconnectivity_v1_ListGroupsRequest, __Marshaller_google_cloud_networkconnectivity_v1_ListGroupsResponse); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_UpdateGroup = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "UpdateGroup", + __Marshaller_google_cloud_networkconnectivity_v1_UpdateGroupRequest, + __Marshaller_google_longrunning_Operation); + /// Service descriptor public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor { @@ -365,6 +387,19 @@ public abstract partial class HubServiceBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task QueryHubStatus(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + /// /// Lists the Network Connectivity Center spokes in a specified project and /// location. @@ -479,7 +514,7 @@ public abstract partial class HubServiceBase } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request received from the client. /// The context of the server-side call handler being invoked. @@ -491,7 +526,7 @@ public abstract partial class HubServiceBase } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request received from the client. /// The context of the server-side call handler being invoked. @@ -526,6 +561,18 @@ public abstract partial class HubServiceBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task UpdateGroup(global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + } /// Client for HubService @@ -856,6 +903,58 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return CallInvoker.AsyncUnaryCall(__Method_ListHubSpokes, null, options, request); } /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusResponse QueryHubStatus(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return QueryHubStatus(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusResponse QueryHubStatus(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_QueryHubStatus, null, options, request); + } + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall QueryHubStatusAsync(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return QueryHubStatusAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall QueryHubStatusAsync(global::Google.Cloud.NetworkConnectivity.V1.QueryHubStatusRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_QueryHubStatus, null, options, request); + } + /// /// Lists the Network Connectivity Center spokes in a specified project and /// location. /// @@ -1308,7 +1407,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return CallInvoker.AsyncUnaryCall(__Method_GetRoute, null, options, request); } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request to send to the server. /// The initial metadata to send with the call. This parameter is optional. @@ -1321,7 +1420,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return ListRoutes(request, new grpc::CallOptions(headers, deadline, cancellationToken)); } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request to send to the server. /// The options for the call. @@ -1332,7 +1431,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return CallInvoker.BlockingUnaryCall(__Method_ListRoutes, null, options, request); } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request to send to the server. /// The initial metadata to send with the call. This parameter is optional. @@ -1345,7 +1444,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return ListRoutesAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request to send to the server. /// The options for the call. @@ -1356,7 +1455,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return CallInvoker.AsyncUnaryCall(__Method_ListRoutes, null, options, request); } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request to send to the server. /// The initial metadata to send with the call. This parameter is optional. @@ -1369,7 +1468,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return ListRouteTables(request, new grpc::CallOptions(headers, deadline, cancellationToken)); } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request to send to the server. /// The options for the call. @@ -1380,7 +1479,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return CallInvoker.BlockingUnaryCall(__Method_ListRouteTables, null, options, request); } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request to send to the server. /// The initial metadata to send with the call. This parameter is optional. @@ -1393,7 +1492,7 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu return ListRouteTablesAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request to send to the server. /// The options for the call. @@ -1499,6 +1598,54 @@ protected HubServiceClient(ClientBaseConfiguration configuration) : base(configu { return CallInvoker.AsyncUnaryCall(__Method_ListGroups, null, options, request); } + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.LongRunning.Operation UpdateGroup(global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return UpdateGroup(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.LongRunning.Operation UpdateGroup(global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_UpdateGroup, null, options, request); + } + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall UpdateGroupAsync(global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return UpdateGroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall UpdateGroupAsync(global::Google.Cloud.NetworkConnectivity.V1.UpdateGroupRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_UpdateGroup, null, options, request); + } /// Creates a new instance of client from given ClientBaseConfiguration. [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] protected override HubServiceClient NewInstance(ClientBaseConfiguration configuration) @@ -1519,6 +1666,7 @@ protected override HubServiceClient NewInstance(ClientBaseConfiguration configur .AddMethod(__Method_UpdateHub, serviceImpl.UpdateHub) .AddMethod(__Method_DeleteHub, serviceImpl.DeleteHub) .AddMethod(__Method_ListHubSpokes, serviceImpl.ListHubSpokes) + .AddMethod(__Method_QueryHubStatus, serviceImpl.QueryHubStatus) .AddMethod(__Method_ListSpokes, serviceImpl.ListSpokes) .AddMethod(__Method_GetSpoke, serviceImpl.GetSpoke) .AddMethod(__Method_CreateSpoke, serviceImpl.CreateSpoke) @@ -1531,7 +1679,8 @@ protected override HubServiceClient NewInstance(ClientBaseConfiguration configur .AddMethod(__Method_ListRoutes, serviceImpl.ListRoutes) .AddMethod(__Method_ListRouteTables, serviceImpl.ListRouteTables) .AddMethod(__Method_GetGroup, serviceImpl.GetGroup) - .AddMethod(__Method_ListGroups, serviceImpl.ListGroups).Build(); + .AddMethod(__Method_ListGroups, serviceImpl.ListGroups) + .AddMethod(__Method_UpdateGroup, serviceImpl.UpdateGroup).Build(); } /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. @@ -1547,6 +1696,7 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, HubService serviceBinder.AddMethod(__Method_UpdateHub, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.UpdateHub)); serviceBinder.AddMethod(__Method_DeleteHub, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.DeleteHub)); serviceBinder.AddMethod(__Method_ListHubSpokes, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ListHubSpokes)); + serviceBinder.AddMethod(__Method_QueryHubStatus, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.QueryHubStatus)); serviceBinder.AddMethod(__Method_ListSpokes, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ListSpokes)); serviceBinder.AddMethod(__Method_GetSpoke, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetSpoke)); serviceBinder.AddMethod(__Method_CreateSpoke, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CreateSpoke)); @@ -1560,6 +1710,7 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, HubService serviceBinder.AddMethod(__Method_ListRouteTables, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ListRouteTables)); serviceBinder.AddMethod(__Method_GetGroup, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetGroup)); serviceBinder.AddMethod(__Method_ListGroups, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ListGroups)); + serviceBinder.AddMethod(__Method_UpdateGroup, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.UpdateGroup)); } } diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubResourceNames.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubResourceNames.g.cs index d1689dcee629..92d046f1952d 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubResourceNames.g.cs +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubResourceNames.g.cs @@ -1893,6 +1893,18 @@ public partial class ListHubSpokesRequest } } + public partial class QueryHubStatusRequest + { + /// + /// -typed view over the resource name property. + /// + public gcnv::HubName HubName + { + get => string.IsNullOrEmpty(Name) ? null : gcnv::HubName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } + public partial class ListSpokesRequest { /// @@ -2099,6 +2111,44 @@ public NetworkName UriAsNetworkName get => string.IsNullOrEmpty(Uri) ? null : NetworkName.Parse(Uri, allowUnparsed: true); set => Uri = value?.ToString() ?? ""; } + + /// + /// -typed view over the resource name property. + /// + public gax::ResourceNameList ProducerVpcSpokesAsSpokeNames + { + get => new gax::ResourceNameList(ProducerVpcSpokes, s => string.IsNullOrEmpty(s) ? null : SpokeName.Parse(s, allowUnparsed: true)); + } + } + + public partial class LinkedProducerVpcNetwork + { + /// + /// -typed view over the resource name property. + /// + public NetworkName NetworkAsNetworkName + { + get => string.IsNullOrEmpty(Network) ? null : NetworkName.Parse(Network, allowUnparsed: true); + set => Network = value?.ToString() ?? ""; + } + + /// + /// -typed view over the resource name property. + /// + public NetworkName ProducerNetworkAsNetworkName + { + get => string.IsNullOrEmpty(ProducerNetwork) ? null : NetworkName.Parse(ProducerNetwork, allowUnparsed: true); + set => ProducerNetwork = value?.ToString() ?? ""; + } + + /// + /// -typed view over the resource name property. + /// + public SpokeName ServiceConsumerVpcSpokeAsSpokeName + { + get => string.IsNullOrEmpty(ServiceConsumerVpcSpoke) ? null : SpokeName.Parse(ServiceConsumerVpcSpoke, allowUnparsed: true); + set => ServiceConsumerVpcSpoke = value?.ToString() ?? ""; + } } public partial class RouterApplianceInstance @@ -2123,6 +2173,65 @@ public NetworkName UriAsNetworkName } } + public partial class NextHopVPNTunnel + { + /// -typed view over the resource name property. + public VpnTunnelName UriAsVpnTunnelName + { + get => string.IsNullOrEmpty(Uri) ? null : VpnTunnelName.Parse(Uri, allowUnparsed: true); + set => Uri = value?.ToString() ?? ""; + } + + /// + /// -typed view over the resource name property. + /// + public NetworkName VpcNetworkAsNetworkName + { + get => string.IsNullOrEmpty(VpcNetwork) ? null : NetworkName.Parse(VpcNetwork, allowUnparsed: true); + set => VpcNetwork = value?.ToString() ?? ""; + } + } + + public partial class NextHopRouterApplianceInstance + { + /// -typed view over the resource name property. + public InstanceName UriAsInstanceName + { + get => string.IsNullOrEmpty(Uri) ? null : InstanceName.Parse(Uri, allowUnparsed: true); + set => Uri = value?.ToString() ?? ""; + } + + /// + /// -typed view over the resource name property. + /// + public NetworkName VpcNetworkAsNetworkName + { + get => string.IsNullOrEmpty(VpcNetwork) ? null : NetworkName.Parse(VpcNetwork, allowUnparsed: true); + set => VpcNetwork = value?.ToString() ?? ""; + } + } + + public partial class NextHopInterconnectAttachment + { + /// + /// -typed view over the resource name property. + /// + public InterconnectAttachmentName UriAsInterconnectAttachmentName + { + get => string.IsNullOrEmpty(Uri) ? null : InterconnectAttachmentName.Parse(Uri, allowUnparsed: true); + set => Uri = value?.ToString() ?? ""; + } + + /// + /// -typed view over the resource name property. + /// + public NetworkName VpcNetworkAsNetworkName + { + get => string.IsNullOrEmpty(VpcNetwork) ? null : NetworkName.Parse(VpcNetwork, allowUnparsed: true); + set => VpcNetwork = value?.ToString() ?? ""; + } + } + public partial class GetGroupRequest { /// diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubServiceClient.g.cs b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubServiceClient.g.cs index 74c8245effee..fcc02d2eef37 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubServiceClient.g.cs +++ b/apis/Google.Cloud.NetworkConnectivity.V1/Google.Cloud.NetworkConnectivity.V1/HubServiceClient.g.cs @@ -59,6 +59,7 @@ private HubServiceSettings(HubServiceSettings existing) : base(existing) DeleteHubSettings = existing.DeleteHubSettings; DeleteHubOperationsSettings = existing.DeleteHubOperationsSettings.Clone(); ListHubSpokesSettings = existing.ListHubSpokesSettings; + QueryHubStatusSettings = existing.QueryHubStatusSettings; ListSpokesSettings = existing.ListSpokesSettings; GetSpokeSettings = existing.GetSpokeSettings; CreateSpokeSettings = existing.CreateSpokeSettings; @@ -77,6 +78,8 @@ private HubServiceSettings(HubServiceSettings existing) : base(existing) ListRouteTablesSettings = existing.ListRouteTablesSettings; GetGroupSettings = existing.GetGroupSettings; ListGroupsSettings = existing.ListGroupsSettings; + UpdateGroupSettings = existing.UpdateGroupSettings; + UpdateGroupOperationsSettings = existing.UpdateGroupOperationsSettings.Clone(); LocationsSettings = existing.LocationsSettings; IAMPolicySettings = existing.IAMPolicySettings; OnCopy(existing); @@ -228,6 +231,24 @@ private HubServiceSettings(HubServiceSettings existing) : base(existing) /// public gaxgrpc::CallSettings ListHubSpokesSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + /// + /// for synchronous and asynchronous calls to + /// HubServiceClient.QueryHubStatus and HubServiceClient.QueryHubStatusAsync. + /// + /// + /// + /// Initial retry delay: 1000 milliseconds. + /// Retry delay multiplier: 1.3 + /// Retry maximum delay: 10000 milliseconds. + /// Maximum attempts: 5 + /// + /// Retriable status codes: . + /// + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings QueryHubStatusSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + /// /// for synchronous and asynchronous calls to HubServiceClient.ListSpokes /// and HubServiceClient.ListSpokesAsync. @@ -534,6 +555,42 @@ private HubServiceSettings(HubServiceSettings existing) : base(existing) /// public gaxgrpc::CallSettings ListGroupsSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + /// + /// for synchronous and asynchronous calls to + /// HubServiceClient.UpdateGroup and HubServiceClient.UpdateGroupAsync. + /// + /// + /// + /// Initial retry delay: 1000 milliseconds. + /// Retry delay multiplier: 1.3 + /// Retry maximum delay: 10000 milliseconds. + /// Maximum attempts: 5 + /// + /// Retriable status codes: . + /// + /// Timeout: 60 seconds. + /// + /// + public gaxgrpc::CallSettings UpdateGroupSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + + /// + /// Long Running Operation settings for calls to HubServiceClient.UpdateGroup and + /// HubServiceClient.UpdateGroupAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings UpdateGroupOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + /// /// The settings to use for the associated with the client. /// @@ -1536,6 +1593,162 @@ public virtual Hub GetHub(HubName name, gaxgrpc::CallSettings callSettings = nul return ListHubSpokesAsync(request, callSettings); } + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable QueryHubStatus(QueryHubStatusRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable QueryHubStatusAsync(QueryHubStatusRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// + /// Required. The name of the hub. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable QueryHubStatus(string name, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + QueryHubStatusRequest request = new QueryHubStatusRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return QueryHubStatus(request, callSettings); + } + + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// + /// Required. The name of the hub. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable QueryHubStatusAsync(string name, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + QueryHubStatusRequest request = new QueryHubStatusRequest + { + Name = gax::GaxPreconditions.CheckNotNullOrEmpty(name, nameof(name)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return QueryHubStatusAsync(request, callSettings); + } + + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// + /// Required. The name of the hub. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable QueryHubStatus(HubName name, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + QueryHubStatusRequest request = new QueryHubStatusRequest + { + HubName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return QueryHubStatus(request, callSettings); + } + + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// + /// Required. The name of the hub. + /// + /// + /// The token returned from the previous request. A value of null or an empty string retrieves the first + /// page. + /// + /// + /// The size of page to request. The response will not be larger than this, but may be smaller. A value of + /// null or 0 uses a server-defined page size. + /// + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable QueryHubStatusAsync(HubName name, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + QueryHubStatusRequest request = new QueryHubStatusRequest + { + HubName = gax::GaxPreconditions.CheckNotNull(name, nameof(name)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return QueryHubStatusAsync(request, callSettings); + } + /// /// Lists the Network Connectivity Center spokes in a specified project and /// location. @@ -2771,7 +2984,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti GetRouteAsync(name, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -2780,7 +2993,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti throw new sys::NotImplementedException(); /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -2789,7 +3002,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti throw new sys::NotImplementedException(); /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// /// Required. The parent resource's name. @@ -2822,7 +3035,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// /// Required. The parent resource's name. @@ -2855,7 +3068,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// /// Required. The parent resource's name. @@ -2888,7 +3101,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// /// Required. The parent resource's name. @@ -2921,7 +3134,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -2930,7 +3143,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti throw new sys::NotImplementedException(); /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -2939,7 +3152,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti throw new sys::NotImplementedException(); /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// /// Required. The parent resource's name. @@ -2972,7 +3185,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// /// Required. The parent resource's name. @@ -3005,7 +3218,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// /// Required. The parent resource's name. @@ -3038,7 +3251,7 @@ public virtual Route GetRoute(HubRouteName name, gaxgrpc::CallSettings callSetti } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// /// Required. The parent resource's name. @@ -3324,6 +3537,121 @@ public virtual Group GetGroup(GroupName name, gaxgrpc::CallSettings callSettings } return ListGroupsAsync(request, callSettings); } + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation UpdateGroup(UpdateGroupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> UpdateGroupAsync(UpdateGroupRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> UpdateGroupAsync(UpdateGroupRequest request, st::CancellationToken cancellationToken) => + UpdateGroupAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// The long-running operations client for UpdateGroup. + public virtual lro::OperationsClient UpdateGroupOperationsClient => throw new sys::NotImplementedException(); + + /// + /// Poll an operation once, using an operationName from a previous invocation of UpdateGroup. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceUpdateGroup(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), UpdateGroupOperationsClient, callSettings); + + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// UpdateGroup. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceUpdateGroupAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), UpdateGroupOperationsClient, callSettings); + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// + /// Required. The state that the group should be in after the update. + /// + /// + /// Optional. In the case of an update to an existing group, field mask is used + /// to specify the fields to be overwritten. The fields specified in the + /// update_mask are relative to the resource, not the full request. A field is + /// overwritten if it is in the mask. If the user does not provide a mask, then + /// all fields are overwritten. + /// + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation UpdateGroup(Group group, wkt::FieldMask updateMask, gaxgrpc::CallSettings callSettings = null) => + UpdateGroup(new UpdateGroupRequest + { + UpdateMask = updateMask, + Group = gax::GaxPreconditions.CheckNotNull(group, nameof(group)), + }, callSettings); + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// + /// Required. The state that the group should be in after the update. + /// + /// + /// Optional. In the case of an update to an existing group, field mask is used + /// to specify the fields to be overwritten. The fields specified in the + /// update_mask are relative to the resource, not the full request. A field is + /// overwritten if it is in the mask. If the user does not provide a mask, then + /// all fields are overwritten. + /// + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> UpdateGroupAsync(Group group, wkt::FieldMask updateMask, gaxgrpc::CallSettings callSettings = null) => + UpdateGroupAsync(new UpdateGroupRequest + { + UpdateMask = updateMask, + Group = gax::GaxPreconditions.CheckNotNull(group, nameof(group)), + }, callSettings); + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// + /// Required. The state that the group should be in after the update. + /// + /// + /// Optional. In the case of an update to an existing group, field mask is used + /// to specify the fields to be overwritten. The fields specified in the + /// update_mask are relative to the resource, not the full request. A field is + /// overwritten if it is in the mask. If the user does not provide a mask, then + /// all fields are overwritten. + /// + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> UpdateGroupAsync(Group group, wkt::FieldMask updateMask, st::CancellationToken cancellationToken) => + UpdateGroupAsync(group, updateMask, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); } /// HubService client wrapper implementation, for convenient use. @@ -3346,6 +3674,8 @@ public sealed partial class HubServiceClientImpl : HubServiceClient private readonly gaxgrpc::ApiCall _callListHubSpokes; + private readonly gaxgrpc::ApiCall _callQueryHubStatus; + private readonly gaxgrpc::ApiCall _callListSpokes; private readonly gaxgrpc::ApiCall _callGetSpoke; @@ -3372,6 +3702,8 @@ public sealed partial class HubServiceClientImpl : HubServiceClient private readonly gaxgrpc::ApiCall _callListGroups; + private readonly gaxgrpc::ApiCall _callUpdateGroup; + /// /// Constructs a client wrapper for the HubService service, with the specified gRPC client and settings. /// @@ -3395,6 +3727,7 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe RejectHubSpokeOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.RejectHubSpokeOperationsSettings, logger); AcceptHubSpokeOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.AcceptHubSpokeOperationsSettings, logger); DeleteSpokeOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.DeleteSpokeOperationsSettings, logger); + UpdateGroupOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.UpdateGroupOperationsSettings, logger); LocationsClient = new gcl::LocationsClientImpl(grpcClient.CreateLocationsClient(), effectiveSettings.LocationsSettings, logger); IAMPolicyClient = new gciv::IAMPolicyClientImpl(grpcClient.CreateIAMPolicyClient(), effectiveSettings.IAMPolicySettings, logger); _callListHubs = clientHelper.BuildApiCall("ListHubs", grpcClient.ListHubsAsync, grpcClient.ListHubs, effectiveSettings.ListHubsSettings).WithGoogleRequestParam("parent", request => request.Parent); @@ -3415,6 +3748,9 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe _callListHubSpokes = clientHelper.BuildApiCall("ListHubSpokes", grpcClient.ListHubSpokesAsync, grpcClient.ListHubSpokes, effectiveSettings.ListHubSpokesSettings).WithGoogleRequestParam("name", request => request.Name); Modify_ApiCall(ref _callListHubSpokes); Modify_ListHubSpokesApiCall(ref _callListHubSpokes); + _callQueryHubStatus = clientHelper.BuildApiCall("QueryHubStatus", grpcClient.QueryHubStatusAsync, grpcClient.QueryHubStatus, effectiveSettings.QueryHubStatusSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callQueryHubStatus); + Modify_QueryHubStatusApiCall(ref _callQueryHubStatus); _callListSpokes = clientHelper.BuildApiCall("ListSpokes", grpcClient.ListSpokesAsync, grpcClient.ListSpokes, effectiveSettings.ListSpokesSettings).WithGoogleRequestParam("parent", request => request.Parent); Modify_ApiCall(ref _callListSpokes); Modify_ListSpokesApiCall(ref _callListSpokes); @@ -3454,6 +3790,9 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe _callListGroups = clientHelper.BuildApiCall("ListGroups", grpcClient.ListGroupsAsync, grpcClient.ListGroups, effectiveSettings.ListGroupsSettings).WithGoogleRequestParam("parent", request => request.Parent); Modify_ApiCall(ref _callListGroups); Modify_ListGroupsApiCall(ref _callListGroups); + _callUpdateGroup = clientHelper.BuildApiCall("UpdateGroup", grpcClient.UpdateGroupAsync, grpcClient.UpdateGroup, effectiveSettings.UpdateGroupSettings).WithGoogleRequestParam("group.name", request => request.Group?.Name); + Modify_ApiCall(ref _callUpdateGroup); + Modify_UpdateGroupApiCall(ref _callUpdateGroup); OnConstruction(grpcClient, effectiveSettings, clientHelper); } @@ -3471,6 +3810,8 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe partial void Modify_ListHubSpokesApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_QueryHubStatusApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_ListSpokesApiCall(ref gaxgrpc::ApiCall call); partial void Modify_GetSpokeApiCall(ref gaxgrpc::ApiCall call); @@ -3497,6 +3838,8 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe partial void Modify_ListGroupsApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_UpdateGroupApiCall(ref gaxgrpc::ApiCall call); + partial void OnConstruction(HubService.HubServiceClient grpcClient, HubServiceSettings effectiveSettings, gaxgrpc::ClientHelper clientHelper); /// The underlying gRPC HubService client @@ -3520,6 +3863,8 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe partial void Modify_ListHubSpokesRequest(ref ListHubSpokesRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_QueryHubStatusRequest(ref QueryHubStatusRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_ListSpokesRequest(ref ListSpokesRequest request, ref gaxgrpc::CallSettings settings); partial void Modify_GetSpokeRequest(ref GetSpokeRequest request, ref gaxgrpc::CallSettings settings); @@ -3546,6 +3891,8 @@ public HubServiceClientImpl(HubService.HubServiceClient grpcClient, HubServiceSe partial void Modify_ListGroupsRequest(ref ListGroupsRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_UpdateGroupRequest(ref UpdateGroupRequest request, ref gaxgrpc::CallSettings settings); + /// /// Lists the Network Connectivity Center hubs associated with a given project. /// @@ -3705,6 +4052,32 @@ public override Hub GetHub(GetHubRequest request, gaxgrpc::CallSettings callSett return new gaxgrpc::GrpcPagedAsyncEnumerable(_callListHubSpokes, request, callSettings); } + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public override gax::PagedEnumerable QueryHubStatus(QueryHubStatusRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_QueryHubStatusRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedEnumerable(_callQueryHubStatus, request, callSettings); + } + + /// + /// Query the Private Service Connect propagation status of a Network + /// Connectivity Center hub. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public override gax::PagedAsyncEnumerable QueryHubStatusAsync(QueryHubStatusRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_QueryHubStatusRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedAsyncEnumerable(_callQueryHubStatus, request, callSettings); + } + /// /// Lists the Network Connectivity Center spokes in a specified project and /// location. @@ -3947,7 +4320,7 @@ public override Route GetRoute(GetRouteRequest request, gaxgrpc::CallSettings ca } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -3959,7 +4332,7 @@ public override Route GetRoute(GetRouteRequest request, gaxgrpc::CallSettings ca } /// - /// Lists routes in a given project. + /// Lists routes in a given route table. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -3971,7 +4344,7 @@ public override Route GetRoute(GetRouteRequest request, gaxgrpc::CallSettings ca } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -3983,7 +4356,7 @@ public override Route GetRoute(GetRouteRequest request, gaxgrpc::CallSettings ca } /// - /// Lists route tables in a given project. + /// Lists route tables in a given hub. /// /// The request object containing all of the parameters for the API call. /// If not null, applies overrides to this RPC call. @@ -4041,6 +4414,33 @@ public override Group GetGroup(GetGroupRequest request, gaxgrpc::CallSettings ca Modify_ListGroupsRequest(ref request, ref callSettings); return new gaxgrpc::GrpcPagedAsyncEnumerable(_callListGroups, request, callSettings); } + + /// The long-running operations client for UpdateGroup. + public override lro::OperationsClient UpdateGroupOperationsClient { get; } + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation UpdateGroup(UpdateGroupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_UpdateGroupRequest(ref request, ref callSettings); + return new lro::Operation(_callUpdateGroup.Sync(request, callSettings), UpdateGroupOperationsClient); + } + + /// + /// Updates the parameters of a Network Connectivity Center group. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> UpdateGroupAsync(UpdateGroupRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_UpdateGroupRequest(ref request, ref callSettings); + return new lro::Operation(await _callUpdateGroup.Async(request, callSettings).ConfigureAwait(false), UpdateGroupOperationsClient); + } } public partial class ListHubsRequest : gaxgrpc::IPageRequest @@ -4051,6 +4451,10 @@ public partial class ListHubSpokesRequest : gaxgrpc::IPageRequest { } + public partial class QueryHubStatusRequest : gaxgrpc::IPageRequest + { + } + public partial class ListSpokesRequest : gaxgrpc::IPageRequest { } @@ -4083,6 +4487,14 @@ public partial class ListHubSpokesResponse : gaxgrpc::IPageResponse sc::IEnumerator sc::IEnumerable.GetEnumerator() => GetEnumerator(); } + public partial class QueryHubStatusResponse : gaxgrpc::IPageResponse + { + /// Returns an enumerator that iterates through the resources in this response. + public scg::IEnumerator GetEnumerator() => HubStatusEntries.GetEnumerator(); + + sc::IEnumerator sc::IEnumerable.GetEnumerator() => GetEnumerator(); + } + public partial class ListSpokesResponse : gaxgrpc::IPageResponse { /// Returns an enumerator that iterates through the resources in this response. diff --git a/apis/Google.Cloud.NetworkConnectivity.V1/gapic_metadata.json b/apis/Google.Cloud.NetworkConnectivity.V1/gapic_metadata.json index fd07b6331cc1..78cb6df8ad83 100644 --- a/apis/Google.Cloud.NetworkConnectivity.V1/gapic_metadata.json +++ b/apis/Google.Cloud.NetworkConnectivity.V1/gapic_metadata.json @@ -106,12 +106,24 @@ "ListSpokesAsync" ] }, + "QueryHubStatus": { + "methods": [ + "QueryHubStatus", + "QueryHubStatusAsync" + ] + }, "RejectHubSpoke": { "methods": [ "RejectHubSpoke", "RejectHubSpokeAsync" ] }, + "UpdateGroup": { + "methods": [ + "UpdateGroup", + "UpdateGroupAsync" + ] + }, "UpdateHub": { "methods": [ "UpdateHub",