diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsyncSnippet.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsyncSnippet.g.cs new file mode 100644 index 000000000000..c984bd44f3ec --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsyncSnippet.g.cs @@ -0,0 +1,79 @@ +// Copyright 2026 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async_flattened] + using Google.Api.Gax; + using Google.Cloud.BackupDR.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + public sealed partial class GeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigsAsync + /// + /// 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 ListResourceBackupConfigsAsync() + { + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = await BackupDrProtectionSummaryClient.CreateAsync(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]"; + // Make the request + PagedAsyncEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigsAsync(parent); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((ResourceBackupConfig 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((ListResourceBackupConfigsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async_flattened] +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectAsyncSnippet.g.cs new file mode 100644 index 000000000000..946a4fcd0af2 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectAsyncSnippet.g.cs @@ -0,0 +1,85 @@ +// Copyright 2026 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async] + using Google.Api.Gax; + using Google.Api.Gax.ResourceNames; + using Google.Cloud.BackupDR.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + public sealed partial class GeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigsAsync + /// + /// 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 ListResourceBackupConfigsRequestObjectAsync() + { + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = await BackupDrProtectionSummaryClient.CreateAsync(); + // Initialize request argument(s) + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"), + Filter = "", + OrderBy = "", + }; + // Make the request + PagedAsyncEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigsAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((ResourceBackupConfig 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((ListResourceBackupConfigsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async] +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectSnippet.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectSnippet.g.cs new file mode 100644 index 000000000000..6d3cc173f504 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectSnippet.g.cs @@ -0,0 +1,83 @@ +// Copyright 2026 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync] + using Google.Api.Gax; + using Google.Api.Gax.ResourceNames; + using Google.Cloud.BackupDR.V1; + using System; + + public sealed partial class GeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigs + /// + /// 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 ListResourceBackupConfigsRequestObject() + { + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = BackupDrProtectionSummaryClient.Create(); + // Initialize request argument(s) + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"), + Filter = "", + OrderBy = "", + }; + // Make the request + PagedEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigs(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (ResourceBackupConfig 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 (ListResourceBackupConfigsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync] +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesAsyncSnippet.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesAsyncSnippet.g.cs new file mode 100644 index 000000000000..c1efd701a39f --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesAsyncSnippet.g.cs @@ -0,0 +1,80 @@ +// Copyright 2026 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async_flattened_resourceNames] + using Google.Api.Gax; + using Google.Api.Gax.ResourceNames; + using Google.Cloud.BackupDR.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + public sealed partial class GeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigsAsync + /// + /// 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 ListResourceBackupConfigsResourceNamesAsync() + { + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = await BackupDrProtectionSummaryClient.CreateAsync(); + // Initialize request argument(s) + LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"); + // Make the request + PagedAsyncEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigsAsync(parent); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((ResourceBackupConfig 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((ListResourceBackupConfigsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async_flattened_resourceNames] +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesSnippet.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesSnippet.g.cs new file mode 100644 index 000000000000..e2d0976cb9aa --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesSnippet.g.cs @@ -0,0 +1,78 @@ +// Copyright 2026 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync_flattened_resourceNames] + using Google.Api.Gax; + using Google.Api.Gax.ResourceNames; + using Google.Cloud.BackupDR.V1; + using System; + + public sealed partial class GeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigs + /// + /// 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 ListResourceBackupConfigsResourceNames() + { + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = BackupDrProtectionSummaryClient.Create(); + // Initialize request argument(s) + LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"); + // Make the request + PagedEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigs(parent); + + // Iterate over all response items, lazily performing RPCs as required + foreach (ResourceBackupConfig 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 (ListResourceBackupConfigsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync_flattened_resourceNames] +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsSnippet.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsSnippet.g.cs new file mode 100644 index 000000000000..a646a225c317 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/BackupDrProtectionSummaryClient.ListResourceBackupConfigsSnippet.g.cs @@ -0,0 +1,77 @@ +// Copyright 2026 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync_flattened] + using Google.Api.Gax; + using Google.Cloud.BackupDR.V1; + using System; + + public sealed partial class GeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigs + /// + /// 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 ListResourceBackupConfigs() + { + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = BackupDrProtectionSummaryClient.Create(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]"; + // Make the request + PagedEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigs(parent); + + // Iterate over all response items, lazily performing RPCs as required + foreach (ResourceBackupConfig 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 (ListResourceBackupConfigsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync_flattened] +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/snippet_metadata_google.cloud.backupdr.v1.json b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/snippet_metadata_google.cloud.backupdr.v1.json index 18490dacd1f3..75fc180d8ae5 100644 --- a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/snippet_metadata_google.cloud.backupdr.v1.json +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.GeneratedSnippets/snippet_metadata_google.cloud.backupdr.v1.json @@ -10579,6 +10579,325 @@ "type": "SHORT" } ] + }, + { + "regionTag": "backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync", + "title": "ListResourceBackupConfigsRequestObject", + "description": "Snippet for ListResourceBackupConfigs", + "file": "BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "ListResourceBackupConfigs", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient.ListResourceBackupConfigs", + "parameters": [ + { + "type": "Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedEnumerable", + "client": { + "shortName": "BackupDrProtectionSummaryClient", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient" + }, + "method": { + "shortName": "ListResourceBackupConfigs", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary.ListResourceBackupConfigs", + "service": { + "shortName": "BackupDrProtectionSummary", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 81, + "type": "FULL" + }, + { + "start": 37, + "end": 79, + "type": "SHORT" + } + ] + }, + { + "regionTag": "backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async", + "title": "ListResourceBackupConfigsRequestObjectAsync", + "description": "Snippet for ListResourceBackupConfigsAsync", + "file": "BackupDrProtectionSummaryClient.ListResourceBackupConfigsRequestObjectAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "ListResourceBackupConfigsAsync", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedAsyncEnumerable", + "client": { + "shortName": "BackupDrProtectionSummaryClient", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient" + }, + "method": { + "shortName": "ListResourceBackupConfigs", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary.ListResourceBackupConfigs", + "service": { + "shortName": "BackupDrProtectionSummary", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 83, + "type": "FULL" + }, + { + "start": 39, + "end": 81, + "type": "SHORT" + } + ] + }, + { + "regionTag": "backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync_flattened", + "title": "ListResourceBackupConfigs", + "description": "Snippet for ListResourceBackupConfigs", + "file": "BackupDrProtectionSummaryClient.ListResourceBackupConfigsSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "ListResourceBackupConfigs", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient.ListResourceBackupConfigs", + "parameters": [ + { + "type": "System.String", + "name": "parent" + }, + { + "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": "BackupDrProtectionSummaryClient", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient" + }, + "method": { + "shortName": "ListResourceBackupConfigs", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary.ListResourceBackupConfigs", + "service": { + "shortName": "BackupDrProtectionSummary", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 75, + "type": "FULL" + }, + { + "start": 36, + "end": 73, + "type": "SHORT" + } + ] + }, + { + "regionTag": "backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async_flattened", + "title": "ListResourceBackupConfigsAsync", + "description": "Snippet for ListResourceBackupConfigsAsync", + "file": "BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "ListResourceBackupConfigsAsync", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsync", + "async": true, + "parameters": [ + { + "type": "System.String", + "name": "parent" + }, + { + "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": "BackupDrProtectionSummaryClient", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient" + }, + "method": { + "shortName": "ListResourceBackupConfigs", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary.ListResourceBackupConfigs", + "service": { + "shortName": "BackupDrProtectionSummary", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 77, + "type": "FULL" + }, + { + "start": 38, + "end": 75, + "type": "SHORT" + } + ] + }, + { + "regionTag": "backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_sync_flattened_resourceNames", + "title": "ListResourceBackupConfigsResourceNames", + "description": "Snippet for ListResourceBackupConfigs", + "file": "BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "ListResourceBackupConfigs", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient.ListResourceBackupConfigs", + "parameters": [ + { + "type": "Google.Api.Gax.ResourceNames.LocationName", + "name": "parent" + }, + { + "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": "BackupDrProtectionSummaryClient", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient" + }, + "method": { + "shortName": "ListResourceBackupConfigs", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary.ListResourceBackupConfigs", + "service": { + "shortName": "BackupDrProtectionSummary", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 76, + "type": "FULL" + }, + { + "start": 37, + "end": 74, + "type": "SHORT" + } + ] + }, + { + "regionTag": "backupdr_v1_generated_BackupDrProtectionSummary_ListResourceBackupConfigs_async_flattened_resourceNames", + "title": "ListResourceBackupConfigsResourceNamesAsync", + "description": "Snippet for ListResourceBackupConfigsAsync", + "file": "BackupDrProtectionSummaryClient.ListResourceBackupConfigsResourceNamesAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "ListResourceBackupConfigsAsync", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsync", + "async": true, + "parameters": [ + { + "type": "Google.Api.Gax.ResourceNames.LocationName", + "name": "parent" + }, + { + "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": "BackupDrProtectionSummaryClient", + "fullName": "Google.Cloud.BackupDR.V1.BackupDrProtectionSummaryClient" + }, + "method": { + "shortName": "ListResourceBackupConfigs", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary.ListResourceBackupConfigs", + "service": { + "shortName": "BackupDrProtectionSummary", + "fullName": "google.cloud.backupdr.v1.BackupDrProtectionSummary" + } + } + }, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 78, + "type": "FULL" + }, + { + "start": 39, + "end": 76, + "type": "SHORT" + } + ] } ] } diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.Snippets/BackupDrProtectionSummaryClientSnippets.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.Snippets/BackupDrProtectionSummaryClientSnippets.g.cs new file mode 100644 index 000000000000..4b9a7257a1cf --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1.Snippets/BackupDrProtectionSummaryClientSnippets.g.cs @@ -0,0 +1,309 @@ +// Copyright 2026 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 +{ + using Google.Api.Gax; + using Google.Api.Gax.ResourceNames; + using Google.Cloud.BackupDR.V1; + using System; + using System.Linq; + using System.Threading.Tasks; + + /// Generated snippets. + public sealed class AllGeneratedBackupDrProtectionSummaryClientSnippets + { + /// Snippet for ListResourceBackupConfigs + public void ListResourceBackupConfigsRequestObject() + { + // Snippet: ListResourceBackupConfigs(ListResourceBackupConfigsRequest, CallSettings) + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = BackupDrProtectionSummaryClient.Create(); + // Initialize request argument(s) + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"), + Filter = "", + OrderBy = "", + }; + // Make the request + PagedEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigs(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (ResourceBackupConfig 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 (ListResourceBackupConfigsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 ListResourceBackupConfigsAsync + public async Task ListResourceBackupConfigsRequestObjectAsync() + { + // Snippet: ListResourceBackupConfigsAsync(ListResourceBackupConfigsRequest, CallSettings) + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = await BackupDrProtectionSummaryClient.CreateAsync(); + // Initialize request argument(s) + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"), + Filter = "", + OrderBy = "", + }; + // Make the request + PagedAsyncEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigsAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((ResourceBackupConfig 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((ListResourceBackupConfigsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 ListResourceBackupConfigs + public void ListResourceBackupConfigs() + { + // Snippet: ListResourceBackupConfigs(string, string, int?, CallSettings) + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = BackupDrProtectionSummaryClient.Create(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]"; + // Make the request + PagedEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigs(parent); + + // Iterate over all response items, lazily performing RPCs as required + foreach (ResourceBackupConfig 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 (ListResourceBackupConfigsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 ListResourceBackupConfigsAsync + public async Task ListResourceBackupConfigsAsync() + { + // Snippet: ListResourceBackupConfigsAsync(string, string, int?, CallSettings) + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = await BackupDrProtectionSummaryClient.CreateAsync(); + // Initialize request argument(s) + string parent = "projects/[PROJECT]/locations/[LOCATION]"; + // Make the request + PagedAsyncEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigsAsync(parent); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((ResourceBackupConfig 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((ListResourceBackupConfigsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 ListResourceBackupConfigs + public void ListResourceBackupConfigsResourceNames() + { + // Snippet: ListResourceBackupConfigs(LocationName, string, int?, CallSettings) + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = BackupDrProtectionSummaryClient.Create(); + // Initialize request argument(s) + LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"); + // Make the request + PagedEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigs(parent); + + // Iterate over all response items, lazily performing RPCs as required + foreach (ResourceBackupConfig 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 (ListResourceBackupConfigsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 ListResourceBackupConfigsAsync + public async Task ListResourceBackupConfigsResourceNamesAsync() + { + // Snippet: ListResourceBackupConfigsAsync(LocationName, string, int?, CallSettings) + // Create client + BackupDrProtectionSummaryClient backupDrProtectionSummaryClient = await BackupDrProtectionSummaryClient.CreateAsync(); + // Initialize request argument(s) + LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"); + // Make the request + PagedAsyncEnumerable response = backupDrProtectionSummaryClient.ListResourceBackupConfigsAsync(parent); + + // Iterate over all response items, lazily performing RPCs as required + await response.ForEachAsync((ResourceBackupConfig 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((ListResourceBackupConfigsResponse page) => + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (ResourceBackupConfig 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 (ResourceBackupConfig 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 + } + } +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/BackupDrProtectionSummaryClient.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/BackupDrProtectionSummaryClient.g.cs new file mode 100644 index 000000000000..e8273ba51634 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/BackupDrProtectionSummaryClient.g.cs @@ -0,0 +1,516 @@ +// Copyright 2026 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! + +#pragma warning disable CS8981 +using gagr = Google.Api.Gax.ResourceNames; +using gax = Google.Api.Gax; +using gaxgrpc = Google.Api.Gax.Grpc; +using gciv = Google.Cloud.Iam.V1; +using gcl = Google.Cloud.Location; +using grpccore = Grpc.Core; +using grpcinter = Grpc.Core.Interceptors; +using mel = Microsoft.Extensions.Logging; +using proto = Google.Protobuf; +using sc = System.Collections; +using scg = System.Collections.Generic; +using sco = System.Collections.ObjectModel; +using st = System.Threading; +using stt = System.Threading.Tasks; +using sys = System; + +namespace Google.Cloud.BackupDR.V1 +{ + /// Settings for instances. + public sealed partial class BackupDrProtectionSummarySettings : gaxgrpc::ServiceSettingsBase + { + /// Get a new instance of the default . + /// A new instance of the default . + public static BackupDrProtectionSummarySettings GetDefault() => new BackupDrProtectionSummarySettings(); + + /// + /// Constructs a new object with default settings. + /// + public BackupDrProtectionSummarySettings() + { + } + + private BackupDrProtectionSummarySettings(BackupDrProtectionSummarySettings existing) : base(existing) + { + gax::GaxPreconditions.CheckNotNull(existing, nameof(existing)); + ListResourceBackupConfigsSettings = existing.ListResourceBackupConfigsSettings; + LocationsSettings = existing.LocationsSettings; + IAMPolicySettings = existing.IAMPolicySettings; + OnCopy(existing); + } + + partial void OnCopy(BackupDrProtectionSummarySettings existing); + + /// + /// for synchronous and asynchronous calls to + /// BackupDrProtectionSummaryClient.ListResourceBackupConfigs and + /// BackupDrProtectionSummaryClient.ListResourceBackupConfigsAsync. + /// + /// + /// + /// 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 ListResourceBackupConfigsSettings { 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))); + + /// + /// The settings to use for the associated with the client. + /// + public gcl::LocationsSettings LocationsSettings { get; set; } = gcl::LocationsSettings.GetDefault(); + + /// + /// The settings to use for the associated with the client. + /// + public gciv::IAMPolicySettings IAMPolicySettings { get; set; } = gciv::IAMPolicySettings.GetDefault(); + + /// Creates a deep clone of this object, with all the same property values. + /// A deep clone of this object. + public BackupDrProtectionSummarySettings Clone() => new BackupDrProtectionSummarySettings(this); + } + + /// + /// Builder class for to provide simple configuration of credentials, + /// endpoint etc. + /// + public sealed partial class BackupDrProtectionSummaryClientBuilder : gaxgrpc::ClientBuilderBase + { + /// The settings to use for RPCs, or null for the default settings. + public BackupDrProtectionSummarySettings Settings { get; set; } + + /// Creates a new builder with default settings. + public BackupDrProtectionSummaryClientBuilder() : base(BackupDrProtectionSummaryClient.ServiceMetadata) + { + } + + partial void InterceptBuild(ref BackupDrProtectionSummaryClient client); + + partial void InterceptBuildAsync(st::CancellationToken cancellationToken, ref stt::Task task); + + /// Builds the resulting client. + public override BackupDrProtectionSummaryClient Build() + { + BackupDrProtectionSummaryClient client = null; + InterceptBuild(ref client); + return client ?? BuildImpl(); + } + + /// Builds the resulting client asynchronously. + public override stt::Task BuildAsync(st::CancellationToken cancellationToken = default) + { + stt::Task task = null; + InterceptBuildAsync(cancellationToken, ref task); + return task ?? BuildAsyncImpl(cancellationToken); + } + + private BackupDrProtectionSummaryClient BuildImpl() + { + Validate(); + grpccore::CallInvoker callInvoker = CreateCallInvoker(); + return BackupDrProtectionSummaryClient.Create(callInvoker, GetEffectiveSettings(Settings?.Clone()), Logger); + } + + private async stt::Task BuildAsyncImpl(st::CancellationToken cancellationToken) + { + Validate(); + grpccore::CallInvoker callInvoker = await CreateCallInvokerAsync(cancellationToken).ConfigureAwait(false); + return BackupDrProtectionSummaryClient.Create(callInvoker, GetEffectiveSettings(Settings?.Clone()), Logger); + } + + /// Returns the channel pool to use when no other options are specified. + protected override gaxgrpc::ChannelPool GetChannelPool() => BackupDrProtectionSummaryClient.ChannelPool; + } + + /// BackupDrProtectionSummary client wrapper, for convenient use. + /// + /// The Protection Summary service. + /// + public abstract partial class BackupDrProtectionSummaryClient + { + /// + /// The default endpoint for the BackupDrProtectionSummary service, which is a host of "backupdr.googleapis.com" + /// and a port of 443. + /// + public static string DefaultEndpoint { get; } = "backupdr.googleapis.com:443"; + + /// The default BackupDrProtectionSummary scopes. + /// + /// The default BackupDrProtectionSummary scopes are: + /// + /// https://www.googleapis.com/auth/cloud-platform + /// + /// + public static scg::IReadOnlyList DefaultScopes { get; } = new sco::ReadOnlyCollection(new string[] + { + "https://www.googleapis.com/auth/cloud-platform", + }); + + /// The service metadata associated with this client type. + public static gaxgrpc::ServiceMetadata ServiceMetadata { get; } = new gaxgrpc::ServiceMetadata(BackupDrProtectionSummary.Descriptor, DefaultEndpoint, DefaultScopes, true, gax::ApiTransports.Grpc | gax::ApiTransports.Rest, PackageApiMetadata.ApiMetadata); + + internal static gaxgrpc::ChannelPool ChannelPool { get; } = new gaxgrpc::ChannelPool(ServiceMetadata); + + /// + /// Asynchronously creates a using the default credentials, + /// endpoint and settings. To specify custom credentials or other settings, use + /// . + /// + /// + /// The to use while creating the client. + /// + /// The task representing the created . + public static stt::Task CreateAsync(st::CancellationToken cancellationToken = default) => + new BackupDrProtectionSummaryClientBuilder().BuildAsync(cancellationToken); + + /// + /// Synchronously creates a using the default credentials, + /// endpoint and settings. To specify custom credentials or other settings, use + /// . + /// + /// The created . + public static BackupDrProtectionSummaryClient Create() => new BackupDrProtectionSummaryClientBuilder().Build(); + + /// + /// Creates a which uses the specified call invoker for remote + /// operations. + /// + /// + /// The for remote operations. Must not be null. + /// + /// Optional . + /// Optional . + /// The created . + internal static BackupDrProtectionSummaryClient Create(grpccore::CallInvoker callInvoker, BackupDrProtectionSummarySettings settings = null, mel::ILogger logger = null) + { + gax::GaxPreconditions.CheckNotNull(callInvoker, nameof(callInvoker)); + grpcinter::Interceptor interceptor = settings?.Interceptor; + if (interceptor != null) + { + callInvoker = grpcinter::CallInvokerExtensions.Intercept(callInvoker, interceptor); + } + BackupDrProtectionSummary.BackupDrProtectionSummaryClient grpcClient = new BackupDrProtectionSummary.BackupDrProtectionSummaryClient(callInvoker); + return new BackupDrProtectionSummaryClientImpl(grpcClient, settings, logger); + } + + /// + /// Shuts down any channels automatically created by and + /// . Channels which weren't automatically created are not + /// affected. + /// + /// + /// After calling this method, further calls to and + /// will create new channels, which could in turn be shut down + /// by another call to this method. + /// + /// A task representing the asynchronous shutdown operation. + public static stt::Task ShutdownDefaultChannelsAsync() => ChannelPool.ShutdownChannelsAsync(); + + /// The underlying gRPC BackupDrProtectionSummary client + public virtual BackupDrProtectionSummary.BackupDrProtectionSummaryClient GrpcClient => throw new sys::NotImplementedException(); + + /// The associated with this client. + public virtual gcl::LocationsClient LocationsClient => throw new sys::NotImplementedException(); + + /// The associated with this client. + public virtual gciv::IAMPolicyClient IAMPolicyClient => throw new sys::NotImplementedException(); + + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigs(ListResourceBackupConfigsRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigsAsync(ListResourceBackupConfigsRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Lists ResourceBackupConfigs. + /// + /// + /// Required. The project and location for which to retrieve resource backup + /// configs. Format: 'projects/{project_id}/locations/{location}'. In Google + /// Cloud Backup and DR, locations map to Google Cloud regions, for example + /// **us-central1**. + /// + /// + /// 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 ListResourceBackupConfigs(string parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + Parent = gax::GaxPreconditions.CheckNotNullOrEmpty(parent, nameof(parent)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return ListResourceBackupConfigs(request, callSettings); + } + + /// + /// Lists ResourceBackupConfigs. + /// + /// + /// Required. The project and location for which to retrieve resource backup + /// configs. Format: 'projects/{project_id}/locations/{location}'. In Google + /// Cloud Backup and DR, locations map to Google Cloud regions, for example + /// **us-central1**. + /// + /// + /// 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 ListResourceBackupConfigsAsync(string parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + Parent = gax::GaxPreconditions.CheckNotNullOrEmpty(parent, nameof(parent)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return ListResourceBackupConfigsAsync(request, callSettings); + } + + /// + /// Lists ResourceBackupConfigs. + /// + /// + /// Required. The project and location for which to retrieve resource backup + /// configs. Format: 'projects/{project_id}/locations/{location}'. In Google + /// Cloud Backup and DR, locations map to Google Cloud regions, for example + /// **us-central1**. + /// + /// + /// 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 ListResourceBackupConfigs(gagr::LocationName parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + ParentAsLocationName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return ListResourceBackupConfigs(request, callSettings); + } + + /// + /// Lists ResourceBackupConfigs. + /// + /// + /// Required. The project and location for which to retrieve resource backup + /// configs. Format: 'projects/{project_id}/locations/{location}'. In Google + /// Cloud Backup and DR, locations map to Google Cloud regions, for example + /// **us-central1**. + /// + /// + /// 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 ListResourceBackupConfigsAsync(gagr::LocationName parent, string pageToken = null, int? pageSize = null, gaxgrpc::CallSettings callSettings = null) + { + ListResourceBackupConfigsRequest request = new ListResourceBackupConfigsRequest + { + ParentAsLocationName = gax::GaxPreconditions.CheckNotNull(parent, nameof(parent)), + }; + if (pageToken != null) + { + request.PageToken = pageToken; + } + if (pageSize != null) + { + request.PageSize = pageSize.Value; + } + return ListResourceBackupConfigsAsync(request, callSettings); + } + } + + /// BackupDrProtectionSummary client wrapper implementation, for convenient use. + /// + /// The Protection Summary service. + /// + public sealed partial class BackupDrProtectionSummaryClientImpl : BackupDrProtectionSummaryClient + { + private readonly gaxgrpc::ApiCall _callListResourceBackupConfigs; + + /// + /// Constructs a client wrapper for the BackupDrProtectionSummary service, with the specified gRPC client and + /// settings. + /// + /// The underlying gRPC client. + /// + /// The base used within this client. + /// + /// Optional to use within this client. + public BackupDrProtectionSummaryClientImpl(BackupDrProtectionSummary.BackupDrProtectionSummaryClient grpcClient, BackupDrProtectionSummarySettings settings, mel::ILogger logger) + { + GrpcClient = grpcClient; + BackupDrProtectionSummarySettings effectiveSettings = settings ?? BackupDrProtectionSummarySettings.GetDefault(); + gaxgrpc::ClientHelper clientHelper = new gaxgrpc::ClientHelper(new gaxgrpc::ClientHelper.Options + { + Settings = effectiveSettings, + Logger = logger, + }); + LocationsClient = new gcl::LocationsClientImpl(grpcClient.CreateLocationsClient(), effectiveSettings.LocationsSettings, logger); + IAMPolicyClient = new gciv::IAMPolicyClientImpl(grpcClient.CreateIAMPolicyClient(), effectiveSettings.IAMPolicySettings, logger); + _callListResourceBackupConfigs = clientHelper.BuildApiCall("ListResourceBackupConfigs", grpcClient.ListResourceBackupConfigsAsync, grpcClient.ListResourceBackupConfigs, effectiveSettings.ListResourceBackupConfigsSettings).WithGoogleRequestParam("parent", request => request.Parent); + Modify_ApiCall(ref _callListResourceBackupConfigs); + Modify_ListResourceBackupConfigsApiCall(ref _callListResourceBackupConfigs); + OnConstruction(grpcClient, effectiveSettings, clientHelper); + } + + partial void Modify_ApiCall(ref gaxgrpc::ApiCall call) where TRequest : class, proto::IMessage where TResponse : class, proto::IMessage; + + partial void Modify_ListResourceBackupConfigsApiCall(ref gaxgrpc::ApiCall call); + + partial void OnConstruction(BackupDrProtectionSummary.BackupDrProtectionSummaryClient grpcClient, BackupDrProtectionSummarySettings effectiveSettings, gaxgrpc::ClientHelper clientHelper); + + /// The underlying gRPC BackupDrProtectionSummary client + public override BackupDrProtectionSummary.BackupDrProtectionSummaryClient GrpcClient { get; } + + /// The associated with this client. + public override gcl::LocationsClient LocationsClient { get; } + + /// The associated with this client. + public override gciv::IAMPolicyClient IAMPolicyClient { get; } + + partial void Modify_ListResourceBackupConfigsRequest(ref ListResourceBackupConfigsRequest request, ref gaxgrpc::CallSettings settings); + + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigs(ListResourceBackupConfigsRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_ListResourceBackupConfigsRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedEnumerable(_callListResourceBackupConfigs, request, callSettings); + } + + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigsAsync(ListResourceBackupConfigsRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_ListResourceBackupConfigsRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedAsyncEnumerable(_callListResourceBackupConfigs, request, callSettings); + } + } + + public partial class ListResourceBackupConfigsRequest : gaxgrpc::IPageRequest + { + } + + public partial class ListResourceBackupConfigsResponse : gaxgrpc::IPageResponse + { + /// Returns an enumerator that iterates through the resources in this response. + public scg::IEnumerator GetEnumerator() => ResourceBackupConfigs.GetEnumerator(); + + sc::IEnumerator sc::IEnumerable.GetEnumerator() => GetEnumerator(); + } + + public static partial class BackupDrProtectionSummary + { + public partial class BackupDrProtectionSummaryClient + { + /// + /// Creates a new instance of using the same call invoker as + /// this client. + /// + /// + /// A new for the same target as this client. + /// + public virtual gcl::Locations.LocationsClient CreateLocationsClient() => + new gcl::Locations.LocationsClient(CallInvoker); + + /// + /// Creates a new instance of using the same call invoker as + /// this client. + /// + /// + /// A new for the same target as this client. + /// + public virtual gciv::IAMPolicy.IAMPolicyClient CreateIAMPolicyClient() => + new gciv::IAMPolicy.IAMPolicyClient(CallInvoker); + } + } +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/PackageApiMetadata.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/PackageApiMetadata.g.cs index e0767f3689a3..10457fbed69c 100644 --- a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/PackageApiMetadata.g.cs +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/PackageApiMetadata.g.cs @@ -91,6 +91,7 @@ internal static class PackageApiMetadata yield return BackupvaultDiskReflection.Descriptor; yield return BackupvaultGceReflection.Descriptor; yield return DatasourcereferenceReflection.Descriptor; + yield return ProtectionSummaryReflection.Descriptor; yield return gciv::IamPolicyReflection.Descriptor; yield return gciv::OptionsReflection.Descriptor; yield return gciv::PolicyReflection.Descriptor; diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummary.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummary.g.cs new file mode 100644 index 000000000000..321840a670b9 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummary.g.cs @@ -0,0 +1,3127 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/cloud/backupdr/v1/protection_summary.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace Google.Cloud.BackupDR.V1 { + + /// Holder for reflection information generated from google/cloud/backupdr/v1/protection_summary.proto + public static partial class ProtectionSummaryReflection { + + #region Descriptor + /// File descriptor for google/cloud/backupdr/v1/protection_summary.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static ProtectionSummaryReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "CjFnb29nbGUvY2xvdWQvYmFja3VwZHIvdjEvcHJvdGVjdGlvbl9zdW1tYXJ5", + "LnByb3RvEhhnb29nbGUuY2xvdWQuYmFja3VwZHIudjEaHGdvb2dsZS9hcGkv", + "YW5ub3RhdGlvbnMucHJvdG8aF2dvb2dsZS9hcGkvY2xpZW50LnByb3RvGh9n", + "b29nbGUvYXBpL2ZpZWxkX2JlaGF2aW9yLnByb3RvGhtnb29nbGUvYXBpL2Zp", + "ZWxkX2luZm8ucHJvdG8aGWdvb2dsZS9hcGkvcmVzb3VyY2UucHJvdG8aH2dv", + "b2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8iugEKIExpc3RSZXNvdXJj", + "ZUJhY2t1cENvbmZpZ3NSZXF1ZXN0EjkKBnBhcmVudBgBIAEoCUIp4EEC+kEj", + "CiFsb2NhdGlvbnMuZ29vZ2xlYXBpcy5jb20vTG9jYXRpb24SFgoJcGFnZV9z", + "aXplGAIgASgFQgPgQQESFwoKcGFnZV90b2tlbhgDIAEoCUID4EEBEhMKBmZp", + "bHRlchgEIAEoCUID4EEBEhUKCG9yZGVyX2J5GAUgASgJQgPgQQEijQEKIUxp", + "c3RSZXNvdXJjZUJhY2t1cENvbmZpZ3NSZXNwb25zZRJPChdyZXNvdXJjZV9i", + "YWNrdXBfY29uZmlncxgBIAMoCzIuLmdvb2dsZS5jbG91ZC5iYWNrdXBkci52", + "MS5SZXNvdXJjZUJhY2t1cENvbmZpZxIXCg9uZXh0X3BhZ2VfdG9rZW4YAiAB", + "KAki7AYKFFJlc291cmNlQmFja3VwQ29uZmlnEhEKBG5hbWUYASABKAlCA+BB", + "CBIYCgN1aWQYAiABKAlCC+BBA+KMz9cIAggBEhwKD3RhcmdldF9yZXNvdXJj", + "ZRgDIAEoCUID4EEDEikKHHRhcmdldF9yZXNvdXJjZV9kaXNwbGF5X25hbWUY", + "BCABKAlCA+BBAxJeChR0YXJnZXRfcmVzb3VyY2VfdHlwZRgFIAEoDjI7Lmdv", + "b2dsZS5jbG91ZC5iYWNrdXBkci52MS5SZXNvdXJjZUJhY2t1cENvbmZpZy5S", + "ZXNvdXJjZVR5cGVCA+BBAxJoChZ0YXJnZXRfcmVzb3VyY2VfbGFiZWxzGAYg", + "AygLMkguZ29vZ2xlLmNsb3VkLmJhY2t1cGRyLnYxLlJlc291cmNlQmFja3Vw", + "Q29uZmlnLlRhcmdldFJlc291cmNlTGFiZWxzRW50cnkSTQoWYmFja3VwX2Nv", + "bmZpZ3NfZGV0YWlscxgHIAMoCzItLmdvb2dsZS5jbG91ZC5iYWNrdXBkci52", + "MS5CYWNrdXBDb25maWdEZXRhaWxzEh4KEWJhY2t1cF9jb25maWd1cmVkGAgg", + "ASgIQgPgQQMSFAoHdmF1bHRlZBgJIAEoCEID4EEDGjsKGVRhcmdldFJlc291", + "cmNlTGFiZWxzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4", + "ASKXAQoMUmVzb3VyY2VUeXBlEh0KGVJFU09VUkNFX1RZUEVfVU5TUEVDSUZJ", + "RUQQABIWChJDTE9VRF9TUUxfSU5TVEFOQ0UQARIVChFDT01QVVRFX0VOR0lO", + "RV9WTRACEhcKE0NPTVBVVEVfRU5HSU5FX0RJU0sQAxIgChxDT01QVVRFX0VO", + "R0lORV9SRUdJT05BTF9ESVNLEAQ6twHqQbMBCixiYWNrdXBkci5nb29nbGVh", + "cGlzLmNvbS9SZXNvdXJjZUJhY2t1cENvbmZpZxJWcHJvamVjdHMve3Byb2pl", + "Y3R9L2xvY2F0aW9ucy97bG9jYXRpb259L3Jlc291cmNlQmFja3VwQ29uZmln", + "cy97cmVzb3VyY2VfYmFja3VwX2NvbmZpZ30qFXJlc291cmNlQmFja3VwQ29u", + "ZmlnczIUcmVzb3VyY2VCYWNrdXBDb25maWciogcKE0JhY2t1cENvbmZpZ0Rl", + "dGFpbHMSIQoUYmFja3VwX2NvbmZpZ19zb3VyY2UYASABKAlCA+BBAxIuCiFi", + "YWNrdXBfY29uZmlnX3NvdXJjZV9kaXNwbGF5X25hbWUYAiABKAlCA+BBAxJF", + "CgR0eXBlGAMgASgOMjIuZ29vZ2xlLmNsb3VkLmJhY2t1cGRyLnYxLkJhY2t1", + "cENvbmZpZ0RldGFpbHMuVHlwZUID4EEDEkcKBXN0YXRlGAQgASgOMjMuZ29v", + "Z2xlLmNsb3VkLmJhY2t1cGRyLnYxLkJhY2t1cENvbmZpZ0RldGFpbHMuU3Rh", + "dGVCA+BBAxJCCg1waXRyX3NldHRpbmdzGAUgASgLMiYuZ29vZ2xlLmNsb3Vk", + "LmJhY2t1cGRyLnYxLlBpdHJTZXR0aW5nc0ID4EEDEkYKHWxhdGVzdF9zdWNj", + "ZXNzZnVsX2JhY2t1cF90aW1lGAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcEID4EEDEiAKE2FwcGxpY2FibGVfcmVzb3VyY2UYByABKAlCA+BB", + "AxIZCgxiYWNrdXBfdmF1bHQYCCABKAlCA+BBAxJCChBiYWNrdXBfbG9jYXRp", + "b25zGAwgAygLMiguZ29vZ2xlLmNsb3VkLmJhY2t1cGRyLnYxLkJhY2t1cExv", + "Y2F0aW9uEk0KFWJhY2t1cF9kcl9wbGFuX2NvbmZpZxgKIAEoCzIsLmdvb2ds", + "ZS5jbG91ZC5iYWNrdXBkci52MS5CYWNrdXBEclBsYW5Db25maWdIABJVChli", + "YWNrdXBfZHJfdGVtcGxhdGVfY29uZmlnGAsgASgLMjAuZ29vZ2xlLmNsb3Vk", + "LmJhY2t1cGRyLnYxLkJhY2t1cERyVGVtcGxhdGVDb25maWdIACKXAQoEVHlw", + "ZRIUChBUWVBFX1VOU1BFQ0lGSUVEEAASJAogQ0xPVURfU1FMX0lOU1RBTkNF", + "X0JBQ0tVUF9DT05GSUcQARIiCh5DT01QVVRFX0VOR0lORV9SRVNPVVJDRV9Q", + "T0xJQ1kQAhIYChRCQUNLVVBEUl9CQUNLVVBfUExBThADEhUKEUJBQ0tVUERS", + "X1RFTVBMQVRFEAQiQwoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIK", + "CgZBQ1RJVkUQARIMCghJTkFDVElWRRACEgkKBUVSUk9SEANCFgoUcGxhbl9z", + "cGVjaWZpY19jb25maWciKwoMUGl0clNldHRpbmdzEhsKDnJldGVudGlvbl9k", + "YXlzGAEgASgFQgPgQQMiagoWQmFja3VwRHJUZW1wbGF0ZUNvbmZpZxInChpm", + "aXJzdF9wYXJ0eV9tYW5hZ2VtZW50X3VyaRgBIAEoCUID4EEDEicKGnRoaXJk", + "X3BhcnR5X21hbmFnZW1lbnRfdXJpGAIgASgJQgPgQQMiXgoSQmFja3VwRHJQ", + "bGFuQ29uZmlnEkgKFGJhY2t1cF9kcl9wbGFuX3J1bGVzGAEgAygLMiouZ29v", + "Z2xlLmNsb3VkLmJhY2t1cGRyLnYxLkJhY2t1cERyUGxhblJ1bGUibgoQQmFj", + "a3VwRHJQbGFuUnVsZRIUCgdydWxlX2lkGAEgASgJQgPgQQMSRAobbGFzdF9z", + "dWNjZXNzZnVsX2JhY2t1cF90aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVm", + "LlRpbWVzdGFtcEID4EEDIrcBCg5CYWNrdXBMb2NhdGlvbhJACgR0eXBlGAEg", + "ASgOMi0uZ29vZ2xlLmNsb3VkLmJhY2t1cGRyLnYxLkJhY2t1cExvY2F0aW9u", + "LlR5cGVCA+BBAxIYCgtsb2NhdGlvbl9pZBgCIAEoCUID4EEDIkkKBFR5cGUS", + "FAoQVFlQRV9VTlNQRUNJRklFRBAAEgkKBVpPTkFMEAESDAoIUkVHSU9OQUwQ", + "AhISCg5NVUxUSV9SRUdJT05BTBADMssCChlCYWNrdXBEclByb3RlY3Rpb25T", + "dW1tYXJ5EuABChlMaXN0UmVzb3VyY2VCYWNrdXBDb25maWdzEjouZ29vZ2xl", + "LmNsb3VkLmJhY2t1cGRyLnYxLkxpc3RSZXNvdXJjZUJhY2t1cENvbmZpZ3NS", + "ZXF1ZXN0GjsuZ29vZ2xlLmNsb3VkLmJhY2t1cGRyLnYxLkxpc3RSZXNvdXJj", + "ZUJhY2t1cENvbmZpZ3NSZXNwb25zZSJK2kEGcGFyZW50gtPkkwI7EjkvdjEv", + "e3BhcmVudD1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qfS9yZXNvdXJjZUJhY2t1", + "cENvbmZpZ3MaS8pBF2JhY2t1cGRyLmdvb2dsZWFwaXMuY29t0kEuaHR0cHM6", + "Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jbG91ZC1wbGF0Zm9ybULGAQoc", + "Y29tLmdvb2dsZS5jbG91ZC5iYWNrdXBkci52MUIWUHJvdGVjdGlvblN1bW1h", + "cnlQcm90b1ABWjhjbG91ZC5nb29nbGUuY29tL2dvL2JhY2t1cGRyL2FwaXYx", + "L2JhY2t1cGRycGI7YmFja3VwZHJwYqoCGEdvb2dsZS5DbG91ZC5CYWNrdXBE", + "Ui5WMcoCGEdvb2dsZVxDbG91ZFxCYWNrdXBEUlxWMeoCG0dvb2dsZTo6Q2xv", + "dWQ6OkJhY2t1cERSOjpWMWIGcHJvdG8z")); + 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.FieldInfoReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest), global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest.Parser, new[]{ "Parent", "PageSize", "PageToken", "Filter", "OrderBy" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsResponse), global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsResponse.Parser, new[]{ "ResourceBackupConfigs", "NextPageToken" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.ResourceBackupConfig), global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Parser, new[]{ "Name", "Uid", "TargetResource", "TargetResourceDisplayName", "TargetResourceType", "TargetResourceLabels", "BackupConfigsDetails", "BackupConfigured", "Vaulted" }, null, new[]{ typeof(global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.BackupConfigDetails), global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Parser, new[]{ "BackupConfigSource", "BackupConfigSourceDisplayName", "Type", "State", "PitrSettings", "LatestSuccessfulBackupTime", "ApplicableResource", "BackupVault", "BackupLocations", "BackupDrPlanConfig", "BackupDrTemplateConfig" }, new[]{ "PlanSpecificConfig" }, new[]{ typeof(global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type), typeof(global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State) }, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.PitrSettings), global::Google.Cloud.BackupDR.V1.PitrSettings.Parser, new[]{ "RetentionDays" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig), global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig.Parser, new[]{ "FirstPartyManagementUri", "ThirdPartyManagementUri" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig), global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig.Parser, new[]{ "BackupDrPlanRules" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.BackupDrPlanRule), global::Google.Cloud.BackupDR.V1.BackupDrPlanRule.Parser, new[]{ "RuleId", "LastSuccessfulBackupTime" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.BackupDR.V1.BackupLocation), global::Google.Cloud.BackupDR.V1.BackupLocation.Parser, new[]{ "Type", "LocationId" }, null, new[]{ typeof(global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type) }, null, null) + })); + } + #endregion + + } + #region Messages + /// + /// Request for ListResourceBackupConfigs. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ListResourceBackupConfigsRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListResourceBackupConfigsRequest()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[0]; } + } + + [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 ListResourceBackupConfigsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListResourceBackupConfigsRequest(ListResourceBackupConfigsRequest 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 ListResourceBackupConfigsRequest Clone() { + return new ListResourceBackupConfigsRequest(this); + } + + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; + /// + /// Required. The project and location for which to retrieve resource backup + /// configs. Format: 'projects/{project_id}/locations/{location}'. In Google + /// Cloud Backup and DR, locations map to Google Cloud regions, for example + /// **us-central1**. + /// + [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_; + /// + /// Optional. Requested page size. Server may return fewer items than + /// requested. If unspecified, server will use 100 as default. Maximum value is + /// 500 and values above 500 will be coerced to 500. + /// + [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_ = ""; + /// + /// Optional. A token identifying a page of results the server should return. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string PageToken { + get { return pageToken_; } + set { + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 4; + private string filter_ = ""; + /// + /// Optional. Filtering 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_ = ""; + /// + /// Optional. Hint for how to order the results. + /// + [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 ListResourceBackupConfigsRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ListResourceBackupConfigsRequest 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; + } + + [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 (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(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); + } + #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 (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(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); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [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 (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ListResourceBackupConfigsRequest 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; + } + _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: { + 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(); + 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: { + 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(); + break; + } + } + } + } + #endif + + } + + /// + /// Response for ListResourceBackupConfigs. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ListResourceBackupConfigsResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListResourceBackupConfigsResponse()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[1]; } + } + + [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 ListResourceBackupConfigsResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListResourceBackupConfigsResponse(ListResourceBackupConfigsResponse other) : this() { + resourceBackupConfigs_ = other.resourceBackupConfigs_.Clone(); + nextPageToken_ = other.nextPageToken_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListResourceBackupConfigsResponse Clone() { + return new ListResourceBackupConfigsResponse(this); + } + + /// Field number for the "resource_backup_configs" field. + public const int ResourceBackupConfigsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_resourceBackupConfigs_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Parser); + private readonly pbc::RepeatedField resourceBackupConfigs_ = new pbc::RepeatedField(); + /// + /// The list of ResourceBackupConfigs for the specified scope. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField ResourceBackupConfigs { + get { return resourceBackupConfigs_; } + } + + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; + /// + /// A token identifying a page of results the server should return. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string NextPageToken { + get { return nextPageToken_; } + set { + nextPageToken_ = 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 ListResourceBackupConfigsResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ListResourceBackupConfigsResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!resourceBackupConfigs_.Equals(other.resourceBackupConfigs_)) return false; + if (NextPageToken != other.NextPageToken) 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 ^= resourceBackupConfigs_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.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 + resourceBackupConfigs_.WriteTo(output, _repeated_resourceBackupConfigs_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + 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) { + resourceBackupConfigs_.WriteTo(ref output, _repeated_resourceBackupConfigs_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + 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 += resourceBackupConfigs_.CalculateSize(_repeated_resourceBackupConfigs_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ListResourceBackupConfigsResponse other) { + if (other == null) { + return; + } + resourceBackupConfigs_.Add(other.resourceBackupConfigs_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; + } + _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: { + resourceBackupConfigs_.AddEntriesFrom(input, _repeated_resourceBackupConfigs_codec); + break; + } + case 18: { + NextPageToken = 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: { + resourceBackupConfigs_.AddEntriesFrom(ref input, _repeated_resourceBackupConfigs_codec); + break; + } + case 18: { + NextPageToken = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// ResourceBackupConfig represents a resource along with its backup + /// configurations. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ResourceBackupConfig : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ResourceBackupConfig()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[2]; } + } + + [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 ResourceBackupConfig() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResourceBackupConfig(ResourceBackupConfig other) : this() { + name_ = other.name_; + uid_ = other.uid_; + targetResource_ = other.targetResource_; + targetResourceDisplayName_ = other.targetResourceDisplayName_; + targetResourceType_ = other.targetResourceType_; + targetResourceLabels_ = other.targetResourceLabels_.Clone(); + backupConfigsDetails_ = other.backupConfigsDetails_.Clone(); + backupConfigured_ = other.backupConfigured_; + vaulted_ = other.vaulted_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResourceBackupConfig Clone() { + return new ResourceBackupConfig(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Identifier. The resource name of the ResourceBackupConfig. + /// Format: + /// projects/{project}/locations/{location}/resourceBackupConfigs/{uid} + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "uid" field. + public const int UidFieldNumber = 2; + private string uid_ = ""; + /// + /// Output only. The unique identifier of the resource backup config. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Uid { + get { return uid_; } + set { + uid_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "target_resource" field. + public const int TargetResourceFieldNumber = 3; + private string targetResource_ = ""; + /// + /// Output only. The [full resource + /// name](https://cloud.google.com/asset-inventory/docs/resource-name-format) + /// of the cloud resource that this configuration applies to. Supported + /// resource types are + /// [ResourceBackupConfig.ResourceType][google.cloud.backupdr.v1.ResourceBackupConfig.ResourceType]. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TargetResource { + get { return targetResource_; } + set { + targetResource_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "target_resource_display_name" field. + public const int TargetResourceDisplayNameFieldNumber = 4; + private string targetResourceDisplayName_ = ""; + /// + /// Output only. The human friendly name of the target resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TargetResourceDisplayName { + get { return targetResourceDisplayName_; } + set { + targetResourceDisplayName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "target_resource_type" field. + public const int TargetResourceTypeFieldNumber = 5; + private global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType targetResourceType_ = global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType.Unspecified; + /// + /// Output only. The type of the target resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType TargetResourceType { + get { return targetResourceType_; } + set { + targetResourceType_ = value; + } + } + + /// Field number for the "target_resource_labels" field. + public const int TargetResourceLabelsFieldNumber = 6; + private static readonly pbc::MapField.Codec _map_targetResourceLabels_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 50); + private readonly pbc::MapField targetResourceLabels_ = new pbc::MapField(); + /// + /// Labels associated with the target resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField TargetResourceLabels { + get { return targetResourceLabels_; } + } + + /// Field number for the "backup_configs_details" field. + public const int BackupConfigsDetailsFieldNumber = 7; + private static readonly pb::FieldCodec _repeated_backupConfigsDetails_codec + = pb::FieldCodec.ForMessage(58, global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Parser); + private readonly pbc::RepeatedField backupConfigsDetails_ = new pbc::RepeatedField(); + /// + /// Backup configurations applying to the target resource, including those + /// targeting its related/child resources. For example, backup configuration + /// applicable to Compute Engine disks will be populated in this field for a + /// Compute Engine VM which has the disk associated. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField BackupConfigsDetails { + get { return backupConfigsDetails_; } + } + + /// Field number for the "backup_configured" field. + public const int BackupConfiguredFieldNumber = 8; + private bool backupConfigured_; + /// + /// Output only. Whether the target resource is configured for backup. This is + /// true if the backup_configs_details is not empty. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool BackupConfigured { + get { return backupConfigured_; } + set { + backupConfigured_ = value; + } + } + + /// Field number for the "vaulted" field. + public const int VaultedFieldNumber = 9; + private bool vaulted_; + /// + /// Output only. Whether the target resource is protected by a backup vault. + /// This is true if the backup_configs_details is not empty and any of the + /// [ResourceBackupConfig.backup_configs_details][google.cloud.backupdr.v1.ResourceBackupConfig.backup_configs_details] + /// has a backup configuration with + /// [BackupConfigDetails.backup_vault][google.cloud.backupdr.v1.BackupConfigDetails.backup_vault] + /// set. set. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Vaulted { + get { return vaulted_; } + set { + vaulted_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ResourceBackupConfig); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ResourceBackupConfig other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (Uid != other.Uid) return false; + if (TargetResource != other.TargetResource) return false; + if (TargetResourceDisplayName != other.TargetResourceDisplayName) return false; + if (TargetResourceType != other.TargetResourceType) return false; + if (!TargetResourceLabels.Equals(other.TargetResourceLabels)) return false; + if(!backupConfigsDetails_.Equals(other.backupConfigsDetails_)) return false; + if (BackupConfigured != other.BackupConfigured) return false; + if (Vaulted != other.Vaulted) 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 (Uid.Length != 0) hash ^= Uid.GetHashCode(); + if (TargetResource.Length != 0) hash ^= TargetResource.GetHashCode(); + if (TargetResourceDisplayName.Length != 0) hash ^= TargetResourceDisplayName.GetHashCode(); + if (TargetResourceType != global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType.Unspecified) hash ^= TargetResourceType.GetHashCode(); + hash ^= TargetResourceLabels.GetHashCode(); + hash ^= backupConfigsDetails_.GetHashCode(); + if (BackupConfigured != false) hash ^= BackupConfigured.GetHashCode(); + if (Vaulted != false) hash ^= Vaulted.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 (Uid.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Uid); + } + if (TargetResource.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TargetResource); + } + if (TargetResourceDisplayName.Length != 0) { + output.WriteRawTag(34); + output.WriteString(TargetResourceDisplayName); + } + if (TargetResourceType != global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) TargetResourceType); + } + targetResourceLabels_.WriteTo(output, _map_targetResourceLabels_codec); + backupConfigsDetails_.WriteTo(output, _repeated_backupConfigsDetails_codec); + if (BackupConfigured != false) { + output.WriteRawTag(64); + output.WriteBool(BackupConfigured); + } + if (Vaulted != false) { + output.WriteRawTag(72); + output.WriteBool(Vaulted); + } + 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 (Uid.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Uid); + } + if (TargetResource.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TargetResource); + } + if (TargetResourceDisplayName.Length != 0) { + output.WriteRawTag(34); + output.WriteString(TargetResourceDisplayName); + } + if (TargetResourceType != global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType.Unspecified) { + output.WriteRawTag(40); + output.WriteEnum((int) TargetResourceType); + } + targetResourceLabels_.WriteTo(ref output, _map_targetResourceLabels_codec); + backupConfigsDetails_.WriteTo(ref output, _repeated_backupConfigsDetails_codec); + if (BackupConfigured != false) { + output.WriteRawTag(64); + output.WriteBool(BackupConfigured); + } + if (Vaulted != false) { + output.WriteRawTag(72); + output.WriteBool(Vaulted); + } + 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 (Uid.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Uid); + } + if (TargetResource.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TargetResource); + } + if (TargetResourceDisplayName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TargetResourceDisplayName); + } + if (TargetResourceType != global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) TargetResourceType); + } + size += targetResourceLabels_.CalculateSize(_map_targetResourceLabels_codec); + size += backupConfigsDetails_.CalculateSize(_repeated_backupConfigsDetails_codec); + if (BackupConfigured != false) { + size += 1 + 1; + } + if (Vaulted != 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(ResourceBackupConfig other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Uid.Length != 0) { + Uid = other.Uid; + } + if (other.TargetResource.Length != 0) { + TargetResource = other.TargetResource; + } + if (other.TargetResourceDisplayName.Length != 0) { + TargetResourceDisplayName = other.TargetResourceDisplayName; + } + if (other.TargetResourceType != global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType.Unspecified) { + TargetResourceType = other.TargetResourceType; + } + targetResourceLabels_.MergeFrom(other.targetResourceLabels_); + backupConfigsDetails_.Add(other.backupConfigsDetails_); + if (other.BackupConfigured != false) { + BackupConfigured = other.BackupConfigured; + } + if (other.Vaulted != false) { + Vaulted = other.Vaulted; + } + _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: { + Name = input.ReadString(); + break; + } + case 18: { + Uid = input.ReadString(); + break; + } + case 26: { + TargetResource = input.ReadString(); + break; + } + case 34: { + TargetResourceDisplayName = input.ReadString(); + break; + } + case 40: { + TargetResourceType = (global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType) input.ReadEnum(); + break; + } + case 50: { + targetResourceLabels_.AddEntriesFrom(input, _map_targetResourceLabels_codec); + break; + } + case 58: { + backupConfigsDetails_.AddEntriesFrom(input, _repeated_backupConfigsDetails_codec); + break; + } + case 64: { + BackupConfigured = input.ReadBool(); + break; + } + case 72: { + Vaulted = 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: { + Name = input.ReadString(); + break; + } + case 18: { + Uid = input.ReadString(); + break; + } + case 26: { + TargetResource = input.ReadString(); + break; + } + case 34: { + TargetResourceDisplayName = input.ReadString(); + break; + } + case 40: { + TargetResourceType = (global::Google.Cloud.BackupDR.V1.ResourceBackupConfig.Types.ResourceType) input.ReadEnum(); + break; + } + case 50: { + targetResourceLabels_.AddEntriesFrom(ref input, _map_targetResourceLabels_codec); + break; + } + case 58: { + backupConfigsDetails_.AddEntriesFrom(ref input, _repeated_backupConfigsDetails_codec); + break; + } + case 64: { + BackupConfigured = input.ReadBool(); + break; + } + case 72: { + Vaulted = input.ReadBool(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the ResourceBackupConfig message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// The type of the cloud resource. + /// + public enum ResourceType { + /// + /// Resource type not set. + /// + [pbr::OriginalName("RESOURCE_TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// Cloud SQL instance. + /// + [pbr::OriginalName("CLOUD_SQL_INSTANCE")] CloudSqlInstance = 1, + /// + /// Compute Engine VM. + /// + [pbr::OriginalName("COMPUTE_ENGINE_VM")] ComputeEngineVm = 2, + /// + /// Compute Engine Disk. + /// + [pbr::OriginalName("COMPUTE_ENGINE_DISK")] ComputeEngineDisk = 3, + /// + /// Compute Engine Regional Disk. + /// + [pbr::OriginalName("COMPUTE_ENGINE_REGIONAL_DISK")] ComputeEngineRegionalDisk = 4, + } + + } + #endregion + + } + + /// + /// BackupConfigDetails has information about how the resource is configured + /// for backups and about the most recent backup taken for this configuration. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BackupConfigDetails : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BackupConfigDetails()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[3]; } + } + + [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 BackupConfigDetails() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupConfigDetails(BackupConfigDetails other) : this() { + backupConfigSource_ = other.backupConfigSource_; + backupConfigSourceDisplayName_ = other.backupConfigSourceDisplayName_; + type_ = other.type_; + state_ = other.state_; + pitrSettings_ = other.pitrSettings_ != null ? other.pitrSettings_.Clone() : null; + latestSuccessfulBackupTime_ = other.latestSuccessfulBackupTime_ != null ? other.latestSuccessfulBackupTime_.Clone() : null; + applicableResource_ = other.applicableResource_; + backupVault_ = other.backupVault_; + backupLocations_ = other.backupLocations_.Clone(); + switch (other.PlanSpecificConfigCase) { + case PlanSpecificConfigOneofCase.BackupDrPlanConfig: + BackupDrPlanConfig = other.BackupDrPlanConfig.Clone(); + break; + case PlanSpecificConfigOneofCase.BackupDrTemplateConfig: + BackupDrTemplateConfig = other.BackupDrTemplateConfig.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupConfigDetails Clone() { + return new BackupConfigDetails(this); + } + + /// Field number for the "backup_config_source" field. + public const int BackupConfigSourceFieldNumber = 1; + private string backupConfigSource_ = ""; + /// + /// Output only. The full resource name of the backup config source resource. + /// For example, + /// "//backupdr.googleapis.com/v1/projects/{project}/locations/{region}/backupPlans/{backupplanId}" + /// or + /// "//compute.googleapis.com/projects/{project}/locations/{region}/resourcePolicies/{resourcePolicyId}". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string BackupConfigSource { + get { return backupConfigSource_; } + set { + backupConfigSource_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "backup_config_source_display_name" field. + public const int BackupConfigSourceDisplayNameFieldNumber = 2; + private string backupConfigSourceDisplayName_ = ""; + /// + /// Output only. The display name of the backup config source resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string BackupConfigSourceDisplayName { + get { return backupConfigSourceDisplayName_; } + set { + backupConfigSourceDisplayName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 3; + private global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type type_ = global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type.Unspecified; + /// + /// Output only. The type of the backup config resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "state" field. + public const int StateFieldNumber = 4; + private global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State state_ = global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State.Unspecified; + /// + /// Output only. The state of the backup config resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State State { + get { return state_; } + set { + state_ = value; + } + } + + /// Field number for the "pitr_settings" field. + public const int PitrSettingsFieldNumber = 5; + private global::Google.Cloud.BackupDR.V1.PitrSettings pitrSettings_; + /// + /// Output only. Point in time recovery settings of the backup configuration + /// resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.PitrSettings PitrSettings { + get { return pitrSettings_; } + set { + pitrSettings_ = value; + } + } + + /// Field number for the "latest_successful_backup_time" field. + public const int LatestSuccessfulBackupTimeFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp latestSuccessfulBackupTime_; + /// + /// Output only. Timestamp of the latest successful backup created via this + /// backup configuration. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp LatestSuccessfulBackupTime { + get { return latestSuccessfulBackupTime_; } + set { + latestSuccessfulBackupTime_ = value; + } + } + + /// Field number for the "applicable_resource" field. + public const int ApplicableResourceFieldNumber = 7; + private string applicableResource_ = ""; + /// + /// Output only. The [full resource + /// name](https://cloud.google.com/asset-inventory/docs/resource-name-format) + /// of the resource that is applicable for the backup configuration. Example: + /// "//compute.googleapis.com/projects/{project}/zones/{zone}/instances/{instance}" + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ApplicableResource { + get { return applicableResource_; } + set { + applicableResource_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "backup_vault" field. + public const int BackupVaultFieldNumber = 8; + private string backupVault_ = ""; + /// + /// Output only. The [full resource + /// name](https://cloud.google.com/asset-inventory/docs/resource-name-format) + /// of the backup vault that will store the backups generated through this + /// backup configuration. Example: + /// "//backupdr.googleapis.com/v1/projects/{project}/locations/{region}/backupVaults/{backupvaultId}" + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string BackupVault { + get { return backupVault_; } + set { + backupVault_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "backup_locations" field. + public const int BackupLocationsFieldNumber = 12; + private static readonly pb::FieldCodec _repeated_backupLocations_codec + = pb::FieldCodec.ForMessage(98, global::Google.Cloud.BackupDR.V1.BackupLocation.Parser); + private readonly pbc::RepeatedField backupLocations_ = new pbc::RepeatedField(); + /// + /// The locations where the backups are to be stored. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField BackupLocations { + get { return backupLocations_; } + } + + /// Field number for the "backup_dr_plan_config" field. + public const int BackupDrPlanConfigFieldNumber = 10; + /// + /// Google Cloud Backup and DR's Backup Plan specific data. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig BackupDrPlanConfig { + get { return planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig ? (global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig) planSpecificConfig_ : null; } + set { + planSpecificConfig_ = value; + planSpecificConfigCase_ = value == null ? PlanSpecificConfigOneofCase.None : PlanSpecificConfigOneofCase.BackupDrPlanConfig; + } + } + + /// Field number for the "backup_dr_template_config" field. + public const int BackupDrTemplateConfigFieldNumber = 11; + /// + /// Google Cloud Backup and DR's Template specific data. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig BackupDrTemplateConfig { + get { return planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig ? (global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig) planSpecificConfig_ : null; } + set { + planSpecificConfig_ = value; + planSpecificConfigCase_ = value == null ? PlanSpecificConfigOneofCase.None : PlanSpecificConfigOneofCase.BackupDrTemplateConfig; + } + } + + private object planSpecificConfig_; + /// Enum of possible cases for the "plan_specific_config" oneof. + public enum PlanSpecificConfigOneofCase { + None = 0, + BackupDrPlanConfig = 10, + BackupDrTemplateConfig = 11, + } + private PlanSpecificConfigOneofCase planSpecificConfigCase_ = PlanSpecificConfigOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PlanSpecificConfigOneofCase PlanSpecificConfigCase { + get { return planSpecificConfigCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearPlanSpecificConfig() { + planSpecificConfigCase_ = PlanSpecificConfigOneofCase.None; + planSpecificConfig_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BackupConfigDetails); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BackupConfigDetails other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (BackupConfigSource != other.BackupConfigSource) return false; + if (BackupConfigSourceDisplayName != other.BackupConfigSourceDisplayName) return false; + if (Type != other.Type) return false; + if (State != other.State) return false; + if (!object.Equals(PitrSettings, other.PitrSettings)) return false; + if (!object.Equals(LatestSuccessfulBackupTime, other.LatestSuccessfulBackupTime)) return false; + if (ApplicableResource != other.ApplicableResource) return false; + if (BackupVault != other.BackupVault) return false; + if(!backupLocations_.Equals(other.backupLocations_)) return false; + if (!object.Equals(BackupDrPlanConfig, other.BackupDrPlanConfig)) return false; + if (!object.Equals(BackupDrTemplateConfig, other.BackupDrTemplateConfig)) return false; + if (PlanSpecificConfigCase != other.PlanSpecificConfigCase) 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 (BackupConfigSource.Length != 0) hash ^= BackupConfigSource.GetHashCode(); + if (BackupConfigSourceDisplayName.Length != 0) hash ^= BackupConfigSourceDisplayName.GetHashCode(); + if (Type != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type.Unspecified) hash ^= Type.GetHashCode(); + if (State != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State.Unspecified) hash ^= State.GetHashCode(); + if (pitrSettings_ != null) hash ^= PitrSettings.GetHashCode(); + if (latestSuccessfulBackupTime_ != null) hash ^= LatestSuccessfulBackupTime.GetHashCode(); + if (ApplicableResource.Length != 0) hash ^= ApplicableResource.GetHashCode(); + if (BackupVault.Length != 0) hash ^= BackupVault.GetHashCode(); + hash ^= backupLocations_.GetHashCode(); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig) hash ^= BackupDrPlanConfig.GetHashCode(); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig) hash ^= BackupDrTemplateConfig.GetHashCode(); + hash ^= (int) planSpecificConfigCase_; + 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 (BackupConfigSource.Length != 0) { + output.WriteRawTag(10); + output.WriteString(BackupConfigSource); + } + if (BackupConfigSourceDisplayName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(BackupConfigSourceDisplayName); + } + if (Type != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) Type); + } + if (State != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) State); + } + if (pitrSettings_ != null) { + output.WriteRawTag(42); + output.WriteMessage(PitrSettings); + } + if (latestSuccessfulBackupTime_ != null) { + output.WriteRawTag(50); + output.WriteMessage(LatestSuccessfulBackupTime); + } + if (ApplicableResource.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ApplicableResource); + } + if (BackupVault.Length != 0) { + output.WriteRawTag(66); + output.WriteString(BackupVault); + } + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig) { + output.WriteRawTag(82); + output.WriteMessage(BackupDrPlanConfig); + } + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig) { + output.WriteRawTag(90); + output.WriteMessage(BackupDrTemplateConfig); + } + backupLocations_.WriteTo(output, _repeated_backupLocations_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) { + if (BackupConfigSource.Length != 0) { + output.WriteRawTag(10); + output.WriteString(BackupConfigSource); + } + if (BackupConfigSourceDisplayName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(BackupConfigSourceDisplayName); + } + if (Type != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) Type); + } + if (State != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) State); + } + if (pitrSettings_ != null) { + output.WriteRawTag(42); + output.WriteMessage(PitrSettings); + } + if (latestSuccessfulBackupTime_ != null) { + output.WriteRawTag(50); + output.WriteMessage(LatestSuccessfulBackupTime); + } + if (ApplicableResource.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ApplicableResource); + } + if (BackupVault.Length != 0) { + output.WriteRawTag(66); + output.WriteString(BackupVault); + } + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig) { + output.WriteRawTag(82); + output.WriteMessage(BackupDrPlanConfig); + } + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig) { + output.WriteRawTag(90); + output.WriteMessage(BackupDrTemplateConfig); + } + backupLocations_.WriteTo(ref output, _repeated_backupLocations_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; + if (BackupConfigSource.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(BackupConfigSource); + } + if (BackupConfigSourceDisplayName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(BackupConfigSourceDisplayName); + } + if (Type != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (State != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + } + if (pitrSettings_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(PitrSettings); + } + if (latestSuccessfulBackupTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(LatestSuccessfulBackupTime); + } + if (ApplicableResource.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ApplicableResource); + } + if (BackupVault.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(BackupVault); + } + size += backupLocations_.CalculateSize(_repeated_backupLocations_codec); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(BackupDrPlanConfig); + } + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(BackupDrTemplateConfig); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BackupConfigDetails other) { + if (other == null) { + return; + } + if (other.BackupConfigSource.Length != 0) { + BackupConfigSource = other.BackupConfigSource; + } + if (other.BackupConfigSourceDisplayName.Length != 0) { + BackupConfigSourceDisplayName = other.BackupConfigSourceDisplayName; + } + if (other.Type != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type.Unspecified) { + Type = other.Type; + } + if (other.State != global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State.Unspecified) { + State = other.State; + } + if (other.pitrSettings_ != null) { + if (pitrSettings_ == null) { + PitrSettings = new global::Google.Cloud.BackupDR.V1.PitrSettings(); + } + PitrSettings.MergeFrom(other.PitrSettings); + } + if (other.latestSuccessfulBackupTime_ != null) { + if (latestSuccessfulBackupTime_ == null) { + LatestSuccessfulBackupTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + LatestSuccessfulBackupTime.MergeFrom(other.LatestSuccessfulBackupTime); + } + if (other.ApplicableResource.Length != 0) { + ApplicableResource = other.ApplicableResource; + } + if (other.BackupVault.Length != 0) { + BackupVault = other.BackupVault; + } + backupLocations_.Add(other.backupLocations_); + switch (other.PlanSpecificConfigCase) { + case PlanSpecificConfigOneofCase.BackupDrPlanConfig: + if (BackupDrPlanConfig == null) { + BackupDrPlanConfig = new global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig(); + } + BackupDrPlanConfig.MergeFrom(other.BackupDrPlanConfig); + break; + case PlanSpecificConfigOneofCase.BackupDrTemplateConfig: + if (BackupDrTemplateConfig == null) { + BackupDrTemplateConfig = new global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig(); + } + BackupDrTemplateConfig.MergeFrom(other.BackupDrTemplateConfig); + break; + } + + _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: { + BackupConfigSource = input.ReadString(); + break; + } + case 18: { + BackupConfigSourceDisplayName = input.ReadString(); + break; + } + case 24: { + Type = (global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type) input.ReadEnum(); + break; + } + case 32: { + State = (global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State) input.ReadEnum(); + break; + } + case 42: { + if (pitrSettings_ == null) { + PitrSettings = new global::Google.Cloud.BackupDR.V1.PitrSettings(); + } + input.ReadMessage(PitrSettings); + break; + } + case 50: { + if (latestSuccessfulBackupTime_ == null) { + LatestSuccessfulBackupTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(LatestSuccessfulBackupTime); + break; + } + case 58: { + ApplicableResource = input.ReadString(); + break; + } + case 66: { + BackupVault = input.ReadString(); + break; + } + case 82: { + global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig subBuilder = new global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig(); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig) { + subBuilder.MergeFrom(BackupDrPlanConfig); + } + input.ReadMessage(subBuilder); + BackupDrPlanConfig = subBuilder; + break; + } + case 90: { + global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig subBuilder = new global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig(); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig) { + subBuilder.MergeFrom(BackupDrTemplateConfig); + } + input.ReadMessage(subBuilder); + BackupDrTemplateConfig = subBuilder; + break; + } + case 98: { + backupLocations_.AddEntriesFrom(input, _repeated_backupLocations_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: { + BackupConfigSource = input.ReadString(); + break; + } + case 18: { + BackupConfigSourceDisplayName = input.ReadString(); + break; + } + case 24: { + Type = (global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.Type) input.ReadEnum(); + break; + } + case 32: { + State = (global::Google.Cloud.BackupDR.V1.BackupConfigDetails.Types.State) input.ReadEnum(); + break; + } + case 42: { + if (pitrSettings_ == null) { + PitrSettings = new global::Google.Cloud.BackupDR.V1.PitrSettings(); + } + input.ReadMessage(PitrSettings); + break; + } + case 50: { + if (latestSuccessfulBackupTime_ == null) { + LatestSuccessfulBackupTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(LatestSuccessfulBackupTime); + break; + } + case 58: { + ApplicableResource = input.ReadString(); + break; + } + case 66: { + BackupVault = input.ReadString(); + break; + } + case 82: { + global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig subBuilder = new global::Google.Cloud.BackupDR.V1.BackupDrPlanConfig(); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrPlanConfig) { + subBuilder.MergeFrom(BackupDrPlanConfig); + } + input.ReadMessage(subBuilder); + BackupDrPlanConfig = subBuilder; + break; + } + case 90: { + global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig subBuilder = new global::Google.Cloud.BackupDR.V1.BackupDrTemplateConfig(); + if (planSpecificConfigCase_ == PlanSpecificConfigOneofCase.BackupDrTemplateConfig) { + subBuilder.MergeFrom(BackupDrTemplateConfig); + } + input.ReadMessage(subBuilder); + BackupDrTemplateConfig = subBuilder; + break; + } + case 98: { + backupLocations_.AddEntriesFrom(ref input, _repeated_backupLocations_codec); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the BackupConfigDetails message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// Type of the backup configuration. + /// This enum may receive new values in the future. + /// + public enum Type { + /// + /// Backup config type is unspecified. + /// + [pbr::OriginalName("TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// Backup config is Cloud SQL instance's automated backup config. + /// + [pbr::OriginalName("CLOUD_SQL_INSTANCE_BACKUP_CONFIG")] CloudSqlInstanceBackupConfig = 1, + /// + /// Backup config is Compute Engine Resource Policy. + /// + [pbr::OriginalName("COMPUTE_ENGINE_RESOURCE_POLICY")] ComputeEngineResourcePolicy = 2, + /// + /// Backup config is Google Cloud Backup and DR's Backup Plan. + /// + [pbr::OriginalName("BACKUPDR_BACKUP_PLAN")] BackupdrBackupPlan = 3, + /// + /// Backup config is Google Cloud Backup and DR's Template. + /// + [pbr::OriginalName("BACKUPDR_TEMPLATE")] BackupdrTemplate = 4, + } + + /// + /// The state tells whether the backup config is active or not. + /// + public enum State { + /// + /// Backup config state not set. + /// + [pbr::OriginalName("STATE_UNSPECIFIED")] Unspecified = 0, + /// + /// The config is in an active state protecting the resource + /// + [pbr::OriginalName("ACTIVE")] Active = 1, + /// + /// The config is currently not protecting the resource. Either because it is + /// disabled or the owning project has been deleted without cleanup of the + /// actual resource. + /// + [pbr::OriginalName("INACTIVE")] Inactive = 2, + /// + /// The config still exists but because of some error state it is not + /// protecting the resource. Like the source project is deleted. For eg. + /// PlanAssociation, BackupPlan is deleted. + /// + [pbr::OriginalName("ERROR")] Error = 3, + } + + } + #endregion + + } + + /// + /// Point in time recovery settings of the backup configuration resource. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class PitrSettings : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PitrSettings()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[4]; } + } + + [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 PitrSettings() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PitrSettings(PitrSettings other) : this() { + retentionDays_ = other.retentionDays_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PitrSettings Clone() { + return new PitrSettings(this); + } + + /// Field number for the "retention_days" field. + public const int RetentionDaysFieldNumber = 1; + private int retentionDays_; + /// + /// Output only. Number of days to retain the backup. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int RetentionDays { + get { return retentionDays_; } + set { + retentionDays_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as PitrSettings); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(PitrSettings other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (RetentionDays != other.RetentionDays) 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 (RetentionDays != 0) hash ^= RetentionDays.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 (RetentionDays != 0) { + output.WriteRawTag(8); + output.WriteInt32(RetentionDays); + } + 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 (RetentionDays != 0) { + output.WriteRawTag(8); + output.WriteInt32(RetentionDays); + } + 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 (RetentionDays != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(RetentionDays); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(PitrSettings other) { + if (other == null) { + return; + } + if (other.RetentionDays != 0) { + RetentionDays = other.RetentionDays; + } + _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: { + RetentionDays = input.ReadInt32(); + 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: { + RetentionDays = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + /// + /// Provides additional information about Google Cloud Backup + /// and DR's Template backup configuration. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BackupDrTemplateConfig : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BackupDrTemplateConfig()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[5]; } + } + + [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 BackupDrTemplateConfig() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupDrTemplateConfig(BackupDrTemplateConfig other) : this() { + firstPartyManagementUri_ = other.firstPartyManagementUri_; + thirdPartyManagementUri_ = other.thirdPartyManagementUri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupDrTemplateConfig Clone() { + return new BackupDrTemplateConfig(this); + } + + /// Field number for the "first_party_management_uri" field. + public const int FirstPartyManagementUriFieldNumber = 1; + private string firstPartyManagementUri_ = ""; + /// + /// Output only. The URI of the BackupDr template resource for the first party + /// identity users. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string FirstPartyManagementUri { + get { return firstPartyManagementUri_; } + set { + firstPartyManagementUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "third_party_management_uri" field. + public const int ThirdPartyManagementUriFieldNumber = 2; + private string thirdPartyManagementUri_ = ""; + /// + /// Output only. The URI of the BackupDr template resource for the third party + /// identity users. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ThirdPartyManagementUri { + get { return thirdPartyManagementUri_; } + set { + thirdPartyManagementUri_ = 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 BackupDrTemplateConfig); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BackupDrTemplateConfig other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (FirstPartyManagementUri != other.FirstPartyManagementUri) return false; + if (ThirdPartyManagementUri != other.ThirdPartyManagementUri) 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 (FirstPartyManagementUri.Length != 0) hash ^= FirstPartyManagementUri.GetHashCode(); + if (ThirdPartyManagementUri.Length != 0) hash ^= ThirdPartyManagementUri.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 (FirstPartyManagementUri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(FirstPartyManagementUri); + } + if (ThirdPartyManagementUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ThirdPartyManagementUri); + } + 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 (FirstPartyManagementUri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(FirstPartyManagementUri); + } + if (ThirdPartyManagementUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ThirdPartyManagementUri); + } + 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 (FirstPartyManagementUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(FirstPartyManagementUri); + } + if (ThirdPartyManagementUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ThirdPartyManagementUri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BackupDrTemplateConfig other) { + if (other == null) { + return; + } + if (other.FirstPartyManagementUri.Length != 0) { + FirstPartyManagementUri = other.FirstPartyManagementUri; + } + if (other.ThirdPartyManagementUri.Length != 0) { + ThirdPartyManagementUri = other.ThirdPartyManagementUri; + } + _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: { + FirstPartyManagementUri = input.ReadString(); + break; + } + case 18: { + ThirdPartyManagementUri = 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: { + FirstPartyManagementUri = input.ReadString(); + break; + } + case 18: { + ThirdPartyManagementUri = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// BackupDrPlanConfig has additional information about Google Cloud Backup and + /// DR's Plan backup configuration. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BackupDrPlanConfig : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BackupDrPlanConfig()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[6]; } + } + + [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 BackupDrPlanConfig() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupDrPlanConfig(BackupDrPlanConfig other) : this() { + backupDrPlanRules_ = other.backupDrPlanRules_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupDrPlanConfig Clone() { + return new BackupDrPlanConfig(this); + } + + /// Field number for the "backup_dr_plan_rules" field. + public const int BackupDrPlanRulesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_backupDrPlanRules_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.BackupDR.V1.BackupDrPlanRule.Parser); + private readonly pbc::RepeatedField backupDrPlanRules_ = new pbc::RepeatedField(); + /// + /// Backup rules of the backup plan resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField BackupDrPlanRules { + get { return backupDrPlanRules_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BackupDrPlanConfig); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BackupDrPlanConfig other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!backupDrPlanRules_.Equals(other.backupDrPlanRules_)) 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 ^= backupDrPlanRules_.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 + backupDrPlanRules_.WriteTo(output, _repeated_backupDrPlanRules_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) { + backupDrPlanRules_.WriteTo(ref output, _repeated_backupDrPlanRules_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 += backupDrPlanRules_.CalculateSize(_repeated_backupDrPlanRules_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BackupDrPlanConfig other) { + if (other == null) { + return; + } + backupDrPlanRules_.Add(other.backupDrPlanRules_); + _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: { + backupDrPlanRules_.AddEntriesFrom(input, _repeated_backupDrPlanRules_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: { + backupDrPlanRules_.AddEntriesFrom(ref input, _repeated_backupDrPlanRules_codec); + break; + } + } + } + } + #endif + + } + + /// + /// BackupDrPlanRule has rule specific information of the backup plan resource. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BackupDrPlanRule : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BackupDrPlanRule()); + 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.BackupDR.V1.ProtectionSummaryReflection.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 BackupDrPlanRule() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupDrPlanRule(BackupDrPlanRule other) : this() { + ruleId_ = other.ruleId_; + lastSuccessfulBackupTime_ = other.lastSuccessfulBackupTime_ != null ? other.lastSuccessfulBackupTime_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupDrPlanRule Clone() { + return new BackupDrPlanRule(this); + } + + /// Field number for the "rule_id" field. + public const int RuleIdFieldNumber = 1; + private string ruleId_ = ""; + /// + /// Output only. Unique Id of the backup rule. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RuleId { + get { return ruleId_; } + set { + ruleId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "last_successful_backup_time" field. + public const int LastSuccessfulBackupTimeFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.Timestamp lastSuccessfulBackupTime_; + /// + /// Output only. Timestamp of the latest successful backup created via this + /// backup rule. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp LastSuccessfulBackupTime { + get { return lastSuccessfulBackupTime_; } + set { + lastSuccessfulBackupTime_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BackupDrPlanRule); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BackupDrPlanRule other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (RuleId != other.RuleId) return false; + if (!object.Equals(LastSuccessfulBackupTime, other.LastSuccessfulBackupTime)) 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 (RuleId.Length != 0) hash ^= RuleId.GetHashCode(); + if (lastSuccessfulBackupTime_ != null) hash ^= LastSuccessfulBackupTime.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 (RuleId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(RuleId); + } + if (lastSuccessfulBackupTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(LastSuccessfulBackupTime); + } + 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 (RuleId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(RuleId); + } + if (lastSuccessfulBackupTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(LastSuccessfulBackupTime); + } + 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 (RuleId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RuleId); + } + if (lastSuccessfulBackupTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(LastSuccessfulBackupTime); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BackupDrPlanRule other) { + if (other == null) { + return; + } + if (other.RuleId.Length != 0) { + RuleId = other.RuleId; + } + if (other.lastSuccessfulBackupTime_ != null) { + if (lastSuccessfulBackupTime_ == null) { + LastSuccessfulBackupTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + LastSuccessfulBackupTime.MergeFrom(other.LastSuccessfulBackupTime); + } + _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: { + RuleId = input.ReadString(); + break; + } + case 18: { + if (lastSuccessfulBackupTime_ == null) { + LastSuccessfulBackupTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(LastSuccessfulBackupTime); + 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: { + RuleId = input.ReadString(); + break; + } + case 18: { + if (lastSuccessfulBackupTime_ == null) { + LastSuccessfulBackupTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(LastSuccessfulBackupTime); + break; + } + } + } + } + #endif + + } + + /// + /// BackupLocation represents a cloud location where a backup can be stored. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BackupLocation : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BackupLocation()); + 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.BackupDR.V1.ProtectionSummaryReflection.Descriptor.MessageTypes[8]; } + } + + [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 BackupLocation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupLocation(BackupLocation other) : this() { + type_ = other.type_; + locationId_ = other.locationId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BackupLocation Clone() { + return new BackupLocation(this); + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 1; + private global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type type_ = global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type.Unspecified; + /// + /// Output only. The type of the location. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "location_id" field. + public const int LocationIdFieldNumber = 2; + private string locationId_ = ""; + /// + /// Output only. The id of the cloud location. Example: "us-central1" + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string LocationId { + get { return locationId_; } + set { + locationId_ = 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 BackupLocation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BackupLocation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Type != other.Type) return false; + if (LocationId != other.LocationId) 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 (Type != global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type.Unspecified) hash ^= Type.GetHashCode(); + if (LocationId.Length != 0) hash ^= LocationId.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 (Type != global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Type); + } + if (LocationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(LocationId); + } + 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 (Type != global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Type); + } + if (LocationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(LocationId); + } + 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 (Type != global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (LocationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(LocationId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BackupLocation other) { + if (other == null) { + return; + } + if (other.Type != global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type.Unspecified) { + Type = other.Type; + } + if (other.LocationId.Length != 0) { + LocationId = other.LocationId; + } + _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: { + Type = (global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type) input.ReadEnum(); + break; + } + case 18: { + LocationId = 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 8: { + Type = (global::Google.Cloud.BackupDR.V1.BackupLocation.Types.Type) input.ReadEnum(); + break; + } + case 18: { + LocationId = input.ReadString(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the BackupLocation message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// The type of the location. + /// + public enum Type { + /// + /// Location type is unspecified. + /// + [pbr::OriginalName("TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// Location type is zonal. + /// + [pbr::OriginalName("ZONAL")] Zonal = 1, + /// + /// Location type is regional. + /// + [pbr::OriginalName("REGIONAL")] Regional = 2, + /// + /// Location type is multi regional. + /// + [pbr::OriginalName("MULTI_REGIONAL")] MultiRegional = 3, + } + + } + #endregion + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummaryGrpc.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummaryGrpc.g.cs new file mode 100644 index 000000000000..f329861dce65 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummaryGrpc.g.cs @@ -0,0 +1,207 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/cloud/backupdr/v1/protection_summary.proto +// +// Original file comments: +// Copyright 2025 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 +// +// http://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. +// +#pragma warning disable 0414, 1591, 8981, 0612 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace Google.Cloud.BackupDR.V1 { + /// + /// The Protection Summary service. + /// + public static partial class BackupDrProtectionSummary + { + static readonly string __ServiceName = "google.cloud.backupdr.v1.BackupDrProtectionSummary"; + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static void __Helper_SerializeMessage(global::Google.Protobuf.IMessage message, grpc::SerializationContext context) + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (message is global::Google.Protobuf.IBufferMessage) + { + context.SetPayloadLength(message.CalculateSize()); + global::Google.Protobuf.MessageExtensions.WriteTo(message, context.GetBufferWriter()); + context.Complete(); + return; + } + #endif + context.Complete(global::Google.Protobuf.MessageExtensions.ToByteArray(message)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static class __Helper_MessageCache + { + public static readonly bool IsBufferMessage = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(global::Google.Protobuf.IBufferMessage)).IsAssignableFrom(typeof(T)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static T __Helper_DeserializeMessage(grpc::DeserializationContext context, global::Google.Protobuf.MessageParser parser) where T : global::Google.Protobuf.IMessage + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (__Helper_MessageCache.IsBufferMessage) + { + return parser.ParseFrom(context.PayloadAsReadOnlySequence()); + } + #endif + return parser.ParseFrom(context.PayloadAsNewBuffer()); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_backupdr_v1_ListResourceBackupConfigsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_backupdr_v1_ListResourceBackupConfigsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsResponse.Parser)); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ListResourceBackupConfigs = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ListResourceBackupConfigs", + __Marshaller_google_cloud_backupdr_v1_ListResourceBackupConfigsRequest, + __Marshaller_google_cloud_backupdr_v1_ListResourceBackupConfigsResponse); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Google.Cloud.BackupDR.V1.ProtectionSummaryReflection.Descriptor.Services[0]; } + } + + /// Base class for server-side implementations of BackupDrProtectionSummary + [grpc::BindServiceMethod(typeof(BackupDrProtectionSummary), "BindService")] + public abstract partial class BackupDrProtectionSummaryBase + { + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigs(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for BackupDrProtectionSummary + public partial class BackupDrProtectionSummaryClient : grpc::ClientBase + { + /// Creates a new client for BackupDrProtectionSummary + /// The channel to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public BackupDrProtectionSummaryClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for BackupDrProtectionSummary that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public BackupDrProtectionSummaryClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected BackupDrProtectionSummaryClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected BackupDrProtectionSummaryClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + /// + /// Lists ResourceBackupConfigs. + /// + /// 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.BackupDR.V1.ListResourceBackupConfigsResponse ListResourceBackupConfigs(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ListResourceBackupConfigs(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Lists ResourceBackupConfigs. + /// + /// 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.BackupDR.V1.ListResourceBackupConfigsResponse ListResourceBackupConfigs(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ListResourceBackupConfigs, null, options, request); + } + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigsAsync(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ListResourceBackupConfigsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Lists ResourceBackupConfigs. + /// + /// 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 ListResourceBackupConfigsAsync(global::Google.Cloud.BackupDR.V1.ListResourceBackupConfigsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ListResourceBackupConfigs, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected override BackupDrProtectionSummaryClient NewInstance(ClientBaseConfiguration configuration) + { + return new BackupDrProtectionSummaryClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public static grpc::ServerServiceDefinition BindService(BackupDrProtectionSummaryBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_ListResourceBackupConfigs, serviceImpl.ListResourceBackupConfigs).Build(); + } + + /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. + /// Note: this method is part of an experimental API that can change or be removed without any prior notice. + /// Service methods will be bound by calling AddMethod on this object. + /// An object implementing the server-side handling logic. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public static void BindService(grpc::ServiceBinderBase serviceBinder, BackupDrProtectionSummaryBase serviceImpl) + { + serviceBinder.AddMethod(__Method_ListResourceBackupConfigs, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ListResourceBackupConfigs)); + } + + } +} +#endregion diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummaryResourceNames.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummaryResourceNames.g.cs new file mode 100644 index 000000000000..d050bfbc88e1 --- /dev/null +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ProtectionSummaryResourceNames.g.cs @@ -0,0 +1,324 @@ +// Copyright 2026 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! + +#pragma warning disable CS8981 +using gagr = Google.Api.Gax.ResourceNames; +using gax = Google.Api.Gax; +using gcbv = Google.Cloud.BackupDR.V1; +using sys = System; + +namespace Google.Cloud.BackupDR.V1 +{ + /// Resource name for the ResourceBackupConfig resource. + public sealed partial class ResourceBackupConfigName : gax::IResourceName, sys::IEquatable + { + /// The possible contents of . + public enum ResourceNameType + { + /// An unparsed resource name. + Unparsed = 0, + + /// + /// A resource name with pattern + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}. + /// + ProjectLocationResourceBackupConfig = 1, + } + + private static gax::PathTemplate s_projectLocationResourceBackupConfig = new gax::PathTemplate("projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}"); + + /// Creates a containing an unparsed resource name. + /// The unparsed resource name. Must not be null. + /// + /// A new instance of containing the provided + /// . + /// + public static ResourceBackupConfigName FromUnparsed(gax::UnparsedResourceName unparsedResourceName) => + new ResourceBackupConfigName(ResourceNameType.Unparsed, gax::GaxPreconditions.CheckNotNull(unparsedResourceName, nameof(unparsedResourceName))); + + /// + /// Creates a with the pattern + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}. + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// + /// The ResourceBackupConfig ID. Must not be null or empty. + /// + /// + /// A new instance of constructed from the provided ids. + /// + public static ResourceBackupConfigName FromProjectLocationResourceBackupConfig(string projectId, string locationId, string resourceBackupConfigId) => + new ResourceBackupConfigName(ResourceNameType.ProjectLocationResourceBackupConfig, projectId: gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), locationId: gax::GaxPreconditions.CheckNotNullOrEmpty(locationId, nameof(locationId)), resourceBackupConfigId: gax::GaxPreconditions.CheckNotNullOrEmpty(resourceBackupConfigId, nameof(resourceBackupConfigId))); + + /// + /// Formats the IDs into the string representation of this with pattern + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}. + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// + /// The ResourceBackupConfig ID. Must not be null or empty. + /// + /// + /// The string representation of this with pattern + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}. + /// + public static string Format(string projectId, string locationId, string resourceBackupConfigId) => + FormatProjectLocationResourceBackupConfig(projectId, locationId, resourceBackupConfigId); + + /// + /// Formats the IDs into the string representation of this with pattern + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}. + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// + /// The ResourceBackupConfig ID. Must not be null or empty. + /// + /// + /// The string representation of this with pattern + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config}. + /// + public static string FormatProjectLocationResourceBackupConfig(string projectId, string locationId, string resourceBackupConfigId) => + s_projectLocationResourceBackupConfig.Expand(gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), gax::GaxPreconditions.CheckNotNullOrEmpty(locationId, nameof(locationId)), gax::GaxPreconditions.CheckNotNullOrEmpty(resourceBackupConfigId, nameof(resourceBackupConfigId))); + + /// + /// Parses the given resource name string into a new instance. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config} + /// + /// + /// + /// + /// The resource name in string form. Must not be null. + /// The parsed if successful. + public static ResourceBackupConfigName Parse(string resourceBackupConfigName) => + Parse(resourceBackupConfigName, false); + + /// + /// Parses the given resource name string into a new instance; optionally + /// allowing an unparseable resource name. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config} + /// + /// + /// + /// Or may be in any format if is true. + /// + /// The resource name in string form. Must not be null. + /// + /// If true will successfully store an unparseable resource name into the + /// property; otherwise will throw an if an unparseable resource name is + /// specified. + /// + /// The parsed if successful. + public static ResourceBackupConfigName Parse(string resourceBackupConfigName, bool allowUnparsed) => + TryParse(resourceBackupConfigName, allowUnparsed, out ResourceBackupConfigName result) ? result : throw new sys::ArgumentException("The given resource-name matches no pattern."); + + /// + /// Tries to parse the given resource name string into a new instance. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config} + /// + /// + /// + /// + /// The resource name in string form. Must not be null. + /// + /// When this method returns, the parsed , or null if parsing + /// failed. + /// + /// true if the name was parsed successfully; false otherwise. + public static bool TryParse(string resourceBackupConfigName, out ResourceBackupConfigName result) => + TryParse(resourceBackupConfigName, false, out result); + + /// + /// Tries to parse the given resource name string into a new instance; + /// optionally allowing an unparseable resource name. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// + /// + /// projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config} + /// + /// + /// + /// Or may be in any format if is true. + /// + /// The resource name in string form. Must not be null. + /// + /// If true will successfully store an unparseable resource name into the + /// property; otherwise will throw an if an unparseable resource name is + /// specified. + /// + /// + /// When this method returns, the parsed , or null if parsing + /// failed. + /// + /// true if the name was parsed successfully; false otherwise. + public static bool TryParse(string resourceBackupConfigName, bool allowUnparsed, out ResourceBackupConfigName result) + { + gax::GaxPreconditions.CheckNotNull(resourceBackupConfigName, nameof(resourceBackupConfigName)); + gax::TemplatedResourceName resourceName; + if (s_projectLocationResourceBackupConfig.TryParseName(resourceBackupConfigName, out resourceName)) + { + result = FromProjectLocationResourceBackupConfig(resourceName[0], resourceName[1], resourceName[2]); + return true; + } + if (allowUnparsed) + { + if (gax::UnparsedResourceName.TryParse(resourceBackupConfigName, out gax::UnparsedResourceName unparsedResourceName)) + { + result = FromUnparsed(unparsedResourceName); + return true; + } + } + result = null; + return false; + } + + private ResourceBackupConfigName(ResourceNameType type, gax::UnparsedResourceName unparsedResourceName = null, string locationId = null, string projectId = null, string resourceBackupConfigId = null) + { + Type = type; + UnparsedResource = unparsedResourceName; + LocationId = locationId; + ProjectId = projectId; + ResourceBackupConfigId = resourceBackupConfigId; + } + + /// + /// Constructs a new instance of a class from the component parts of + /// pattern projects/{project}/locations/{location}/resourceBackupConfigs/{resource_backup_config} + /// + /// The Project ID. Must not be null or empty. + /// The Location ID. Must not be null or empty. + /// + /// The ResourceBackupConfig ID. Must not be null or empty. + /// + public ResourceBackupConfigName(string projectId, string locationId, string resourceBackupConfigId) : this(ResourceNameType.ProjectLocationResourceBackupConfig, projectId: gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), locationId: gax::GaxPreconditions.CheckNotNullOrEmpty(locationId, nameof(locationId)), resourceBackupConfigId: gax::GaxPreconditions.CheckNotNullOrEmpty(resourceBackupConfigId, nameof(resourceBackupConfigId))) + { + } + + /// The of the contained resource name. + public ResourceNameType Type { get; } + + /// + /// The contained . Only non-null if this instance contains an + /// unparsed resource name. + /// + public gax::UnparsedResourceName UnparsedResource { get; } + + /// + /// The Location ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string LocationId { get; } + + /// + /// The Project ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string ProjectId { get; } + + /// + /// The ResourceBackupConfig ID. Will not be null, unless this instance contains an unparsed + /// resource name. + /// + public string ResourceBackupConfigId { get; } + + /// Whether this instance contains a resource name with a known pattern. + public bool IsKnownPattern => Type != ResourceNameType.Unparsed; + + /// The string representation of the resource name. + /// The string representation of the resource name. + public override string ToString() + { + switch (Type) + { + case ResourceNameType.Unparsed: return UnparsedResource.ToString(); + case ResourceNameType.ProjectLocationResourceBackupConfig: return s_projectLocationResourceBackupConfig.Expand(ProjectId, LocationId, ResourceBackupConfigId); + default: throw new sys::InvalidOperationException("Unrecognized resource-type."); + } + } + + /// Returns a hash code for this resource name. + public override int GetHashCode() => ToString().GetHashCode(); + + /// + public override bool Equals(object obj) => Equals(obj as ResourceBackupConfigName); + + /// + public bool Equals(ResourceBackupConfigName other) => ToString() == other?.ToString(); + + /// Determines whether two specified resource names have the same value. + /// The first resource name to compare, or null. + /// The second resource name to compare, or null. + /// + /// true if the value of is the same as the value of ; otherwise, + /// false. + /// + public static bool operator ==(ResourceBackupConfigName a, ResourceBackupConfigName b) => ReferenceEquals(a, b) || (a?.Equals(b) ?? false); + + /// Determines whether two specified resource names have different values. + /// The first resource name to compare, or null. + /// The second resource name to compare, or null. + /// + /// true if the value of is different from the value of ; otherwise, + /// false. + /// + public static bool operator !=(ResourceBackupConfigName a, ResourceBackupConfigName b) => !(a == b); + } + + public partial class ListResourceBackupConfigsRequest + { + /// + /// -typed view over the resource name property. + /// + public gagr::LocationName ParentAsLocationName + { + get => string.IsNullOrEmpty(Parent) ? null : gagr::LocationName.Parse(Parent, allowUnparsed: true); + set => Parent = value?.ToString() ?? ""; + } + } + + public partial class ResourceBackupConfig + { + /// + /// -typed view over the resource name property. + /// + public gcbv::ResourceBackupConfigName ResourceBackupConfigName + { + get => string.IsNullOrEmpty(Name) ? null : gcbv::ResourceBackupConfigName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } +} diff --git a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ServiceCollectionExtensions.g.cs b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ServiceCollectionExtensions.g.cs index c820fe78eeab..f84c9a906bf8 100644 --- a/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ServiceCollectionExtensions.g.cs +++ b/apis/Google.Cloud.BackupDR.V1/Google.Cloud.BackupDR.V1/ServiceCollectionExtensions.g.cs @@ -61,5 +61,41 @@ public static IServiceCollection AddBackupDRClient(this IServiceCollection servi action?.Invoke(provider, builder); return builder.Build(provider); }); + + /// + /// Adds a singleton to . + /// + /// + /// The service collection to add the client to. The services are used to configure the client when requested. + /// + /// + /// An optional action to invoke on the client builder. This is invoked before services from + /// are used. + /// + public static IServiceCollection AddBackupDrProtectionSummaryClient(this IServiceCollection services, sys::Action action = null) => + services.AddSingleton(provider => + { + gcbv::BackupDrProtectionSummaryClientBuilder builder = new gcbv::BackupDrProtectionSummaryClientBuilder(); + action?.Invoke(builder); + return builder.Build(provider); + }); + + /// + /// Adds a singleton to . + /// + /// + /// The service collection to add the client to. The services are used to configure the client when requested. + /// + /// + /// An optional action to invoke on the client builder. This is invoked before services from + /// are used. + /// + public static IServiceCollection AddBackupDrProtectionSummaryClient(this IServiceCollection services, sys::Action action) => + services.AddSingleton(provider => + { + gcbv::BackupDrProtectionSummaryClientBuilder builder = new gcbv::BackupDrProtectionSummaryClientBuilder(); + action?.Invoke(provider, builder); + return builder.Build(provider); + }); } } diff --git a/apis/Google.Cloud.BackupDR.V1/gapic_metadata.json b/apis/Google.Cloud.BackupDR.V1/gapic_metadata.json index 34bbc9d02d4b..45e2fbd83f97 100644 --- a/apis/Google.Cloud.BackupDR.V1/gapic_metadata.json +++ b/apis/Google.Cloud.BackupDR.V1/gapic_metadata.json @@ -235,6 +235,21 @@ } } } + }, + "BackupDrProtectionSummary": { + "clients": { + "grpc": { + "libraryClient": "BackupDrProtectionSummaryClient", + "rpcs": { + "ListResourceBackupConfigs": { + "methods": [ + "ListResourceBackupConfigs", + "ListResourceBackupConfigsAsync" + ] + } + } + } + } } } } diff --git a/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/Resources.g.cs b/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/Resources.g.cs index 33aa604b9b6c..ca1b77da71ac 100644 --- a/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/Resources.g.cs +++ b/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/Resources.g.cs @@ -174,20 +174,20 @@ static ResourcesReflection() { "Y2Vzc19yZWFzb25zGAEgAygOMiEuZ29vZ2xlLmNsb3VkLmttcy52MS5BY2Nl", "c3NSZWFzb24qagoPUHJvdGVjdGlvbkxldmVsEiAKHFBST1RFQ1RJT05fTEVW", "RUxfVU5TUEVDSUZJRUQQABIMCghTT0ZUV0FSRRABEgcKA0hTTRACEgwKCEVY", - "VEVSTkFMEAMSEAoMRVhURVJOQUxfVlBDEAQqqwMKDEFjY2Vzc1JlYXNvbhIW", + "VEVSTkFMEAMSEAoMRVhURVJOQUxfVlBDEAQqswMKDEFjY2Vzc1JlYXNvbhIW", "ChJSRUFTT05fVU5TUEVDSUZJRUQQABIeChpDVVNUT01FUl9JTklUSUFURURf", "U1VQUE9SVBABEhwKGEdPT0dMRV9JTklUSUFURURfU0VSVklDRRACEhwKGFRI", "SVJEX1BBUlRZX0RBVEFfUkVRVUVTVBADEhsKF0dPT0dMRV9JTklUSUFURURf", "UkVWSUVXEAQSHQoZQ1VTVE9NRVJfSU5JVElBVEVEX0FDQ0VTUxAFEiUKIUdP", "T0dMRV9JTklUSUFURURfU1lTVEVNX09QRVJBVElPThAGEhcKE1JFQVNPTl9O", - "T1RfRVhQRUNURUQQBxImCiJNT0RJRklFRF9DVVNUT01FUl9JTklUSUFURURf", - "QUNDRVNTEAgSLgoqTU9ESUZJRURfR09PR0xFX0lOSVRJQVRFRF9TWVNURU1f", - "T1BFUkFUSU9OEAkSJwojR09PR0xFX1JFU1BPTlNFX1RPX1BST0RVQ1RJT05f", - "QUxFUlQQChIqCiZDVVNUT01FUl9BVVRIT1JJWkVEX1dPUktGTE9XX1NFUlZJ", - "Q0lORxALQoUBChdjb20uZ29vZ2xlLmNsb3VkLmttcy52MUIRS21zUmVzb3Vy", - "Y2VzUHJvdG9QAVopY2xvdWQuZ29vZ2xlLmNvbS9nby9rbXMvYXBpdjEva21z", - "cGI7a21zcGKqAhNHb29nbGUuQ2xvdWQuS21zLlYxygITR29vZ2xlXENsb3Vk", - "XEttc1xWMWIGcHJvdG8z")); + "T1RfRVhQRUNURUQQBxIqCiJNT0RJRklFRF9DVVNUT01FUl9JTklUSUFURURf", + "QUNDRVNTEAgaAggBEjIKKk1PRElGSUVEX0dPT0dMRV9JTklUSUFURURfU1lT", + "VEVNX09QRVJBVElPThAJGgIIARInCiNHT09HTEVfUkVTUE9OU0VfVE9fUFJP", + "RFVDVElPTl9BTEVSVBAKEioKJkNVU1RPTUVSX0FVVEhPUklaRURfV09SS0ZM", + "T1dfU0VSVklDSU5HEAtChQEKF2NvbS5nb29nbGUuY2xvdWQua21zLnYxQhFL", + "bXNSZXNvdXJjZXNQcm90b1ABWiljbG91ZC5nb29nbGUuY29tL2dvL2ttcy9h", + "cGl2MS9rbXNwYjtrbXNwYqoCE0dvb2dsZS5DbG91ZC5LbXMuVjHKAhNHb29n", + "bGVcQ2xvdWRcS21zXFYxYgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.Kms.V1.ProtectionLevel), typeof(global::Google.Cloud.Kms.V1.AccessReason), }, null, new pbr::GeneratedClrTypeInfo[] { @@ -276,6 +276,11 @@ public enum AccessReason { /// [pbr::OriginalName("REASON_NOT_EXPECTED")] ReasonNotExpected = 7, /// + /// Deprecated: This code is no longer generated by Google Cloud. The + /// GOOGLE_RESPONSE_TO_PRODUCTION_ALERT justification codes available in both + /// Key Access Justifications and Access Transparency logs provide + /// customer-visible signals of emergency access in more precise contexts. + /// /// Customer uses their account to perform any access to their own data which /// their IAM policy authorizes, and one of the following is true: /// @@ -285,8 +290,14 @@ public enum AccessReason { /// resource in the same project or folder as the currently accessed resource /// within the past 7 days. /// + [global::System.ObsoleteAttribute] [pbr::OriginalName("MODIFIED_CUSTOMER_INITIATED_ACCESS")] ModifiedCustomerInitiatedAccess = 8, /// + /// Deprecated: This code is no longer generated by Google Cloud. The + /// GOOGLE_RESPONSE_TO_PRODUCTION_ALERT justification codes available in both + /// Key Access Justifications and Access Transparency logs provide + /// customer-visible signals of emergency access in more precise contexts. + /// /// Google systems access customer data to help optimize the structure of the /// data or quality for future uses by the customer, and one of the following /// is true: @@ -297,6 +308,7 @@ public enum AccessReason { /// resource in the same project or folder as the currently accessed resource /// within the past 7 days. /// + [global::System.ObsoleteAttribute] [pbr::OriginalName("MODIFIED_GOOGLE_INITIATED_SYSTEM_OPERATION")] ModifiedGoogleInitiatedSystemOperation = 9, /// /// Google-initiated access to maintain system reliability. diff --git a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PublisherServiceApiClient.g.cs b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PublisherServiceApiClient.g.cs index da9b2eb37091..dffd4d3d4def 100644 --- a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PublisherServiceApiClient.g.cs +++ b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PublisherServiceApiClient.g.cs @@ -674,8 +674,8 @@ public virtual PublishResponse Publish(PublishRequest request, gaxgrpc::CallSett /// does not exist. /// /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// /// /// Required. The messages to publish. @@ -697,8 +697,8 @@ public virtual PublishResponse Publish(string topic, scg::IEnumerable /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// /// /// Required. The messages to publish. @@ -720,8 +720,8 @@ public virtual PublishResponse Publish(string topic, scg::IEnumerable /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// /// /// Required. The messages to publish. @@ -736,8 +736,8 @@ public virtual PublishResponse Publish(string topic, scg::IEnumerable /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// /// /// Required. The messages to publish. @@ -759,8 +759,8 @@ public virtual PublishResponse Publish(TopicName topic, scg::IEnumerable /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// /// /// Required. The messages to publish. @@ -782,8 +782,8 @@ public virtual PublishResponse Publish(TopicName topic, scg::IEnumerable /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// /// /// Required. The messages to publish. @@ -824,7 +824,7 @@ public virtual Topic GetTopic(GetTopicRequest request, gaxgrpc::CallSettings cal /// Gets the configuration of a topic. /// /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -839,7 +839,7 @@ public virtual Topic GetTopic(string topic, gaxgrpc::CallSettings callSettings = /// Gets the configuration of a topic. /// /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -854,7 +854,7 @@ public virtual Topic GetTopic(string topic, gaxgrpc::CallSettings callSettings = /// Gets the configuration of a topic. /// /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// /// A to use for this RPC. @@ -866,7 +866,7 @@ public virtual Topic GetTopic(string topic, gaxgrpc::CallSettings callSettings = /// Gets the configuration of a topic. /// /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -881,7 +881,7 @@ public virtual Topic GetTopic(TopicName topic, gaxgrpc::CallSettings callSetting /// Gets the configuration of a topic. /// /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -896,7 +896,7 @@ public virtual Topic GetTopic(TopicName topic, gaxgrpc::CallSettings callSetting /// Gets the configuration of a topic. /// /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// /// A to use for this RPC. @@ -926,7 +926,7 @@ public virtual Topic GetTopic(TopicName topic, gaxgrpc::CallSettings callSetting /// Lists matching topics. /// /// - /// Required. Identifier. The name of the project in which to list topics. + /// Required. The name of the project in which to list topics. /// Format is `projects/{project-id}`. /// /// @@ -960,7 +960,7 @@ public virtual Topic GetTopic(TopicName topic, gaxgrpc::CallSettings callSetting /// Lists matching topics. /// /// - /// Required. Identifier. The name of the project in which to list topics. + /// Required. The name of the project in which to list topics. /// Format is `projects/{project-id}`. /// /// @@ -994,7 +994,7 @@ public virtual Topic GetTopic(TopicName topic, gaxgrpc::CallSettings callSetting /// Lists matching topics. /// /// - /// Required. Identifier. The name of the project in which to list topics. + /// Required. The name of the project in which to list topics. /// Format is `projects/{project-id}`. /// /// @@ -1028,7 +1028,7 @@ public virtual Topic GetTopic(TopicName topic, gaxgrpc::CallSettings callSetting /// Lists matching topics. /// /// - /// Required. Identifier. The name of the project in which to list topics. + /// Required. The name of the project in which to list topics. /// Format is `projects/{project-id}`. /// /// @@ -1437,7 +1437,7 @@ public virtual void DeleteTopic(DeleteTopicRequest request, gaxgrpc::CallSetting /// not deleted, but their `topic` field is set to `_deleted-topic_`. /// /// - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -1456,7 +1456,7 @@ public virtual void DeleteTopic(string topic, gaxgrpc::CallSettings callSettings /// not deleted, but their `topic` field is set to `_deleted-topic_`. /// /// - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -1475,7 +1475,7 @@ public virtual void DeleteTopic(string topic, gaxgrpc::CallSettings callSettings /// not deleted, but their `topic` field is set to `_deleted-topic_`. /// /// - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// /// A to use for this RPC. @@ -1491,7 +1491,7 @@ public virtual void DeleteTopic(string topic, gaxgrpc::CallSettings callSettings /// not deleted, but their `topic` field is set to `_deleted-topic_`. /// /// - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -1510,7 +1510,7 @@ public virtual void DeleteTopic(TopicName topic, gaxgrpc::CallSettings callSetti /// not deleted, but their `topic` field is set to `_deleted-topic_`. /// /// - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// /// If not null, applies overrides to this RPC call. @@ -1529,7 +1529,7 @@ public virtual void DeleteTopic(TopicName topic, gaxgrpc::CallSettings callSetti /// not deleted, but their `topic` field is set to `_deleted-topic_`. /// /// - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// /// A to use for this RPC. diff --git a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/Pubsub.g.cs b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/Pubsub.g.cs index 313fd7d26ff7..c29c975bf96d 100644 --- a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/Pubsub.g.cs +++ b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/Pubsub.g.cs @@ -29,493 +29,501 @@ static PubsubReflection() { "aS9jbGllbnQucHJvdG8aH2dvb2dsZS9hcGkvZmllbGRfYmVoYXZpb3IucHJv", "dG8aGWdvb2dsZS9hcGkvcmVzb3VyY2UucHJvdG8aHmdvb2dsZS9wcm90b2J1", "Zi9kdXJhdGlvbi5wcm90bxobZ29vZ2xlL3Byb3RvYnVmL2VtcHR5LnByb3Rv", - "GiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxofZ29vZ2xlL3By", - "b3RvYnVmL3RpbWVzdGFtcC5wcm90bxodZ29vZ2xlL3B1YnN1Yi92MS9zY2hl", - "bWEucHJvdG8iYQoUTWVzc2FnZVN0b3JhZ2VQb2xpY3kSKAobYWxsb3dlZF9w", - "ZXJzaXN0ZW5jZV9yZWdpb25zGAEgAygJQgPgQQESHwoSZW5mb3JjZV9pbl90", - "cmFuc2l0GAIgASgIQgPgQQEiuAEKDlNjaGVtYVNldHRpbmdzEjQKBnNjaGVt", - "YRgBIAEoCUIk4EEC+kEeChxwdWJzdWIuZ29vZ2xlYXBpcy5jb20vU2NoZW1h", - "EjEKCGVuY29kaW5nGAIgASgOMhouZ29vZ2xlLnB1YnN1Yi52MS5FbmNvZGlu", - "Z0ID4EEBEh4KEWZpcnN0X3JldmlzaW9uX2lkGAMgASgJQgPgQQESHQoQbGFz", - "dF9yZXZpc2lvbl9pZBgEIAEoCUID4EEBIugXChtJbmdlc3Rpb25EYXRhU291", - "cmNlU2V0dGluZ3MSVAoLYXdzX2tpbmVzaXMYASABKAsyOC5nb29nbGUucHVi", - "c3ViLnYxLkluZ2VzdGlvbkRhdGFTb3VyY2VTZXR0aW5ncy5Bd3NLaW5lc2lz", - "QgPgQQFIABJYCg1jbG91ZF9zdG9yYWdlGAIgASgLMjouZ29vZ2xlLnB1YnN1", - "Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0dGluZ3MuQ2xvdWRTdG9yYWdl", - "QgPgQQFIABJdChBhenVyZV9ldmVudF9odWJzGAMgASgLMjwuZ29vZ2xlLnB1", - "YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0dGluZ3MuQXp1cmVFdmVu", - "dEh1YnNCA+BBAUgAEkwKB2F3c19tc2sYBSABKAsyNC5nb29nbGUucHVic3Vi", - "LnYxLkluZ2VzdGlvbkRhdGFTb3VyY2VTZXR0aW5ncy5Bd3NNc2tCA+BBAUgA", - "ElwKD2NvbmZsdWVudF9jbG91ZBgGIAEoCzI8Lmdvb2dsZS5wdWJzdWIudjEu", - "SW5nZXN0aW9uRGF0YVNvdXJjZVNldHRpbmdzLkNvbmZsdWVudENsb3VkQgPg", - "QQFIABJLChZwbGF0Zm9ybV9sb2dzX3NldHRpbmdzGAQgASgLMiYuZ29vZ2xl", - "LnB1YnN1Yi52MS5QbGF0Zm9ybUxvZ3NTZXR0aW5nc0ID4EEBGuoCCgpBd3NL", - "aW5lc2lzElIKBXN0YXRlGAEgASgOMj4uZ29vZ2xlLnB1YnN1Yi52MS5Jbmdl", - "c3Rpb25EYXRhU291cmNlU2V0dGluZ3MuQXdzS2luZXNpcy5TdGF0ZUID4EED", - "EhcKCnN0cmVhbV9hcm4YAiABKAlCA+BBAhIZCgxjb25zdW1lcl9hcm4YAyAB", - "KAlCA+BBAhIZCgxhd3Nfcm9sZV9hcm4YBCABKAlCA+BBAhIgChNnY3Bfc2Vy", - "dmljZV9hY2NvdW50GAUgASgJQgPgQQIilgEKBVN0YXRlEhUKEVNUQVRFX1VO", - "U1BFQ0lGSUVEEAASCgoGQUNUSVZFEAESHQoZS0lORVNJU19QRVJNSVNTSU9O", - "X0RFTklFRBACEh0KGVBVQkxJU0hfUEVSTUlTU0lPTl9ERU5JRUQQAxIUChBT", - "VFJFQU1fTk9UX0ZPVU5EEAQSFgoSQ09OU1VNRVJfTk9UX0ZPVU5EEAUalQYK", - "DENsb3VkU3RvcmFnZRJUCgVzdGF0ZRgBIAEoDjJALmdvb2dsZS5wdWJzdWIu", - "djEuSW5nZXN0aW9uRGF0YVNvdXJjZVNldHRpbmdzLkNsb3VkU3RvcmFnZS5T", - "dGF0ZUID4EEDEhMKBmJ1Y2tldBgCIAEoCUID4EEBEmEKC3RleHRfZm9ybWF0", - "GAMgASgLMkUuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNl", - "U2V0dGluZ3MuQ2xvdWRTdG9yYWdlLlRleHRGb3JtYXRCA+BBAUgAEmEKC2F2", - "cm9fZm9ybWF0GAQgASgLMkUuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25E", - "YXRhU291cmNlU2V0dGluZ3MuQ2xvdWRTdG9yYWdlLkF2cm9Gb3JtYXRCA+BB", - "AUgAEm4KEnB1YnN1Yl9hdnJvX2Zvcm1hdBgFIAEoCzJLLmdvb2dsZS5wdWJz", - "dWIudjEuSW5nZXN0aW9uRGF0YVNvdXJjZVNldHRpbmdzLkNsb3VkU3RvcmFn", - "ZS5QdWJTdWJBdnJvRm9ybWF0QgPgQQFIABJDChptaW5pbXVtX29iamVjdF9j", - "cmVhdGVfdGltZRgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBC", - "A+BBARIXCgptYXRjaF9nbG9iGAkgASgJQgPgQQEaNwoKVGV4dEZvcm1hdBIb", - "CglkZWxpbWl0ZXIYASABKAlCA+BBAUgAiAEBQgwKCl9kZWxpbWl0ZXIaDAoK", - "QXZyb0Zvcm1hdBoSChBQdWJTdWJBdnJvRm9ybWF0IpoBCgVTdGF0ZRIVChFT", - "VEFURV9VTlNQRUNJRklFRBAAEgoKBkFDVElWRRABEiMKH0NMT1VEX1NUT1JB", - "R0VfUEVSTUlTU0lPTl9ERU5JRUQQAhIdChlQVUJMSVNIX1BFUk1JU1NJT05f", - "REVOSUVEEAMSFAoQQlVDS0VUX05PVF9GT1VORBAEEhQKEFRPT19NQU5ZX09C", - "SkVDVFMQBUIOCgxpbnB1dF9mb3JtYXQa/wMKDkF6dXJlRXZlbnRIdWJzElYK", - "BXN0YXRlGAEgASgOMkIuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRh", - "U291cmNlU2V0dGluZ3MuQXp1cmVFdmVudEh1YnMuU3RhdGVCA+BBAxIbCg5y", - "ZXNvdXJjZV9ncm91cBgCIAEoCUID4EEBEhYKCW5hbWVzcGFjZRgDIAEoCUID", - "4EEBEhYKCWV2ZW50X2h1YhgEIAEoCUID4EEBEhYKCWNsaWVudF9pZBgFIAEo", - "CUID4EEBEhYKCXRlbmFudF9pZBgGIAEoCUID4EEBEhwKD3N1YnNjcmlwdGlv", - "bl9pZBgHIAEoCUID4EEBEiAKE2djcF9zZXJ2aWNlX2FjY291bnQYCCABKAlC", - "A+BBASLXAQoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIKCgZBQ1RJ", - "VkUQARIgChxFVkVOVF9IVUJTX1BFUk1JU1NJT05fREVOSUVEEAISHQoZUFVC", - "TElTSF9QRVJNSVNTSU9OX0RFTklFRBADEhcKE05BTUVTUEFDRV9OT1RfRk9V", - "TkQQBBIXChNFVkVOVF9IVUJfTk9UX0ZPVU5EEAUSGgoWU1VCU0NSSVBUSU9O", - "X05PVF9GT1VORBAGEhwKGFJFU09VUkNFX0dST1VQX05PVF9GT1VORBAHGvYC", - "CgZBd3NNc2sSTgoFc3RhdGUYASABKA4yOi5nb29nbGUucHVic3ViLnYxLklu", - "Z2VzdGlvbkRhdGFTb3VyY2VTZXR0aW5ncy5Bd3NNc2suU3RhdGVCA+BBAxIY", - "CgtjbHVzdGVyX2FybhgCIAEoCUID4EECEjIKBXRvcGljGAMgASgJQiPgQQL6", - "QR0KG3B1YnN1Yi5nb29nbGVhcGlzLmNvbS9Ub3BpYxIZCgxhd3Nfcm9sZV9h", - "cm4YBCABKAlCA+BBAhIgChNnY3Bfc2VydmljZV9hY2NvdW50GAUgASgJQgPg", - "QQIikAEKBVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVEEAASCgoGQUNUSVZF", - "EAESGQoVTVNLX1BFUk1JU1NJT05fREVOSUVEEAISHQoZUFVCTElTSF9QRVJN", - "SVNTSU9OX0RFTklFRBADEhUKEUNMVVNURVJfTk9UX0ZPVU5EEAQSEwoPVE9Q", - "SUNfTk9UX0ZPVU5EEAUatgMKDkNvbmZsdWVudENsb3VkElYKBXN0YXRlGAEg", - "ASgOMkIuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0", - "dGluZ3MuQ29uZmx1ZW50Q2xvdWQuU3RhdGVCA+BBAxIdChBib290c3RyYXBf", - "c2VydmVyGAIgASgJQgPgQQISFwoKY2x1c3Rlcl9pZBgDIAEoCUID4EECEhIK", - "BXRvcGljGAQgASgJQgPgQQISHQoQaWRlbnRpdHlfcG9vbF9pZBgFIAEoCUID", - "4EECEiAKE2djcF9zZXJ2aWNlX2FjY291bnQYBiABKAlCA+BBAiK+AQoFU3Rh", - "dGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIKCgZBQ1RJVkUQARIlCiFDT05G", - "TFVFTlRfQ0xPVURfUEVSTUlTU0lPTl9ERU5JRUQQAhIdChlQVUJMSVNIX1BF", - "Uk1JU1NJT05fREVOSUVEEAMSIAocVU5SRUFDSEFCTEVfQk9PVFNUUkFQX1NF", - "UlZFUhAEEhUKEUNMVVNURVJfTk9UX0ZPVU5EEAUSEwoPVE9QSUNfTk9UX0ZP", - "VU5EEAZCCAoGc291cmNlIr8BChRQbGF0Zm9ybUxvZ3NTZXR0aW5ncxJGCghz", - "ZXZlcml0eRgBIAEoDjIvLmdvb2dsZS5wdWJzdWIudjEuUGxhdGZvcm1Mb2dz", - "U2V0dGluZ3MuU2V2ZXJpdHlCA+BBASJfCghTZXZlcml0eRIYChRTRVZFUklU", - "WV9VTlNQRUNJRklFRBAAEgwKCERJU0FCTEVEEAESCQoFREVCVUcQAhIICgRJ", - "TkZPEAMSCwoHV0FSTklORxAEEgkKBUVSUk9SEAUiuRgKFUluZ2VzdGlvbkZh", - "aWx1cmVFdmVudBIyCgV0b3BpYxgBIAEoCUIj4EEC+kEdChtwdWJzdWIuZ29v", - "Z2xlYXBpcy5jb20vVG9waWMSGgoNZXJyb3JfbWVzc2FnZRgCIAEoCUID4EEC", - "EmEKFWNsb3VkX3N0b3JhZ2VfZmFpbHVyZRgDIAEoCzI7Lmdvb2dsZS5wdWJz", - "dWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LkNsb3VkU3RvcmFnZUZhaWx1", - "cmVCA+BBAUgAElsKD2F3c19tc2tfZmFpbHVyZRgEIAEoCzI7Lmdvb2dsZS5w", - "dWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LkF3c01za0ZhaWx1cmVS", - "ZWFzb25CA+BBAUgAEmwKGGF6dXJlX2V2ZW50X2h1YnNfZmFpbHVyZRgFIAEo", - "CzJDLmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LkF6", - "dXJlRXZlbnRIdWJzRmFpbHVyZVJlYXNvbkID4EEBSAASawoXY29uZmx1ZW50", - "X2Nsb3VkX2ZhaWx1cmUYBiABKAsyQy5nb29nbGUucHVic3ViLnYxLkluZ2Vz", - "dGlvbkZhaWx1cmVFdmVudC5Db25mbHVlbnRDbG91ZEZhaWx1cmVSZWFzb25C", - "A+BBAUgAEmMKE2F3c19raW5lc2lzX2ZhaWx1cmUYByABKAsyPy5nb29nbGUu", - "cHVic3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5Bd3NLaW5lc2lzRmFp", - "bHVyZVJlYXNvbkID4EEBSAAaFAoSQXBpVmlvbGF0aW9uUmVhc29uGhMKEUF2", - "cm9GYWlsdXJlUmVhc29uGhcKFVNjaGVtYVZpb2xhdGlvblJlYXNvbhokCiJN", - "ZXNzYWdlVHJhbnNmb3JtYXRpb25GYWlsdXJlUmVhc29uGpgEChNDbG91ZFN0", - "b3JhZ2VGYWlsdXJlEhMKBmJ1Y2tldBgBIAEoCUID4EEBEhgKC29iamVjdF9u", - "YW1lGAIgASgJQgPgQQESHgoRb2JqZWN0X2dlbmVyYXRpb24YAyABKANCA+BB", - "ARJdChNhdnJvX2ZhaWx1cmVfcmVhc29uGAUgASgLMjkuZ29vZ2xlLnB1YnN1", - "Yi52MS5Jbmdlc3Rpb25GYWlsdXJlRXZlbnQuQXZyb0ZhaWx1cmVSZWFzb25C", - "A+BBAUgAEl8KFGFwaV92aW9sYXRpb25fcmVhc29uGAYgASgLMjouZ29vZ2xl", + "GiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxocZ29vZ2xlL3By", + "b3RvYnVmL3N0cnVjdC5wcm90bxofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFt", + "cC5wcm90bxodZ29vZ2xlL3B1YnN1Yi92MS9zY2hlbWEucHJvdG8iYQoUTWVz", + "c2FnZVN0b3JhZ2VQb2xpY3kSKAobYWxsb3dlZF9wZXJzaXN0ZW5jZV9yZWdp", + "b25zGAEgAygJQgPgQQESHwoSZW5mb3JjZV9pbl90cmFuc2l0GAIgASgIQgPg", + "QQEiuAEKDlNjaGVtYVNldHRpbmdzEjQKBnNjaGVtYRgBIAEoCUIk4EEC+kEe", + "ChxwdWJzdWIuZ29vZ2xlYXBpcy5jb20vU2NoZW1hEjEKCGVuY29kaW5nGAIg", + "ASgOMhouZ29vZ2xlLnB1YnN1Yi52MS5FbmNvZGluZ0ID4EEBEh4KEWZpcnN0", + "X3JldmlzaW9uX2lkGAMgASgJQgPgQQESHQoQbGFzdF9yZXZpc2lvbl9pZBgE", + "IAEoCUID4EEBIugXChtJbmdlc3Rpb25EYXRhU291cmNlU2V0dGluZ3MSVAoL", + "YXdzX2tpbmVzaXMYASABKAsyOC5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlv", + "bkRhdGFTb3VyY2VTZXR0aW5ncy5Bd3NLaW5lc2lzQgPgQQFIABJYCg1jbG91", + "ZF9zdG9yYWdlGAIgASgLMjouZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25E", + "YXRhU291cmNlU2V0dGluZ3MuQ2xvdWRTdG9yYWdlQgPgQQFIABJdChBhenVy", + "ZV9ldmVudF9odWJzGAMgASgLMjwuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rp", + "b25EYXRhU291cmNlU2V0dGluZ3MuQXp1cmVFdmVudEh1YnNCA+BBAUgAEkwK", + "B2F3c19tc2sYBSABKAsyNC5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlvbkRh", + "dGFTb3VyY2VTZXR0aW5ncy5Bd3NNc2tCA+BBAUgAElwKD2NvbmZsdWVudF9j", + "bG91ZBgGIAEoCzI8Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRGF0YVNv", + "dXJjZVNldHRpbmdzLkNvbmZsdWVudENsb3VkQgPgQQFIABJLChZwbGF0Zm9y", + "bV9sb2dzX3NldHRpbmdzGAQgASgLMiYuZ29vZ2xlLnB1YnN1Yi52MS5QbGF0", + "Zm9ybUxvZ3NTZXR0aW5nc0ID4EEBGuoCCgpBd3NLaW5lc2lzElIKBXN0YXRl", + "GAEgASgOMj4uZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNl", + "U2V0dGluZ3MuQXdzS2luZXNpcy5TdGF0ZUID4EEDEhcKCnN0cmVhbV9hcm4Y", + "AiABKAlCA+BBAhIZCgxjb25zdW1lcl9hcm4YAyABKAlCA+BBAhIZCgxhd3Nf", + "cm9sZV9hcm4YBCABKAlCA+BBAhIgChNnY3Bfc2VydmljZV9hY2NvdW50GAUg", + "ASgJQgPgQQIilgEKBVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVEEAASCgoG", + "QUNUSVZFEAESHQoZS0lORVNJU19QRVJNSVNTSU9OX0RFTklFRBACEh0KGVBV", + "QkxJU0hfUEVSTUlTU0lPTl9ERU5JRUQQAxIUChBTVFJFQU1fTk9UX0ZPVU5E", + "EAQSFgoSQ09OU1VNRVJfTk9UX0ZPVU5EEAUalQYKDENsb3VkU3RvcmFnZRJU", + "CgVzdGF0ZRgBIAEoDjJALmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRGF0", + "YVNvdXJjZVNldHRpbmdzLkNsb3VkU3RvcmFnZS5TdGF0ZUID4EEDEhMKBmJ1", + "Y2tldBgCIAEoCUID4EEBEmEKC3RleHRfZm9ybWF0GAMgASgLMkUuZ29vZ2xl", + "LnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0dGluZ3MuQ2xvdWRT", + "dG9yYWdlLlRleHRGb3JtYXRCA+BBAUgAEmEKC2F2cm9fZm9ybWF0GAQgASgL", + "MkUuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0dGlu", + "Z3MuQ2xvdWRTdG9yYWdlLkF2cm9Gb3JtYXRCA+BBAUgAEm4KEnB1YnN1Yl9h", + "dnJvX2Zvcm1hdBgFIAEoCzJLLmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9u", + "RGF0YVNvdXJjZVNldHRpbmdzLkNsb3VkU3RvcmFnZS5QdWJTdWJBdnJvRm9y", + "bWF0QgPgQQFIABJDChptaW5pbXVtX29iamVjdF9jcmVhdGVfdGltZRgGIAEo", + "CzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBARIXCgptYXRjaF9n", + "bG9iGAkgASgJQgPgQQEaNwoKVGV4dEZvcm1hdBIbCglkZWxpbWl0ZXIYASAB", + "KAlCA+BBAUgAiAEBQgwKCl9kZWxpbWl0ZXIaDAoKQXZyb0Zvcm1hdBoSChBQ", + "dWJTdWJBdnJvRm9ybWF0IpoBCgVTdGF0ZRIVChFTVEFURV9VTlNQRUNJRklF", + "RBAAEgoKBkFDVElWRRABEiMKH0NMT1VEX1NUT1JBR0VfUEVSTUlTU0lPTl9E", + "RU5JRUQQAhIdChlQVUJMSVNIX1BFUk1JU1NJT05fREVOSUVEEAMSFAoQQlVD", + "S0VUX05PVF9GT1VORBAEEhQKEFRPT19NQU5ZX09CSkVDVFMQBUIOCgxpbnB1", + "dF9mb3JtYXQa/wMKDkF6dXJlRXZlbnRIdWJzElYKBXN0YXRlGAEgASgOMkIu", + "Z29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0dGluZ3Mu", + "QXp1cmVFdmVudEh1YnMuU3RhdGVCA+BBAxIbCg5yZXNvdXJjZV9ncm91cBgC", + "IAEoCUID4EEBEhYKCW5hbWVzcGFjZRgDIAEoCUID4EEBEhYKCWV2ZW50X2h1", + "YhgEIAEoCUID4EEBEhYKCWNsaWVudF9pZBgFIAEoCUID4EEBEhYKCXRlbmFu", + "dF9pZBgGIAEoCUID4EEBEhwKD3N1YnNjcmlwdGlvbl9pZBgHIAEoCUID4EEB", + "EiAKE2djcF9zZXJ2aWNlX2FjY291bnQYCCABKAlCA+BBASLXAQoFU3RhdGUS", + "FQoRU1RBVEVfVU5TUEVDSUZJRUQQABIKCgZBQ1RJVkUQARIgChxFVkVOVF9I", + "VUJTX1BFUk1JU1NJT05fREVOSUVEEAISHQoZUFVCTElTSF9QRVJNSVNTSU9O", + "X0RFTklFRBADEhcKE05BTUVTUEFDRV9OT1RfRk9VTkQQBBIXChNFVkVOVF9I", + "VUJfTk9UX0ZPVU5EEAUSGgoWU1VCU0NSSVBUSU9OX05PVF9GT1VORBAGEhwK", + "GFJFU09VUkNFX0dST1VQX05PVF9GT1VORBAHGvYCCgZBd3NNc2sSTgoFc3Rh", + "dGUYASABKA4yOi5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlvbkRhdGFTb3Vy", + "Y2VTZXR0aW5ncy5Bd3NNc2suU3RhdGVCA+BBAxIYCgtjbHVzdGVyX2FybhgC", + "IAEoCUID4EECEjIKBXRvcGljGAMgASgJQiPgQQL6QR0KG3B1YnN1Yi5nb29n", + "bGVhcGlzLmNvbS9Ub3BpYxIZCgxhd3Nfcm9sZV9hcm4YBCABKAlCA+BBAhIg", + "ChNnY3Bfc2VydmljZV9hY2NvdW50GAUgASgJQgPgQQIikAEKBVN0YXRlEhUK", + "EVNUQVRFX1VOU1BFQ0lGSUVEEAASCgoGQUNUSVZFEAESGQoVTVNLX1BFUk1J", + "U1NJT05fREVOSUVEEAISHQoZUFVCTElTSF9QRVJNSVNTSU9OX0RFTklFRBAD", + "EhUKEUNMVVNURVJfTk9UX0ZPVU5EEAQSEwoPVE9QSUNfTk9UX0ZPVU5EEAUa", + "tgMKDkNvbmZsdWVudENsb3VkElYKBXN0YXRlGAEgASgOMkIuZ29vZ2xlLnB1", + "YnN1Yi52MS5Jbmdlc3Rpb25EYXRhU291cmNlU2V0dGluZ3MuQ29uZmx1ZW50", + "Q2xvdWQuU3RhdGVCA+BBAxIdChBib290c3RyYXBfc2VydmVyGAIgASgJQgPg", + "QQISFwoKY2x1c3Rlcl9pZBgDIAEoCUID4EECEhIKBXRvcGljGAQgASgJQgPg", + "QQISHQoQaWRlbnRpdHlfcG9vbF9pZBgFIAEoCUID4EECEiAKE2djcF9zZXJ2", + "aWNlX2FjY291bnQYBiABKAlCA+BBAiK+AQoFU3RhdGUSFQoRU1RBVEVfVU5T", + "UEVDSUZJRUQQABIKCgZBQ1RJVkUQARIlCiFDT05GTFVFTlRfQ0xPVURfUEVS", + "TUlTU0lPTl9ERU5JRUQQAhIdChlQVUJMSVNIX1BFUk1JU1NJT05fREVOSUVE", + "EAMSIAocVU5SRUFDSEFCTEVfQk9PVFNUUkFQX1NFUlZFUhAEEhUKEUNMVVNU", + "RVJfTk9UX0ZPVU5EEAUSEwoPVE9QSUNfTk9UX0ZPVU5EEAZCCAoGc291cmNl", + "Ir8BChRQbGF0Zm9ybUxvZ3NTZXR0aW5ncxJGCghzZXZlcml0eRgBIAEoDjIv", + "Lmdvb2dsZS5wdWJzdWIudjEuUGxhdGZvcm1Mb2dzU2V0dGluZ3MuU2V2ZXJp", + "dHlCA+BBASJfCghTZXZlcml0eRIYChRTRVZFUklUWV9VTlNQRUNJRklFRBAA", + "EgwKCERJU0FCTEVEEAESCQoFREVCVUcQAhIICgRJTkZPEAMSCwoHV0FSTklO", + "RxAEEgkKBUVSUk9SEAUiuRgKFUluZ2VzdGlvbkZhaWx1cmVFdmVudBIyCgV0", + "b3BpYxgBIAEoCUIj4EEC+kEdChtwdWJzdWIuZ29vZ2xlYXBpcy5jb20vVG9w", + "aWMSGgoNZXJyb3JfbWVzc2FnZRgCIAEoCUID4EECEmEKFWNsb3VkX3N0b3Jh", + "Z2VfZmFpbHVyZRgDIAEoCzI7Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9u", + "RmFpbHVyZUV2ZW50LkNsb3VkU3RvcmFnZUZhaWx1cmVCA+BBAUgAElsKD2F3", + "c19tc2tfZmFpbHVyZRgEIAEoCzI7Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0", + "aW9uRmFpbHVyZUV2ZW50LkF3c01za0ZhaWx1cmVSZWFzb25CA+BBAUgAEmwK", + "GGF6dXJlX2V2ZW50X2h1YnNfZmFpbHVyZRgFIAEoCzJDLmdvb2dsZS5wdWJz", + "dWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LkF6dXJlRXZlbnRIdWJzRmFp", + "bHVyZVJlYXNvbkID4EEBSAASawoXY29uZmx1ZW50X2Nsb3VkX2ZhaWx1cmUY", + "BiABKAsyQy5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVu", + "dC5Db25mbHVlbnRDbG91ZEZhaWx1cmVSZWFzb25CA+BBAUgAEmMKE2F3c19r", + "aW5lc2lzX2ZhaWx1cmUYByABKAsyPy5nb29nbGUucHVic3ViLnYxLkluZ2Vz", + "dGlvbkZhaWx1cmVFdmVudC5Bd3NLaW5lc2lzRmFpbHVyZVJlYXNvbkID4EEB", + "SAAaFAoSQXBpVmlvbGF0aW9uUmVhc29uGhMKEUF2cm9GYWlsdXJlUmVhc29u", + "GhcKFVNjaGVtYVZpb2xhdGlvblJlYXNvbhokCiJNZXNzYWdlVHJhbnNmb3Jt", + "YXRpb25GYWlsdXJlUmVhc29uGpgEChNDbG91ZFN0b3JhZ2VGYWlsdXJlEhMK", + "BmJ1Y2tldBgBIAEoCUID4EEBEhgKC29iamVjdF9uYW1lGAIgASgJQgPgQQES", + "HgoRb2JqZWN0X2dlbmVyYXRpb24YAyABKANCA+BBARJdChNhdnJvX2ZhaWx1", + "cmVfcmVhc29uGAUgASgLMjkuZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25G", + "YWlsdXJlRXZlbnQuQXZyb0ZhaWx1cmVSZWFzb25CA+BBAUgAEl8KFGFwaV92", + "aW9sYXRpb25fcmVhc29uGAYgASgLMjouZ29vZ2xlLnB1YnN1Yi52MS5Jbmdl", + "c3Rpb25GYWlsdXJlRXZlbnQuQXBpVmlvbGF0aW9uUmVhc29uQgPgQQFIABJl", + "ChdzY2hlbWFfdmlvbGF0aW9uX3JlYXNvbhgHIAEoCzI9Lmdvb2dsZS5wdWJz", + "dWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LlNjaGVtYVZpb2xhdGlvblJl", + "YXNvbkID4EEBSAASgAEKJW1lc3NhZ2VfdHJhbnNmb3JtYXRpb25fZmFpbHVy", + "ZV9yZWFzb24YCCABKAsySi5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlvbkZh", + "aWx1cmVFdmVudC5NZXNzYWdlVHJhbnNmb3JtYXRpb25GYWlsdXJlUmVhc29u", + "QgPgQQFIAEIICgZyZWFzb24azgMKE0F3c01za0ZhaWx1cmVSZWFzb24SGAoL", + "Y2x1c3Rlcl9hcm4YASABKAlCA+BBARIYCgtrYWZrYV90b3BpYxgCIAEoCUID", + "4EEBEhkKDHBhcnRpdGlvbl9pZBgDIAEoA0ID4EEBEhMKBm9mZnNldBgEIAEo", + "A0ID4EEBEl8KFGFwaV92aW9sYXRpb25fcmVhc29uGAUgASgLMjouZ29vZ2xl", "LnB1YnN1Yi52MS5Jbmdlc3Rpb25GYWlsdXJlRXZlbnQuQXBpVmlvbGF0aW9u", - "UmVhc29uQgPgQQFIABJlChdzY2hlbWFfdmlvbGF0aW9uX3JlYXNvbhgHIAEo", + "UmVhc29uQgPgQQFIABJlChdzY2hlbWFfdmlvbGF0aW9uX3JlYXNvbhgGIAEo", "CzI9Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LlNj", "aGVtYVZpb2xhdGlvblJlYXNvbkID4EEBSAASgAEKJW1lc3NhZ2VfdHJhbnNm", - "b3JtYXRpb25fZmFpbHVyZV9yZWFzb24YCCABKAsySi5nb29nbGUucHVic3Vi", + "b3JtYXRpb25fZmFpbHVyZV9yZWFzb24YByABKAsySi5nb29nbGUucHVic3Vi", "LnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5NZXNzYWdlVHJhbnNmb3JtYXRp", - "b25GYWlsdXJlUmVhc29uQgPgQQFIAEIICgZyZWFzb24azgMKE0F3c01za0Zh", - "aWx1cmVSZWFzb24SGAoLY2x1c3Rlcl9hcm4YASABKAlCA+BBARIYCgtrYWZr", - "YV90b3BpYxgCIAEoCUID4EEBEhkKDHBhcnRpdGlvbl9pZBgDIAEoA0ID4EEB", - "EhMKBm9mZnNldBgEIAEoA0ID4EEBEl8KFGFwaV92aW9sYXRpb25fcmVhc29u", - "GAUgASgLMjouZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25GYWlsdXJlRXZl", - "bnQuQXBpVmlvbGF0aW9uUmVhc29uQgPgQQFIABJlChdzY2hlbWFfdmlvbGF0", - "aW9uX3JlYXNvbhgGIAEoCzI9Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9u", - "RmFpbHVyZUV2ZW50LlNjaGVtYVZpb2xhdGlvblJlYXNvbkID4EEBSAASgAEK", - "JW1lc3NhZ2VfdHJhbnNmb3JtYXRpb25fZmFpbHVyZV9yZWFzb24YByABKAsy", - "Si5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5NZXNz", - "YWdlVHJhbnNmb3JtYXRpb25GYWlsdXJlUmVhc29uQgPgQQFIAEIICgZyZWFz", - "b24a0gMKG0F6dXJlRXZlbnRIdWJzRmFpbHVyZVJlYXNvbhIWCgluYW1lc3Bh", - "Y2UYASABKAlCA+BBARIWCglldmVudF9odWIYAiABKAlCA+BBARIZCgxwYXJ0", - "aXRpb25faWQYAyABKANCA+BBARITCgZvZmZzZXQYBCABKANCA+BBARJfChRh", - "cGlfdmlvbGF0aW9uX3JlYXNvbhgFIAEoCzI6Lmdvb2dsZS5wdWJzdWIudjEu", - "SW5nZXN0aW9uRmFpbHVyZUV2ZW50LkFwaVZpb2xhdGlvblJlYXNvbkID4EEB", - "SAASZQoXc2NoZW1hX3Zpb2xhdGlvbl9yZWFzb24YBiABKAsyPS5nb29nbGUu", - "cHVic3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5TY2hlbWFWaW9sYXRp", - "b25SZWFzb25CA+BBAUgAEoABCiVtZXNzYWdlX3RyYW5zZm9ybWF0aW9uX2Zh", - "aWx1cmVfcmVhc29uGAcgASgLMkouZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rp", - "b25GYWlsdXJlRXZlbnQuTWVzc2FnZVRyYW5zZm9ybWF0aW9uRmFpbHVyZVJl", - "YXNvbkID4EEBSABCCAoGcmVhc29uGtUDChtDb25mbHVlbnRDbG91ZEZhaWx1", - "cmVSZWFzb24SFwoKY2x1c3Rlcl9pZBgBIAEoCUID4EEBEhgKC2thZmthX3Rv", - "cGljGAIgASgJQgPgQQESGQoMcGFydGl0aW9uX2lkGAMgASgDQgPgQQESEwoG", - "b2Zmc2V0GAQgASgDQgPgQQESXwoUYXBpX3Zpb2xhdGlvbl9yZWFzb24YBSAB", - "KAsyOi5nb29nbGUucHVic3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5B", - "cGlWaW9sYXRpb25SZWFzb25CA+BBAUgAEmUKF3NjaGVtYV92aW9sYXRpb25f", - "cmVhc29uGAYgASgLMj0uZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25GYWls", - "dXJlRXZlbnQuU2NoZW1hVmlvbGF0aW9uUmVhc29uQgPgQQFIABKAAQolbWVz", - "c2FnZV90cmFuc2Zvcm1hdGlvbl9mYWlsdXJlX3JlYXNvbhgHIAEoCzJKLmdv", - "b2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50Lk1lc3NhZ2VU", - "cmFuc2Zvcm1hdGlvbkZhaWx1cmVSZWFzb25CA+BBAUgAQggKBnJlYXNvbhrB", - "AwoXQXdzS2luZXNpc0ZhaWx1cmVSZWFzb24SFwoKc3RyZWFtX2FybhgBIAEo", - "CUID4EEBEhoKDXBhcnRpdGlvbl9rZXkYAiABKAlCA+BBARIcCg9zZXF1ZW5j", - "ZV9udW1iZXIYAyABKAlCA+BBARJlChdzY2hlbWFfdmlvbGF0aW9uX3JlYXNv", - "bhgEIAEoCzI9Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2", - "ZW50LlNjaGVtYVZpb2xhdGlvblJlYXNvbkID4EEBSAASgAEKJW1lc3NhZ2Vf", - "dHJhbnNmb3JtYXRpb25fZmFpbHVyZV9yZWFzb24YBSABKAsySi5nb29nbGUu", - "cHVic3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5NZXNzYWdlVHJhbnNm", - "b3JtYXRpb25GYWlsdXJlUmVhc29uQgPgQQFIABJfChRhcGlfdmlvbGF0aW9u", - "X3JlYXNvbhgGIAEoCzI6Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFp", - "bHVyZUV2ZW50LkFwaVZpb2xhdGlvblJlYXNvbkID4EEBSABCCAoGcmVhc29u", - "QgkKB2ZhaWx1cmUiPgoNSmF2YVNjcmlwdFVERhIaCg1mdW5jdGlvbl9uYW1l", - "GAEgASgJQgPgQQISEQoEY29kZRgCIAEoCUID4EECIo4BChBNZXNzYWdlVHJh", - "bnNmb3JtEj4KDmphdmFzY3JpcHRfdWRmGAIgASgLMh8uZ29vZ2xlLnB1YnN1", - "Yi52MS5KYXZhU2NyaXB0VURGQgPgQQFIABIWCgdlbmFibGVkGAMgASgIQgUY", - "AeBBARIVCghkaXNhYmxlZBgEIAEoCEID4EEBQgsKCXRyYW5zZm9ybSKgBwoF", - "VG9waWMSFAoEbmFtZRgBIAEoCUIG4EEC4EEIEjgKBmxhYmVscxgCIAMoCzIj", - "Lmdvb2dsZS5wdWJzdWIudjEuVG9waWMuTGFiZWxzRW50cnlCA+BBARJLChZt", - "ZXNzYWdlX3N0b3JhZ2VfcG9saWN5GAMgASgLMiYuZ29vZ2xlLnB1YnN1Yi52", - "MS5NZXNzYWdlU3RvcmFnZVBvbGljeUID4EEBEj8KDGttc19rZXlfbmFtZRgF", - "IAEoCUIp4EEB+kEjCiFjbG91ZGttcy5nb29nbGVhcGlzLmNvbS9DcnlwdG9L", - "ZXkSPgoPc2NoZW1hX3NldHRpbmdzGAYgASgLMiAuZ29vZ2xlLnB1YnN1Yi52", - "MS5TY2hlbWFTZXR0aW5nc0ID4EEBEhoKDXNhdGlzZmllc19wenMYByABKAhC", - "A+BBARJCChptZXNzYWdlX3JldGVudGlvbl9kdXJhdGlvbhgIIAEoCzIZLmdv", - "b2dsZS5wcm90b2J1Zi5EdXJhdGlvbkID4EEBEjEKBXN0YXRlGAkgASgOMh0u", - "Z29vZ2xlLnB1YnN1Yi52MS5Ub3BpYy5TdGF0ZUID4EEDEloKHmluZ2VzdGlv", - "bl9kYXRhX3NvdXJjZV9zZXR0aW5ncxgKIAEoCzItLmdvb2dsZS5wdWJzdWIu", - "djEuSW5nZXN0aW9uRGF0YVNvdXJjZVNldHRpbmdzQgPgQQESQwoSbWVzc2Fn", - "ZV90cmFuc2Zvcm1zGA0gAygLMiIuZ29vZ2xlLnB1YnN1Yi52MS5NZXNzYWdl", - "VHJhbnNmb3JtQgPgQQESOgoEdGFncxgOIAMoCzIhLmdvb2dsZS5wdWJzdWIu", - "djEuVG9waWMuVGFnc0VudHJ5QgngQQTgQQXgQQEaLQoLTGFiZWxzRW50cnkS", - "CwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARorCglUYWdzRW50cnkS", - "CwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASJICgVTdGF0ZRIVChFT", - "VEFURV9VTlNQRUNJRklFRBAAEgoKBkFDVElWRRABEhwKGElOR0VTVElPTl9S", - "RVNPVVJDRV9FUlJPUhACOmPqQWAKG3B1YnN1Yi5nb29nbGVhcGlzLmNvbS9U", - "b3BpYxIhcHJvamVjdHMve3Byb2plY3R9L3RvcGljcy97dG9waWN9Eg9fZGVs", - "ZXRlZC10b3BpY18qBnRvcGljczIFdG9waWMigAIKDVB1YnN1Yk1lc3NhZ2US", - "EQoEZGF0YRgBIAEoDEID4EEBEkgKCmF0dHJpYnV0ZXMYAiADKAsyLy5nb29n", - "bGUucHVic3ViLnYxLlB1YnN1Yk1lc3NhZ2UuQXR0cmlidXRlc0VudHJ5QgPg", - "QQESEgoKbWVzc2FnZV9pZBgDIAEoCRIwCgxwdWJsaXNoX3RpbWUYBCABKAsy", - "Gi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhkKDG9yZGVyaW5nX2tleRgF", - "IAEoCUID4EEBGjEKD0F0dHJpYnV0ZXNFbnRyeRILCgNrZXkYASABKAkSDQoF", - "dmFsdWUYAiABKAk6AjgBIkgKD0dldFRvcGljUmVxdWVzdBI1CgV0b3BpYxgB", - "IAEoCUIm4EEC4EEI+kEdChtwdWJzdWIuZ29vZ2xlYXBpcy5jb20vVG9waWMi", - "dwoSVXBkYXRlVG9waWNSZXF1ZXN0EisKBXRvcGljGAEgASgLMhcuZ29vZ2xl", - "LnB1YnN1Yi52MS5Ub3BpY0ID4EECEjQKC3VwZGF0ZV9tYXNrGAIgASgLMhou", - "Z29vZ2xlLnByb3RvYnVmLkZpZWxkTWFza0ID4EECIn8KDlB1Ymxpc2hSZXF1", - "ZXN0EjUKBXRvcGljGAEgASgJQibgQQLgQQj6QR0KG3B1YnN1Yi5nb29nbGVh", - "cGlzLmNvbS9Ub3BpYxI2CghtZXNzYWdlcxgCIAMoCzIfLmdvb2dsZS5wdWJz", - "dWIudjEuUHVic3ViTWVzc2FnZUID4EECIisKD1B1Ymxpc2hSZXNwb25zZRIY", - "CgttZXNzYWdlX2lkcxgBIAMoCUID4EEBIo0BChFMaXN0VG9waWNzUmVxdWVz", - "dBJHCgdwcm9qZWN0GAEgASgJQjbgQQLgQQj6QS0KK2Nsb3VkcmVzb3VyY2Vt", - "YW5hZ2VyLmdvb2dsZWFwaXMuY29tL1Byb2plY3QSFgoJcGFnZV9zaXplGAIg", - "ASgFQgPgQQESFwoKcGFnZV90b2tlbhgDIAEoCUID4EEBImAKEkxpc3RUb3Bp", - "Y3NSZXNwb25zZRIsCgZ0b3BpY3MYASADKAsyFy5nb29nbGUucHVic3ViLnYx", - "LlRvcGljQgPgQQESHAoPbmV4dF9wYWdlX3Rva2VuGAIgASgJQgPgQQEihAEK", - "HUxpc3RUb3BpY1N1YnNjcmlwdGlvbnNSZXF1ZXN0EjIKBXRvcGljGAEgASgJ", - "QiPgQQL6QR0KG3B1YnN1Yi5nb29nbGVhcGlzLmNvbS9Ub3BpYxIWCglwYWdl", - "X3NpemUYAiABKAVCA+BBARIXCgpwYWdlX3Rva2VuGAMgASgJQgPgQQEigQEK", - "Hkxpc3RUb3BpY1N1YnNjcmlwdGlvbnNSZXNwb25zZRJBCg1zdWJzY3JpcHRp", - "b25zGAEgAygJQirgQQH6QSQKInB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJz", - "Y3JpcHRpb24SHAoPbmV4dF9wYWdlX3Rva2VuGAIgASgJQgPgQQEigAEKGUxp", - "c3RUb3BpY1NuYXBzaG90c1JlcXVlc3QSMgoFdG9waWMYASABKAlCI+BBAvpB", - "HQobcHVic3ViLmdvb2dsZWFwaXMuY29tL1RvcGljEhYKCXBhZ2Vfc2l6ZRgC", - "IAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4YAyABKAlCA+BBASJ1ChpMaXN0VG9w", - "aWNTbmFwc2hvdHNSZXNwb25zZRI5CglzbmFwc2hvdHMYASADKAlCJuBBAfpB", - "IAoecHVic3ViLmdvb2dsZWFwaXMuY29tL1NuYXBzaG90EhwKD25leHRfcGFn", - "ZV90b2tlbhgCIAEoCUID4EEBIksKEkRlbGV0ZVRvcGljUmVxdWVzdBI1CgV0", - "b3BpYxgBIAEoCUIm4EEC4EEI+kEdChtwdWJzdWIuZ29vZ2xlYXBpcy5jb20v", - "VG9waWMiXQoZRGV0YWNoU3Vic2NyaXB0aW9uUmVxdWVzdBJACgxzdWJzY3Jp", - "cHRpb24YASABKAlCKuBBAvpBJAoicHVic3ViLmdvb2dsZWFwaXMuY29tL1N1", - "YnNjcmlwdGlvbiIcChpEZXRhY2hTdWJzY3JpcHRpb25SZXNwb25zZSKoDAoM", - "U3Vic2NyaXB0aW9uEhQKBG5hbWUYASABKAlCBuBBAuBBCBIyCgV0b3BpYxgC", - "IAEoCUIj4EEC+kEdChtwdWJzdWIuZ29vZ2xlYXBpcy5jb20vVG9waWMSNgoL", - "cHVzaF9jb25maWcYBCABKAsyHC5nb29nbGUucHVic3ViLnYxLlB1c2hDb25m", - "aWdCA+BBARI+Cg9iaWdxdWVyeV9jb25maWcYEiABKAsyIC5nb29nbGUucHVi", - "c3ViLnYxLkJpZ1F1ZXJ5Q29uZmlnQgPgQQESRwoUY2xvdWRfc3RvcmFnZV9j", - "b25maWcYFiABKAsyJC5nb29nbGUucHVic3ViLnYxLkNsb3VkU3RvcmFnZUNv", - "bmZpZ0ID4EEBEiEKFGFja19kZWFkbGluZV9zZWNvbmRzGAUgASgFQgPgQQES", - "IgoVcmV0YWluX2Fja2VkX21lc3NhZ2VzGAcgASgIQgPgQQESQgoabWVzc2Fn", - "ZV9yZXRlbnRpb25fZHVyYXRpb24YCCABKAsyGS5nb29nbGUucHJvdG9idWYu", - "RHVyYXRpb25CA+BBARI/CgZsYWJlbHMYCSADKAsyKi5nb29nbGUucHVic3Vi", - "LnYxLlN1YnNjcmlwdGlvbi5MYWJlbHNFbnRyeUID4EEBEiQKF2VuYWJsZV9t", - "ZXNzYWdlX29yZGVyaW5nGAogASgIQgPgQQESQgoRZXhwaXJhdGlvbl9wb2xp", - "Y3kYCyABKAsyIi5nb29nbGUucHVic3ViLnYxLkV4cGlyYXRpb25Qb2xpY3lC", - "A+BBARITCgZmaWx0ZXIYDCABKAlCA+BBARJDChJkZWFkX2xldHRlcl9wb2xp", - "Y3kYDSABKAsyIi5nb29nbGUucHVic3ViLnYxLkRlYWRMZXR0ZXJQb2xpY3lC", - "A+BBARI4CgxyZXRyeV9wb2xpY3kYDiABKAsyHS5nb29nbGUucHVic3ViLnYx", - "LlJldHJ5UG9saWN5QgPgQQESFQoIZGV0YWNoZWQYDyABKAhCA+BBARIpChxl", - "bmFibGVfZXhhY3RseV9vbmNlX2RlbGl2ZXJ5GBAgASgIQgPgQQESSAogdG9w", - "aWNfbWVzc2FnZV9yZXRlbnRpb25fZHVyYXRpb24YESABKAsyGS5nb29nbGUu", - "cHJvdG9idWYuRHVyYXRpb25CA+BBAxI4CgVzdGF0ZRgTIAEoDjIkLmdvb2ds", - "ZS5wdWJzdWIudjEuU3Vic2NyaXB0aW9uLlN0YXRlQgPgQQMSaQofYW5hbHl0", - "aWNzX2h1Yl9zdWJzY3JpcHRpb25faW5mbxgXIAEoCzI7Lmdvb2dsZS5wdWJz", - "dWIudjEuU3Vic2NyaXB0aW9uLkFuYWx5dGljc0h1YlN1YnNjcmlwdGlvbklu", - "Zm9CA+BBAxJDChJtZXNzYWdlX3RyYW5zZm9ybXMYGSADKAsyIi5nb29nbGUu", - "cHVic3ViLnYxLk1lc3NhZ2VUcmFuc2Zvcm1CA+BBARJBCgR0YWdzGBogAygL", - "MiguZ29vZ2xlLnB1YnN1Yi52MS5TdWJzY3JpcHRpb24uVGFnc0VudHJ5Qgng", - "QQTgQQXgQQEadwocQW5hbHl0aWNzSHViU3Vic2NyaXB0aW9uSW5mbxI8Cgds", - "aXN0aW5nGAEgASgJQivgQQH6QSUKI2FuYWx5dGljc2h1Yi5nb29nbGVhcGlz", - "LmNvbS9MaXN0aW5nEhkKDHN1YnNjcmlwdGlvbhgCIAEoCUID4EEBGi0KC0xh", - "YmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEaKwoJ", - "VGFnc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEiPgoF", - "U3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIKCgZBQ1RJVkUQARISCg5S", - "RVNPVVJDRV9FUlJPUhACOnXqQXIKInB1YnN1Yi5nb29nbGVhcGlzLmNvbS9T", - "dWJzY3JpcHRpb24SL3Byb2plY3RzL3twcm9qZWN0fS9zdWJzY3JpcHRpb25z", - "L3tzdWJzY3JpcHRpb259Kg1zdWJzY3JpcHRpb25zMgxzdWJzY3JpcHRpb24i", - "fwoLUmV0cnlQb2xpY3kSNwoPbWluaW11bV9iYWNrb2ZmGAEgASgLMhkuZ29v", - "Z2xlLnByb3RvYnVmLkR1cmF0aW9uQgPgQQESNwoPbWF4aW11bV9iYWNrb2Zm", - "GAIgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQgPgQQEidgoQRGVh", - "ZExldHRlclBvbGljeRI+ChFkZWFkX2xldHRlcl90b3BpYxgBIAEoCUIj4EEB", - "+kEdChtwdWJzdWIuZ29vZ2xlYXBpcy5jb20vVG9waWMSIgoVbWF4X2RlbGl2", - "ZXJ5X2F0dGVtcHRzGAIgASgFQgPgQQEiPwoQRXhwaXJhdGlvblBvbGljeRIr", - "CgN0dGwYASABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CA+BBASKa", - "BAoKUHVzaENvbmZpZxIaCg1wdXNoX2VuZHBvaW50GAEgASgJQgPgQQESRQoK", - "YXR0cmlidXRlcxgCIAMoCzIsLmdvb2dsZS5wdWJzdWIudjEuUHVzaENvbmZp", - "Zy5BdHRyaWJ1dGVzRW50cnlCA+BBARJBCgpvaWRjX3Rva2VuGAMgASgLMiYu", - "Z29vZ2xlLnB1YnN1Yi52MS5QdXNoQ29uZmlnLk9pZGNUb2tlbkID4EEBSAAS", - "SQoOcHVic3ViX3dyYXBwZXIYBCABKAsyKi5nb29nbGUucHVic3ViLnYxLlB1", - "c2hDb25maWcuUHVic3ViV3JhcHBlckID4EEBSAESQQoKbm9fd3JhcHBlchgF", - "IAEoCzImLmdvb2dsZS5wdWJzdWIudjEuUHVzaENvbmZpZy5Ob1dyYXBwZXJC", - "A+BBAUgBGkYKCU9pZGNUb2tlbhIiChVzZXJ2aWNlX2FjY291bnRfZW1haWwY", - "ASABKAlCA+BBARIVCghhdWRpZW5jZRgCIAEoCUID4EEBGg8KDVB1YnN1Yldy", - "YXBwZXIaKAoJTm9XcmFwcGVyEhsKDndyaXRlX21ldGFkYXRhGAEgASgIQgPg", - "QQEaMQoPQXR0cmlidXRlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgC", - "IAEoCToCOAFCFwoVYXV0aGVudGljYXRpb25fbWV0aG9kQgkKB3dyYXBwZXIi", - "jgMKDkJpZ1F1ZXJ5Q29uZmlnEhIKBXRhYmxlGAEgASgJQgPgQQESHQoQdXNl", - "X3RvcGljX3NjaGVtYRgCIAEoCEID4EEBEhsKDndyaXRlX21ldGFkYXRhGAMg", - "ASgIQgPgQQESIAoTZHJvcF91bmtub3duX2ZpZWxkcxgEIAEoCEID4EEBEjoK", - "BXN0YXRlGAUgASgOMiYuZ29vZ2xlLnB1YnN1Yi52MS5CaWdRdWVyeUNvbmZp", - "Zy5TdGF0ZUID4EEDEh0KEHVzZV90YWJsZV9zY2hlbWEYBiABKAhCA+BBARIi", - "ChVzZXJ2aWNlX2FjY291bnRfZW1haWwYByABKAlCA+BBASKKAQoFU3RhdGUS", - "FQoRU1RBVEVfVU5TUEVDSUZJRUQQABIKCgZBQ1RJVkUQARIVChFQRVJNSVNT", - "SU9OX0RFTklFRBACEg0KCU5PVF9GT1VORBADEhMKD1NDSEVNQV9NSVNNQVRD", - "SBAEEiMKH0lOX1RSQU5TSVRfTE9DQVRJT05fUkVTVFJJQ1RJT04QBSLpBQoS", - "Q2xvdWRTdG9yYWdlQ29uZmlnEhMKBmJ1Y2tldBgBIAEoCUID4EECEhwKD2Zp", - "bGVuYW1lX3ByZWZpeBgCIAEoCUID4EEBEhwKD2ZpbGVuYW1lX3N1ZmZpeBgD", - "IAEoCUID4EEBEiUKGGZpbGVuYW1lX2RhdGV0aW1lX2Zvcm1hdBgKIAEoCUID", - "4EEBEksKC3RleHRfY29uZmlnGAQgASgLMi8uZ29vZ2xlLnB1YnN1Yi52MS5D", - "bG91ZFN0b3JhZ2VDb25maWcuVGV4dENvbmZpZ0ID4EEBSAASSwoLYXZyb19j", - "b25maWcYBSABKAsyLy5nb29nbGUucHVic3ViLnYxLkNsb3VkU3RvcmFnZUNv", - "bmZpZy5BdnJvQ29uZmlnQgPgQQFIABI0CgxtYXhfZHVyYXRpb24YBiABKAsy", - "GS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25CA+BBARIWCgltYXhfYnl0ZXMY", - "ByABKANCA+BBARIZCgxtYXhfbWVzc2FnZXMYCCABKANCA+BBARI+CgVzdGF0", - "ZRgJIAEoDjIqLmdvb2dsZS5wdWJzdWIudjEuQ2xvdWRTdG9yYWdlQ29uZmln", - "LlN0YXRlQgPgQQMSIgoVc2VydmljZV9hY2NvdW50X2VtYWlsGAsgASgJQgPg", - "QQEaDAoKVGV4dENvbmZpZxpICgpBdnJvQ29uZmlnEhsKDndyaXRlX21ldGFk", - "YXRhGAEgASgIQgPgQQESHQoQdXNlX3RvcGljX3NjaGVtYRgCIAEoCEID4EEB", - "IooBCgVTdGF0ZRIVChFTVEFURV9VTlNQRUNJRklFRBAAEgoKBkFDVElWRRAB", - "EhUKEVBFUk1JU1NJT05fREVOSUVEEAISDQoJTk9UX0ZPVU5EEAMSIwofSU5f", - "VFJBTlNJVF9MT0NBVElPTl9SRVNUUklDVElPThAEEhMKD1NDSEVNQV9NSVNN", - "QVRDSBAFQg8KDW91dHB1dF9mb3JtYXQifAoPUmVjZWl2ZWRNZXNzYWdlEhMK", - "BmFja19pZBgBIAEoCUID4EEBEjUKB21lc3NhZ2UYAiABKAsyHy5nb29nbGUu", - "cHVic3ViLnYxLlB1YnN1Yk1lc3NhZ2VCA+BBARIdChBkZWxpdmVyeV9hdHRl", - "bXB0GAMgASgFQgPgQQEiXQoWR2V0U3Vic2NyaXB0aW9uUmVxdWVzdBJDCgxz", - "dWJzY3JpcHRpb24YASABKAlCLeBBAuBBCPpBJAoicHVic3ViLmdvb2dsZWFw", - "aXMuY29tL1N1YnNjcmlwdGlvbiKMAQoZVXBkYXRlU3Vic2NyaXB0aW9uUmVx", - "dWVzdBI5CgxzdWJzY3JpcHRpb24YASABKAsyHi5nb29nbGUucHVic3ViLnYx", - "LlN1YnNjcmlwdGlvbkID4EECEjQKC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29v", - "Z2xlLnByb3RvYnVmLkZpZWxkTWFza0ID4EECIpQBChhMaXN0U3Vic2NyaXB0", - "aW9uc1JlcXVlc3QSRwoHcHJvamVjdBgBIAEoCUI24EEC4EEI+kEtCitjbG91", - "ZHJlc291cmNlbWFuYWdlci5nb29nbGVhcGlzLmNvbS9Qcm9qZWN0EhYKCXBh", - "Z2Vfc2l6ZRgCIAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4YAyABKAlCA+BBASJ1", - "ChlMaXN0U3Vic2NyaXB0aW9uc1Jlc3BvbnNlEjoKDXN1YnNjcmlwdGlvbnMY", - "ASADKAsyHi5nb29nbGUucHVic3ViLnYxLlN1YnNjcmlwdGlvbkID4EEBEhwK", - "D25leHRfcGFnZV90b2tlbhgCIAEoCUID4EEBImAKGURlbGV0ZVN1YnNjcmlw", - "dGlvblJlcXVlc3QSQwoMc3Vic2NyaXB0aW9uGAEgASgJQi3gQQLgQQj6QSQK", - "InB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJzY3JpcHRpb24ikwEKF01vZGlm", - "eVB1c2hDb25maWdSZXF1ZXN0EkAKDHN1YnNjcmlwdGlvbhgBIAEoCUIq4EEC", - "+kEkCiJwdWJzdWIuZ29vZ2xlYXBpcy5jb20vU3Vic2NyaXB0aW9uEjYKC3B1", - "c2hfY29uZmlnGAIgASgLMhwuZ29vZ2xlLnB1YnN1Yi52MS5QdXNoQ29uZmln", - "QgPgQQIijQEKC1B1bGxSZXF1ZXN0EkAKDHN1YnNjcmlwdGlvbhgBIAEoCUIq", - "4EEC+kEkCiJwdWJzdWIuZ29vZ2xlYXBpcy5jb20vU3Vic2NyaXB0aW9uEiEK", - "EnJldHVybl9pbW1lZGlhdGVseRgCIAEoCEIFGAHgQQESGQoMbWF4X21lc3Nh", - "Z2VzGAMgASgFQgPgQQIiUQoMUHVsbFJlc3BvbnNlEkEKEXJlY2VpdmVkX21l", - "c3NhZ2VzGAEgAygLMiEuZ29vZ2xlLnB1YnN1Yi52MS5SZWNlaXZlZE1lc3Nh", - "Z2VCA+BBASKVAQoYTW9kaWZ5QWNrRGVhZGxpbmVSZXF1ZXN0EkAKDHN1YnNj", - "cmlwdGlvbhgBIAEoCUIq4EEC+kEkCiJwdWJzdWIuZ29vZ2xlYXBpcy5jb20v", - "U3Vic2NyaXB0aW9uEhQKB2Fja19pZHMYBCADKAlCA+BBAhIhChRhY2tfZGVh", - "ZGxpbmVfc2Vjb25kcxgDIAEoBUID4EECImwKEkFja25vd2xlZGdlUmVxdWVz", - "dBJACgxzdWJzY3JpcHRpb24YASABKAlCKuBBAvpBJAoicHVic3ViLmdvb2ds", - "ZWFwaXMuY29tL1N1YnNjcmlwdGlvbhIUCgdhY2tfaWRzGAIgAygJQgPgQQIi", - "5gIKFFN0cmVhbWluZ1B1bGxSZXF1ZXN0EkAKDHN1YnNjcmlwdGlvbhgBIAEo", - "CUIq4EEC+kEkCiJwdWJzdWIuZ29vZ2xlYXBpcy5jb20vU3Vic2NyaXB0aW9u", - "EhQKB2Fja19pZHMYAiADKAlCA+BBARIkChdtb2RpZnlfZGVhZGxpbmVfc2Vj", - "b25kcxgDIAMoBUID4EEBEiQKF21vZGlmeV9kZWFkbGluZV9hY2tfaWRzGAQg", - "AygJQgPgQQESKAobc3RyZWFtX2Fja19kZWFkbGluZV9zZWNvbmRzGAUgASgF", - "QgPgQQISFgoJY2xpZW50X2lkGAYgASgJQgPgQQESJQoYbWF4X291dHN0YW5k", - "aW5nX21lc3NhZ2VzGAcgASgDQgPgQQESIgoVbWF4X291dHN0YW5kaW5nX2J5", - "dGVzGAggASgDQgPgQQESHQoQcHJvdG9jb2xfdmVyc2lvbhgKIAEoA0ID4EEB", - "Ip4GChVTdHJlYW1pbmdQdWxsUmVzcG9uc2USQQoRcmVjZWl2ZWRfbWVzc2Fn", + "b25GYWlsdXJlUmVhc29uQgPgQQFIAEIICgZyZWFzb24a0gMKG0F6dXJlRXZl", + "bnRIdWJzRmFpbHVyZVJlYXNvbhIWCgluYW1lc3BhY2UYASABKAlCA+BBARIW", + "CglldmVudF9odWIYAiABKAlCA+BBARIZCgxwYXJ0aXRpb25faWQYAyABKANC", + "A+BBARITCgZvZmZzZXQYBCABKANCA+BBARJfChRhcGlfdmlvbGF0aW9uX3Jl", + "YXNvbhgFIAEoCzI6Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVy", + "ZUV2ZW50LkFwaVZpb2xhdGlvblJlYXNvbkID4EEBSAASZQoXc2NoZW1hX3Zp", + "b2xhdGlvbl9yZWFzb24YBiABKAsyPS5nb29nbGUucHVic3ViLnYxLkluZ2Vz", + "dGlvbkZhaWx1cmVFdmVudC5TY2hlbWFWaW9sYXRpb25SZWFzb25CA+BBAUgA", + "EoABCiVtZXNzYWdlX3RyYW5zZm9ybWF0aW9uX2ZhaWx1cmVfcmVhc29uGAcg", + "ASgLMkouZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25GYWlsdXJlRXZlbnQu", + "TWVzc2FnZVRyYW5zZm9ybWF0aW9uRmFpbHVyZVJlYXNvbkID4EEBSABCCAoG", + "cmVhc29uGtUDChtDb25mbHVlbnRDbG91ZEZhaWx1cmVSZWFzb24SFwoKY2x1", + "c3Rlcl9pZBgBIAEoCUID4EEBEhgKC2thZmthX3RvcGljGAIgASgJQgPgQQES", + "GQoMcGFydGl0aW9uX2lkGAMgASgDQgPgQQESEwoGb2Zmc2V0GAQgASgDQgPg", + "QQESXwoUYXBpX3Zpb2xhdGlvbl9yZWFzb24YBSABKAsyOi5nb29nbGUucHVi", + "c3ViLnYxLkluZ2VzdGlvbkZhaWx1cmVFdmVudC5BcGlWaW9sYXRpb25SZWFz", + "b25CA+BBAUgAEmUKF3NjaGVtYV92aW9sYXRpb25fcmVhc29uGAYgASgLMj0u", + "Z29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rpb25GYWlsdXJlRXZlbnQuU2NoZW1h", + "VmlvbGF0aW9uUmVhc29uQgPgQQFIABKAAQolbWVzc2FnZV90cmFuc2Zvcm1h", + "dGlvbl9mYWlsdXJlX3JlYXNvbhgHIAEoCzJKLmdvb2dsZS5wdWJzdWIudjEu", + "SW5nZXN0aW9uRmFpbHVyZUV2ZW50Lk1lc3NhZ2VUcmFuc2Zvcm1hdGlvbkZh", + "aWx1cmVSZWFzb25CA+BBAUgAQggKBnJlYXNvbhrBAwoXQXdzS2luZXNpc0Zh", + "aWx1cmVSZWFzb24SFwoKc3RyZWFtX2FybhgBIAEoCUID4EEBEhoKDXBhcnRp", + "dGlvbl9rZXkYAiABKAlCA+BBARIcCg9zZXF1ZW5jZV9udW1iZXIYAyABKAlC", + "A+BBARJlChdzY2hlbWFfdmlvbGF0aW9uX3JlYXNvbhgEIAEoCzI9Lmdvb2ds", + "ZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LlNjaGVtYVZpb2xh", + "dGlvblJlYXNvbkID4EEBSAASgAEKJW1lc3NhZ2VfdHJhbnNmb3JtYXRpb25f", + "ZmFpbHVyZV9yZWFzb24YBSABKAsySi5nb29nbGUucHVic3ViLnYxLkluZ2Vz", + "dGlvbkZhaWx1cmVFdmVudC5NZXNzYWdlVHJhbnNmb3JtYXRpb25GYWlsdXJl", + "UmVhc29uQgPgQQFIABJfChRhcGlfdmlvbGF0aW9uX3JlYXNvbhgGIAEoCzI6", + "Lmdvb2dsZS5wdWJzdWIudjEuSW5nZXN0aW9uRmFpbHVyZUV2ZW50LkFwaVZp", + "b2xhdGlvblJlYXNvbkID4EEBSABCCAoGcmVhc29uQgkKB2ZhaWx1cmUiPgoN", + "SmF2YVNjcmlwdFVERhIaCg1mdW5jdGlvbl9uYW1lGAEgASgJQgPgQQISEQoE", + "Y29kZRgCIAEoCUID4EECIoECCgtBSUluZmVyZW5jZRIVCghlbmRwb2ludBgB", + "IAEoCUID4EECEloKFnVuc3RydWN0dXJlZF9pbmZlcmVuY2UYAiABKAsyMy5n", + "b29nbGUucHVic3ViLnYxLkFJSW5mZXJlbmNlLlVuc3RydWN0dXJlZEluZmVy", + "ZW5jZUID4EEBSAASIgoVc2VydmljZV9hY2NvdW50X2VtYWlsGAMgASgJQgPg", + "QQEaSQoVVW5zdHJ1Y3R1cmVkSW5mZXJlbmNlEjAKCnBhcmFtZXRlcnMYASAB", + "KAsyFy5nb29nbGUucHJvdG9idWYuU3RydWN0QgPgQQFCEAoOaW5mZXJlbmNl", + "X21vZGUiygEKEE1lc3NhZ2VUcmFuc2Zvcm0SPgoOamF2YXNjcmlwdF91ZGYY", + "AiABKAsyHy5nb29nbGUucHVic3ViLnYxLkphdmFTY3JpcHRVREZCA+BBAUgA", + "EjoKDGFpX2luZmVyZW5jZRgGIAEoCzIdLmdvb2dsZS5wdWJzdWIudjEuQUlJ", + "bmZlcmVuY2VCA+BBAUgAEhYKB2VuYWJsZWQYAyABKAhCBRgB4EEBEhUKCGRp", + "c2FibGVkGAQgASgIQgPgQQFCCwoJdHJhbnNmb3JtIqAHCgVUb3BpYxIUCgRu", + "YW1lGAEgASgJQgbgQQLgQQgSOAoGbGFiZWxzGAIgAygLMiMuZ29vZ2xlLnB1", + "YnN1Yi52MS5Ub3BpYy5MYWJlbHNFbnRyeUID4EEBEksKFm1lc3NhZ2Vfc3Rv", + "cmFnZV9wb2xpY3kYAyABKAsyJi5nb29nbGUucHVic3ViLnYxLk1lc3NhZ2VT", + "dG9yYWdlUG9saWN5QgPgQQESPwoMa21zX2tleV9uYW1lGAUgASgJQingQQH6", + "QSMKIWNsb3Vka21zLmdvb2dsZWFwaXMuY29tL0NyeXB0b0tleRI+Cg9zY2hl", + "bWFfc2V0dGluZ3MYBiABKAsyIC5nb29nbGUucHVic3ViLnYxLlNjaGVtYVNl", + "dHRpbmdzQgPgQQESGgoNc2F0aXNmaWVzX3B6cxgHIAEoCEID4EEBEkIKGm1l", + "c3NhZ2VfcmV0ZW50aW9uX2R1cmF0aW9uGAggASgLMhkuZ29vZ2xlLnByb3Rv", + "YnVmLkR1cmF0aW9uQgPgQQESMQoFc3RhdGUYCSABKA4yHS5nb29nbGUucHVi", + "c3ViLnYxLlRvcGljLlN0YXRlQgPgQQMSWgoeaW5nZXN0aW9uX2RhdGFfc291", + "cmNlX3NldHRpbmdzGAogASgLMi0uZ29vZ2xlLnB1YnN1Yi52MS5Jbmdlc3Rp", + "b25EYXRhU291cmNlU2V0dGluZ3NCA+BBARJDChJtZXNzYWdlX3RyYW5zZm9y", + "bXMYDSADKAsyIi5nb29nbGUucHVic3ViLnYxLk1lc3NhZ2VUcmFuc2Zvcm1C", + "A+BBARI6CgR0YWdzGA4gAygLMiEuZ29vZ2xlLnB1YnN1Yi52MS5Ub3BpYy5U", + "YWdzRW50cnlCCeBBBOBBBeBBARotCgtMYWJlbHNFbnRyeRILCgNrZXkYASAB", + "KAkSDQoFdmFsdWUYAiABKAk6AjgBGisKCVRhZ3NFbnRyeRILCgNrZXkYASAB", + "KAkSDQoFdmFsdWUYAiABKAk6AjgBIkgKBVN0YXRlEhUKEVNUQVRFX1VOU1BF", + "Q0lGSUVEEAASCgoGQUNUSVZFEAESHAoYSU5HRVNUSU9OX1JFU09VUkNFX0VS", + "Uk9SEAI6Y+pBYAobcHVic3ViLmdvb2dsZWFwaXMuY29tL1RvcGljEiFwcm9q", + "ZWN0cy97cHJvamVjdH0vdG9waWNzL3t0b3BpY30SD19kZWxldGVkLXRvcGlj", + "XyoGdG9waWNzMgV0b3BpYyKAAgoNUHVic3ViTWVzc2FnZRIRCgRkYXRhGAEg", + "ASgMQgPgQQESSAoKYXR0cmlidXRlcxgCIAMoCzIvLmdvb2dsZS5wdWJzdWIu", + "djEuUHVic3ViTWVzc2FnZS5BdHRyaWJ1dGVzRW50cnlCA+BBARISCgptZXNz", + "YWdlX2lkGAMgASgJEjAKDHB1Ymxpc2hfdGltZRgEIAEoCzIaLmdvb2dsZS5w", + "cm90b2J1Zi5UaW1lc3RhbXASGQoMb3JkZXJpbmdfa2V5GAUgASgJQgPgQQEa", + "MQoPQXR0cmlidXRlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEo", + "CToCOAEiRQoPR2V0VG9waWNSZXF1ZXN0EjIKBXRvcGljGAEgASgJQiPgQQL6", + "QR0KG3B1YnN1Yi5nb29nbGVhcGlzLmNvbS9Ub3BpYyJ3ChJVcGRhdGVUb3Bp", + "Y1JlcXVlc3QSKwoFdG9waWMYASABKAsyFy5nb29nbGUucHVic3ViLnYxLlRv", + "cGljQgPgQQISNAoLdXBkYXRlX21hc2sYAiABKAsyGi5nb29nbGUucHJvdG9i", + "dWYuRmllbGRNYXNrQgPgQQIifAoOUHVibGlzaFJlcXVlc3QSMgoFdG9waWMY", + "ASABKAlCI+BBAvpBHQobcHVic3ViLmdvb2dsZWFwaXMuY29tL1RvcGljEjYK", + "CG1lc3NhZ2VzGAIgAygLMh8uZ29vZ2xlLnB1YnN1Yi52MS5QdWJzdWJNZXNz", + "YWdlQgPgQQIiKwoPUHVibGlzaFJlc3BvbnNlEhgKC21lc3NhZ2VfaWRzGAEg", + "AygJQgPgQQEiigEKEUxpc3RUb3BpY3NSZXF1ZXN0EkQKB3Byb2plY3QYASAB", + "KAlCM+BBAvpBLQorY2xvdWRyZXNvdXJjZW1hbmFnZXIuZ29vZ2xlYXBpcy5j", + "b20vUHJvamVjdBIWCglwYWdlX3NpemUYAiABKAVCA+BBARIXCgpwYWdlX3Rv", + "a2VuGAMgASgJQgPgQQEiYAoSTGlzdFRvcGljc1Jlc3BvbnNlEiwKBnRvcGlj", + "cxgBIAMoCzIXLmdvb2dsZS5wdWJzdWIudjEuVG9waWNCA+BBARIcCg9uZXh0", + "X3BhZ2VfdG9rZW4YAiABKAlCA+BBASKEAQodTGlzdFRvcGljU3Vic2NyaXB0", + "aW9uc1JlcXVlc3QSMgoFdG9waWMYASABKAlCI+BBAvpBHQobcHVic3ViLmdv", + "b2dsZWFwaXMuY29tL1RvcGljEhYKCXBhZ2Vfc2l6ZRgCIAEoBUID4EEBEhcK", + "CnBhZ2VfdG9rZW4YAyABKAlCA+BBASKBAQoeTGlzdFRvcGljU3Vic2NyaXB0", + "aW9uc1Jlc3BvbnNlEkEKDXN1YnNjcmlwdGlvbnMYASADKAlCKuBBAfpBJAoi", + "cHVic3ViLmdvb2dsZWFwaXMuY29tL1N1YnNjcmlwdGlvbhIcCg9uZXh0X3Bh", + "Z2VfdG9rZW4YAiABKAlCA+BBASKAAQoZTGlzdFRvcGljU25hcHNob3RzUmVx", + "dWVzdBIyCgV0b3BpYxgBIAEoCUIj4EEC+kEdChtwdWJzdWIuZ29vZ2xlYXBp", + "cy5jb20vVG9waWMSFgoJcGFnZV9zaXplGAIgASgFQgPgQQESFwoKcGFnZV90", + "b2tlbhgDIAEoCUID4EEBInUKGkxpc3RUb3BpY1NuYXBzaG90c1Jlc3BvbnNl", + "EjkKCXNuYXBzaG90cxgBIAMoCUIm4EEB+kEgCh5wdWJzdWIuZ29vZ2xlYXBp", + "cy5jb20vU25hcHNob3QSHAoPbmV4dF9wYWdlX3Rva2VuGAIgASgJQgPgQQEi", + "SAoSRGVsZXRlVG9waWNSZXF1ZXN0EjIKBXRvcGljGAEgASgJQiPgQQL6QR0K", + "G3B1YnN1Yi5nb29nbGVhcGlzLmNvbS9Ub3BpYyJdChlEZXRhY2hTdWJzY3Jp", + "cHRpb25SZXF1ZXN0EkAKDHN1YnNjcmlwdGlvbhgBIAEoCUIq4EEC+kEkCiJw", + "dWJzdWIuZ29vZ2xlYXBpcy5jb20vU3Vic2NyaXB0aW9uIhwKGkRldGFjaFN1", + "YnNjcmlwdGlvblJlc3BvbnNlIqgMCgxTdWJzY3JpcHRpb24SFAoEbmFtZRgB", + "IAEoCUIG4EEC4EEIEjIKBXRvcGljGAIgASgJQiPgQQL6QR0KG3B1YnN1Yi5n", + "b29nbGVhcGlzLmNvbS9Ub3BpYxI2CgtwdXNoX2NvbmZpZxgEIAEoCzIcLmdv", + "b2dsZS5wdWJzdWIudjEuUHVzaENvbmZpZ0ID4EEBEj4KD2JpZ3F1ZXJ5X2Nv", + "bmZpZxgSIAEoCzIgLmdvb2dsZS5wdWJzdWIudjEuQmlnUXVlcnlDb25maWdC", + "A+BBARJHChRjbG91ZF9zdG9yYWdlX2NvbmZpZxgWIAEoCzIkLmdvb2dsZS5w", + "dWJzdWIudjEuQ2xvdWRTdG9yYWdlQ29uZmlnQgPgQQESIQoUYWNrX2RlYWRs", + "aW5lX3NlY29uZHMYBSABKAVCA+BBARIiChVyZXRhaW5fYWNrZWRfbWVzc2Fn", + "ZXMYByABKAhCA+BBARJCChptZXNzYWdlX3JldGVudGlvbl9kdXJhdGlvbhgI", + "IAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkID4EEBEj8KBmxhYmVs", + "cxgJIAMoCzIqLmdvb2dsZS5wdWJzdWIudjEuU3Vic2NyaXB0aW9uLkxhYmVs", + "c0VudHJ5QgPgQQESJAoXZW5hYmxlX21lc3NhZ2Vfb3JkZXJpbmcYCiABKAhC", + "A+BBARJCChFleHBpcmF0aW9uX3BvbGljeRgLIAEoCzIiLmdvb2dsZS5wdWJz", + "dWIudjEuRXhwaXJhdGlvblBvbGljeUID4EEBEhMKBmZpbHRlchgMIAEoCUID", + "4EEBEkMKEmRlYWRfbGV0dGVyX3BvbGljeRgNIAEoCzIiLmdvb2dsZS5wdWJz", + "dWIudjEuRGVhZExldHRlclBvbGljeUID4EEBEjgKDHJldHJ5X3BvbGljeRgO", + "IAEoCzIdLmdvb2dsZS5wdWJzdWIudjEuUmV0cnlQb2xpY3lCA+BBARIVCghk", + "ZXRhY2hlZBgPIAEoCEID4EEBEikKHGVuYWJsZV9leGFjdGx5X29uY2VfZGVs", + "aXZlcnkYECABKAhCA+BBARJICiB0b3BpY19tZXNzYWdlX3JldGVudGlvbl9k", + "dXJhdGlvbhgRIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkID4EED", + "EjgKBXN0YXRlGBMgASgOMiQuZ29vZ2xlLnB1YnN1Yi52MS5TdWJzY3JpcHRp", + "b24uU3RhdGVCA+BBAxJpCh9hbmFseXRpY3NfaHViX3N1YnNjcmlwdGlvbl9p", + "bmZvGBcgASgLMjsuZ29vZ2xlLnB1YnN1Yi52MS5TdWJzY3JpcHRpb24uQW5h", + "bHl0aWNzSHViU3Vic2NyaXB0aW9uSW5mb0ID4EEDEkMKEm1lc3NhZ2VfdHJh", + "bnNmb3JtcxgZIAMoCzIiLmdvb2dsZS5wdWJzdWIudjEuTWVzc2FnZVRyYW5z", + "Zm9ybUID4EEBEkEKBHRhZ3MYGiADKAsyKC5nb29nbGUucHVic3ViLnYxLlN1", + "YnNjcmlwdGlvbi5UYWdzRW50cnlCCeBBBOBBBeBBARp3ChxBbmFseXRpY3NI", + "dWJTdWJzY3JpcHRpb25JbmZvEjwKB2xpc3RpbmcYASABKAlCK+BBAfpBJQoj", + "YW5hbHl0aWNzaHViLmdvb2dsZWFwaXMuY29tL0xpc3RpbmcSGQoMc3Vic2Ny", + "aXB0aW9uGAIgASgJQgPgQQEaLQoLTGFiZWxzRW50cnkSCwoDa2V5GAEgASgJ", + "Eg0KBXZhbHVlGAIgASgJOgI4ARorCglUYWdzRW50cnkSCwoDa2V5GAEgASgJ", + "Eg0KBXZhbHVlGAIgASgJOgI4ASI+CgVTdGF0ZRIVChFTVEFURV9VTlNQRUNJ", + "RklFRBAAEgoKBkFDVElWRRABEhIKDlJFU09VUkNFX0VSUk9SEAI6depBcgoi", + "cHVic3ViLmdvb2dsZWFwaXMuY29tL1N1YnNjcmlwdGlvbhIvcHJvamVjdHMv", + "e3Byb2plY3R9L3N1YnNjcmlwdGlvbnMve3N1YnNjcmlwdGlvbn0qDXN1YnNj", + "cmlwdGlvbnMyDHN1YnNjcmlwdGlvbiJ/CgtSZXRyeVBvbGljeRI3Cg9taW5p", + "bXVtX2JhY2tvZmYYASABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25C", + "A+BBARI3Cg9tYXhpbXVtX2JhY2tvZmYYAiABKAsyGS5nb29nbGUucHJvdG9i", + "dWYuRHVyYXRpb25CA+BBASJ2ChBEZWFkTGV0dGVyUG9saWN5Ej4KEWRlYWRf", + "bGV0dGVyX3RvcGljGAEgASgJQiPgQQH6QR0KG3B1YnN1Yi5nb29nbGVhcGlz", + "LmNvbS9Ub3BpYxIiChVtYXhfZGVsaXZlcnlfYXR0ZW1wdHMYAiABKAVCA+BB", + "ASI/ChBFeHBpcmF0aW9uUG9saWN5EisKA3R0bBgBIAEoCzIZLmdvb2dsZS5w", + "cm90b2J1Zi5EdXJhdGlvbkID4EEBIpoECgpQdXNoQ29uZmlnEhoKDXB1c2hf", + "ZW5kcG9pbnQYASABKAlCA+BBARJFCgphdHRyaWJ1dGVzGAIgAygLMiwuZ29v", + "Z2xlLnB1YnN1Yi52MS5QdXNoQ29uZmlnLkF0dHJpYnV0ZXNFbnRyeUID4EEB", + "EkEKCm9pZGNfdG9rZW4YAyABKAsyJi5nb29nbGUucHVic3ViLnYxLlB1c2hD", + "b25maWcuT2lkY1Rva2VuQgPgQQFIABJJCg5wdWJzdWJfd3JhcHBlchgEIAEo", + "CzIqLmdvb2dsZS5wdWJzdWIudjEuUHVzaENvbmZpZy5QdWJzdWJXcmFwcGVy", + "QgPgQQFIARJBCgpub193cmFwcGVyGAUgASgLMiYuZ29vZ2xlLnB1YnN1Yi52", + "MS5QdXNoQ29uZmlnLk5vV3JhcHBlckID4EEBSAEaRgoJT2lkY1Rva2VuEiIK", + "FXNlcnZpY2VfYWNjb3VudF9lbWFpbBgBIAEoCUID4EEBEhUKCGF1ZGllbmNl", + "GAIgASgJQgPgQQEaDwoNUHVic3ViV3JhcHBlchooCglOb1dyYXBwZXISGwoO", + "d3JpdGVfbWV0YWRhdGEYASABKAhCA+BBARoxCg9BdHRyaWJ1dGVzRW50cnkS", + "CwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4AUIXChVhdXRoZW50aWNh", + "dGlvbl9tZXRob2RCCQoHd3JhcHBlciKyAwoOQmlnUXVlcnlDb25maWcSEgoF", + "dGFibGUYASABKAlCA+BBARIdChB1c2VfdG9waWNfc2NoZW1hGAIgASgIQgPg", + "QQESGwoOd3JpdGVfbWV0YWRhdGEYAyABKAhCA+BBARIgChNkcm9wX3Vua25v", + "d25fZmllbGRzGAQgASgIQgPgQQESOgoFc3RhdGUYBSABKA4yJi5nb29nbGUu", + "cHVic3ViLnYxLkJpZ1F1ZXJ5Q29uZmlnLlN0YXRlQgPgQQMSHQoQdXNlX3Rh", + "YmxlX3NjaGVtYRgGIAEoCEID4EEBEiIKFXNlcnZpY2VfYWNjb3VudF9lbWFp", + "bBgHIAEoCUID4EEBIq4BCgVTdGF0ZRIVChFTVEFURV9VTlNQRUNJRklFRBAA", + "EgoKBkFDVElWRRABEhUKEVBFUk1JU1NJT05fREVOSUVEEAISDQoJTk9UX0ZP", + "VU5EEAMSEwoPU0NIRU1BX01JU01BVENIEAQSIwofSU5fVFJBTlNJVF9MT0NB", + "VElPTl9SRVNUUklDVElPThAFEiIKHlZFUlRFWF9BSV9MT0NBVElPTl9SRVNU", + "UklDVElPThAGIo0GChJDbG91ZFN0b3JhZ2VDb25maWcSEwoGYnVja2V0GAEg", + "ASgJQgPgQQISHAoPZmlsZW5hbWVfcHJlZml4GAIgASgJQgPgQQESHAoPZmls", + "ZW5hbWVfc3VmZml4GAMgASgJQgPgQQESJQoYZmlsZW5hbWVfZGF0ZXRpbWVf", + "Zm9ybWF0GAogASgJQgPgQQESSwoLdGV4dF9jb25maWcYBCABKAsyLy5nb29n", + "bGUucHVic3ViLnYxLkNsb3VkU3RvcmFnZUNvbmZpZy5UZXh0Q29uZmlnQgPg", + "QQFIABJLCgthdnJvX2NvbmZpZxgFIAEoCzIvLmdvb2dsZS5wdWJzdWIudjEu", + "Q2xvdWRTdG9yYWdlQ29uZmlnLkF2cm9Db25maWdCA+BBAUgAEjQKDG1heF9k", + "dXJhdGlvbhgGIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJhdGlvbkID4EEB", + "EhYKCW1heF9ieXRlcxgHIAEoA0ID4EEBEhkKDG1heF9tZXNzYWdlcxgIIAEo", + "A0ID4EEBEj4KBXN0YXRlGAkgASgOMiouZ29vZ2xlLnB1YnN1Yi52MS5DbG91", + "ZFN0b3JhZ2VDb25maWcuU3RhdGVCA+BBAxIiChVzZXJ2aWNlX2FjY291bnRf", + "ZW1haWwYCyABKAlCA+BBARoMCgpUZXh0Q29uZmlnGkgKCkF2cm9Db25maWcS", + "GwoOd3JpdGVfbWV0YWRhdGEYASABKAhCA+BBARIdChB1c2VfdG9waWNfc2No", + "ZW1hGAIgASgIQgPgQQEirgEKBVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVE", + "EAASCgoGQUNUSVZFEAESFQoRUEVSTUlTU0lPTl9ERU5JRUQQAhINCglOT1Rf", + "Rk9VTkQQAxIjCh9JTl9UUkFOU0lUX0xPQ0FUSU9OX1JFU1RSSUNUSU9OEAQS", + "EwoPU0NIRU1BX01JU01BVENIEAUSIgoeVkVSVEVYX0FJX0xPQ0FUSU9OX1JF", + "U1RSSUNUSU9OEAZCDwoNb3V0cHV0X2Zvcm1hdCJ8Cg9SZWNlaXZlZE1lc3Nh", + "Z2USEwoGYWNrX2lkGAEgASgJQgPgQQESNQoHbWVzc2FnZRgCIAEoCzIfLmdv", + "b2dsZS5wdWJzdWIudjEuUHVic3ViTWVzc2FnZUID4EEBEh0KEGRlbGl2ZXJ5", + "X2F0dGVtcHQYAyABKAVCA+BBASJaChZHZXRTdWJzY3JpcHRpb25SZXF1ZXN0", + "EkAKDHN1YnNjcmlwdGlvbhgBIAEoCUIq4EEC+kEkCiJwdWJzdWIuZ29vZ2xl", + "YXBpcy5jb20vU3Vic2NyaXB0aW9uIowBChlVcGRhdGVTdWJzY3JpcHRpb25S", + "ZXF1ZXN0EjkKDHN1YnNjcmlwdGlvbhgBIAEoCzIeLmdvb2dsZS5wdWJzdWIu", + "djEuU3Vic2NyaXB0aW9uQgPgQQISNAoLdXBkYXRlX21hc2sYAiABKAsyGi5n", + "b29nbGUucHJvdG9idWYuRmllbGRNYXNrQgPgQQIikQEKGExpc3RTdWJzY3Jp", + "cHRpb25zUmVxdWVzdBJECgdwcm9qZWN0GAEgASgJQjPgQQL6QS0KK2Nsb3Vk", + "cmVzb3VyY2VtYW5hZ2VyLmdvb2dsZWFwaXMuY29tL1Byb2plY3QSFgoJcGFn", + "ZV9zaXplGAIgASgFQgPgQQESFwoKcGFnZV90b2tlbhgDIAEoCUID4EEBInUK", + "GUxpc3RTdWJzY3JpcHRpb25zUmVzcG9uc2USOgoNc3Vic2NyaXB0aW9ucxgB", + "IAMoCzIeLmdvb2dsZS5wdWJzdWIudjEuU3Vic2NyaXB0aW9uQgPgQQESHAoP", + "bmV4dF9wYWdlX3Rva2VuGAIgASgJQgPgQQEiXQoZRGVsZXRlU3Vic2NyaXB0", + "aW9uUmVxdWVzdBJACgxzdWJzY3JpcHRpb24YASABKAlCKuBBAvpBJAoicHVi", + "c3ViLmdvb2dsZWFwaXMuY29tL1N1YnNjcmlwdGlvbiKTAQoXTW9kaWZ5UHVz", + "aENvbmZpZ1JlcXVlc3QSQAoMc3Vic2NyaXB0aW9uGAEgASgJQirgQQL6QSQK", + "InB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJzY3JpcHRpb24SNgoLcHVzaF9j", + "b25maWcYAiABKAsyHC5nb29nbGUucHVic3ViLnYxLlB1c2hDb25maWdCA+BB", + "AiKNAQoLUHVsbFJlcXVlc3QSQAoMc3Vic2NyaXB0aW9uGAEgASgJQirgQQL6", + "QSQKInB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJzY3JpcHRpb24SIQoScmV0", + "dXJuX2ltbWVkaWF0ZWx5GAIgASgIQgUYAeBBARIZCgxtYXhfbWVzc2FnZXMY", + "AyABKAVCA+BBAiJRCgxQdWxsUmVzcG9uc2USQQoRcmVjZWl2ZWRfbWVzc2Fn", "ZXMYASADKAsyIS5nb29nbGUucHVic3ViLnYxLlJlY2VpdmVkTWVzc2FnZUID", - "4EEBEmYKGGFja25vd2xlZGdlX2NvbmZpcm1hdGlvbhgFIAEoCzI/Lmdvb2ds", - "ZS5wdWJzdWIudjEuU3RyZWFtaW5nUHVsbFJlc3BvbnNlLkFja25vd2xlZGdl", - "Q29uZmlybWF0aW9uQgPgQQESdAogbW9kaWZ5X2Fja19kZWFkbGluZV9jb25m", - "aXJtYXRpb24YAyABKAsyRS5nb29nbGUucHVic3ViLnYxLlN0cmVhbWluZ1B1", - "bGxSZXNwb25zZS5Nb2RpZnlBY2tEZWFkbGluZUNvbmZpcm1hdGlvbkID4EEB", - "EmQKF3N1YnNjcmlwdGlvbl9wcm9wZXJ0aWVzGAQgASgLMj4uZ29vZ2xlLnB1", - "YnN1Yi52MS5TdHJlYW1pbmdQdWxsUmVzcG9uc2UuU3Vic2NyaXB0aW9uUHJv", - "cGVydGllc0ID4EEBGpQBChdBY2tub3dsZWRnZUNvbmZpcm1hdGlvbhIUCgdh", - "Y2tfaWRzGAEgAygJQgPgQQESHAoPaW52YWxpZF9hY2tfaWRzGAIgAygJQgPg", - "QQESHgoRdW5vcmRlcmVkX2Fja19pZHMYAyADKAlCA+BBARIlChh0ZW1wb3Jh", - "cnlfZmFpbGVkX2Fja19pZHMYBCADKAlCA+BBARp6Ch1Nb2RpZnlBY2tEZWFk", - "bGluZUNvbmZpcm1hdGlvbhIUCgdhY2tfaWRzGAEgAygJQgPgQQESHAoPaW52", - "YWxpZF9hY2tfaWRzGAIgAygJQgPgQQESJQoYdGVtcG9yYXJ5X2ZhaWxlZF9h", - "Y2tfaWRzGAMgAygJQgPgQQEaawoWU3Vic2NyaXB0aW9uUHJvcGVydGllcxIq", - "Ch1leGFjdGx5X29uY2VfZGVsaXZlcnlfZW5hYmxlZBgBIAEoCEID4EEBEiUK", - "GG1lc3NhZ2Vfb3JkZXJpbmdfZW5hYmxlZBgCIAEoCEID4EEBIoQDChVDcmVh", - "dGVTbmFwc2hvdFJlcXVlc3QSNwoEbmFtZRgBIAEoCUIp4EEC4EEI+kEgCh5w", - "dWJzdWIuZ29vZ2xlYXBpcy5jb20vU25hcHNob3QSQAoMc3Vic2NyaXB0aW9u", - "GAIgASgJQirgQQL6QSQKInB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJzY3Jp", - "cHRpb24SSAoGbGFiZWxzGAMgAygLMjMuZ29vZ2xlLnB1YnN1Yi52MS5DcmVh", - "dGVTbmFwc2hvdFJlcXVlc3QuTGFiZWxzRW50cnlCA+BBARJKCgR0YWdzGAQg", - "AygLMjEuZ29vZ2xlLnB1YnN1Yi52MS5DcmVhdGVTbmFwc2hvdFJlcXVlc3Qu", - "VGFnc0VudHJ5QgngQQTgQQXgQQEaLQoLTGFiZWxzRW50cnkSCwoDa2V5GAEg", - "ASgJEg0KBXZhbHVlGAIgASgJOgI4ARorCglUYWdzRW50cnkSCwoDa2V5GAEg", - "ASgJEg0KBXZhbHVlGAIgASgJOgI4ASKAAQoVVXBkYXRlU25hcHNob3RSZXF1", - "ZXN0EjEKCHNuYXBzaG90GAEgASgLMhouZ29vZ2xlLnB1YnN1Yi52MS5TbmFw", - "c2hvdEID4EECEjQKC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29vZ2xlLnByb3Rv", - "YnVmLkZpZWxkTWFza0ID4EECItYCCghTbmFwc2hvdBIRCgRuYW1lGAEgASgJ", - "QgPgQQESMgoFdG9waWMYAiABKAlCI+BBAfpBHQobcHVic3ViLmdvb2dsZWFw", - "aXMuY29tL1RvcGljEjQKC2V4cGlyZV90aW1lGAMgASgLMhouZ29vZ2xlLnBy", - "b3RvYnVmLlRpbWVzdGFtcEID4EEBEjsKBmxhYmVscxgEIAMoCzImLmdvb2ds", - "ZS5wdWJzdWIudjEuU25hcHNob3QuTGFiZWxzRW50cnlCA+BBARotCgtMYWJl", - "bHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBOmHqQV4K", - "HnB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TbmFwc2hvdBIncHJvamVjdHMve3By", - "b2plY3R9L3NuYXBzaG90cy97c25hcHNob3R9KglzbmFwc2hvdHMyCHNuYXBz", - "aG90IlEKEkdldFNuYXBzaG90UmVxdWVzdBI7CghzbmFwc2hvdBgBIAEoCUIp", - "4EEC4EEI+kEgCh5wdWJzdWIuZ29vZ2xlYXBpcy5jb20vU25hcHNob3QikAEK", - "FExpc3RTbmFwc2hvdHNSZXF1ZXN0EkcKB3Byb2plY3QYASABKAlCNuBBAuBB", - "CPpBLQorY2xvdWRyZXNvdXJjZW1hbmFnZXIuZ29vZ2xlYXBpcy5jb20vUHJv", - "amVjdBIWCglwYWdlX3NpemUYAiABKAVCA+BBARIXCgpwYWdlX3Rva2VuGAMg", - "ASgJQgPgQQEiaQoVTGlzdFNuYXBzaG90c1Jlc3BvbnNlEjIKCXNuYXBzaG90", - "cxgBIAMoCzIaLmdvb2dsZS5wdWJzdWIudjEuU25hcHNob3RCA+BBARIcCg9u", - "ZXh0X3BhZ2VfdG9rZW4YAiABKAlCA+BBASJUChVEZWxldGVTbmFwc2hvdFJl", - "cXVlc3QSOwoIc25hcHNob3QYASABKAlCKeBBAuBBCPpBIAoecHVic3ViLmdv", - "b2dsZWFwaXMuY29tL1NuYXBzaG90IsYBCgtTZWVrUmVxdWVzdBJACgxzdWJz", - "Y3JpcHRpb24YASABKAlCKuBBAvpBJAoicHVic3ViLmdvb2dsZWFwaXMuY29t", - "L1N1YnNjcmlwdGlvbhIvCgR0aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVm", - "LlRpbWVzdGFtcEID4EEBSAASOgoIc25hcHNob3QYAyABKAlCJuBBAfpBIAoe", - "cHVic3ViLmdvb2dsZWFwaXMuY29tL1NuYXBzaG90SABCCAoGdGFyZ2V0Ig4K", - "DFNlZWtSZXNwb25zZTK4CwoJUHVibGlzaGVyEnEKC0NyZWF0ZVRvcGljEhcu", - "Z29vZ2xlLnB1YnN1Yi52MS5Ub3BpYxoXLmdvb2dsZS5wdWJzdWIudjEuVG9w", - "aWMiMNpBBG5hbWWC0+STAiMaHi92MS97bmFtZT1wcm9qZWN0cy8qL3RvcGlj", - "cy8qfToBKhKRAQoLVXBkYXRlVG9waWMSJC5nb29nbGUucHVic3ViLnYxLlVw", - "ZGF0ZVRvcGljUmVxdWVzdBoXLmdvb2dsZS5wdWJzdWIudjEuVG9waWMiQ9pB", - "EXRvcGljLHVwZGF0ZV9tYXNrgtPkkwIpMiQvdjEve3RvcGljLm5hbWU9cHJv", - "amVjdHMvKi90b3BpY3MvKn06ASoSkwEKB1B1Ymxpc2gSIC5nb29nbGUucHVi", - "c3ViLnYxLlB1Ymxpc2hSZXF1ZXN0GiEuZ29vZ2xlLnB1YnN1Yi52MS5QdWJs", - "aXNoUmVzcG9uc2UiQ9pBDnRvcGljLG1lc3NhZ2VzgtPkkwIsIicvdjEve3Rv", - "cGljPXByb2plY3RzLyovdG9waWNzLyp9OnB1Ymxpc2g6ASoSdwoIR2V0VG9w", - "aWMSIS5nb29nbGUucHVic3ViLnYxLkdldFRvcGljUmVxdWVzdBoXLmdvb2ds", - "ZS5wdWJzdWIudjEuVG9waWMiL9pBBXRvcGljgtPkkwIhEh8vdjEve3RvcGlj", - "PXByb2plY3RzLyovdG9waWNzLyp9EooBCgpMaXN0VG9waWNzEiMuZ29vZ2xl", - "LnB1YnN1Yi52MS5MaXN0VG9waWNzUmVxdWVzdBokLmdvb2dsZS5wdWJzdWIu", - "djEuTGlzdFRvcGljc1Jlc3BvbnNlIjHaQQdwcm9qZWN0gtPkkwIhEh8vdjEv", - "e3Byb2plY3Q9cHJvamVjdHMvKn0vdG9waWNzEroBChZMaXN0VG9waWNTdWJz", - "Y3JpcHRpb25zEi8uZ29vZ2xlLnB1YnN1Yi52MS5MaXN0VG9waWNTdWJzY3Jp", - "cHRpb25zUmVxdWVzdBowLmdvb2dsZS5wdWJzdWIudjEuTGlzdFRvcGljU3Vi", - "c2NyaXB0aW9uc1Jlc3BvbnNlIj3aQQV0b3BpY4LT5JMCLxItL3YxL3t0b3Bp", - "Yz1wcm9qZWN0cy8qL3RvcGljcy8qfS9zdWJzY3JpcHRpb25zEqoBChJMaXN0", - "VG9waWNTbmFwc2hvdHMSKy5nb29nbGUucHVic3ViLnYxLkxpc3RUb3BpY1Nu", - "YXBzaG90c1JlcXVlc3QaLC5nb29nbGUucHVic3ViLnYxLkxpc3RUb3BpY1Nu", - "YXBzaG90c1Jlc3BvbnNlIjnaQQV0b3BpY4LT5JMCKxIpL3YxL3t0b3BpYz1w", - "cm9qZWN0cy8qL3RvcGljcy8qfS9zbmFwc2hvdHMSfAoLRGVsZXRlVG9waWMS", - "JC5nb29nbGUucHVic3ViLnYxLkRlbGV0ZVRvcGljUmVxdWVzdBoWLmdvb2ds", - "ZS5wcm90b2J1Zi5FbXB0eSIv2kEFdG9waWOC0+STAiEqHy92MS97dG9waWM9", - "cHJvamVjdHMvKi90b3BpY3MvKn0SrQEKEkRldGFjaFN1YnNjcmlwdGlvbhIr", - "Lmdvb2dsZS5wdWJzdWIudjEuRGV0YWNoU3Vic2NyaXB0aW9uUmVxdWVzdBos", - "Lmdvb2dsZS5wdWJzdWIudjEuRGV0YWNoU3Vic2NyaXB0aW9uUmVzcG9uc2Ui", - "PILT5JMCNiI0L3YxL3tzdWJzY3JpcHRpb249cHJvamVjdHMvKi9zdWJzY3Jp", - "cHRpb25zLyp9OmRldGFjaBpwykEVcHVic3ViLmdvb2dsZWFwaXMuY29t0kFV", - "aHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jbG91ZC1wbGF0Zm9y", - "bSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL3B1YnN1YjLSFQoK", - "U3Vic2NyaWJlchK0AQoSQ3JlYXRlU3Vic2NyaXB0aW9uEh4uZ29vZ2xlLnB1", - "YnN1Yi52MS5TdWJzY3JpcHRpb24aHi5nb29nbGUucHVic3ViLnYxLlN1YnNj", - "cmlwdGlvbiJe2kErbmFtZSx0b3BpYyxwdXNoX2NvbmZpZyxhY2tfZGVhZGxp", - "bmVfc2Vjb25kc4LT5JMCKholL3YxL3tuYW1lPXByb2plY3RzLyovc3Vic2Ny", - "aXB0aW9ucy8qfToBKhKhAQoPR2V0U3Vic2NyaXB0aW9uEiguZ29vZ2xlLnB1", - "YnN1Yi52MS5HZXRTdWJzY3JpcHRpb25SZXF1ZXN0Gh4uZ29vZ2xlLnB1YnN1", - "Yi52MS5TdWJzY3JpcHRpb24iRNpBDHN1YnNjcmlwdGlvboLT5JMCLxItL3Yx", - "L3tzdWJzY3JpcHRpb249cHJvamVjdHMvKi9zdWJzY3JpcHRpb25zLyp9ErsB", - "ChJVcGRhdGVTdWJzY3JpcHRpb24SKy5nb29nbGUucHVic3ViLnYxLlVwZGF0", - "ZVN1YnNjcmlwdGlvblJlcXVlc3QaHi5nb29nbGUucHVic3ViLnYxLlN1YnNj", - "cmlwdGlvbiJY2kEYc3Vic2NyaXB0aW9uLHVwZGF0ZV9tYXNrgtPkkwI3MjIv", - "djEve3N1YnNjcmlwdGlvbi5uYW1lPXByb2plY3RzLyovc3Vic2NyaXB0aW9u", - "cy8qfToBKhKmAQoRTGlzdFN1YnNjcmlwdGlvbnMSKi5nb29nbGUucHVic3Vi", - "LnYxLkxpc3RTdWJzY3JpcHRpb25zUmVxdWVzdBorLmdvb2dsZS5wdWJzdWIu", - "djEuTGlzdFN1YnNjcmlwdGlvbnNSZXNwb25zZSI42kEHcHJvamVjdILT5JMC", - "KBImL3YxL3twcm9qZWN0PXByb2plY3RzLyp9L3N1YnNjcmlwdGlvbnMSnwEK", - "EkRlbGV0ZVN1YnNjcmlwdGlvbhIrLmdvb2dsZS5wdWJzdWIudjEuRGVsZXRl", - "U3Vic2NyaXB0aW9uUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJE", - "2kEMc3Vic2NyaXB0aW9ugtPkkwIvKi0vdjEve3N1YnNjcmlwdGlvbj1wcm9q", - "ZWN0cy8qL3N1YnNjcmlwdGlvbnMvKn0SzwEKEU1vZGlmeUFja0RlYWRsaW5l", - "EiouZ29vZ2xlLnB1YnN1Yi52MS5Nb2RpZnlBY2tEZWFkbGluZVJlcXVlc3Qa", - "Fi5nb29nbGUucHJvdG9idWYuRW1wdHkidtpBKXN1YnNjcmlwdGlvbixhY2tf", - "aWRzLGFja19kZWFkbGluZV9zZWNvbmRzgtPkkwJEIj8vdjEve3N1YnNjcmlw", - "dGlvbj1wcm9qZWN0cy8qL3N1YnNjcmlwdGlvbnMvKn06bW9kaWZ5QWNrRGVh", - "ZGxpbmU6ASoSqAEKC0Fja25vd2xlZGdlEiQuZ29vZ2xlLnB1YnN1Yi52MS5B", - "Y2tub3dsZWRnZVJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiW9pB", - "FHN1YnNjcmlwdGlvbixhY2tfaWRzgtPkkwI+IjkvdjEve3N1YnNjcmlwdGlv", - "bj1wcm9qZWN0cy8qL3N1YnNjcmlwdGlvbnMvKn06YWNrbm93bGVkZ2U6ASoS", - "0AEKBFB1bGwSHS5nb29nbGUucHVic3ViLnYxLlB1bGxSZXF1ZXN0Gh4uZ29v", - "Z2xlLnB1YnN1Yi52MS5QdWxsUmVzcG9uc2UiiAHaQSxzdWJzY3JpcHRpb24s", - "cmV0dXJuX2ltbWVkaWF0ZWx5LG1heF9tZXNzYWdlc9pBGXN1YnNjcmlwdGlv", - "bixtYXhfbWVzc2FnZXOC0+STAjciMi92MS97c3Vic2NyaXB0aW9uPXByb2pl", - "Y3RzLyovc3Vic2NyaXB0aW9ucy8qfTpwdWxsOgEqEmYKDVN0cmVhbWluZ1B1", - "bGwSJi5nb29nbGUucHVic3ViLnYxLlN0cmVhbWluZ1B1bGxSZXF1ZXN0Gicu", - "Z29vZ2xlLnB1YnN1Yi52MS5TdHJlYW1pbmdQdWxsUmVzcG9uc2UiACgBMAES", - "uwEKEE1vZGlmeVB1c2hDb25maWcSKS5nb29nbGUucHVic3ViLnYxLk1vZGlm", - "eVB1c2hDb25maWdSZXF1ZXN0GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5ImTa", - "QRhzdWJzY3JpcHRpb24scHVzaF9jb25maWeC0+STAkMiPi92MS97c3Vic2Ny", - "aXB0aW9uPXByb2plY3RzLyovc3Vic2NyaXB0aW9ucy8qfTptb2RpZnlQdXNo", - "Q29uZmlnOgEqEokBCgtHZXRTbmFwc2hvdBIkLmdvb2dsZS5wdWJzdWIudjEu", - "R2V0U25hcHNob3RSZXF1ZXN0GhouZ29vZ2xlLnB1YnN1Yi52MS5TbmFwc2hv", - "dCI42kEIc25hcHNob3SC0+STAicSJS92MS97c25hcHNob3Q9cHJvamVjdHMv", - "Ki9zbmFwc2hvdHMvKn0SlgEKDUxpc3RTbmFwc2hvdHMSJi5nb29nbGUucHVi", - "c3ViLnYxLkxpc3RTbmFwc2hvdHNSZXF1ZXN0GicuZ29vZ2xlLnB1YnN1Yi52", - "MS5MaXN0U25hcHNob3RzUmVzcG9uc2UiNNpBB3Byb2plY3SC0+STAiQSIi92", - "MS97cHJvamVjdD1wcm9qZWN0cy8qfS9zbmFwc2hvdHMSlwEKDkNyZWF0ZVNu", - "YXBzaG90EicuZ29vZ2xlLnB1YnN1Yi52MS5DcmVhdGVTbmFwc2hvdFJlcXVl", - "c3QaGi5nb29nbGUucHVic3ViLnYxLlNuYXBzaG90IkDaQRFuYW1lLHN1YnNj", - "cmlwdGlvboLT5JMCJhohL3YxL3tuYW1lPXByb2plY3RzLyovc25hcHNob3Rz", - "Lyp9OgEqEqMBCg5VcGRhdGVTbmFwc2hvdBInLmdvb2dsZS5wdWJzdWIudjEu", - "VXBkYXRlU25hcHNob3RSZXF1ZXN0GhouZ29vZ2xlLnB1YnN1Yi52MS5TbmFw", - "c2hvdCJM2kEUc25hcHNob3QsdXBkYXRlX21hc2uC0+STAi8yKi92MS97c25h", - "cHNob3QubmFtZT1wcm9qZWN0cy8qL3NuYXBzaG90cy8qfToBKhKLAQoORGVs", - "ZXRlU25hcHNob3QSJy5nb29nbGUucHVic3ViLnYxLkRlbGV0ZVNuYXBzaG90", - "UmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSI42kEIc25hcHNob3SC", - "0+STAicqJS92MS97c25hcHNob3Q9cHJvamVjdHMvKi9zbmFwc2hvdHMvKn0S", - "hAEKBFNlZWsSHS5nb29nbGUucHVic3ViLnYxLlNlZWtSZXF1ZXN0Gh4uZ29v", - "Z2xlLnB1YnN1Yi52MS5TZWVrUmVzcG9uc2UiPYLT5JMCNyIyL3YxL3tzdWJz", - "Y3JpcHRpb249cHJvamVjdHMvKi9zdWJzY3JpcHRpb25zLyp9OnNlZWs6ASoa", - "cMpBFXB1YnN1Yi5nb29nbGVhcGlzLmNvbdJBVWh0dHBzOi8vd3d3Lmdvb2ds", - "ZWFwaXMuY29tL2F1dGgvY2xvdWQtcGxhdGZvcm0saHR0cHM6Ly93d3cuZ29v", - "Z2xlYXBpcy5jb20vYXV0aC9wdWJzdWJCpwMKFGNvbS5nb29nbGUucHVic3Vi", - "LnYxQgtQdWJzdWJQcm90b1ABWjVjbG91ZC5nb29nbGUuY29tL2dvL3B1YnN1", - "Yi92Mi9hcGl2MS9wdWJzdWJwYjtwdWJzdWJwYqoCFkdvb2dsZS5DbG91ZC5Q", - "dWJTdWIuVjHKAhZHb29nbGVcQ2xvdWRcUHViU3ViXFYx6gIZR29vZ2xlOjpD", - "bG91ZDo6UHViU3ViOjpWMepBeAohY2xvdWRrbXMuZ29vZ2xlYXBpcy5jb20v", - "Q3J5cHRvS2V5ElNwcm9qZWN0cy97cHJvamVjdH0vbG9jYXRpb25zL3tsb2Nh", - "dGlvbn0va2V5UmluZ3Mve2tleV9yaW5nfS9jcnlwdG9LZXlzL3tjcnlwdG9f", - "a2V5fepBfwojYW5hbHl0aWNzaHViLmdvb2dsZWFwaXMuY29tL0xpc3RpbmcS", - "WHByb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xvY2F0aW9ufS9kYXRh", - "RXhjaGFuZ2VzL3tkYXRhX2V4Y2hhbmdlfS9saXN0aW5ncy97bGlzdGluZ31i", - "BnByb3RvMw==")); + "4EEBIpUBChhNb2RpZnlBY2tEZWFkbGluZVJlcXVlc3QSQAoMc3Vic2NyaXB0", + "aW9uGAEgASgJQirgQQL6QSQKInB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJz", + "Y3JpcHRpb24SFAoHYWNrX2lkcxgEIAMoCUID4EECEiEKFGFja19kZWFkbGlu", + "ZV9zZWNvbmRzGAMgASgFQgPgQQIibAoSQWNrbm93bGVkZ2VSZXF1ZXN0EkAK", + "DHN1YnNjcmlwdGlvbhgBIAEoCUIq4EEC+kEkCiJwdWJzdWIuZ29vZ2xlYXBp", + "cy5jb20vU3Vic2NyaXB0aW9uEhQKB2Fja19pZHMYAiADKAlCA+BBAiLmAgoU", + "U3RyZWFtaW5nUHVsbFJlcXVlc3QSQAoMc3Vic2NyaXB0aW9uGAEgASgJQirg", + "QQL6QSQKInB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TdWJzY3JpcHRpb24SFAoH", + "YWNrX2lkcxgCIAMoCUID4EEBEiQKF21vZGlmeV9kZWFkbGluZV9zZWNvbmRz", + "GAMgAygFQgPgQQESJAoXbW9kaWZ5X2RlYWRsaW5lX2Fja19pZHMYBCADKAlC", + "A+BBARIoChtzdHJlYW1fYWNrX2RlYWRsaW5lX3NlY29uZHMYBSABKAVCA+BB", + "AhIWCgljbGllbnRfaWQYBiABKAlCA+BBARIlChhtYXhfb3V0c3RhbmRpbmdf", + "bWVzc2FnZXMYByABKANCA+BBARIiChVtYXhfb3V0c3RhbmRpbmdfYnl0ZXMY", + "CCABKANCA+BBARIdChBwcm90b2NvbF92ZXJzaW9uGAogASgDQgPgQQEingYK", + "FVN0cmVhbWluZ1B1bGxSZXNwb25zZRJBChFyZWNlaXZlZF9tZXNzYWdlcxgB", + "IAMoCzIhLmdvb2dsZS5wdWJzdWIudjEuUmVjZWl2ZWRNZXNzYWdlQgPgQQES", + "ZgoYYWNrbm93bGVkZ2VfY29uZmlybWF0aW9uGAUgASgLMj8uZ29vZ2xlLnB1", + "YnN1Yi52MS5TdHJlYW1pbmdQdWxsUmVzcG9uc2UuQWNrbm93bGVkZ2VDb25m", + "aXJtYXRpb25CA+BBARJ0CiBtb2RpZnlfYWNrX2RlYWRsaW5lX2NvbmZpcm1h", + "dGlvbhgDIAEoCzJFLmdvb2dsZS5wdWJzdWIudjEuU3RyZWFtaW5nUHVsbFJl", + "c3BvbnNlLk1vZGlmeUFja0RlYWRsaW5lQ29uZmlybWF0aW9uQgPgQQESZAoX", + "c3Vic2NyaXB0aW9uX3Byb3BlcnRpZXMYBCABKAsyPi5nb29nbGUucHVic3Vi", + "LnYxLlN0cmVhbWluZ1B1bGxSZXNwb25zZS5TdWJzY3JpcHRpb25Qcm9wZXJ0", + "aWVzQgPgQQEalAEKF0Fja25vd2xlZGdlQ29uZmlybWF0aW9uEhQKB2Fja19p", + "ZHMYASADKAlCA+BBARIcCg9pbnZhbGlkX2Fja19pZHMYAiADKAlCA+BBARIe", + "ChF1bm9yZGVyZWRfYWNrX2lkcxgDIAMoCUID4EEBEiUKGHRlbXBvcmFyeV9m", + "YWlsZWRfYWNrX2lkcxgEIAMoCUID4EEBGnoKHU1vZGlmeUFja0RlYWRsaW5l", + "Q29uZmlybWF0aW9uEhQKB2Fja19pZHMYASADKAlCA+BBARIcCg9pbnZhbGlk", + "X2Fja19pZHMYAiADKAlCA+BBARIlChh0ZW1wb3JhcnlfZmFpbGVkX2Fja19p", + "ZHMYAyADKAlCA+BBARprChZTdWJzY3JpcHRpb25Qcm9wZXJ0aWVzEioKHWV4", + "YWN0bHlfb25jZV9kZWxpdmVyeV9lbmFibGVkGAEgASgIQgPgQQESJQoYbWVz", + "c2FnZV9vcmRlcmluZ19lbmFibGVkGAIgASgIQgPgQQEigQMKFUNyZWF0ZVNu", + "YXBzaG90UmVxdWVzdBI0CgRuYW1lGAEgASgJQibgQQL6QSAKHnB1YnN1Yi5n", + "b29nbGVhcGlzLmNvbS9TbmFwc2hvdBJACgxzdWJzY3JpcHRpb24YAiABKAlC", + "KuBBAvpBJAoicHVic3ViLmdvb2dsZWFwaXMuY29tL1N1YnNjcmlwdGlvbhJI", + "CgZsYWJlbHMYAyADKAsyMy5nb29nbGUucHVic3ViLnYxLkNyZWF0ZVNuYXBz", + "aG90UmVxdWVzdC5MYWJlbHNFbnRyeUID4EEBEkoKBHRhZ3MYBCADKAsyMS5n", + "b29nbGUucHVic3ViLnYxLkNyZWF0ZVNuYXBzaG90UmVxdWVzdC5UYWdzRW50", + "cnlCCeBBBOBBBeBBARotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoF", + "dmFsdWUYAiABKAk6AjgBGisKCVRhZ3NFbnRyeRILCgNrZXkYASABKAkSDQoF", + "dmFsdWUYAiABKAk6AjgBIoABChVVcGRhdGVTbmFwc2hvdFJlcXVlc3QSMQoI", + "c25hcHNob3QYASABKAsyGi5nb29nbGUucHVic3ViLnYxLlNuYXBzaG90QgPg", + "QQISNAoLdXBkYXRlX21hc2sYAiABKAsyGi5nb29nbGUucHJvdG9idWYuRmll", + "bGRNYXNrQgPgQQIi1gIKCFNuYXBzaG90EhEKBG5hbWUYASABKAlCA+BBARIy", + "CgV0b3BpYxgCIAEoCUIj4EEB+kEdChtwdWJzdWIuZ29vZ2xlYXBpcy5jb20v", + "VG9waWMSNAoLZXhwaXJlX3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYu", + "VGltZXN0YW1wQgPgQQESOwoGbGFiZWxzGAQgAygLMiYuZ29vZ2xlLnB1YnN1", + "Yi52MS5TbmFwc2hvdC5MYWJlbHNFbnRyeUID4EEBGi0KC0xhYmVsc0VudHJ5", + "EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAE6YepBXgoecHVic3Vi", + "Lmdvb2dsZWFwaXMuY29tL1NuYXBzaG90Eidwcm9qZWN0cy97cHJvamVjdH0v", + "c25hcHNob3RzL3tzbmFwc2hvdH0qCXNuYXBzaG90czIIc25hcHNob3QiTgoS", + "R2V0U25hcHNob3RSZXF1ZXN0EjgKCHNuYXBzaG90GAEgASgJQibgQQL6QSAK", + "HnB1YnN1Yi5nb29nbGVhcGlzLmNvbS9TbmFwc2hvdCKNAQoUTGlzdFNuYXBz", + "aG90c1JlcXVlc3QSRAoHcHJvamVjdBgBIAEoCUIz4EEC+kEtCitjbG91ZHJl", + "c291cmNlbWFuYWdlci5nb29nbGVhcGlzLmNvbS9Qcm9qZWN0EhYKCXBhZ2Vf", + "c2l6ZRgCIAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4YAyABKAlCA+BBASJpChVM", + "aXN0U25hcHNob3RzUmVzcG9uc2USMgoJc25hcHNob3RzGAEgAygLMhouZ29v", + "Z2xlLnB1YnN1Yi52MS5TbmFwc2hvdEID4EEBEhwKD25leHRfcGFnZV90b2tl", + "bhgCIAEoCUID4EEBIlEKFURlbGV0ZVNuYXBzaG90UmVxdWVzdBI4CghzbmFw", + "c2hvdBgBIAEoCUIm4EEC+kEgCh5wdWJzdWIuZ29vZ2xlYXBpcy5jb20vU25h", + "cHNob3QixgEKC1NlZWtSZXF1ZXN0EkAKDHN1YnNjcmlwdGlvbhgBIAEoCUIq", + "4EEC+kEkCiJwdWJzdWIuZ29vZ2xlYXBpcy5jb20vU3Vic2NyaXB0aW9uEi8K", + "BHRpbWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQFI", + "ABI6CghzbmFwc2hvdBgDIAEoCUIm4EEB+kEgCh5wdWJzdWIuZ29vZ2xlYXBp", + "cy5jb20vU25hcHNob3RIAEIICgZ0YXJnZXQiDgoMU2Vla1Jlc3BvbnNlMrgL", + "CglQdWJsaXNoZXIScQoLQ3JlYXRlVG9waWMSFy5nb29nbGUucHVic3ViLnYx", + "LlRvcGljGhcuZ29vZ2xlLnB1YnN1Yi52MS5Ub3BpYyIw2kEEbmFtZYLT5JMC", + "IxoeL3YxL3tuYW1lPXByb2plY3RzLyovdG9waWNzLyp9OgEqEpEBCgtVcGRh", + "dGVUb3BpYxIkLmdvb2dsZS5wdWJzdWIudjEuVXBkYXRlVG9waWNSZXF1ZXN0", + "GhcuZ29vZ2xlLnB1YnN1Yi52MS5Ub3BpYyJD2kERdG9waWMsdXBkYXRlX21h", + "c2uC0+STAikyJC92MS97dG9waWMubmFtZT1wcm9qZWN0cy8qL3RvcGljcy8q", + "fToBKhKTAQoHUHVibGlzaBIgLmdvb2dsZS5wdWJzdWIudjEuUHVibGlzaFJl", + "cXVlc3QaIS5nb29nbGUucHVic3ViLnYxLlB1Ymxpc2hSZXNwb25zZSJD2kEO", + "dG9waWMsbWVzc2FnZXOC0+STAiwiJy92MS97dG9waWM9cHJvamVjdHMvKi90", + "b3BpY3MvKn06cHVibGlzaDoBKhJ3CghHZXRUb3BpYxIhLmdvb2dsZS5wdWJz", + "dWIudjEuR2V0VG9waWNSZXF1ZXN0GhcuZ29vZ2xlLnB1YnN1Yi52MS5Ub3Bp", + "YyIv2kEFdG9waWOC0+STAiESHy92MS97dG9waWM9cHJvamVjdHMvKi90b3Bp", + "Y3MvKn0SigEKCkxpc3RUb3BpY3MSIy5nb29nbGUucHVic3ViLnYxLkxpc3RU", + "b3BpY3NSZXF1ZXN0GiQuZ29vZ2xlLnB1YnN1Yi52MS5MaXN0VG9waWNzUmVz", + "cG9uc2UiMdpBB3Byb2plY3SC0+STAiESHy92MS97cHJvamVjdD1wcm9qZWN0", + "cy8qfS90b3BpY3MSugEKFkxpc3RUb3BpY1N1YnNjcmlwdGlvbnMSLy5nb29n", + "bGUucHVic3ViLnYxLkxpc3RUb3BpY1N1YnNjcmlwdGlvbnNSZXF1ZXN0GjAu", + "Z29vZ2xlLnB1YnN1Yi52MS5MaXN0VG9waWNTdWJzY3JpcHRpb25zUmVzcG9u", + "c2UiPdpBBXRvcGljgtPkkwIvEi0vdjEve3RvcGljPXByb2plY3RzLyovdG9w", + "aWNzLyp9L3N1YnNjcmlwdGlvbnMSqgEKEkxpc3RUb3BpY1NuYXBzaG90cxIr", + "Lmdvb2dsZS5wdWJzdWIudjEuTGlzdFRvcGljU25hcHNob3RzUmVxdWVzdBos", + "Lmdvb2dsZS5wdWJzdWIudjEuTGlzdFRvcGljU25hcHNob3RzUmVzcG9uc2Ui", + "OdpBBXRvcGljgtPkkwIrEikvdjEve3RvcGljPXByb2plY3RzLyovdG9waWNz", + "Lyp9L3NuYXBzaG90cxJ8CgtEZWxldGVUb3BpYxIkLmdvb2dsZS5wdWJzdWIu", + "djEuRGVsZXRlVG9waWNSZXF1ZXN0GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5", + "Ii/aQQV0b3BpY4LT5JMCISofL3YxL3t0b3BpYz1wcm9qZWN0cy8qL3RvcGlj", + "cy8qfRKtAQoSRGV0YWNoU3Vic2NyaXB0aW9uEisuZ29vZ2xlLnB1YnN1Yi52", + "MS5EZXRhY2hTdWJzY3JpcHRpb25SZXF1ZXN0GiwuZ29vZ2xlLnB1YnN1Yi52", + "MS5EZXRhY2hTdWJzY3JpcHRpb25SZXNwb25zZSI8gtPkkwI2IjQvdjEve3N1", + "YnNjcmlwdGlvbj1wcm9qZWN0cy8qL3N1YnNjcmlwdGlvbnMvKn06ZGV0YWNo", + "GnDKQRVwdWJzdWIuZ29vZ2xlYXBpcy5jb23SQVVodHRwczovL3d3dy5nb29n", + "bGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtLGh0dHBzOi8vd3d3Lmdv", + "b2dsZWFwaXMuY29tL2F1dGgvcHVic3ViMtIVCgpTdWJzY3JpYmVyErQBChJD", + "cmVhdGVTdWJzY3JpcHRpb24SHi5nb29nbGUucHVic3ViLnYxLlN1YnNjcmlw", + "dGlvbhoeLmdvb2dsZS5wdWJzdWIudjEuU3Vic2NyaXB0aW9uIl7aQStuYW1l", + "LHRvcGljLHB1c2hfY29uZmlnLGFja19kZWFkbGluZV9zZWNvbmRzgtPkkwIq", + "GiUvdjEve25hbWU9cHJvamVjdHMvKi9zdWJzY3JpcHRpb25zLyp9OgEqEqEB", + "Cg9HZXRTdWJzY3JpcHRpb24SKC5nb29nbGUucHVic3ViLnYxLkdldFN1YnNj", + "cmlwdGlvblJlcXVlc3QaHi5nb29nbGUucHVic3ViLnYxLlN1YnNjcmlwdGlv", + "biJE2kEMc3Vic2NyaXB0aW9ugtPkkwIvEi0vdjEve3N1YnNjcmlwdGlvbj1w", + "cm9qZWN0cy8qL3N1YnNjcmlwdGlvbnMvKn0SuwEKElVwZGF0ZVN1YnNjcmlw", + "dGlvbhIrLmdvb2dsZS5wdWJzdWIudjEuVXBkYXRlU3Vic2NyaXB0aW9uUmVx", + "dWVzdBoeLmdvb2dsZS5wdWJzdWIudjEuU3Vic2NyaXB0aW9uIljaQRhzdWJz", + "Y3JpcHRpb24sdXBkYXRlX21hc2uC0+STAjcyMi92MS97c3Vic2NyaXB0aW9u", + "Lm5hbWU9cHJvamVjdHMvKi9zdWJzY3JpcHRpb25zLyp9OgEqEqYBChFMaXN0", + "U3Vic2NyaXB0aW9ucxIqLmdvb2dsZS5wdWJzdWIudjEuTGlzdFN1YnNjcmlw", + "dGlvbnNSZXF1ZXN0GisuZ29vZ2xlLnB1YnN1Yi52MS5MaXN0U3Vic2NyaXB0", + "aW9uc1Jlc3BvbnNlIjjaQQdwcm9qZWN0gtPkkwIoEiYvdjEve3Byb2plY3Q9", + "cHJvamVjdHMvKn0vc3Vic2NyaXB0aW9ucxKfAQoSRGVsZXRlU3Vic2NyaXB0", + "aW9uEisuZ29vZ2xlLnB1YnN1Yi52MS5EZWxldGVTdWJzY3JpcHRpb25SZXF1", + "ZXN0GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5IkTaQQxzdWJzY3JpcHRpb26C", + "0+STAi8qLS92MS97c3Vic2NyaXB0aW9uPXByb2plY3RzLyovc3Vic2NyaXB0", + "aW9ucy8qfRLPAQoRTW9kaWZ5QWNrRGVhZGxpbmUSKi5nb29nbGUucHVic3Vi", + "LnYxLk1vZGlmeUFja0RlYWRsaW5lUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1", + "Zi5FbXB0eSJ22kEpc3Vic2NyaXB0aW9uLGFja19pZHMsYWNrX2RlYWRsaW5l", + "X3NlY29uZHOC0+STAkQiPy92MS97c3Vic2NyaXB0aW9uPXByb2plY3RzLyov", + "c3Vic2NyaXB0aW9ucy8qfTptb2RpZnlBY2tEZWFkbGluZToBKhKoAQoLQWNr", + "bm93bGVkZ2USJC5nb29nbGUucHVic3ViLnYxLkFja25vd2xlZGdlUmVxdWVz", + "dBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJb2kEUc3Vic2NyaXB0aW9uLGFj", + "a19pZHOC0+STAj4iOS92MS97c3Vic2NyaXB0aW9uPXByb2plY3RzLyovc3Vi", + "c2NyaXB0aW9ucy8qfTphY2tub3dsZWRnZToBKhLQAQoEUHVsbBIdLmdvb2ds", + "ZS5wdWJzdWIudjEuUHVsbFJlcXVlc3QaHi5nb29nbGUucHVic3ViLnYxLlB1", + "bGxSZXNwb25zZSKIAdpBLHN1YnNjcmlwdGlvbixyZXR1cm5faW1tZWRpYXRl", + "bHksbWF4X21lc3NhZ2Vz2kEZc3Vic2NyaXB0aW9uLG1heF9tZXNzYWdlc4LT", + "5JMCNyIyL3YxL3tzdWJzY3JpcHRpb249cHJvamVjdHMvKi9zdWJzY3JpcHRp", + "b25zLyp9OnB1bGw6ASoSZgoNU3RyZWFtaW5nUHVsbBImLmdvb2dsZS5wdWJz", + "dWIudjEuU3RyZWFtaW5nUHVsbFJlcXVlc3QaJy5nb29nbGUucHVic3ViLnYx", + "LlN0cmVhbWluZ1B1bGxSZXNwb25zZSIAKAEwARK7AQoQTW9kaWZ5UHVzaENv", + "bmZpZxIpLmdvb2dsZS5wdWJzdWIudjEuTW9kaWZ5UHVzaENvbmZpZ1JlcXVl", + "c3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiZNpBGHN1YnNjcmlwdGlvbixw", + "dXNoX2NvbmZpZ4LT5JMCQyI+L3YxL3tzdWJzY3JpcHRpb249cHJvamVjdHMv", + "Ki9zdWJzY3JpcHRpb25zLyp9Om1vZGlmeVB1c2hDb25maWc6ASoSiQEKC0dl", + "dFNuYXBzaG90EiQuZ29vZ2xlLnB1YnN1Yi52MS5HZXRTbmFwc2hvdFJlcXVl", + "c3QaGi5nb29nbGUucHVic3ViLnYxLlNuYXBzaG90IjjaQQhzbmFwc2hvdILT", + "5JMCJxIlL3YxL3tzbmFwc2hvdD1wcm9qZWN0cy8qL3NuYXBzaG90cy8qfRKW", + "AQoNTGlzdFNuYXBzaG90cxImLmdvb2dsZS5wdWJzdWIudjEuTGlzdFNuYXBz", + "aG90c1JlcXVlc3QaJy5nb29nbGUucHVic3ViLnYxLkxpc3RTbmFwc2hvdHNS", + "ZXNwb25zZSI02kEHcHJvamVjdILT5JMCJBIiL3YxL3twcm9qZWN0PXByb2pl", + "Y3RzLyp9L3NuYXBzaG90cxKXAQoOQ3JlYXRlU25hcHNob3QSJy5nb29nbGUu", + "cHVic3ViLnYxLkNyZWF0ZVNuYXBzaG90UmVxdWVzdBoaLmdvb2dsZS5wdWJz", + "dWIudjEuU25hcHNob3QiQNpBEW5hbWUsc3Vic2NyaXB0aW9ugtPkkwImGiEv", + "djEve25hbWU9cHJvamVjdHMvKi9zbmFwc2hvdHMvKn06ASoSowEKDlVwZGF0", + "ZVNuYXBzaG90EicuZ29vZ2xlLnB1YnN1Yi52MS5VcGRhdGVTbmFwc2hvdFJl", + "cXVlc3QaGi5nb29nbGUucHVic3ViLnYxLlNuYXBzaG90IkzaQRRzbmFwc2hv", + "dCx1cGRhdGVfbWFza4LT5JMCLzIqL3YxL3tzbmFwc2hvdC5uYW1lPXByb2pl", + "Y3RzLyovc25hcHNob3RzLyp9OgEqEosBCg5EZWxldGVTbmFwc2hvdBInLmdv", + "b2dsZS5wdWJzdWIudjEuRGVsZXRlU25hcHNob3RSZXF1ZXN0GhYuZ29vZ2xl", + "LnByb3RvYnVmLkVtcHR5IjjaQQhzbmFwc2hvdILT5JMCJyolL3YxL3tzbmFw", + "c2hvdD1wcm9qZWN0cy8qL3NuYXBzaG90cy8qfRKEAQoEU2VlaxIdLmdvb2ds", + "ZS5wdWJzdWIudjEuU2Vla1JlcXVlc3QaHi5nb29nbGUucHVic3ViLnYxLlNl", + "ZWtSZXNwb25zZSI9gtPkkwI3IjIvdjEve3N1YnNjcmlwdGlvbj1wcm9qZWN0", + "cy8qL3N1YnNjcmlwdGlvbnMvKn06c2VlazoBKhpwykEVcHVic3ViLmdvb2ds", + "ZWFwaXMuY29t0kFVaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9j", + "bG91ZC1wbGF0Zm9ybSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRo", + "L3B1YnN1YkKnAwoUY29tLmdvb2dsZS5wdWJzdWIudjFCC1B1YnN1YlByb3Rv", + "UAFaNWNsb3VkLmdvb2dsZS5jb20vZ28vcHVic3ViL3YyL2FwaXYxL3B1YnN1", + "YnBiO3B1YnN1YnBiqgIWR29vZ2xlLkNsb3VkLlB1YlN1Yi5WMcoCFkdvb2ds", + "ZVxDbG91ZFxQdWJTdWJcVjHqAhlHb29nbGU6OkNsb3VkOjpQdWJTdWI6OlYx", + "6kF4CiFjbG91ZGttcy5nb29nbGVhcGlzLmNvbS9DcnlwdG9LZXkSU3Byb2pl", + "Y3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xvY2F0aW9ufS9rZXlSaW5ncy97", + "a2V5X3Jpbmd9L2NyeXB0b0tleXMve2NyeXB0b19rZXl96kF/CiNhbmFseXRp", + "Y3NodWIuZ29vZ2xlYXBpcy5jb20vTGlzdGluZxJYcHJvamVjdHMve3Byb2pl", + "Y3R9L2xvY2F0aW9ucy97bG9jYXRpb259L2RhdGFFeGNoYW5nZXMve2RhdGFf", + "ZXhjaGFuZ2V9L2xpc3RpbmdzL3tsaXN0aW5nfWIGcHJvdG8z")); 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.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Cloud.PubSub.V1.SchemaReflection.Descriptor, }, + 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.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Cloud.PubSub.V1.SchemaReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.MessageStoragePolicy), global::Google.Cloud.PubSub.V1.MessageStoragePolicy.Parser, new[]{ "AllowedPersistenceRegions", "EnforceInTransit" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.SchemaSettings), global::Google.Cloud.PubSub.V1.SchemaSettings.Parser, new[]{ "Schema", "Encoding", "FirstRevisionId", "LastRevisionId" }, null, null, null, null), @@ -537,7 +545,8 @@ static PubsubReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.IngestionFailureEvent.Types.ConfluentCloudFailureReason), global::Google.Cloud.PubSub.V1.IngestionFailureEvent.Types.ConfluentCloudFailureReason.Parser, new[]{ "ClusterId", "KafkaTopic", "PartitionId", "Offset", "ApiViolationReason", "SchemaViolationReason", "MessageTransformationFailureReason" }, new[]{ "Reason" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.IngestionFailureEvent.Types.AwsKinesisFailureReason), global::Google.Cloud.PubSub.V1.IngestionFailureEvent.Types.AwsKinesisFailureReason.Parser, new[]{ "StreamArn", "PartitionKey", "SequenceNumber", "SchemaViolationReason", "MessageTransformationFailureReason", "ApiViolationReason" }, new[]{ "Reason" }, null, null, null)}), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.JavaScriptUDF), global::Google.Cloud.PubSub.V1.JavaScriptUDF.Parser, new[]{ "FunctionName", "Code" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.MessageTransform), global::Google.Cloud.PubSub.V1.MessageTransform.Parser, new[]{ "JavascriptUdf", "Enabled", "Disabled" }, new[]{ "Transform" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.AIInference), global::Google.Cloud.PubSub.V1.AIInference.Parser, new[]{ "Endpoint", "UnstructuredInference", "ServiceAccountEmail" }, new[]{ "InferenceMode" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference), global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference.Parser, new[]{ "Parameters" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.MessageTransform), global::Google.Cloud.PubSub.V1.MessageTransform.Parser, new[]{ "JavascriptUdf", "AiInference", "Enabled", "Disabled" }, new[]{ "Transform" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.Topic), global::Google.Cloud.PubSub.V1.Topic.Parser, new[]{ "Name", "Labels", "MessageStoragePolicy", "KmsKeyName", "SchemaSettings", "SatisfiesPzs", "MessageRetentionDuration", "State", "IngestionDataSourceSettings", "MessageTransforms", "Tags" }, null, new[]{ typeof(global::Google.Cloud.PubSub.V1.Topic.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { null, null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.PubsubMessage), global::Google.Cloud.PubSub.V1.PubsubMessage.Parser, new[]{ "Data", "Attributes", "MessageId", "PublishTime", "OrderingKey" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.PubSub.V1.GetTopicRequest), global::Google.Cloud.PubSub.V1.GetTopicRequest.Parser, new[]{ "Topic" }, null, null, null, null), @@ -8797,6 +8806,548 @@ public void MergeFrom(pb::CodedInputStream input) { } + /// + /// Configuration for making inference requests against Vertex AI models. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AIInference : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AIInference()); + 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.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[6]; } + } + + [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 AIInference() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AIInference(AIInference other) : this() { + endpoint_ = other.endpoint_; + serviceAccountEmail_ = other.serviceAccountEmail_; + switch (other.InferenceModeCase) { + case InferenceModeOneofCase.UnstructuredInference: + UnstructuredInference = other.UnstructuredInference.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AIInference Clone() { + return new AIInference(this); + } + + /// Field number for the "endpoint" field. + public const int EndpointFieldNumber = 1; + private string endpoint_ = ""; + /// + /// Required. An endpoint to a Vertex AI model of the form + /// `projects/{project}/locations/{location}/endpoints/{endpoint}` or + /// `projects/{project}/locations/{location}/publishers/{publisher}/models/{model}`. + /// Vertex AI API requests will be sent to this endpoint. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Endpoint { + get { return endpoint_; } + set { + endpoint_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "unstructured_inference" field. + public const int UnstructuredInferenceFieldNumber = 2; + /// + /// Optional. Requests and responses can be any arbitrary JSON object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference UnstructuredInference { + get { return inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference ? (global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference) inferenceMode_ : null; } + set { + inferenceMode_ = value; + inferenceModeCase_ = value == null ? InferenceModeOneofCase.None : InferenceModeOneofCase.UnstructuredInference; + } + } + + /// Field number for the "service_account_email" field. + public const int ServiceAccountEmailFieldNumber = 3; + private string serviceAccountEmail_ = ""; + /// + /// Optional. The service account to use to make prediction requests against + /// endpoints. The resource creator or updater that specifies this field must + /// have `iam.serviceAccounts.actAs` permission on the service account. If not + /// specified, the Pub/Sub [service + /// agent]({$universe.dns_names.final_documentation_domain}/iam/docs/service-agents), + /// service-{project_number}@gcp-sa-pubsub.iam.gserviceaccount.com, is used. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ServiceAccountEmail { + get { return serviceAccountEmail_; } + set { + serviceAccountEmail_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + private object inferenceMode_; + /// Enum of possible cases for the "inference_mode" oneof. + public enum InferenceModeOneofCase { + None = 0, + UnstructuredInference = 2, + } + private InferenceModeOneofCase inferenceModeCase_ = InferenceModeOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public InferenceModeOneofCase InferenceModeCase { + get { return inferenceModeCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearInferenceMode() { + inferenceModeCase_ = InferenceModeOneofCase.None; + inferenceMode_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AIInference); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AIInference other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Endpoint != other.Endpoint) return false; + if (!object.Equals(UnstructuredInference, other.UnstructuredInference)) return false; + if (ServiceAccountEmail != other.ServiceAccountEmail) return false; + if (InferenceModeCase != other.InferenceModeCase) 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 (Endpoint.Length != 0) hash ^= Endpoint.GetHashCode(); + if (inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference) hash ^= UnstructuredInference.GetHashCode(); + if (ServiceAccountEmail.Length != 0) hash ^= ServiceAccountEmail.GetHashCode(); + hash ^= (int) inferenceModeCase_; + 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 (Endpoint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Endpoint); + } + if (inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference) { + output.WriteRawTag(18); + output.WriteMessage(UnstructuredInference); + } + if (ServiceAccountEmail.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ServiceAccountEmail); + } + 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 (Endpoint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Endpoint); + } + if (inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference) { + output.WriteRawTag(18); + output.WriteMessage(UnstructuredInference); + } + if (ServiceAccountEmail.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ServiceAccountEmail); + } + 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 (Endpoint.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Endpoint); + } + if (inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnstructuredInference); + } + if (ServiceAccountEmail.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceAccountEmail); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AIInference other) { + if (other == null) { + return; + } + if (other.Endpoint.Length != 0) { + Endpoint = other.Endpoint; + } + if (other.ServiceAccountEmail.Length != 0) { + ServiceAccountEmail = other.ServiceAccountEmail; + } + switch (other.InferenceModeCase) { + case InferenceModeOneofCase.UnstructuredInference: + if (UnstructuredInference == null) { + UnstructuredInference = new global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference(); + } + UnstructuredInference.MergeFrom(other.UnstructuredInference); + break; + } + + _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: { + Endpoint = input.ReadString(); + break; + } + case 18: { + global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference subBuilder = new global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference(); + if (inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference) { + subBuilder.MergeFrom(UnstructuredInference); + } + input.ReadMessage(subBuilder); + UnstructuredInference = subBuilder; + break; + } + case 26: { + ServiceAccountEmail = 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: { + Endpoint = input.ReadString(); + break; + } + case 18: { + global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference subBuilder = new global::Google.Cloud.PubSub.V1.AIInference.Types.UnstructuredInference(); + if (inferenceModeCase_ == InferenceModeOneofCase.UnstructuredInference) { + subBuilder.MergeFrom(UnstructuredInference); + } + input.ReadMessage(subBuilder); + UnstructuredInference = subBuilder; + break; + } + case 26: { + ServiceAccountEmail = input.ReadString(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the AIInference message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// Configuration for making inferences using arbitrary JSON payloads. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class UnstructuredInference : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UnstructuredInference()); + 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.PubSub.V1.AIInference.Descriptor.NestedTypes[0]; } + } + + [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 UnstructuredInference() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnstructuredInference(UnstructuredInference other) : this() { + parameters_ = other.parameters_ != null ? other.parameters_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnstructuredInference Clone() { + return new UnstructuredInference(this); + } + + /// Field number for the "parameters" field. + public const int ParametersFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.Struct parameters_; + /// + /// Optional. A parameters object to be included in each inference request. + /// The parameters object is combined with the data field of the Pub/Sub + /// message to form the inference request. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Struct Parameters { + get { return parameters_; } + set { + parameters_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as UnstructuredInference); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(UnstructuredInference other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Parameters, other.Parameters)) 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 (parameters_ != null) hash ^= Parameters.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 (parameters_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Parameters); + } + 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 (parameters_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Parameters); + } + 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 (parameters_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Parameters); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(UnstructuredInference other) { + if (other == null) { + return; + } + if (other.parameters_ != null) { + if (parameters_ == null) { + Parameters = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + Parameters.MergeFrom(other.Parameters); + } + _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: { + if (parameters_ == null) { + Parameters = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Parameters); + 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: { + if (parameters_ == null) { + Parameters = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Parameters); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + /// /// All supported message transforms types. /// @@ -8815,7 +9366,7 @@ public sealed partial class MessageTransform : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[6]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[7]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8841,6 +9392,9 @@ public MessageTransform(MessageTransform other) : this() { case TransformOneofCase.JavascriptUdf: JavascriptUdf = other.JavascriptUdf.Clone(); break; + case TransformOneofCase.AiInference: + AiInference = other.AiInference.Clone(); + break; } _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); @@ -8868,6 +9422,23 @@ public MessageTransform Clone() { } } + /// Field number for the "ai_inference" field. + public const int AiInferenceFieldNumber = 6; + /// + /// Optional. AI Inference. Specifies the Vertex AI endpoint that inference + /// requests built from the Pub/Sub message data and provided parameters will + /// be sent to. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.PubSub.V1.AIInference AiInference { + get { return transformCase_ == TransformOneofCase.AiInference ? (global::Google.Cloud.PubSub.V1.AIInference) transform_ : null; } + set { + transform_ = value; + transformCase_ = value == null ? TransformOneofCase.None : TransformOneofCase.AiInference; + } + } + /// Field number for the "enabled" field. public const int EnabledFieldNumber = 3; private bool enabled_; @@ -8906,6 +9477,7 @@ public bool Disabled { public enum TransformOneofCase { None = 0, JavascriptUdf = 2, + AiInference = 6, } private TransformOneofCase transformCase_ = TransformOneofCase.None; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8937,6 +9509,7 @@ public bool Equals(MessageTransform other) { return true; } if (!object.Equals(JavascriptUdf, other.JavascriptUdf)) return false; + if (!object.Equals(AiInference, other.AiInference)) return false; if (Enabled != other.Enabled) return false; if (Disabled != other.Disabled) return false; if (TransformCase != other.TransformCase) return false; @@ -8948,6 +9521,7 @@ public bool Equals(MessageTransform other) { public override int GetHashCode() { int hash = 1; if (transformCase_ == TransformOneofCase.JavascriptUdf) hash ^= JavascriptUdf.GetHashCode(); + if (transformCase_ == TransformOneofCase.AiInference) hash ^= AiInference.GetHashCode(); if (Enabled != false) hash ^= Enabled.GetHashCode(); if (Disabled != false) hash ^= Disabled.GetHashCode(); hash ^= (int) transformCase_; @@ -8981,6 +9555,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(32); output.WriteBool(Disabled); } + if (transformCase_ == TransformOneofCase.AiInference) { + output.WriteRawTag(50); + output.WriteMessage(AiInference); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -9003,6 +9581,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(32); output.WriteBool(Disabled); } + if (transformCase_ == TransformOneofCase.AiInference) { + output.WriteRawTag(50); + output.WriteMessage(AiInference); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -9016,6 +9598,9 @@ public int CalculateSize() { if (transformCase_ == TransformOneofCase.JavascriptUdf) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(JavascriptUdf); } + if (transformCase_ == TransformOneofCase.AiInference) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(AiInference); + } if (Enabled != false) { size += 1 + 1; } @@ -9047,6 +9632,12 @@ public void MergeFrom(MessageTransform other) { } JavascriptUdf.MergeFrom(other.JavascriptUdf); break; + case TransformOneofCase.AiInference: + if (AiInference == null) { + AiInference = new global::Google.Cloud.PubSub.V1.AIInference(); + } + AiInference.MergeFrom(other.AiInference); + break; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); @@ -9081,6 +9672,15 @@ public void MergeFrom(pb::CodedInputStream input) { Disabled = input.ReadBool(); break; } + case 50: { + global::Google.Cloud.PubSub.V1.AIInference subBuilder = new global::Google.Cloud.PubSub.V1.AIInference(); + if (transformCase_ == TransformOneofCase.AiInference) { + subBuilder.MergeFrom(AiInference); + } + input.ReadMessage(subBuilder); + AiInference = subBuilder; + break; + } } } #endif @@ -9113,6 +9713,15 @@ public void MergeFrom(pb::CodedInputStream input) { Disabled = input.ReadBool(); break; } + case 50: { + global::Google.Cloud.PubSub.V1.AIInference subBuilder = new global::Google.Cloud.PubSub.V1.AIInference(); + if (transformCase_ == TransformOneofCase.AiInference) { + subBuilder.MergeFrom(AiInference); + } + input.ReadMessage(subBuilder); + AiInference = subBuilder; + break; + } } } } @@ -9138,7 +9747,7 @@ public sealed partial class Topic : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[7]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[8]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9798,7 +10407,7 @@ public sealed partial class PubsubMessage : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[8]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[9]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10167,7 +10776,7 @@ public sealed partial class GetTopicRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[9]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[10]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10201,7 +10810,7 @@ public GetTopicRequest Clone() { public const int TopicFieldNumber = 1; private string topic_ = ""; /// - /// Required. Identifier. The name of the topic to get. + /// Required. The name of the topic to get. /// Format is `projects/{project}/topics/{topic}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10364,7 +10973,7 @@ public sealed partial class UpdateTopicRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[11]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[12]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10657,8 +11266,8 @@ public PublishRequest Clone() { public const int TopicFieldNumber = 1; private string topic_ = ""; /// - /// Required. Identifier. The messages in the request will be published on this - /// topic. Format is `projects/{project}/topics/{topic}`. + /// Required. The messages in the request will be published on this topic. + /// Format is `projects/{project}/topics/{topic}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -10848,7 +11457,7 @@ public sealed partial class PublishResponse : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[12]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[13]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11035,7 +11644,7 @@ public sealed partial class ListTopicsRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[13]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[14]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11071,7 +11680,7 @@ public ListTopicsRequest Clone() { public const int ProjectFieldNumber = 1; private string project_ = ""; /// - /// Required. Identifier. The name of the project in which to list topics. + /// Required. The name of the project in which to list topics. /// Format is `projects/{project-id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11314,7 +11923,7 @@ public sealed partial class ListTopicsResponse : pb::IMessage - /// Required. Identifier. Name of the topic to delete. + /// Required. Name of the topic to delete. /// Format is `projects/{project}/topics/{topic}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -12750,7 +13359,7 @@ public sealed partial class DetachSubscriptionRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[22]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[23]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -13516,7 +14125,7 @@ public bool EnableExactlyOnceDelivery { private global::Google.Cloud.PubSub.V1.Subscription.Types.AnalyticsHubSubscriptionInfo analyticsHubSubscriptionInfo_; /// /// Output only. Information about the associated Analytics Hub subscription. - /// Only set if the subscritpion is created by Analytics Hub. + /// Only set if the subscription is created by Analytics Hub. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -14522,7 +15131,7 @@ public sealed partial class RetryPolicy : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[23]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[24]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -14783,7 +15392,7 @@ public sealed partial class DeadLetterPolicy : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[24]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[25]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -15040,7 +15649,7 @@ public sealed partial class ExpirationPolicy : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[25]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[26]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -15250,7 +15859,7 @@ public sealed partial class PushConfig : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[26]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[27]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -16334,7 +16943,7 @@ public sealed partial class BigQueryConfig : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[27]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[28]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -16808,6 +17417,12 @@ public enum State { /// and the destination locations are not in the allowed regions. /// [pbr::OriginalName("IN_TRANSIT_LOCATION_RESTRICTION")] InTransitLocationRestriction = 5, + /// + /// Cannot write to the BigQuery table because the table is not in the same + /// location as where Vertex AI models used in `message_transform`s are + /// deployed. + /// + [pbr::OriginalName("VERTEX_AI_LOCATION_RESTRICTION")] VertexAiLocationRestriction = 6, } } @@ -16833,7 +17448,7 @@ public sealed partial class CloudStorageConfig : pb::IMessage [pbr::OriginalName("SCHEMA_MISMATCH")] SchemaMismatch = 5, + /// + /// Cannot write to the Cloud Storage bucket because the bucket is not in the + /// same location as where Vertex AI models used in `message_transform`s are + /// deployed. + /// + [pbr::OriginalName("VERTEX_AI_LOCATION_RESTRICTION")] VertexAiLocationRestriction = 6, } /// @@ -17960,7 +18581,7 @@ public sealed partial class ReceivedMessage : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[29]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[30]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -18260,7 +18881,7 @@ public sealed partial class GetSubscriptionRequest : pb::IMessage - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -18457,7 +19078,7 @@ public sealed partial class UpdateSubscriptionRequest : pb::IMessage - /// Required. Identifier. The name of the project in which to list - /// subscriptions. Format is `projects/{project-id}`. + /// Required. The name of the project in which to list subscriptions. + /// Format is `projects/{project-id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -18991,7 +19612,7 @@ public sealed partial class ListSubscriptionsResponse : pb::IMessage - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -19415,7 +20036,7 @@ public sealed partial class ModifyPushConfigRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[36]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[37]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -19952,7 +20573,7 @@ public sealed partial class PullResponse : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[37]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[38]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -20141,7 +20762,7 @@ public sealed partial class ModifyAckDeadlineRequest : pb::IMessage - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -22591,7 +23212,7 @@ public sealed partial class UpdateSnapshotRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[44]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[45]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -23175,7 +23796,7 @@ public sealed partial class GetSnapshotRequest : pb::IMessage - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -23372,7 +23993,7 @@ public sealed partial class ListSnapshotsRequest : pb::IMessage - /// Required. Identifier. The name of the project in which to list snapshots. + /// Required. The name of the project in which to list snapshots. /// Format is `projects/{project-id}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -23651,7 +24272,7 @@ public sealed partial class ListSnapshotsResponse : pb::IMessage - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -24075,7 +24696,7 @@ public sealed partial class SeekRequest : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[49]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[50]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -24423,7 +25044,7 @@ public sealed partial class SeekResponse : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[50]; } + get { return global::Google.Cloud.PubSub.V1.PubsubReflection.Descriptor.MessageTypes[51]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] diff --git a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PubsubGrpc.g.cs b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PubsubGrpc.g.cs index 2d8d653831a2..55ae53ac80d0 100644 --- a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PubsubGrpc.g.cs +++ b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/PubsubGrpc.g.cs @@ -3,7 +3,7 @@ // source: google/pubsub/v1/pubsub.proto // // Original file comments: -// Copyright 2025 Google LLC +// Copyright 2026 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SchemaGrpc.g.cs b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SchemaGrpc.g.cs index 10999e1c1cd4..944086bc33c8 100644 --- a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SchemaGrpc.g.cs +++ b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SchemaGrpc.g.cs @@ -3,7 +3,7 @@ // source: google/pubsub/v1/schema.proto // // Original file comments: -// Copyright 2025 Google LLC +// Copyright 2026 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SubscriberServiceApiClient.g.cs b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SubscriberServiceApiClient.g.cs index 27c7147a5480..832a3217b637 100644 --- a/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SubscriberServiceApiClient.g.cs +++ b/apis/Google.Cloud.PubSub.V1/Google.Cloud.PubSub.V1/SubscriberServiceApiClient.g.cs @@ -994,7 +994,7 @@ public virtual Subscription GetSubscription(GetSubscriptionRequest request, gaxg /// Gets the configuration details of a subscription. /// /// - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1009,7 +1009,7 @@ public virtual Subscription GetSubscription(string subscription, gaxgrpc::CallSe /// Gets the configuration details of a subscription. /// /// - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1024,7 +1024,7 @@ public virtual Subscription GetSubscription(string subscription, gaxgrpc::CallSe /// Gets the configuration details of a subscription. /// /// - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// A to use for this RPC. @@ -1036,7 +1036,7 @@ public virtual Subscription GetSubscription(string subscription, gaxgrpc::CallSe /// Gets the configuration details of a subscription. /// /// - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1051,7 +1051,7 @@ public virtual Subscription GetSubscription(SubscriptionName subscription, gaxgr /// Gets the configuration details of a subscription. /// /// - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1066,7 +1066,7 @@ public virtual Subscription GetSubscription(SubscriptionName subscription, gaxgr /// Gets the configuration details of a subscription. /// /// - /// Required. Identifier. The name of the subscription to get. + /// Required. The name of the subscription to get. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// A to use for this RPC. @@ -1188,8 +1188,8 @@ public virtual Subscription UpdateSubscription(Subscription subscription, wkt::F /// Lists matching subscriptions. /// /// - /// Required. Identifier. The name of the project in which to list - /// subscriptions. Format is `projects/{project-id}`. + /// Required. The name of the project in which to list subscriptions. + /// Format is `projects/{project-id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1222,8 +1222,8 @@ public virtual Subscription UpdateSubscription(Subscription subscription, wkt::F /// Lists matching subscriptions. /// /// - /// Required. Identifier. The name of the project in which to list - /// subscriptions. Format is `projects/{project-id}`. + /// Required. The name of the project in which to list subscriptions. + /// Format is `projects/{project-id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1256,8 +1256,8 @@ public virtual Subscription UpdateSubscription(Subscription subscription, wkt::F /// Lists matching subscriptions. /// /// - /// Required. Identifier. The name of the project in which to list - /// subscriptions. Format is `projects/{project-id}`. + /// Required. The name of the project in which to list subscriptions. + /// Format is `projects/{project-id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1290,8 +1290,8 @@ public virtual Subscription UpdateSubscription(Subscription subscription, wkt::F /// Lists matching subscriptions. /// /// - /// Required. Identifier. The name of the project in which to list - /// subscriptions. Format is `projects/{project-id}`. + /// Required. The name of the project in which to list subscriptions. + /// Format is `projects/{project-id}`. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1367,7 +1367,7 @@ public virtual void DeleteSubscription(DeleteSubscriptionRequest request, gaxgrp /// subscription or its topic unless the same topic is specified. /// /// - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1386,7 +1386,7 @@ public virtual void DeleteSubscription(string subscription, gaxgrpc::CallSetting /// subscription or its topic unless the same topic is specified. /// /// - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1405,7 +1405,7 @@ public virtual void DeleteSubscription(string subscription, gaxgrpc::CallSetting /// subscription or its topic unless the same topic is specified. /// /// - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// A to use for this RPC. @@ -1421,7 +1421,7 @@ public virtual void DeleteSubscription(string subscription, gaxgrpc::CallSetting /// subscription or its topic unless the same topic is specified. /// /// - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1440,7 +1440,7 @@ public virtual void DeleteSubscription(SubscriptionName subscription, gaxgrpc::C /// subscription or its topic unless the same topic is specified. /// /// - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// If not null, applies overrides to this RPC call. @@ -1459,7 +1459,7 @@ public virtual void DeleteSubscription(SubscriptionName subscription, gaxgrpc::C /// subscription or its topic unless the same topic is specified. /// /// - /// Required. Identifier. The subscription to delete. + /// Required. The subscription to delete. /// Format is `projects/{project}/subscriptions/{sub}`. /// /// A to use for this RPC. @@ -2534,7 +2534,7 @@ public virtual Snapshot GetSnapshot(GetSnapshotRequest request, gaxgrpc::CallSet /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -2553,7 +2553,7 @@ public virtual Snapshot GetSnapshot(string snapshot, gaxgrpc::CallSettings callS /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -2572,7 +2572,7 @@ public virtual Snapshot GetSnapshot(string snapshot, gaxgrpc::CallSettings callS /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// /// A to use for this RPC. @@ -2588,7 +2588,7 @@ public virtual Snapshot GetSnapshot(string snapshot, gaxgrpc::CallSettings callS /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -2607,7 +2607,7 @@ public virtual Snapshot GetSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -2626,7 +2626,7 @@ public virtual Snapshot GetSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the snapshot to get. + /// Required. The name of the snapshot to get. /// Format is `projects/{project}/snapshots/{snap}`. /// /// A to use for this RPC. @@ -2668,7 +2668,7 @@ public virtual Snapshot GetSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the project in which to list snapshots. + /// Required. The name of the project in which to list snapshots. /// Format is `projects/{project-id}`. /// /// @@ -2706,7 +2706,7 @@ public virtual Snapshot GetSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the project in which to list snapshots. + /// Required. The name of the project in which to list snapshots. /// Format is `projects/{project-id}`. /// /// @@ -2744,7 +2744,7 @@ public virtual Snapshot GetSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the project in which to list snapshots. + /// Required. The name of the project in which to list snapshots. /// Format is `projects/{project-id}`. /// /// @@ -2782,7 +2782,7 @@ public virtual Snapshot GetSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// state captured by a snapshot. /// /// - /// Required. Identifier. The name of the project in which to list snapshots. + /// Required. The name of the project in which to list snapshots. /// Format is `projects/{project-id}`. /// /// @@ -2903,10 +2903,10 @@ public virtual Snapshot CreateSnapshot(CreateSnapshotRequest request, gaxgrpc::C /// REST API requests, you must specify a name in the request. /// /// - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -2949,10 +2949,10 @@ public virtual Snapshot CreateSnapshot(string name, string subscription, gaxgrpc /// REST API requests, you must specify a name in the request. /// /// - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -2995,10 +2995,10 @@ public virtual Snapshot CreateSnapshot(string name, string subscription, gaxgrpc /// REST API requests, you must specify a name in the request. /// /// - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -3037,10 +3037,10 @@ public virtual Snapshot CreateSnapshot(string name, string subscription, gaxgrpc /// REST API requests, you must specify a name in the request. /// /// - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -3083,10 +3083,10 @@ public virtual Snapshot CreateSnapshot(SnapshotName name, SubscriptionName subsc /// REST API requests, you must specify a name in the request. /// /// - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -3129,10 +3129,10 @@ public virtual Snapshot CreateSnapshot(SnapshotName name, SubscriptionName subsc /// REST API requests, you must specify a name in the request. /// /// - /// Required. Identifier. User-provided name for this snapshot. If the name is - /// not provided in the request, the server will assign a random name for this - /// snapshot on the same project as the subscription. Note that for REST API - /// requests, you must specify a name. See the [resource name + /// Required. User-provided name for this snapshot. If the name is not provided + /// in the request, the server will assign a random name for this snapshot on + /// the same project as the subscription. Note that for REST API requests, you + /// must specify a name. See the [resource name /// rules](https://cloud.google.com/pubsub/docs/pubsub-basics#resource_names). /// Format is `projects/{project}/snapshots/{snap}`. /// @@ -3325,7 +3325,7 @@ public virtual void DeleteSnapshot(DeleteSnapshotRequest request, gaxgrpc::CallS /// snapshot or its subscription, unless the same subscription is specified. /// /// - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -3348,7 +3348,7 @@ public virtual void DeleteSnapshot(string snapshot, gaxgrpc::CallSettings callSe /// snapshot or its subscription, unless the same subscription is specified. /// /// - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -3371,7 +3371,7 @@ public virtual void DeleteSnapshot(string snapshot, gaxgrpc::CallSettings callSe /// snapshot or its subscription, unless the same subscription is specified. /// /// - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// /// A to use for this RPC. @@ -3391,7 +3391,7 @@ public virtual void DeleteSnapshot(string snapshot, gaxgrpc::CallSettings callSe /// snapshot or its subscription, unless the same subscription is specified. /// /// - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -3414,7 +3414,7 @@ public virtual void DeleteSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// snapshot or its subscription, unless the same subscription is specified. /// /// - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// /// If not null, applies overrides to this RPC call. @@ -3437,7 +3437,7 @@ public virtual void DeleteSnapshot(SnapshotName snapshot, gaxgrpc::CallSettings /// snapshot or its subscription, unless the same subscription is specified. /// /// - /// Required. Identifier. The name of the snapshot to delete. + /// Required. The name of the snapshot to delete. /// Format is `projects/{project}/snapshots/{snap}`. /// /// A to use for this RPC. diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json index 124e0c66854b..c3bdd43ed1c5 100644 --- a/generator-input/pipeline-state.json +++ b/generator-input/pipeline-state.json @@ -517,7 +517,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2025-12-03T08:45:49.075870430Z", - "lastGeneratedCommit": "6a7d453e1bd3f1ed759e6ab4546fe96a45b6bd1c", + "lastGeneratedCommit": "524b2de63ab28fd96abd5a1b077f00a5503d79c4", "lastReleasedCommit": "6a7d453e1bd3f1ed759e6ab4546fe96a45b6bd1c", "apiPaths": [ "google/cloud/backupdr/v1" @@ -1912,7 +1912,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2025-11-03T19:12:54.069645433Z", - "lastGeneratedCommit": "9070e63a1f574261c153ef6e94afc55677200337", + "lastGeneratedCommit": "f814267357dca7681f8cee18d3ea204c9a0aec3a", "lastReleasedCommit": "9070e63a1f574261c153ef6e94afc55677200337", "apiPaths": [ "google/cloud/kms/v1" @@ -2662,7 +2662,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2025-11-06T09:00:00.441238316Z", - "lastGeneratedCommit": "ff251e77243a7acef77f602616f3bf6ec0d3c48f", + "lastGeneratedCommit": "9fb55c416c90ff9e14f7101d68394eb9fca5918b", "lastReleasedCommit": "d0ccd99fb95c25c20355550dafb850e45da99b19", "apiPaths": [ "google/pubsub/v1" @@ -4066,7 +4066,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-01-08T08:34:14.291376827Z", - "lastGeneratedCommit": "211d22fa6dfabfa52cbda04d1aee852a01301edf", + "lastGeneratedCommit": "136a2c43b38a67cfe07317031764dd1ca1043fc6", "lastReleasedCommit": "211d22fa6dfabfa52cbda04d1aee852a01301edf", "apiPaths": [ "google/spanner/admin/database/v1",