From b6af3dee40c85d5412548aea17a61a286f05f6a5 Mon Sep 17 00:00:00 2001 From: Google Cloud SDK Librarian Date: Tue, 21 Apr 2026 07:08:28 +0000 Subject: [PATCH 1/3] regen: Regenerate Google.Cloud.AIPlatform.V1Beta1 at API commit a78b583 feat: Add asyncQueryReasoningEngine to aiplatform v1beta1 API PiperOrigin-RevId: 902815104 Source-Link: https://github.com/googleapis/googleapis/commit/a78b5838b801428bfe5b85758727a46d830b7f39 --- ...soningEngineRequestObjectAsyncSnippet.g.cs | 66 ++ ...ryReasoningEngineRequestObjectSnippet.g.cs | 65 ++ ...adata_google.cloud.aiplatform.v1beta1.json | 97 +++ ...gEngineExecutionServiceClientSnippets.g.cs | 70 ++ .../ReasoningEngineExecutionService.g.cs | 793 +++++++++++++++++- ...ReasoningEngineExecutionServiceClient.g.cs | 140 ++++ .../ReasoningEngineExecutionServiceGrpc.g.cs | 78 +- ...ngEngineExecutionServiceResourceNames.g.cs | 12 + .../gapic_metadata.json | 6 + generator-input/pipeline-state.json | 2 +- 10 files changed, 1293 insertions(+), 36 deletions(-) create mode 100644 apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs create mode 100644 apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs new file mode 100644 index 000000000000..28fb87a503de --- /dev/null +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs @@ -0,0 +1,66 @@ +// 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 aiplatform_v1beta1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async] + using Google.Cloud.AIPlatform.V1Beta1; + using Google.LongRunning; + using System.Threading.Tasks; + + public sealed partial class GeneratedReasoningEngineExecutionServiceClientSnippets + { + /// Snippet for AsyncQueryReasoningEngineAsync + /// + /// 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 AsyncQueryReasoningEngineRequestObjectAsync() + { + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = await ReasoningEngineExecutionServiceClient.CreateAsync(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = await reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngineAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + } + } + // [END aiplatform_v1beta1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async] +} diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs new file mode 100644 index 000000000000..7ea320df58b6 --- /dev/null +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs @@ -0,0 +1,65 @@ +// 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 aiplatform_v1beta1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync] + using Google.Cloud.AIPlatform.V1Beta1; + using Google.LongRunning; + + public sealed partial class GeneratedReasoningEngineExecutionServiceClientSnippets + { + /// Snippet for AsyncQueryReasoningEngine + /// + /// 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 AsyncQueryReasoningEngineRequestObject() + { + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = ReasoningEngineExecutionServiceClient.Create(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngine(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + } + } + // [END aiplatform_v1beta1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync] +} diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1beta1.json b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1beta1.json index 35ea78c36a70..9cf23fcbff9c 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1beta1.json +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1beta1.json @@ -85745,6 +85745,103 @@ } ] }, + { + "regionTag": "aiplatform_v1beta1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync", + "title": "AsyncQueryReasoningEngineRequestObject", + "description": "Snippet for AsyncQueryReasoningEngine", + "file": "ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "AsyncQueryReasoningEngine", + "fullName": "Google.Cloud.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine", + "parameters": [ + { + "type": "Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.LongRunning.Operation", + "client": { + "shortName": "ReasoningEngineExecutionServiceClient", + "fullName": "Google.Cloud.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceClient" + }, + "method": { + "shortName": "AsyncQueryReasoningEngine", + "fullName": "google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine", + "service": { + "shortName": "ReasoningEngineExecutionService", + "fullName": "google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 63, + "type": "FULL" + }, + { + "start": 35, + "end": 61, + "type": "SHORT" + } + ] + }, + { + "regionTag": "aiplatform_v1beta1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async", + "title": "AsyncQueryReasoningEngineRequestObjectAsync", + "description": "Snippet for AsyncQueryReasoningEngineAsync", + "file": "ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "AsyncQueryReasoningEngineAsync", + "fullName": "Google.Cloud.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync", + "async": true, + "parameters": [ + { + "type": "Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "System.Threading.Tasks.Task>", + "client": { + "shortName": "ReasoningEngineExecutionServiceClient", + "fullName": "Google.Cloud.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceClient" + }, + "method": { + "shortName": "AsyncQueryReasoningEngine", + "fullName": "google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine", + "service": { + "shortName": "ReasoningEngineExecutionService", + "fullName": "google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 64, + "type": "FULL" + }, + { + "start": 36, + "end": 62, + "type": "SHORT" + } + ] + }, { "regionTag": "aiplatform_v1beta1_generated_ReasoningEngineService_CreateReasoningEngine_sync", "title": "CreateReasoningEngineRequestObject", diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs index 683ad97f437e..b0524567deee 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs @@ -19,6 +19,7 @@ namespace GoogleCSharpSnippets using Google.Api; using Google.Api.Gax.Grpc; using Google.Cloud.AIPlatform.V1Beta1; + using Google.LongRunning; using Google.Protobuf.WellKnownTypes; using System.Threading.Tasks; @@ -89,5 +90,74 @@ public async Task StreamQueryReasoningEngineRequestObject() // The response stream has completed // End snippet } + + /// Snippet for AsyncQueryReasoningEngine + public void AsyncQueryReasoningEngineRequestObject() + { + // Snippet: AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest, CallSettings) + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = ReasoningEngineExecutionServiceClient.Create(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = response.PollUntilCompleted(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngine(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + // End snippet + } + + /// Snippet for AsyncQueryReasoningEngineAsync + public async Task AsyncQueryReasoningEngineRequestObjectAsync() + { + // Snippet: AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest, CallSettings) + // Additional: AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest, CancellationToken) + // Create client + ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = await ReasoningEngineExecutionServiceClient.CreateAsync(); + // Initialize request argument(s) + AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest + { + ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"), + InputGcsUri = "", + OutputGcsUri = "", + }; + // Make the request + Operation response = await reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync(request); + + // Poll until the returned long-running operation is complete + Operation completedResponse = await response.PollUntilCompletedAsync(); + // Retrieve the operation result + AsyncQueryReasoningEngineResponse result = completedResponse.Result; + + // Or get the name of the operation + string operationName = response.Name; + // This name can be stored, then the long-running operation retrieved later by name + Operation retrievedResponse = await reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngineAsync(operationName); + // Check if the retrieved long-running operation has completed + if (retrievedResponse.IsCompleted) + { + // If it has completed, then access the result + AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result; + } + // End snippet + } } } diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionService.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionService.g.cs index 150a8539db7f..b4cef2436f08 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionService.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionService.g.cs @@ -29,43 +29,64 @@ static ReasoningEngineExecutionServiceReflection() { "aXBsYXRmb3JtLnYxYmV0YTEaHGdvb2dsZS9hcGkvYW5ub3RhdGlvbnMucHJv", "dG8aF2dvb2dsZS9hcGkvY2xpZW50LnByb3RvGh9nb29nbGUvYXBpL2ZpZWxk", "X2JlaGF2aW9yLnByb3RvGhlnb29nbGUvYXBpL2h0dHBib2R5LnByb3RvGhln", - "b29nbGUvYXBpL3Jlc291cmNlLnByb3RvGhxnb29nbGUvcHJvdG9idWYvc3Ry", - "dWN0LnByb3RvIqYBChtRdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QSPwoE", - "bmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdvb2dsZWFwaXMuY29t", - "L1JlYXNvbmluZ0VuZ2luZRIrCgVpbnB1dBgCIAEoCzIXLmdvb2dsZS5wcm90", - "b2J1Zi5TdHJ1Y3RCA+BBARIZCgxjbGFzc19tZXRob2QYAyABKAlCA+BBASJG", - "ChxRdWVyeVJlYXNvbmluZ0VuZ2luZVJlc3BvbnNlEiYKBm91dHB1dBgBIAEo", - "CzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZSKsAQohU3RyZWFtUXVlcnlSZWFz", - "b25pbmdFbmdpbmVSZXF1ZXN0Ej8KBG5hbWUYASABKAlCMeBBAvpBKwopYWlw", - "bGF0Zm9ybS5nb29nbGVhcGlzLmNvbS9SZWFzb25pbmdFbmdpbmUSKwoFaW5w", - "dXQYAiABKAsyFy5nb29nbGUucHJvdG9idWYuU3RydWN0QgPgQQESGQoMY2xh", - "c3NfbWV0aG9kGAMgASgJQgPgQQEyhAUKH1JlYXNvbmluZ0VuZ2luZUV4ZWN1", - "dGlvblNlcnZpY2USjgIKFFF1ZXJ5UmVhc29uaW5nRW5naW5lEjwuZ29vZ2xl", - "LmNsb3VkLmFpcGxhdGZvcm0udjFiZXRhMS5RdWVyeVJlYXNvbmluZ0VuZ2lu", - "ZVJlcXVlc3QaPS5nb29nbGUuY2xvdWQuYWlwbGF0Zm9ybS52MWJldGExLlF1", - "ZXJ5UmVhc29uaW5nRW5naW5lUmVzcG9uc2UieYLT5JMCcyI/L3YxYmV0YTEv", - "e25hbWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9yZWFzb25pbmdFbmdpbmVz", - "Lyp9OnF1ZXJ5OgEqWi0iKC92MWJldGExL3tuYW1lPXJlYXNvbmluZ0VuZ2lu", - "ZXMvKn06cXVlcnk6ASoSgAIKGlN0cmVhbVF1ZXJ5UmVhc29uaW5nRW5naW5l", - "EkIuZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjFiZXRhMS5TdHJlYW1RdWVy", - "eVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QaFC5nb29nbGUuYXBpLkh0dHBCb2R5", - "IoUBgtPkkwJ/IkUvdjFiZXRhMS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9u", - "cy8qL3JlYXNvbmluZ0VuZ2luZXMvKn06c3RyZWFtUXVlcnk6ASpaMyIuL3Yx", - "YmV0YTEve25hbWU9cmVhc29uaW5nRW5naW5lcy8qfTpzdHJlYW1RdWVyeToB", - "KjABGk3KQRlhaXBsYXRmb3JtLmdvb2dsZWFwaXMuY29t0kEuaHR0cHM6Ly93", - "d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jbG91ZC1wbGF0Zm9ybUL7AQojY29t", - "Lmdvb2dsZS5jbG91ZC5haXBsYXRmb3JtLnYxYmV0YTFCJFJlYXNvbmluZ0Vu", - "Z2luZUV4ZWN1dGlvblNlcnZpY2VQcm90b1ABWkNjbG91ZC5nb29nbGUuY29t", - "L2dvL2FpcGxhdGZvcm0vYXBpdjFiZXRhMS9haXBsYXRmb3JtcGI7YWlwbGF0", - "Zm9ybXBiqgIfR29vZ2xlLkNsb3VkLkFJUGxhdGZvcm0uVjFCZXRhMcoCH0dv", - "b2dsZVxDbG91ZFxBSVBsYXRmb3JtXFYxYmV0YTHqAiJHb29nbGU6OkNsb3Vk", - "OjpBSVBsYXRmb3JtOjpWMWJldGExYgZwcm90bzM=")); + "b29nbGUvYXBpL3Jlc291cmNlLnByb3RvGi9nb29nbGUvY2xvdWQvYWlwbGF0", + "Zm9ybS92MWJldGExL29wZXJhdGlvbi5wcm90bxojZ29vZ2xlL2xvbmdydW5u", + "aW5nL29wZXJhdGlvbnMucHJvdG8aHGdvb2dsZS9wcm90b2J1Zi9zdHJ1Y3Qu", + "cHJvdG8ipgEKG1F1ZXJ5UmVhc29uaW5nRW5naW5lUmVxdWVzdBI/CgRuYW1l", + "GAEgASgJQjHgQQL6QSsKKWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb20vUmVh", + "c29uaW5nRW5naW5lEisKBWlucHV0GAIgASgLMhcuZ29vZ2xlLnByb3RvYnVm", + "LlN0cnVjdEID4EEBEhkKDGNsYXNzX21ldGhvZBgDIAEoCUID4EEBIkYKHFF1", + "ZXJ5UmVhc29uaW5nRW5naW5lUmVzcG9uc2USJgoGb3V0cHV0GAEgASgLMhYu", + "Z29vZ2xlLnByb3RvYnVmLlZhbHVlIqwBCiFTdHJlYW1RdWVyeVJlYXNvbmlu", + "Z0VuZ2luZVJlcXVlc3QSPwoEbmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRm", + "b3JtLmdvb2dsZWFwaXMuY29tL1JlYXNvbmluZ0VuZ2luZRIrCgVpbnB1dBgC", + "IAEoCzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RCA+BBARIZCgxjbGFzc19t", + "ZXRob2QYAyABKAlCA+BBASKcAQogQXN5bmNRdWVyeVJlYXNvbmluZ0VuZ2lu", + "ZVJlcXVlc3QSPwoEbmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdv", + "b2dsZWFwaXMuY29tL1JlYXNvbmluZ0VuZ2luZRIaCg1pbnB1dF9nY3NfdXJp", + "GAIgASgJQgPgQQESGwoOb3V0cHV0X2djc191cmkYAyABKAlCA+BBASKBAQoq", + "QXN5bmNRdWVyeVJlYXNvbmluZ0VuZ2luZU9wZXJhdGlvbk1ldGFkYXRhElMK", + "EGdlbmVyaWNfbWV0YWRhdGEYASABKAsyOS5nb29nbGUuY2xvdWQuYWlwbGF0", + "Zm9ybS52MWJldGExLkdlbmVyaWNPcGVyYXRpb25NZXRhZGF0YSI7CiFBc3lu", + "Y1F1ZXJ5UmVhc29uaW5nRW5naW5lUmVzcG9uc2USFgoOb3V0cHV0X2djc191", + "cmkYASABKAky3AcKH1JlYXNvbmluZ0VuZ2luZUV4ZWN1dGlvblNlcnZpY2US", + "jgIKFFF1ZXJ5UmVhc29uaW5nRW5naW5lEjwuZ29vZ2xlLmNsb3VkLmFpcGxh", + "dGZvcm0udjFiZXRhMS5RdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QaPS5n", + "b29nbGUuY2xvdWQuYWlwbGF0Zm9ybS52MWJldGExLlF1ZXJ5UmVhc29uaW5n", + "RW5naW5lUmVzcG9uc2UieYLT5JMCcyI/L3YxYmV0YTEve25hbWU9cHJvamVj", + "dHMvKi9sb2NhdGlvbnMvKi9yZWFzb25pbmdFbmdpbmVzLyp9OnF1ZXJ5OgEq", + "Wi0iKC92MWJldGExL3tuYW1lPXJlYXNvbmluZ0VuZ2luZXMvKn06cXVlcnk6", + "ASoSgAIKGlN0cmVhbVF1ZXJ5UmVhc29uaW5nRW5naW5lEkIuZ29vZ2xlLmNs", + "b3VkLmFpcGxhdGZvcm0udjFiZXRhMS5TdHJlYW1RdWVyeVJlYXNvbmluZ0Vu", + "Z2luZVJlcXVlc3QaFC5nb29nbGUuYXBpLkh0dHBCb2R5IoUBgtPkkwJ/IkUv", + "djFiZXRhMS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL3JlYXNvbmlu", + "Z0VuZ2luZXMvKn06c3RyZWFtUXVlcnk6ASpaMyIuL3YxYmV0YTEve25hbWU9", + "cmVhc29uaW5nRW5naW5lcy8qfTpzdHJlYW1RdWVyeToBKjABEtUCChlBc3lu", + "Y1F1ZXJ5UmVhc29uaW5nRW5naW5lEkEuZ29vZ2xlLmNsb3VkLmFpcGxhdGZv", + "cm0udjFiZXRhMS5Bc3luY1F1ZXJ5UmVhc29uaW5nRW5naW5lUmVxdWVzdBod", + "Lmdvb2dsZS5sb25ncnVubmluZy5PcGVyYXRpb24i1QHKQU8KIUFzeW5jUXVl", + "cnlSZWFzb25pbmdFbmdpbmVSZXNwb25zZRIqQXN5bmNRdWVyeVJlYXNvbmlu", + "Z0VuZ2luZU9wZXJhdGlvbk1ldGFkYXRhgtPkkwJ9IkQvdjFiZXRhMS97bmFt", + "ZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL3JlYXNvbmluZ0VuZ2luZXMvKn06", + "YXN5bmNRdWVyeToBKloyIi0vdjFiZXRhMS97bmFtZT1yZWFzb25pbmdFbmdp", + "bmVzLyp9OmFzeW5jUXVlcnk6ASoaTcpBGWFpcGxhdGZvcm0uZ29vZ2xlYXBp", + "cy5jb23SQS5odHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3Vk", + "LXBsYXRmb3JtQvsBCiNjb20uZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjFi", + "ZXRhMUIkUmVhc29uaW5nRW5naW5lRXhlY3V0aW9uU2VydmljZVByb3RvUAFa", + "Q2Nsb3VkLmdvb2dsZS5jb20vZ28vYWlwbGF0Zm9ybS9hcGl2MWJldGExL2Fp", + "cGxhdGZvcm1wYjthaXBsYXRmb3JtcGKqAh9Hb29nbGUuQ2xvdWQuQUlQbGF0", + "Zm9ybS5WMUJldGExygIfR29vZ2xlXENsb3VkXEFJUGxhdGZvcm1cVjFiZXRh", + "MeoCIkdvb2dsZTo6Q2xvdWQ6OkFJUGxhdGZvcm06OlYxYmV0YTFiBnByb3Rv", + "Mw==")); 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.HttpbodyReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.HttpbodyReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.AIPlatform.V1Beta1.OperationReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.QueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1Beta1.QueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.QueryReasoningEngineResponse), global::Google.Cloud.AIPlatform.V1Beta1.QueryReasoningEngineResponse.Parser, new[]{ "Output" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.StreamQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1Beta1.StreamQueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.StreamQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1Beta1.StreamQueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest.Parser, new[]{ "Name", "InputGcsUri", "OutputGcsUri" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineOperationMetadata), global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineOperationMetadata.Parser, new[]{ "GenericMetadata" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineResponse), global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineResponse.Parser, new[]{ "OutputGcsUri" }, null, null, null, null) })); } #endregion @@ -879,6 +900,712 @@ public void MergeFrom(pb::CodedInputStream input) { } + /// + /// Request message for + /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AsyncQueryReasoningEngineRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AsyncQueryReasoningEngineRequest()); + 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.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceReflection.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 AsyncQueryReasoningEngineRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineRequest(AsyncQueryReasoningEngineRequest other) : this() { + name_ = other.name_; + inputGcsUri_ = other.inputGcsUri_; + outputGcsUri_ = other.outputGcsUri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineRequest Clone() { + return new AsyncQueryReasoningEngineRequest(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Required. The name of the ReasoningEngine resource to use. + /// Format: + /// `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}` + /// + [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 "input_gcs_uri" field. + public const int InputGcsUriFieldNumber = 2; + private string inputGcsUri_ = ""; + /// + /// Optional. Input Cloud Storage URI for the Async query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InputGcsUri { + get { return inputGcsUri_; } + set { + inputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "output_gcs_uri" field. + public const int OutputGcsUriFieldNumber = 3; + private string outputGcsUri_ = ""; + /// + /// Optional. Output Cloud Storage URI for the Async query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OutputGcsUri { + get { return outputGcsUri_; } + set { + outputGcsUri_ = 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 AsyncQueryReasoningEngineRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AsyncQueryReasoningEngineRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (InputGcsUri != other.InputGcsUri) return false; + if (OutputGcsUri != other.OutputGcsUri) 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 (InputGcsUri.Length != 0) hash ^= InputGcsUri.GetHashCode(); + if (OutputGcsUri.Length != 0) hash ^= OutputGcsUri.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 (InputGcsUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InputGcsUri); + } + if (OutputGcsUri.Length != 0) { + output.WriteRawTag(26); + output.WriteString(OutputGcsUri); + } + 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 (InputGcsUri.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InputGcsUri); + } + if (OutputGcsUri.Length != 0) { + output.WriteRawTag(26); + output.WriteString(OutputGcsUri); + } + 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 (InputGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InputGcsUri); + } + if (OutputGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputGcsUri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AsyncQueryReasoningEngineRequest other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.InputGcsUri.Length != 0) { + InputGcsUri = other.InputGcsUri; + } + if (other.OutputGcsUri.Length != 0) { + OutputGcsUri = other.OutputGcsUri; + } + _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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + InputGcsUri = input.ReadString(); + break; + } + case 26: { + OutputGcsUri = 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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + InputGcsUri = input.ReadString(); + break; + } + case 26: { + OutputGcsUri = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Operation metadata message for + /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AsyncQueryReasoningEngineOperationMetadata : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AsyncQueryReasoningEngineOperationMetadata()); + 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.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceReflection.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 AsyncQueryReasoningEngineOperationMetadata() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineOperationMetadata(AsyncQueryReasoningEngineOperationMetadata other) : this() { + genericMetadata_ = other.genericMetadata_ != null ? other.genericMetadata_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineOperationMetadata Clone() { + return new AsyncQueryReasoningEngineOperationMetadata(this); + } + + /// Field number for the "generic_metadata" field. + public const int GenericMetadataFieldNumber = 1; + private global::Google.Cloud.AIPlatform.V1Beta1.GenericOperationMetadata genericMetadata_; + /// + /// The common part of the operation metadata. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.AIPlatform.V1Beta1.GenericOperationMetadata GenericMetadata { + get { return genericMetadata_; } + set { + genericMetadata_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AsyncQueryReasoningEngineOperationMetadata); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AsyncQueryReasoningEngineOperationMetadata other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(GenericMetadata, other.GenericMetadata)) 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 (genericMetadata_ != null) hash ^= GenericMetadata.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 (genericMetadata_ != null) { + output.WriteRawTag(10); + output.WriteMessage(GenericMetadata); + } + 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 (genericMetadata_ != null) { + output.WriteRawTag(10); + output.WriteMessage(GenericMetadata); + } + 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 (genericMetadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(GenericMetadata); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AsyncQueryReasoningEngineOperationMetadata other) { + if (other == null) { + return; + } + if (other.genericMetadata_ != null) { + if (genericMetadata_ == null) { + GenericMetadata = new global::Google.Cloud.AIPlatform.V1Beta1.GenericOperationMetadata(); + } + GenericMetadata.MergeFrom(other.GenericMetadata); + } + _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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (genericMetadata_ == null) { + GenericMetadata = new global::Google.Cloud.AIPlatform.V1Beta1.GenericOperationMetadata(); + } + input.ReadMessage(GenericMetadata); + 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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (genericMetadata_ == null) { + GenericMetadata = new global::Google.Cloud.AIPlatform.V1Beta1.GenericOperationMetadata(); + } + input.ReadMessage(GenericMetadata); + break; + } + } + } + } + #endif + + } + + /// + /// Response message for + /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1beta1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine]. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AsyncQueryReasoningEngineResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AsyncQueryReasoningEngineResponse()); + 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.AIPlatform.V1Beta1.ReasoningEngineExecutionServiceReflection.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 AsyncQueryReasoningEngineResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineResponse(AsyncQueryReasoningEngineResponse other) : this() { + outputGcsUri_ = other.outputGcsUri_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AsyncQueryReasoningEngineResponse Clone() { + return new AsyncQueryReasoningEngineResponse(this); + } + + /// Field number for the "output_gcs_uri" field. + public const int OutputGcsUriFieldNumber = 1; + private string outputGcsUri_ = ""; + /// + /// Output Cloud Storage URI for the Async query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OutputGcsUri { + get { return outputGcsUri_; } + set { + outputGcsUri_ = 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 AsyncQueryReasoningEngineResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AsyncQueryReasoningEngineResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (OutputGcsUri != other.OutputGcsUri) 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 (OutputGcsUri.Length != 0) hash ^= OutputGcsUri.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 (OutputGcsUri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(OutputGcsUri); + } + 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 (OutputGcsUri.Length != 0) { + output.WriteRawTag(10); + output.WriteString(OutputGcsUri); + } + 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 (OutputGcsUri.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputGcsUri); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AsyncQueryReasoningEngineResponse other) { + if (other == null) { + return; + } + if (other.OutputGcsUri.Length != 0) { + OutputGcsUri = other.OutputGcsUri; + } + _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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + OutputGcsUri = 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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + OutputGcsUri = input.ReadString(); + break; + } + } + } + } + #endif + + } + #endregion } diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceClient.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceClient.g.cs index a713aebf9177..241afe1d3449 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceClient.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceClient.g.cs @@ -22,6 +22,7 @@ using gcl = Google.Cloud.Location; using grpccore = Grpc.Core; using grpcinter = Grpc.Core.Interceptors; +using lro = Google.LongRunning; using mel = Microsoft.Extensions.Logging; using proto = Google.Protobuf; using scg = System.Collections.Generic; @@ -51,6 +52,8 @@ private ReasoningEngineExecutionServiceSettings(ReasoningEngineExecutionServiceS gax::GaxPreconditions.CheckNotNull(existing, nameof(existing)); QueryReasoningEngineSettings = existing.QueryReasoningEngineSettings; StreamQueryReasoningEngineSettings = existing.StreamQueryReasoningEngineSettings; + AsyncQueryReasoningEngineSettings = existing.AsyncQueryReasoningEngineSettings; + AsyncQueryReasoningEngineOperationsSettings = existing.AsyncQueryReasoningEngineOperationsSettings.Clone(); LocationsSettings = existing.LocationsSettings; IAMPolicySettings = existing.IAMPolicySettings; OnCopy(existing); @@ -84,6 +87,38 @@ private ReasoningEngineExecutionServiceSettings(ReasoningEngineExecutionServiceS /// public gaxgrpc::CallSettings StreamQueryReasoningEngineSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None); + /// + /// for synchronous and asynchronous calls to + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine and + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync. + /// + /// + /// + /// This call will not be retried. + /// No timeout is applied. + /// + /// + public gaxgrpc::CallSettings AsyncQueryReasoningEngineSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None); + + /// + /// Long Running Operation settings for calls to + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine and + /// ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync. + /// + /// + /// Uses default of: + /// + /// Initial delay: 20 seconds. + /// Delay multiplier: 1.5 + /// Maximum delay: 45 seconds. + /// Total timeout: 24 hours. + /// + /// + public lro::OperationsSettings AsyncQueryReasoningEngineOperationsSettings { get; set; } = new lro::OperationsSettings + { + DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)), + }; + /// /// The settings to use for the associated with the client. /// @@ -288,6 +323,60 @@ public abstract partial class StreamQueryReasoningEngineStream : gaxgrpc::Server /// The server stream. public virtual StreamQueryReasoningEngineStream StreamQueryReasoningEngine(StreamQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException(); + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public virtual lro::Operation AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public virtual stt::Task> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// A to use for this RPC. + /// A Task containing the RPC response. + public virtual stt::Task> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, st::CancellationToken cancellationToken) => + AsyncQueryReasoningEngineAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// The long-running operations client for AsyncQueryReasoningEngine. + public virtual lro::OperationsClient AsyncQueryReasoningEngineOperationsClient => throw new sys::NotImplementedException(); + + /// + /// Poll an operation once, using an operationName from a previous invocation of + /// AsyncQueryReasoningEngine. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// The result of polling the operation. + public virtual lro::Operation PollOnceAsyncQueryReasoningEngine(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), AsyncQueryReasoningEngineOperationsClient, callSettings); + + /// + /// Asynchronously poll an operation once, using an operationName from a previous invocation of + /// AsyncQueryReasoningEngine. + /// + /// + /// The name of a previously invoked operation. Must not be null or empty. + /// + /// If not null, applies overrides to this RPC call. + /// A task representing the result of polling the operation. + public virtual stt::Task> PollOnceAsyncQueryReasoningEngineAsync(string operationName, gaxgrpc::CallSettings callSettings = null) => + lro::Operation.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), AsyncQueryReasoningEngineOperationsClient, callSettings); } /// ReasoningEngineExecutionService client wrapper implementation, for convenient use. @@ -300,6 +389,8 @@ public sealed partial class ReasoningEngineExecutionServiceClientImpl : Reasonin private readonly gaxgrpc::ApiServerStreamingCall _callStreamQueryReasoningEngine; + private readonly gaxgrpc::ApiCall _callAsyncQueryReasoningEngine; + /// /// Constructs a client wrapper for the ReasoningEngineExecutionService service, with the specified gRPC client /// and settings. @@ -318,6 +409,7 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService Settings = effectiveSettings, Logger = logger, }); + AsyncQueryReasoningEngineOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.AsyncQueryReasoningEngineOperationsSettings, logger); LocationsClient = new gcl::LocationsClientImpl(grpcClient.CreateLocationsClient(), effectiveSettings.LocationsSettings, logger); IAMPolicyClient = new gciv::IAMPolicyClientImpl(grpcClient.CreateIAMPolicyClient(), effectiveSettings.IAMPolicySettings, logger); _callQueryReasoningEngine = clientHelper.BuildApiCall("QueryReasoningEngine", grpcClient.QueryReasoningEngineAsync, grpcClient.QueryReasoningEngine, effectiveSettings.QueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name); @@ -326,6 +418,9 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService _callStreamQueryReasoningEngine = clientHelper.BuildApiCall("StreamQueryReasoningEngine", grpcClient.StreamQueryReasoningEngine, effectiveSettings.StreamQueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name); Modify_ApiCall(ref _callStreamQueryReasoningEngine); Modify_StreamQueryReasoningEngineApiCall(ref _callStreamQueryReasoningEngine); + _callAsyncQueryReasoningEngine = clientHelper.BuildApiCall("AsyncQueryReasoningEngine", grpcClient.AsyncQueryReasoningEngineAsync, grpcClient.AsyncQueryReasoningEngine, effectiveSettings.AsyncQueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name); + Modify_ApiCall(ref _callAsyncQueryReasoningEngine); + Modify_AsyncQueryReasoningEngineApiCall(ref _callAsyncQueryReasoningEngine); OnConstruction(grpcClient, effectiveSettings, clientHelper); } @@ -337,6 +432,8 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService partial void Modify_StreamQueryReasoningEngineApiCall(ref gaxgrpc::ApiServerStreamingCall call); + partial void Modify_AsyncQueryReasoningEngineApiCall(ref gaxgrpc::ApiCall call); + partial void OnConstruction(ReasoningEngineExecutionService.ReasoningEngineExecutionServiceClient grpcClient, ReasoningEngineExecutionServiceSettings effectiveSettings, gaxgrpc::ClientHelper clientHelper); /// The underlying gRPC ReasoningEngineExecutionService client @@ -352,6 +449,8 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService partial void Modify_StreamQueryReasoningEngineRequest(ref StreamQueryReasoningEngineRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_AsyncQueryReasoningEngineRequest(ref AsyncQueryReasoningEngineRequest request, ref gaxgrpc::CallSettings settings); + /// /// Queries using a reasoning engine. /// @@ -396,6 +495,47 @@ public override ReasoningEngineExecutionServiceClient.StreamQueryReasoningEngine Modify_StreamQueryReasoningEngineRequest(ref request, ref callSettings); return new StreamQueryReasoningEngineStreamImpl(_callStreamQueryReasoningEngine.Call(request, callSettings)); } + + /// The long-running operations client for AsyncQueryReasoningEngine. + public override lro::OperationsClient AsyncQueryReasoningEngineOperationsClient { get; } + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// The RPC response. + public override lro::Operation AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_AsyncQueryReasoningEngineRequest(ref request, ref callSettings); + return new lro::Operation(_callAsyncQueryReasoningEngine.Sync(request, callSettings), AsyncQueryReasoningEngineOperationsClient); + } + + /// + /// Async query using a reasoning engine. + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A Task containing the RPC response. + public override async stt::Task> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_AsyncQueryReasoningEngineRequest(ref request, ref callSettings); + return new lro::Operation(await _callAsyncQueryReasoningEngine.Async(request, callSettings).ConfigureAwait(false), AsyncQueryReasoningEngineOperationsClient); + } + } + + public static partial class ReasoningEngineExecutionService + { + public partial class ReasoningEngineExecutionServiceClient + { + /// + /// Creates a new instance of using the same call invoker as + /// this client. + /// + /// A new Operations client for the same target as this client. + public virtual lro::Operations.OperationsClient CreateOperationsClient() => + new lro::Operations.OperationsClient(CallInvoker); + } } public static partial class ReasoningEngineExecutionService diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceGrpc.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceGrpc.g.cs index 6f525ec42d3d..ed0c5c995a16 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceGrpc.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceGrpc.g.cs @@ -3,7 +3,7 @@ // source: google/cloud/aiplatform/v1beta1/reasoning_engine_execution_service.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. @@ -71,6 +71,10 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl static readonly grpc::Marshaller __Marshaller_google_cloud_aiplatform_v1beta1_StreamQueryReasoningEngineRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.AIPlatform.V1Beta1.StreamQueryReasoningEngineRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_api_HttpBody = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Api.HttpBody.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_cloud_aiplatform_v1beta1_AsyncQueryReasoningEngineRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_longrunning_Operation = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.LongRunning.Operation.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Method __Method_QueryReasoningEngine = new grpc::Method( @@ -88,6 +92,14 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl __Marshaller_google_cloud_aiplatform_v1beta1_StreamQueryReasoningEngineRequest, __Marshaller_google_api_HttpBody); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_AsyncQueryReasoningEngine = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "AsyncQueryReasoningEngine", + __Marshaller_google_cloud_aiplatform_v1beta1_AsyncQueryReasoningEngineRequest, + __Marshaller_google_longrunning_Operation); + /// Service descriptor public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor { @@ -123,6 +135,18 @@ public abstract partial class ReasoningEngineExecutionServiceBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Async query using a reasoning engine. + /// + /// 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 AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + } /// Client for ReasoningEngineExecutionService @@ -224,6 +248,54 @@ protected ReasoningEngineExecutionServiceClient(ClientBaseConfiguration configur { return CallInvoker.AsyncServerStreamingCall(__Method_StreamQueryReasoningEngine, null, options, request); } + /// + /// Async query using a reasoning engine. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.LongRunning.Operation AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return AsyncQueryReasoningEngine(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Async query using a reasoning engine. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.LongRunning.Operation AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_AsyncQueryReasoningEngine, null, options, request); + } + /// + /// Async query using a reasoning engine. + /// + /// 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 AsyncQueryReasoningEngineAsync(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return AsyncQueryReasoningEngineAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Async query using a reasoning engine. + /// + /// 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 AsyncQueryReasoningEngineAsync(global::Google.Cloud.AIPlatform.V1Beta1.AsyncQueryReasoningEngineRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_AsyncQueryReasoningEngine, null, options, request); + } /// Creates a new instance of client from given ClientBaseConfiguration. [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] protected override ReasoningEngineExecutionServiceClient NewInstance(ClientBaseConfiguration configuration) @@ -239,7 +311,8 @@ protected override ReasoningEngineExecutionServiceClient NewInstance(ClientBaseC { return grpc::ServerServiceDefinition.CreateBuilder() .AddMethod(__Method_QueryReasoningEngine, serviceImpl.QueryReasoningEngine) - .AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl.StreamQueryReasoningEngine).Build(); + .AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl.StreamQueryReasoningEngine) + .AddMethod(__Method_AsyncQueryReasoningEngine, serviceImpl.AsyncQueryReasoningEngine).Build(); } /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. @@ -251,6 +324,7 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, ReasoningE { serviceBinder.AddMethod(__Method_QueryReasoningEngine, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.QueryReasoningEngine)); serviceBinder.AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod(serviceImpl.StreamQueryReasoningEngine)); + serviceBinder.AddMethod(__Method_AsyncQueryReasoningEngine, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.AsyncQueryReasoningEngine)); } } diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceResourceNames.g.cs b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceResourceNames.g.cs index ddefdbd83877..f299216dcf04 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceResourceNames.g.cs +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/Google.Cloud.AIPlatform.V1Beta1/ReasoningEngineExecutionServiceResourceNames.g.cs @@ -42,4 +42,16 @@ public partial class StreamQueryReasoningEngineRequest set => Name = value?.ToString() ?? ""; } } + + public partial class AsyncQueryReasoningEngineRequest + { + /// + /// -typed view over the resource name property. + /// + public gcav::ReasoningEngineName ReasoningEngineName + { + get => string.IsNullOrEmpty(Name) ? null : gcav::ReasoningEngineName.Parse(Name, allowUnparsed: true); + set => Name = value?.ToString() ?? ""; + } + } } diff --git a/apis/Google.Cloud.AIPlatform.V1Beta1/gapic_metadata.json b/apis/Google.Cloud.AIPlatform.V1Beta1/gapic_metadata.json index 4023c6b8cb24..6dbc60cfcceb 100644 --- a/apis/Google.Cloud.AIPlatform.V1Beta1/gapic_metadata.json +++ b/apis/Google.Cloud.AIPlatform.V1Beta1/gapic_metadata.json @@ -2131,6 +2131,12 @@ "grpc": { "libraryClient": "ReasoningEngineExecutionServiceClient", "rpcs": { + "AsyncQueryReasoningEngine": { + "methods": [ + "AsyncQueryReasoningEngine", + "AsyncQueryReasoningEngineAsync" + ] + }, "QueryReasoningEngine": { "methods": [ "QueryReasoningEngine", diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json index 57bc7bccfac3..b7932a901f1a 100644 --- a/generator-input/pipeline-state.json +++ b/generator-input/pipeline-state.json @@ -277,7 +277,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-04-06T14:06:48.871341990Z", - "lastGeneratedCommit": "5f39e35169f022491657e7d2f8429bfc7280623a", + "lastGeneratedCommit": "a78b5838b801428bfe5b85758727a46d830b7f39", "lastReleasedCommit": "2fff02315f91f5063d3266adfa32c6bed19a080c", "apiPaths": [ "google/cloud/aiplatform/v1beta1" From 949fccf718926e266827ffd91ec21c1bfde46a4b Mon Sep 17 00:00:00 2001 From: Google Cloud SDK Librarian Date: Tue, 21 Apr 2026 07:09:54 +0000 Subject: [PATCH 2/3] regen: Regenerate Google.Cloud.NetApp.V1 at API commit 4ad1b67 feat: add ScaleType for Storage Pools and LargeCapacityConfig for Volumes docs: A comment for field `large_capacity` in message `.google.cloud.netapp.v1.Volume` is changed PiperOrigin-RevId: 902801207 Source-Link: https://github.com/googleapis/googleapis/commit/4ad1b6750926701f94ae8a88525395fd17b42cfe --- .../Google.Cloud.NetApp.V1/Common.g.cs | 26 +- .../Google.Cloud.NetApp.V1/StoragePool.g.cs | 83 ++- .../Google.Cloud.NetApp.V1/Volume.g.cs | 618 +++++++++++++----- generator-input/pipeline-state.json | 2 +- 4 files changed, 530 insertions(+), 199 deletions(-) diff --git a/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Common.g.cs b/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Common.g.cs index fc65102096b7..36144f139657 100644 --- a/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Common.g.cs +++ b/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Common.g.cs @@ -42,7 +42,9 @@ static CommonReflection() { "ZXJ2aWNlVHlwZRImCiJESVJFQ1RPUllfU0VSVklDRV9UWVBFX1VOU1BFQ0lG", "SUVEEAASFAoQQUNUSVZFX0RJUkVDVE9SWRABKksKD1N0b3JhZ2VQb29sVHlw", "ZRIhCh1TVE9SQUdFX1BPT0xfVFlQRV9VTlNQRUNJRklFRBAAEggKBEZJTEUQ", - "ARILCgdVTklGSUVEEAIqdQoZSHlicmlkUmVwbGljYXRpb25TY2hlZHVsZRIr", + "ARILCgdVTklGSUVEEAIqWAoJU2NhbGVUeXBlEhoKFlNDQUxFX1RZUEVfVU5T", + "UEVDSUZJRUQQABIWChJTQ0FMRV9UWVBFX0RFRkFVTFQQARIXChNTQ0FMRV9U", + "WVBFX1NDQUxFT1VUEAIqdQoZSHlicmlkUmVwbGljYXRpb25TY2hlZHVsZRIr", "CidIWUJSSURfUkVQTElDQVRJT05fU0NIRURVTEVfVU5TUEVDSUZJRUQQABIU", "ChBFVkVSWV8xMF9NSU5VVEVTEAESCgoGSE9VUkxZEAISCQoFREFJTFkQAyo5", "CgdRb3NUeXBlEhgKFFFPU19UWVBFX1VOU1BFQ0lGSUVEEAASCAoEQVVUTxAB", @@ -54,7 +56,7 @@ static CommonReflection() { "cFxWMeoCGUdvb2dsZTo6Q2xvdWQ6Ok5ldEFwcDo6VjFiBnByb3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, }, - new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.NetApp.V1.ServiceLevel), typeof(global::Google.Cloud.NetApp.V1.FlexPerformance), typeof(global::Google.Cloud.NetApp.V1.EncryptionType), typeof(global::Google.Cloud.NetApp.V1.DirectoryServiceType), typeof(global::Google.Cloud.NetApp.V1.StoragePoolType), typeof(global::Google.Cloud.NetApp.V1.HybridReplicationSchedule), typeof(global::Google.Cloud.NetApp.V1.QosType), typeof(global::Google.Cloud.NetApp.V1.OsType), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.NetApp.V1.ServiceLevel), typeof(global::Google.Cloud.NetApp.V1.FlexPerformance), typeof(global::Google.Cloud.NetApp.V1.EncryptionType), typeof(global::Google.Cloud.NetApp.V1.DirectoryServiceType), typeof(global::Google.Cloud.NetApp.V1.StoragePoolType), typeof(global::Google.Cloud.NetApp.V1.ScaleType), typeof(global::Google.Cloud.NetApp.V1.HybridReplicationSchedule), typeof(global::Google.Cloud.NetApp.V1.QosType), typeof(global::Google.Cloud.NetApp.V1.OsType), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.LocationMetadata), global::Google.Cloud.NetApp.V1.LocationMetadata.Parser, new[]{ "SupportedServiceLevels", "SupportedFlexPerformance", "HasVcp", "HasOntapProxy" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.UserCommands), global::Google.Cloud.NetApp.V1.UserCommands.Parser, new[]{ "Commands" }, null, null, null, null) })); @@ -157,6 +159,26 @@ public enum StoragePoolType { [pbr::OriginalName("UNIFIED")] Unified = 2, } + /// + /// Defines the scale-type of a UNIFIED Storage Pool. + /// + public enum ScaleType { + /// + /// Unspecified scale type. + /// + [pbr::OriginalName("SCALE_TYPE_UNSPECIFIED")] Unspecified = 0, + /// + /// Represents standard capacity and performance scale-type. + /// Suitable for general purpose workloads. + /// + [pbr::OriginalName("SCALE_TYPE_DEFAULT")] Default = 1, + /// + /// Represents higher capacity and performance scale-type. + /// Suitable for more demanding workloads. + /// + [pbr::OriginalName("SCALE_TYPE_SCALEOUT")] Scaleout = 2, + } + /// /// Schedule for Hybrid Replication. /// New enum values may be added in future to support different frequency of diff --git a/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/StoragePool.g.cs b/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/StoragePool.g.cs index 01eeefa14e97..e2903cba54fa 100644 --- a/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/StoragePool.g.cs +++ b/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/StoragePool.g.cs @@ -49,7 +49,7 @@ static StoragePoolReflection() { "YW1lGAEgASgJQingQQL6QSMKIW5ldGFwcC5nb29nbGVhcGlzLmNvbS9TdG9y", "YWdlUG9vbCJZCh5Td2l0Y2hBY3RpdmVSZXBsaWNhWm9uZVJlcXVlc3QSNwoE", "bmFtZRgBIAEoCUIp4EEC+kEjCiFuZXRhcHAuZ29vZ2xlYXBpcy5jb20vU3Rv", - "cmFnZVBvb2wi7Q0KC1N0b3JhZ2VQb29sEhEKBG5hbWUYASABKAlCA+BBCBJA", + "cmFnZVBvb2wiqQ4KC1N0b3JhZ2VQb29sEhEKBG5hbWUYASABKAlCA+BBCBJA", "Cg1zZXJ2aWNlX2xldmVsGAIgASgOMiQuZ29vZ2xlLmNsb3VkLm5ldGFwcC52", "MS5TZXJ2aWNlTGV2ZWxCA+BBAhIZCgxjYXBhY2l0eV9naWIYAyABKANCA+BB", "AhIgChN2b2x1bWVfY2FwYWNpdHlfZ2liGAQgASgDQgPgQQMSGQoMdm9sdW1l", @@ -80,24 +80,26 @@ static StoragePoolReflection() { "dXNlZF9naWIYIiABKANCA+BBAxI/CgR0eXBlGCMgASgOMicuZ29vZ2xlLmNs", "b3VkLm5ldGFwcC52MS5TdG9yYWdlUG9vbFR5cGVCA+BBAUgCiAEBEjQKBG1v", "ZGUYJCABKA4yHC5nb29nbGUuY2xvdWQubmV0YXBwLnYxLk1vZGVCA+BBAUgD", - "iAEBGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEo", - "CToCOAEiewoFU3RhdGUSFQoRU1RBVEVfVU5TUEVDSUZJRUQQABIJCgVSRUFE", - "WRABEgwKCENSRUFUSU5HEAISDAoIREVMRVRJTkcQAxIMCghVUERBVElORxAE", - "Eg0KCVJFU1RPUklORxAFEgwKCERJU0FCTEVEEAYSCQoFRVJST1IQBzqHAepB", - "gwEKIW5ldGFwcC5nb29nbGVhcGlzLmNvbS9TdG9yYWdlUG9vbBJDcHJvamVj", - "dHMve3Byb2plY3R9L2xvY2F0aW9ucy97bG9jYXRpb259L3N0b3JhZ2VQb29s", - "cy97c3RvcmFnZV9wb29sfSoMc3RvcmFnZVBvb2xzMgtzdG9yYWdlUG9vbEIY", - "ChZfZ2xvYmFsX2FjY2Vzc19hbGxvd2VkQh4KHF9lbmFibGVfaG90X3RpZXJf", - "YXV0b19yZXNpemVCBwoFX3R5cGVCBwoFX21vZGUiqAEKH1ZhbGlkYXRlRGly", - "ZWN0b3J5U2VydmljZVJlcXVlc3QSNwoEbmFtZRgBIAEoCUIp4EEC+kEjCiFu", - "ZXRhcHAuZ29vZ2xlYXBpcy5jb20vU3RvcmFnZVBvb2wSTAoWZGlyZWN0b3J5", - "X3NlcnZpY2VfdHlwZRgCIAEoDjIsLmdvb2dsZS5jbG91ZC5uZXRhcHAudjEu", - "RGlyZWN0b3J5U2VydmljZVR5cGUqNAoETW9kZRIUChBNT0RFX1VOU1BFQ0lG", - "SUVEEAASCwoHREVGQVVMVBABEgkKBU9OVEFQEAJCsgEKGmNvbS5nb29nbGUu", - "Y2xvdWQubmV0YXBwLnYxQhBTdG9yYWdlUG9vbFByb3RvUAFaMmNsb3VkLmdv", - "b2dsZS5jb20vZ28vbmV0YXBwL2FwaXYxL25ldGFwcHBiO25ldGFwcHBiqgIW", - "R29vZ2xlLkNsb3VkLk5ldEFwcC5WMcoCFkdvb2dsZVxDbG91ZFxOZXRBcHBc", - "VjHqAhlHb29nbGU6OkNsb3VkOjpOZXRBcHA6OlYxYgZwcm90bzM=")); + "iAEBEjoKCnNjYWxlX3R5cGUYJiABKA4yIS5nb29nbGUuY2xvdWQubmV0YXBw", + "LnYxLlNjYWxlVHlwZUID4EEBGi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEo", + "CRINCgV2YWx1ZRgCIAEoCToCOAEiewoFU3RhdGUSFQoRU1RBVEVfVU5TUEVD", + "SUZJRUQQABIJCgVSRUFEWRABEgwKCENSRUFUSU5HEAISDAoIREVMRVRJTkcQ", + "AxIMCghVUERBVElORxAEEg0KCVJFU1RPUklORxAFEgwKCERJU0FCTEVEEAYS", + "CQoFRVJST1IQBzqHAepBgwEKIW5ldGFwcC5nb29nbGVhcGlzLmNvbS9TdG9y", + "YWdlUG9vbBJDcHJvamVjdHMve3Byb2plY3R9L2xvY2F0aW9ucy97bG9jYXRp", + "b259L3N0b3JhZ2VQb29scy97c3RvcmFnZV9wb29sfSoMc3RvcmFnZVBvb2xz", + "MgtzdG9yYWdlUG9vbEIYChZfZ2xvYmFsX2FjY2Vzc19hbGxvd2VkQh4KHF9l", + "bmFibGVfaG90X3RpZXJfYXV0b19yZXNpemVCBwoFX3R5cGVCBwoFX21vZGUi", + "qAEKH1ZhbGlkYXRlRGlyZWN0b3J5U2VydmljZVJlcXVlc3QSNwoEbmFtZRgB", + "IAEoCUIp4EEC+kEjCiFuZXRhcHAuZ29vZ2xlYXBpcy5jb20vU3RvcmFnZVBv", + "b2wSTAoWZGlyZWN0b3J5X3NlcnZpY2VfdHlwZRgCIAEoDjIsLmdvb2dsZS5j", + "bG91ZC5uZXRhcHAudjEuRGlyZWN0b3J5U2VydmljZVR5cGUqNAoETW9kZRIU", + "ChBNT0RFX1VOU1BFQ0lGSUVEEAASCwoHREVGQVVMVBABEgkKBU9OVEFQEAJC", + "sgEKGmNvbS5nb29nbGUuY2xvdWQubmV0YXBwLnYxQhBTdG9yYWdlUG9vbFBy", + "b3RvUAFaMmNsb3VkLmdvb2dsZS5jb20vZ28vbmV0YXBwL2FwaXYxL25ldGFw", + "cHBiO25ldGFwcHBiqgIWR29vZ2xlLkNsb3VkLk5ldEFwcC5WMcoCFkdvb2ds", + "ZVxDbG91ZFxOZXRBcHBcVjHqAhlHb29nbGU6OkNsb3VkOjpOZXRBcHA6OlYx", + "YgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.NetApp.V1.CommonReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.NetApp.V1.Mode), }, null, new pbr::GeneratedClrTypeInfo[] { @@ -108,7 +110,7 @@ static StoragePoolReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.UpdateStoragePoolRequest), global::Google.Cloud.NetApp.V1.UpdateStoragePoolRequest.Parser, new[]{ "UpdateMask", "StoragePool" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.DeleteStoragePoolRequest), global::Google.Cloud.NetApp.V1.DeleteStoragePoolRequest.Parser, new[]{ "Name" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.SwitchActiveReplicaZoneRequest), global::Google.Cloud.NetApp.V1.SwitchActiveReplicaZoneRequest.Parser, new[]{ "Name" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.StoragePool), global::Google.Cloud.NetApp.V1.StoragePool.Parser, new[]{ "Name", "ServiceLevel", "CapacityGib", "VolumeCapacityGib", "VolumeCount", "State", "StateDetails", "CreateTime", "Description", "Labels", "Network", "ActiveDirectory", "KmsConfig", "LdapEnabled", "PsaRange", "EncryptionType", "GlobalAccessAllowed", "AllowAutoTiering", "ReplicaZone", "Zone", "SatisfiesPzs", "SatisfiesPzi", "CustomPerformanceEnabled", "TotalThroughputMibps", "TotalIops", "HotTierSizeGib", "EnableHotTierAutoResize", "QosType", "AvailableThroughputMibps", "ColdTierSizeUsedGib", "HotTierSizeUsedGib", "Type", "Mode" }, new[]{ "GlobalAccessAllowed", "EnableHotTierAutoResize", "Type", "Mode" }, new[]{ typeof(global::Google.Cloud.NetApp.V1.StoragePool.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.StoragePool), global::Google.Cloud.NetApp.V1.StoragePool.Parser, new[]{ "Name", "ServiceLevel", "CapacityGib", "VolumeCapacityGib", "VolumeCount", "State", "StateDetails", "CreateTime", "Description", "Labels", "Network", "ActiveDirectory", "KmsConfig", "LdapEnabled", "PsaRange", "EncryptionType", "GlobalAccessAllowed", "AllowAutoTiering", "ReplicaZone", "Zone", "SatisfiesPzs", "SatisfiesPzi", "CustomPerformanceEnabled", "TotalThroughputMibps", "TotalIops", "HotTierSizeGib", "EnableHotTierAutoResize", "QosType", "AvailableThroughputMibps", "ColdTierSizeUsedGib", "HotTierSizeUsedGib", "Type", "Mode", "ScaleType" }, new[]{ "GlobalAccessAllowed", "EnableHotTierAutoResize", "Type", "Mode" }, new[]{ typeof(global::Google.Cloud.NetApp.V1.StoragePool.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.ValidateDirectoryServiceRequest), global::Google.Cloud.NetApp.V1.ValidateDirectoryServiceRequest.Parser, new[]{ "Name", "DirectoryServiceType" }, null, null, null, null) })); } @@ -2016,6 +2018,7 @@ public StoragePool(StoragePool other) : this() { hotTierSizeUsedGib_ = other.hotTierSizeUsedGib_; type_ = other.type_; mode_ = other.mode_; + scaleType_ = other.scaleType_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -2603,6 +2606,22 @@ public void ClearMode() { _hasBits0 &= ~8; } + /// Field number for the "scale_type" field. + public const int ScaleTypeFieldNumber = 38; + private global::Google.Cloud.NetApp.V1.ScaleType scaleType_ = global::Google.Cloud.NetApp.V1.ScaleType.Unspecified; + /// + /// Optional. The scale type of the storage pool. Defaults to + /// `SCALE_TYPE_DEFAULT` if not specified. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetApp.V1.ScaleType ScaleType { + get { return scaleType_; } + set { + scaleType_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -2651,6 +2670,7 @@ public bool Equals(StoragePool other) { if (HotTierSizeUsedGib != other.HotTierSizeUsedGib) return false; if (Type != other.Type) return false; if (Mode != other.Mode) return false; + if (ScaleType != other.ScaleType) return false; return Equals(_unknownFields, other._unknownFields); } @@ -2691,6 +2711,7 @@ public override int GetHashCode() { if (HotTierSizeUsedGib != 0L) hash ^= HotTierSizeUsedGib.GetHashCode(); if (HasType) hash ^= Type.GetHashCode(); if (HasMode) hash ^= Mode.GetHashCode(); + if (ScaleType != global::Google.Cloud.NetApp.V1.ScaleType.Unspecified) hash ^= ScaleType.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -2838,6 +2859,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(160, 2); output.WriteEnum((int) Mode); } + if (ScaleType != global::Google.Cloud.NetApp.V1.ScaleType.Unspecified) { + output.WriteRawTag(176, 2); + output.WriteEnum((int) ScaleType); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -2977,6 +3002,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(160, 2); output.WriteEnum((int) Mode); } + if (ScaleType != global::Google.Cloud.NetApp.V1.ScaleType.Unspecified) { + output.WriteRawTag(176, 2); + output.WriteEnum((int) ScaleType); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -3084,6 +3113,9 @@ public int CalculateSize() { if (HasMode) { size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) Mode); } + if (ScaleType != global::Google.Cloud.NetApp.V1.ScaleType.Unspecified) { + size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) ScaleType); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -3196,6 +3228,9 @@ public void MergeFrom(StoragePool other) { if (other.HasMode) { Mode = other.Mode; } + if (other.ScaleType != global::Google.Cloud.NetApp.V1.ScaleType.Unspecified) { + ScaleType = other.ScaleType; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -3350,6 +3385,10 @@ public void MergeFrom(pb::CodedInputStream input) { Mode = (global::Google.Cloud.NetApp.V1.Mode) input.ReadEnum(); break; } + case 304: { + ScaleType = (global::Google.Cloud.NetApp.V1.ScaleType) input.ReadEnum(); + break; + } } } #endif @@ -3504,6 +3543,10 @@ public void MergeFrom(pb::CodedInputStream input) { Mode = (global::Google.Cloud.NetApp.V1.Mode) input.ReadEnum(); break; } + case 304: { + ScaleType = (global::Google.Cloud.NetApp.V1.ScaleType) input.ReadEnum(); + break; + } } } } diff --git a/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Volume.g.cs b/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Volume.g.cs index 87734644855c..1f32e40db302 100644 --- a/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Volume.g.cs +++ b/apis/Google.Cloud.NetApp.V1/Google.Cloud.NetApp.V1/Volume.g.cs @@ -47,7 +47,7 @@ static VolumeReflection() { "ZXN0EjIKBG5hbWUYASABKAlCJOBBAvpBHgocbmV0YXBwLmdvb2dsZWFwaXMu", "Y29tL1ZvbHVtZRINCgVmb3JjZRgCIAEoCCJjChNSZXZlcnRWb2x1bWVSZXF1", "ZXN0EjIKBG5hbWUYASABKAlCJOBBAvpBHgocbmV0YXBwLmdvb2dsZWFwaXMu", - "Y29tL1ZvbHVtZRIYCgtzbmFwc2hvdF9pZBgCIAEoCUID4EECItUUCgZWb2x1", + "Y29tL1ZvbHVtZRIYCgtzbmFwc2hvdF9pZBgCIAEoCUID4EECIqYVCgZWb2x1", "bWUSEQoEbmFtZRgBIAEoCUID4EEIEjgKBXN0YXRlGAIgASgOMiQuZ29vZ2xl", "LmNsb3VkLm5ldGFwcC52MS5Wb2x1bWUuU3RhdGVCA+BBAxIaCg1zdGF0ZV9k", "ZXRhaWxzGAMgASgJQgPgQQMSNAoLY3JlYXRlX3RpbWUYBCABKAsyGi5nb29n", @@ -93,160 +93,163 @@ static VolumeReflection() { "IAEoCzInLmdvb2dsZS5jbG91ZC5uZXRhcHAudjEuQ2FjaGVQYXJhbWV0ZXJz", "QgPgQQESIwoWaG90X3RpZXJfc2l6ZV91c2VkX2dpYhgsIAEoA0ID4EEDEj8K", "DWJsb2NrX2RldmljZXMYLSADKAsyIy5nb29nbGUuY2xvdWQubmV0YXBwLnYx", - "LkJsb2NrRGV2aWNlQgPgQQESRwoNY2xvbmVfZGV0YWlscxgvIAEoCzIrLmdv", - "b2dsZS5jbG91ZC5uZXRhcHAudjEuVm9sdW1lLkNsb25lRGV0YWlsc0ID4EED", - "GqsBCgxDbG9uZURldGFpbHMSPwoPc291cmNlX3NuYXBzaG90GAEgASgJQibg", - "QQP6QSAKHm5ldGFwcC5nb29nbGVhcGlzLmNvbS9TbmFwc2hvdBI7Cg1zb3Vy", - "Y2Vfdm9sdW1lGAIgASgJQiTgQQP6QR4KHG5ldGFwcC5nb29nbGVhcGlzLmNv", - "bS9Wb2x1bWUSHQoQc2hhcmVkX3NwYWNlX2dpYhgDIAEoA0ID4EEDGi0KC0xh", - "YmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEimQEK", - "BVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVEEAASCQoFUkVBRFkQARIMCghD", - "UkVBVElORxACEgwKCERFTEVUSU5HEAMSDAoIVVBEQVRJTkcQBBINCglSRVNU", - "T1JJTkcQBRIMCghESVNBQkxFRBAGEgkKBUVSUk9SEAcSDQoJUFJFUEFSSU5H", - "EAgSDQoJUkVBRF9PTkxZEAk6bOpBaQocbmV0YXBwLmdvb2dsZWFwaXMuY29t", - "L1ZvbHVtZRI4cHJvamVjdHMve3Byb2plY3R9L2xvY2F0aW9ucy97bG9jYXRp", - "b259L3ZvbHVtZXMve3ZvbHVtZX0qB3ZvbHVtZXMyBnZvbHVtZUIQCg5fYmFj", - "a3VwX2NvbmZpZ0IRCg9fdGllcmluZ19wb2xpY3kiUgoMRXhwb3J0UG9saWN5", - "EkIKBXJ1bGVzGAEgAygLMi4uZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5TaW1w", - "bGVFeHBvcnRQb2xpY3lSdWxlQgPgQQIi7wYKFlNpbXBsZUV4cG9ydFBvbGlj", - "eVJ1bGUSHAoPYWxsb3dlZF9jbGllbnRzGAEgASgJSACIAQESHAoPaGFzX3Jv", - "b3RfYWNjZXNzGAIgASgJSAGIAQESPAoLYWNjZXNzX3R5cGUYAyABKA4yIi5n", - "b29nbGUuY2xvdWQubmV0YXBwLnYxLkFjY2Vzc1R5cGVIAogBARISCgVuZnN2", - "MxgEIAEoCEgDiAEBEhIKBW5mc3Y0GAUgASgISASIAQESIQoUa2VyYmVyb3Nf", - "NV9yZWFkX29ubHkYBiABKAhIBYgBARIiChVrZXJiZXJvc181X3JlYWRfd3Jp", - "dGUYByABKAhIBogBARIiChVrZXJiZXJvc181aV9yZWFkX29ubHkYCCABKAhI", - "B4gBARIjChZrZXJiZXJvc181aV9yZWFkX3dyaXRlGAkgASgISAiIAQESIgoV", - "a2VyYmVyb3NfNXBfcmVhZF9vbmx5GAogASgISAmIAQESIwoWa2VyYmVyb3Nf", - "NXBfcmVhZF93cml0ZRgLIAEoCEgKiAEBElgKC3NxdWFzaF9tb2RlGAwgASgO", - "MjkuZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5TaW1wbGVFeHBvcnRQb2xpY3lS", - "dWxlLlNxdWFzaE1vZGVCA+BBAUgLiAEBEhoKCGFub25fdWlkGA0gASgDQgPg", - "QQFIDIgBASJeCgpTcXVhc2hNb2RlEhsKF1NRVUFTSF9NT0RFX1VOU1BFQ0lG", - "SUVEEAASEgoOTk9fUk9PVF9TUVVBU0gQARIPCgtST09UX1NRVUFTSBACEg4K", - "CkFMTF9TUVVBU0gQA0ISChBfYWxsb3dlZF9jbGllbnRzQhIKEF9oYXNfcm9v", - "dF9hY2Nlc3NCDgoMX2FjY2Vzc190eXBlQggKBl9uZnN2M0IICgZfbmZzdjRC", - "FwoVX2tlcmJlcm9zXzVfcmVhZF9vbmx5QhgKFl9rZXJiZXJvc181X3JlYWRf", - "d3JpdGVCGAoWX2tlcmJlcm9zXzVpX3JlYWRfb25seUIZChdfa2VyYmVyb3Nf", - "NWlfcmVhZF93cml0ZUIYChZfa2VyYmVyb3NfNXBfcmVhZF9vbmx5QhkKF19r", - "ZXJiZXJvc181cF9yZWFkX3dyaXRlQg4KDF9zcXVhc2hfbW9kZUILCglfYW5v", - "bl91aWQimgMKDlNuYXBzaG90UG9saWN5EhQKB2VuYWJsZWQYASABKAhIAIgB", - "ARJECg9ob3VybHlfc2NoZWR1bGUYAiABKAsyJi5nb29nbGUuY2xvdWQubmV0", - "YXBwLnYxLkhvdXJseVNjaGVkdWxlSAGIAQESQgoOZGFpbHlfc2NoZWR1bGUY", - "AyABKAsyJS5nb29nbGUuY2xvdWQubmV0YXBwLnYxLkRhaWx5U2NoZWR1bGVI", - "AogBARJECg93ZWVrbHlfc2NoZWR1bGUYBCABKAsyJi5nb29nbGUuY2xvdWQu", - "bmV0YXBwLnYxLldlZWtseVNjaGVkdWxlSAOIAQESRgoQbW9udGhseV9zY2hl", - "ZHVsZRgFIAEoCzInLmdvb2dsZS5jbG91ZC5uZXRhcHAudjEuTW9udGhseVNj", - "aGVkdWxlSASIAQFCCgoIX2VuYWJsZWRCEgoQX2hvdXJseV9zY2hlZHVsZUIR", - "Cg9fZGFpbHlfc2NoZWR1bGVCEgoQX3dlZWtseV9zY2hlZHVsZUITChFfbW9u", - "dGhseV9zY2hlZHVsZSJmCg5Ib3VybHlTY2hlZHVsZRIeChFzbmFwc2hvdHNf", - "dG9fa2VlcBgBIAEoAUgAiAEBEhMKBm1pbnV0ZRgCIAEoAUgBiAEBQhQKEl9z", - "bmFwc2hvdHNfdG9fa2VlcEIJCgdfbWludXRlIoEBCg1EYWlseVNjaGVkdWxl", - "Eh4KEXNuYXBzaG90c190b19rZWVwGAEgASgBSACIAQESEwoGbWludXRlGAIg", - "ASgBSAGIAQESEQoEaG91chgDIAEoAUgCiAEBQhQKEl9zbmFwc2hvdHNfdG9f", - "a2VlcEIJCgdfbWludXRlQgcKBV9ob3VyIpwBCg5XZWVrbHlTY2hlZHVsZRIe", - "ChFzbmFwc2hvdHNfdG9fa2VlcBgBIAEoAUgAiAEBEhMKBm1pbnV0ZRgCIAEo", - "AUgBiAEBEhEKBGhvdXIYAyABKAFIAogBARIQCgNkYXkYBCABKAlIA4gBAUIU", - "ChJfc25hcHNob3RzX3RvX2tlZXBCCQoHX21pbnV0ZUIHCgVfaG91ckIGCgRf", - "ZGF5IrEBCg9Nb250aGx5U2NoZWR1bGUSHgoRc25hcHNob3RzX3RvX2tlZXAY", - "ASABKAFIAIgBARITCgZtaW51dGUYAiABKAFIAYgBARIRCgRob3VyGAMgASgB", - "SAKIAQESGgoNZGF5c19vZl9tb250aBgEIAEoCUgDiAEBQhQKEl9zbmFwc2hv", - "dHNfdG9fa2VlcEIJCgdfbWludXRlQgcKBV9ob3VyQhAKDl9kYXlzX29mX21v", - "bnRoIp4BCgtNb3VudE9wdGlvbhIOCgZleHBvcnQYASABKAkSEwoLZXhwb3J0", - "X2Z1bGwYAiABKAkSMwoIcHJvdG9jb2wYAyABKA4yIS5nb29nbGUuY2xvdWQu", - "bmV0YXBwLnYxLlByb3RvY29scxIUCgxpbnN0cnVjdGlvbnMYBCABKAkSHwoK", - "aXBfYWRkcmVzcxgFIAEoCUIL4EED4ozP1wgCCAIidAoRUmVzdG9yZVBhcmFt", - "ZXRlcnMSGQoPc291cmNlX3NuYXBzaG90GAEgASgJSAASOgoNc291cmNlX2Jh", - "Y2t1cBgCIAEoCUIh+kEeChxuZXRhcHAuZ29vZ2xlYXBpcy5jb20vQmFja3Vw", - "SABCCAoGc291cmNlIpoCCgxCYWNrdXBDb25maWcSQwoPYmFja3VwX3BvbGlj", - "aWVzGAEgAygJQirgQQH6QSQKIm5ldGFwcC5nb29nbGVhcGlzLmNvbS9CYWNr", - "dXBQb2xpY3kSPwoMYmFja3VwX3ZhdWx0GAIgASgJQingQQH6QSMKIW5ldGFw", - "cC5nb29nbGVhcGlzLmNvbS9CYWNrdXBWYXVsdBIqChhzY2hlZHVsZWRfYmFj", - "a3VwX2VuYWJsZWQYAyABKAhCA+BBAUgAiAEBEiQKEmJhY2t1cF9jaGFpbl9i", - "eXRlcxgEIAEoA0ID4EEDSAGIAQFCGwoZX3NjaGVkdWxlZF9iYWNrdXBfZW5h", - "YmxlZEIVChNfYmFja3VwX2NoYWluX2J5dGVzIsoCCg1UaWVyaW5nUG9saWN5", - "Ek8KC3RpZXJfYWN0aW9uGAEgASgOMjAuZ29vZ2xlLmNsb3VkLm5ldGFwcC52", - "MS5UaWVyaW5nUG9saWN5LlRpZXJBY3Rpb25CA+BBAUgAiAEBEigKFmNvb2xp", - "bmdfdGhyZXNob2xkX2RheXMYAiABKAVCA+BBAUgBiAEBEi4KHGhvdF90aWVy", - "X2J5cGFzc19tb2RlX2VuYWJsZWQYAyABKAhCA+BBAUgCiAEBIkIKClRpZXJB", - "Y3Rpb24SGwoXVElFUl9BQ1RJT05fVU5TUEVDSUZJRUQQABILCgdFTkFCTEVE", - "EAESCgoGUEFVU0VEEAJCDgoMX3RpZXJfYWN0aW9uQhkKF19jb29saW5nX3Ro", - "cmVzaG9sZF9kYXlzQh8KHV9ob3RfdGllcl9ieXBhc3NfbW9kZV9lbmFibGVk", - "IsMGChtIeWJyaWRSZXBsaWNhdGlvblBhcmFtZXRlcnMSPgoLcmVwbGljYXRp", - "b24YASABKAlCKeBBAvpBIwohbmV0YXBwLmdvb2dsZWFwaXMuY29tL1JlcGxp", - "Y2F0aW9uEh0KEHBlZXJfdm9sdW1lX25hbWUYAiABKAlCA+BBAhIeChFwZWVy", - "X2NsdXN0ZXJfbmFtZRgDIAEoCUID4EECEhoKDXBlZXJfc3ZtX25hbWUYBCAB", - "KAlCA+BBAhIeChFwZWVyX2lwX2FkZHJlc3NlcxgFIAMoCUID4EECEh0KEGNs", - "dXN0ZXJfbG9jYXRpb24YBiABKAlCA+BBARIYCgtkZXNjcmlwdGlvbhgHIAEo", - "CUID4EEBElQKBmxhYmVscxgIIAMoCzI/Lmdvb2dsZS5jbG91ZC5uZXRhcHAu", - "djEuSHlicmlkUmVwbGljYXRpb25QYXJhbWV0ZXJzLkxhYmVsc0VudHJ5QgPg", - "QQESVAoUcmVwbGljYXRpb25fc2NoZWR1bGUYCSABKA4yMS5nb29nbGUuY2xv", - "dWQubmV0YXBwLnYxLkh5YnJpZFJlcGxpY2F0aW9uU2NoZWR1bGVCA+BBARJ1", - "ChdoeWJyaWRfcmVwbGljYXRpb25fdHlwZRgKIAEoDjJPLmdvb2dsZS5jbG91", - "ZC5uZXRhcHAudjEuSHlicmlkUmVwbGljYXRpb25QYXJhbWV0ZXJzLlZvbHVt", - "ZUh5YnJpZFJlcGxpY2F0aW9uVHlwZUID4EEBEisKHmxhcmdlX3ZvbHVtZV9j", - "b25zdGl0dWVudF9jb3VudBgLIAEoBUID4EEBGi0KC0xhYmVsc0VudHJ5EgsK", - "A2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEisAEKG1ZvbHVtZUh5YnJp", - "ZFJlcGxpY2F0aW9uVHlwZRIuCipWT0xVTUVfSFlCUklEX1JFUExJQ0FUSU9O", - "X1RZUEVfVU5TUEVDSUZJRUQQABINCglNSUdSQVRJT04QARIaChZDT05USU5V", - "T1VTX1JFUExJQ0FUSU9OEAISFgoST05QUkVNX1JFUExJQ0FUSU9OEAMSHgoa", - "UkVWRVJTRV9PTlBSRU1fUkVQTElDQVRJT04QBCLqBAoPQ2FjaGVQYXJhbWV0", - "ZXJzEh0KEHBlZXJfdm9sdW1lX25hbWUYASABKAlCA+BBAhIeChFwZWVyX2Ns", - "dXN0ZXJfbmFtZRgCIAEoCUID4EECEhoKDXBlZXJfc3ZtX25hbWUYAyABKAlC", - "A+BBAhIeChFwZWVyX2lwX2FkZHJlc3NlcxgEIAMoCUID4EECEikKF2VuYWJs", - "ZV9nbG9iYWxfZmlsZV9sb2NrGAUgASgIQgPgQQFIAIgBARI+CgxjYWNoZV9j", - "b25maWcYBiABKAsyIy5nb29nbGUuY2xvdWQubmV0YXBwLnYxLkNhY2hlQ29u", - "ZmlnQgPgQQESTAoLY2FjaGVfc3RhdGUYByABKA4yMi5nb29nbGUuY2xvdWQu", - "bmV0YXBwLnYxLkNhY2hlUGFyYW1ldGVycy5DYWNoZVN0YXRlQgPgQQMSFAoH", - "Y29tbWFuZBgIIAEoCUID4EEDEkQKG3BlZXJpbmdfY29tbWFuZF9leHBpcnlf", - "dGltZRgJIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBARIX", - "CgpwYXNzcGhyYXNlGAogASgJQgPgQQMSGgoNc3RhdGVfZGV0YWlscxgMIAEo", - "CUID4EEDInYKCkNhY2hlU3RhdGUSGwoXQ0FDSEVfU1RBVEVfVU5TUEVDSUZJ", - "RUQQABIbChdQRU5ESU5HX0NMVVNURVJfUEVFUklORxABEhcKE1BFTkRJTkdf", - "U1ZNX1BFRVJJTkcQAhIKCgZQRUVSRUQQAxIJCgVFUlJPUhAEQhoKGF9lbmFi", - "bGVfZ2xvYmFsX2ZpbGVfbG9jayK/AwoLQ2FjaGVDb25maWcSSQoSY2FjaGVf", - "cHJlX3BvcHVsYXRlGAEgASgLMiguZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5D", - "YWNoZVByZVBvcHVsYXRlQgPgQQESIwoRd3JpdGViYWNrX2VuYWJsZWQYAiAB", - "KAhCA+BBAUgAiAEBEiwKGmNpZnNfY2hhbmdlX25vdGlmeV9lbmFibGVkGAUg", - "ASgIQgPgQQFIAYgBARJgChhjYWNoZV9wcmVfcG9wdWxhdGVfc3RhdGUYBiAB", - "KA4yOS5nb29nbGUuY2xvdWQubmV0YXBwLnYxLkNhY2hlQ29uZmlnLkNhY2hl", - "UHJlUG9wdWxhdGVTdGF0ZUID4EEDInsKFUNhY2hlUHJlUG9wdWxhdGVTdGF0", - "ZRIoCiRDQUNIRV9QUkVfUE9QVUxBVEVfU1RBVEVfVU5TUEVDSUZJRUQQABIO", - "CgpOT1RfTkVFREVEEAESDwoLSU5fUFJPR1JFU1MQAhIMCghDT01QTEVURRAD", - "EgkKBUVSUk9SEARCFAoSX3dyaXRlYmFja19lbmFibGVkQh0KG19jaWZzX2No", - "YW5nZV9ub3RpZnlfZW5hYmxlZCJ1ChBDYWNoZVByZVBvcHVsYXRlEhYKCXBh", - "dGhfbGlzdBgBIAMoCUID4EEBEh4KEWV4Y2x1ZGVfcGF0aF9saXN0GAIgAygJ", - "QgPgQQESGwoJcmVjdXJzaW9uGAMgASgIQgPgQQFIAIgBAUIMCgpfcmVjdXJz", - "aW9uIucBCgtCbG9ja0RldmljZRIWCgRuYW1lGAEgASgJQgPgQQFIAIgBARI8", - "Cgtob3N0X2dyb3VwcxgCIAMoCUIn4EEB+kEhCh9uZXRhcHAuZ29vZ2xlYXBp", - "cy5jb20vSG9zdEdyb3VwEhcKCmlkZW50aWZpZXIYAyABKAlCA+BBAxIaCghz", - "aXplX2dpYhgEIAEoA0ID4EEBSAGIAQESNwoHb3NfdHlwZRgFIAEoDjIeLmdv", - "b2dsZS5jbG91ZC5uZXRhcHAudjEuT3NUeXBlQgbgQQLgQQVCBwoFX25hbWVC", - "CwoJX3NpemVfZ2liIsQBChlSZXN0b3JlQmFja3VwRmlsZXNSZXF1ZXN0EjIK", - "BG5hbWUYASABKAlCJOBBAvpBHgocbmV0YXBwLmdvb2dsZWFwaXMuY29tL1Zv", - "bHVtZRI0CgZiYWNrdXAYAiABKAlCJOBBAvpBHgocbmV0YXBwLmdvb2dsZWFw", - "aXMuY29tL0JhY2t1cBIWCglmaWxlX2xpc3QYAyADKAlCA+BBAhIlChhyZXN0", - "b3JlX2Rlc3RpbmF0aW9uX3BhdGgYBCABKAlCA+BBASIcChpSZXN0b3JlQmFj", - "a3VwRmlsZXNSZXNwb25zZSLOAQodRXN0YWJsaXNoVm9sdW1lUGVlcmluZ1Jl", - "cXVlc3QSMgoEbmFtZRgBIAEoCUIk4EEC+kEeChxuZXRhcHAuZ29vZ2xlYXBp", - "cy5jb20vVm9sdW1lEh4KEXBlZXJfY2x1c3Rlcl9uYW1lGAIgASgJQgPgQQIS", - "GgoNcGVlcl9zdm1fbmFtZRgDIAEoCUID4EECEh4KEXBlZXJfaXBfYWRkcmVz", - "c2VzGAQgAygJQgPgQQESHQoQcGVlcl92b2x1bWVfbmFtZRgFIAEoCUID4EEC", - "KlAKCVByb3RvY29scxIZChVQUk9UT0NPTFNfVU5TUEVDSUZJRUQQABIJCgVO", - "RlNWMxABEgkKBU5GU1Y0EAISBwoDU01CEAMSCQoFSVNDU0kQBCpXCgpBY2Nl", - "c3NUeXBlEhsKF0FDQ0VTU19UWVBFX1VOU1BFQ0lGSUVEEAASDQoJUkVBRF9P", - "TkxZEAESDgoKUkVBRF9XUklURRACEg0KCVJFQURfTk9ORRADKugBCgtTTUJT", - "ZXR0aW5ncxIcChhTTUJfU0VUVElOR1NfVU5TUEVDSUZJRUQQABIQCgxFTkNS", - "WVBUX0RBVEEQARINCglCUk9XU0FCTEUQAhIRCg1DSEFOR0VfTk9USUZZEAMS", - "EQoNTk9OX0JST1dTQUJMRRAEEgsKB09QTE9DS1MQBRIRCg1TSE9XX1NOQVBT", - "SE9UEAYSGgoWU0hPV19QUkVWSU9VU19WRVJTSU9OUxAHEhwKGEFDQ0VTU19C", - "QVNFRF9FTlVNRVJBVElPThAIEhoKFkNPTlRJTlVPVVNMWV9BVkFJTEFCTEUQ", - "CSpDCg1TZWN1cml0eVN0eWxlEh4KGlNFQ1VSSVRZX1NUWUxFX1VOU1BFQ0lG", - "SUVEEAASCAoETlRGUxABEggKBFVOSVgQAipBChBSZXN0cmljdGVkQWN0aW9u", - "EiEKHVJFU1RSSUNURURfQUNUSU9OX1VOU1BFQ0lGSUVEEAASCgoGREVMRVRF", - "EAFCrQEKGmNvbS5nb29nbGUuY2xvdWQubmV0YXBwLnYxQgtWb2x1bWVQcm90", - "b1ABWjJjbG91ZC5nb29nbGUuY29tL2dvL25ldGFwcC9hcGl2MS9uZXRhcHBw", - "YjtuZXRhcHBwYqoCFkdvb2dsZS5DbG91ZC5OZXRBcHAuVjHKAhZHb29nbGVc", - "Q2xvdWRcTmV0QXBwXFYx6gIZR29vZ2xlOjpDbG91ZDo6TmV0QXBwOjpWMWIG", - "cHJvdG8z")); + "LkJsb2NrRGV2aWNlQgPgQQESTwoVbGFyZ2VfY2FwYWNpdHlfY29uZmlnGC4g", + "ASgLMisuZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5MYXJnZUNhcGFjaXR5Q29u", + "ZmlnQgPgQQESRwoNY2xvbmVfZGV0YWlscxgvIAEoCzIrLmdvb2dsZS5jbG91", + "ZC5uZXRhcHAudjEuVm9sdW1lLkNsb25lRGV0YWlsc0ID4EEDGqsBCgxDbG9u", + "ZURldGFpbHMSPwoPc291cmNlX3NuYXBzaG90GAEgASgJQibgQQP6QSAKHm5l", + "dGFwcC5nb29nbGVhcGlzLmNvbS9TbmFwc2hvdBI7Cg1zb3VyY2Vfdm9sdW1l", + "GAIgASgJQiTgQQP6QR4KHG5ldGFwcC5nb29nbGVhcGlzLmNvbS9Wb2x1bWUS", + "HQoQc2hhcmVkX3NwYWNlX2dpYhgDIAEoA0ID4EEDGi0KC0xhYmVsc0VudHJ5", + "EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEimQEKBVN0YXRlEhUK", + "EVNUQVRFX1VOU1BFQ0lGSUVEEAASCQoFUkVBRFkQARIMCghDUkVBVElORxAC", + "EgwKCERFTEVUSU5HEAMSDAoIVVBEQVRJTkcQBBINCglSRVNUT1JJTkcQBRIM", + "CghESVNBQkxFRBAGEgkKBUVSUk9SEAcSDQoJUFJFUEFSSU5HEAgSDQoJUkVB", + "RF9PTkxZEAk6bOpBaQocbmV0YXBwLmdvb2dsZWFwaXMuY29tL1ZvbHVtZRI4", + "cHJvamVjdHMve3Byb2plY3R9L2xvY2F0aW9ucy97bG9jYXRpb259L3ZvbHVt", + "ZXMve3ZvbHVtZX0qB3ZvbHVtZXMyBnZvbHVtZUIQCg5fYmFja3VwX2NvbmZp", + "Z0IRCg9fdGllcmluZ19wb2xpY3kiNQoTTGFyZ2VDYXBhY2l0eUNvbmZpZxIe", + "ChFjb25zdGl0dWVudF9jb3VudBgBIAEoBUID4EEBIlIKDEV4cG9ydFBvbGlj", + "eRJCCgVydWxlcxgBIAMoCzIuLmdvb2dsZS5jbG91ZC5uZXRhcHAudjEuU2lt", + "cGxlRXhwb3J0UG9saWN5UnVsZUID4EECIu8GChZTaW1wbGVFeHBvcnRQb2xp", + "Y3lSdWxlEhwKD2FsbG93ZWRfY2xpZW50cxgBIAEoCUgAiAEBEhwKD2hhc19y", + "b290X2FjY2VzcxgCIAEoCUgBiAEBEjwKC2FjY2Vzc190eXBlGAMgASgOMiIu", + "Z29vZ2xlLmNsb3VkLm5ldGFwcC52MS5BY2Nlc3NUeXBlSAKIAQESEgoFbmZz", + "djMYBCABKAhIA4gBARISCgVuZnN2NBgFIAEoCEgEiAEBEiEKFGtlcmJlcm9z", + "XzVfcmVhZF9vbmx5GAYgASgISAWIAQESIgoVa2VyYmVyb3NfNV9yZWFkX3dy", + "aXRlGAcgASgISAaIAQESIgoVa2VyYmVyb3NfNWlfcmVhZF9vbmx5GAggASgI", + "SAeIAQESIwoWa2VyYmVyb3NfNWlfcmVhZF93cml0ZRgJIAEoCEgIiAEBEiIK", + "FWtlcmJlcm9zXzVwX3JlYWRfb25seRgKIAEoCEgJiAEBEiMKFmtlcmJlcm9z", + "XzVwX3JlYWRfd3JpdGUYCyABKAhICogBARJYCgtzcXVhc2hfbW9kZRgMIAEo", + "DjI5Lmdvb2dsZS5jbG91ZC5uZXRhcHAudjEuU2ltcGxlRXhwb3J0UG9saWN5", + "UnVsZS5TcXVhc2hNb2RlQgPgQQFIC4gBARIaCghhbm9uX3VpZBgNIAEoA0ID", + "4EEBSAyIAQEiXgoKU3F1YXNoTW9kZRIbChdTUVVBU0hfTU9ERV9VTlNQRUNJ", + "RklFRBAAEhIKDk5PX1JPT1RfU1FVQVNIEAESDwoLUk9PVF9TUVVBU0gQAhIO", + "CgpBTExfU1FVQVNIEANCEgoQX2FsbG93ZWRfY2xpZW50c0ISChBfaGFzX3Jv", + "b3RfYWNjZXNzQg4KDF9hY2Nlc3NfdHlwZUIICgZfbmZzdjNCCAoGX25mc3Y0", + "QhcKFV9rZXJiZXJvc181X3JlYWRfb25seUIYChZfa2VyYmVyb3NfNV9yZWFk", + "X3dyaXRlQhgKFl9rZXJiZXJvc181aV9yZWFkX29ubHlCGQoXX2tlcmJlcm9z", + "XzVpX3JlYWRfd3JpdGVCGAoWX2tlcmJlcm9zXzVwX3JlYWRfb25seUIZChdf", + "a2VyYmVyb3NfNXBfcmVhZF93cml0ZUIOCgxfc3F1YXNoX21vZGVCCwoJX2Fu", + "b25fdWlkIpoDCg5TbmFwc2hvdFBvbGljeRIUCgdlbmFibGVkGAEgASgISACI", + "AQESRAoPaG91cmx5X3NjaGVkdWxlGAIgASgLMiYuZ29vZ2xlLmNsb3VkLm5l", + "dGFwcC52MS5Ib3VybHlTY2hlZHVsZUgBiAEBEkIKDmRhaWx5X3NjaGVkdWxl", + "GAMgASgLMiUuZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5EYWlseVNjaGVkdWxl", + "SAKIAQESRAoPd2Vla2x5X3NjaGVkdWxlGAQgASgLMiYuZ29vZ2xlLmNsb3Vk", + "Lm5ldGFwcC52MS5XZWVrbHlTY2hlZHVsZUgDiAEBEkYKEG1vbnRobHlfc2No", + "ZWR1bGUYBSABKAsyJy5nb29nbGUuY2xvdWQubmV0YXBwLnYxLk1vbnRobHlT", + "Y2hlZHVsZUgEiAEBQgoKCF9lbmFibGVkQhIKEF9ob3VybHlfc2NoZWR1bGVC", + "EQoPX2RhaWx5X3NjaGVkdWxlQhIKEF93ZWVrbHlfc2NoZWR1bGVCEwoRX21v", + "bnRobHlfc2NoZWR1bGUiZgoOSG91cmx5U2NoZWR1bGUSHgoRc25hcHNob3Rz", + "X3RvX2tlZXAYASABKAFIAIgBARITCgZtaW51dGUYAiABKAFIAYgBAUIUChJf", + "c25hcHNob3RzX3RvX2tlZXBCCQoHX21pbnV0ZSKBAQoNRGFpbHlTY2hlZHVs", + "ZRIeChFzbmFwc2hvdHNfdG9fa2VlcBgBIAEoAUgAiAEBEhMKBm1pbnV0ZRgC", + "IAEoAUgBiAEBEhEKBGhvdXIYAyABKAFIAogBAUIUChJfc25hcHNob3RzX3Rv", + "X2tlZXBCCQoHX21pbnV0ZUIHCgVfaG91ciKcAQoOV2Vla2x5U2NoZWR1bGUS", + "HgoRc25hcHNob3RzX3RvX2tlZXAYASABKAFIAIgBARITCgZtaW51dGUYAiAB", + "KAFIAYgBARIRCgRob3VyGAMgASgBSAKIAQESEAoDZGF5GAQgASgJSAOIAQFC", + "FAoSX3NuYXBzaG90c190b19rZWVwQgkKB19taW51dGVCBwoFX2hvdXJCBgoE", + "X2RheSKxAQoPTW9udGhseVNjaGVkdWxlEh4KEXNuYXBzaG90c190b19rZWVw", + "GAEgASgBSACIAQESEwoGbWludXRlGAIgASgBSAGIAQESEQoEaG91chgDIAEo", + "AUgCiAEBEhoKDWRheXNfb2ZfbW9udGgYBCABKAlIA4gBAUIUChJfc25hcHNo", + "b3RzX3RvX2tlZXBCCQoHX21pbnV0ZUIHCgVfaG91ckIQCg5fZGF5c19vZl9t", + "b250aCKeAQoLTW91bnRPcHRpb24SDgoGZXhwb3J0GAEgASgJEhMKC2V4cG9y", + "dF9mdWxsGAIgASgJEjMKCHByb3RvY29sGAMgASgOMiEuZ29vZ2xlLmNsb3Vk", + "Lm5ldGFwcC52MS5Qcm90b2NvbHMSFAoMaW5zdHJ1Y3Rpb25zGAQgASgJEh8K", + "CmlwX2FkZHJlc3MYBSABKAlCC+BBA+KMz9cIAggCInQKEVJlc3RvcmVQYXJh", + "bWV0ZXJzEhkKD3NvdXJjZV9zbmFwc2hvdBgBIAEoCUgAEjoKDXNvdXJjZV9i", + "YWNrdXAYAiABKAlCIfpBHgocbmV0YXBwLmdvb2dsZWFwaXMuY29tL0JhY2t1", + "cEgAQggKBnNvdXJjZSKaAgoMQmFja3VwQ29uZmlnEkMKD2JhY2t1cF9wb2xp", + "Y2llcxgBIAMoCUIq4EEB+kEkCiJuZXRhcHAuZ29vZ2xlYXBpcy5jb20vQmFj", + "a3VwUG9saWN5Ej8KDGJhY2t1cF92YXVsdBgCIAEoCUIp4EEB+kEjCiFuZXRh", + "cHAuZ29vZ2xlYXBpcy5jb20vQmFja3VwVmF1bHQSKgoYc2NoZWR1bGVkX2Jh", + "Y2t1cF9lbmFibGVkGAMgASgIQgPgQQFIAIgBARIkChJiYWNrdXBfY2hhaW5f", + "Ynl0ZXMYBCABKANCA+BBA0gBiAEBQhsKGV9zY2hlZHVsZWRfYmFja3VwX2Vu", + "YWJsZWRCFQoTX2JhY2t1cF9jaGFpbl9ieXRlcyLKAgoNVGllcmluZ1BvbGlj", + "eRJPCgt0aWVyX2FjdGlvbhgBIAEoDjIwLmdvb2dsZS5jbG91ZC5uZXRhcHAu", + "djEuVGllcmluZ1BvbGljeS5UaWVyQWN0aW9uQgPgQQFIAIgBARIoChZjb29s", + "aW5nX3RocmVzaG9sZF9kYXlzGAIgASgFQgPgQQFIAYgBARIuChxob3RfdGll", + "cl9ieXBhc3NfbW9kZV9lbmFibGVkGAMgASgIQgPgQQFIAogBASJCCgpUaWVy", + "QWN0aW9uEhsKF1RJRVJfQUNUSU9OX1VOU1BFQ0lGSUVEEAASCwoHRU5BQkxF", + "RBABEgoKBlBBVVNFRBACQg4KDF90aWVyX2FjdGlvbkIZChdfY29vbGluZ190", + "aHJlc2hvbGRfZGF5c0IfCh1faG90X3RpZXJfYnlwYXNzX21vZGVfZW5hYmxl", + "ZCLDBgobSHlicmlkUmVwbGljYXRpb25QYXJhbWV0ZXJzEj4KC3JlcGxpY2F0", + "aW9uGAEgASgJQingQQL6QSMKIW5ldGFwcC5nb29nbGVhcGlzLmNvbS9SZXBs", + "aWNhdGlvbhIdChBwZWVyX3ZvbHVtZV9uYW1lGAIgASgJQgPgQQISHgoRcGVl", + "cl9jbHVzdGVyX25hbWUYAyABKAlCA+BBAhIaCg1wZWVyX3N2bV9uYW1lGAQg", + "ASgJQgPgQQISHgoRcGVlcl9pcF9hZGRyZXNzZXMYBSADKAlCA+BBAhIdChBj", + "bHVzdGVyX2xvY2F0aW9uGAYgASgJQgPgQQESGAoLZGVzY3JpcHRpb24YByAB", + "KAlCA+BBARJUCgZsYWJlbHMYCCADKAsyPy5nb29nbGUuY2xvdWQubmV0YXBw", + "LnYxLkh5YnJpZFJlcGxpY2F0aW9uUGFyYW1ldGVycy5MYWJlbHNFbnRyeUID", + "4EEBElQKFHJlcGxpY2F0aW9uX3NjaGVkdWxlGAkgASgOMjEuZ29vZ2xlLmNs", + "b3VkLm5ldGFwcC52MS5IeWJyaWRSZXBsaWNhdGlvblNjaGVkdWxlQgPgQQES", + "dQoXaHlicmlkX3JlcGxpY2F0aW9uX3R5cGUYCiABKA4yTy5nb29nbGUuY2xv", + "dWQubmV0YXBwLnYxLkh5YnJpZFJlcGxpY2F0aW9uUGFyYW1ldGVycy5Wb2x1", + "bWVIeWJyaWRSZXBsaWNhdGlvblR5cGVCA+BBARIrCh5sYXJnZV92b2x1bWVf", + "Y29uc3RpdHVlbnRfY291bnQYCyABKAVCA+BBARotCgtMYWJlbHNFbnRyeRIL", + "CgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBIrABChtWb2x1bWVIeWJy", + "aWRSZXBsaWNhdGlvblR5cGUSLgoqVk9MVU1FX0hZQlJJRF9SRVBMSUNBVElP", + "Tl9UWVBFX1VOU1BFQ0lGSUVEEAASDQoJTUlHUkFUSU9OEAESGgoWQ09OVElO", + "VU9VU19SRVBMSUNBVElPThACEhYKEk9OUFJFTV9SRVBMSUNBVElPThADEh4K", + "GlJFVkVSU0VfT05QUkVNX1JFUExJQ0FUSU9OEAQi6gQKD0NhY2hlUGFyYW1l", + "dGVycxIdChBwZWVyX3ZvbHVtZV9uYW1lGAEgASgJQgPgQQISHgoRcGVlcl9j", + "bHVzdGVyX25hbWUYAiABKAlCA+BBAhIaCg1wZWVyX3N2bV9uYW1lGAMgASgJ", + "QgPgQQISHgoRcGVlcl9pcF9hZGRyZXNzZXMYBCADKAlCA+BBAhIpChdlbmFi", + "bGVfZ2xvYmFsX2ZpbGVfbG9jaxgFIAEoCEID4EEBSACIAQESPgoMY2FjaGVf", + "Y29uZmlnGAYgASgLMiMuZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5DYWNoZUNv", + "bmZpZ0ID4EEBEkwKC2NhY2hlX3N0YXRlGAcgASgOMjIuZ29vZ2xlLmNsb3Vk", + "Lm5ldGFwcC52MS5DYWNoZVBhcmFtZXRlcnMuQ2FjaGVTdGF0ZUID4EEDEhQK", + "B2NvbW1hbmQYCCABKAlCA+BBAxJEChtwZWVyaW5nX2NvbW1hbmRfZXhwaXJ5", + "X3RpbWUYCSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQES", + "FwoKcGFzc3BocmFzZRgKIAEoCUID4EEDEhoKDXN0YXRlX2RldGFpbHMYDCAB", + "KAlCA+BBAyJ2CgpDYWNoZVN0YXRlEhsKF0NBQ0hFX1NUQVRFX1VOU1BFQ0lG", + "SUVEEAASGwoXUEVORElOR19DTFVTVEVSX1BFRVJJTkcQARIXChNQRU5ESU5H", + "X1NWTV9QRUVSSU5HEAISCgoGUEVFUkVEEAMSCQoFRVJST1IQBEIaChhfZW5h", + "YmxlX2dsb2JhbF9maWxlX2xvY2sivwMKC0NhY2hlQ29uZmlnEkkKEmNhY2hl", + "X3ByZV9wb3B1bGF0ZRgBIAEoCzIoLmdvb2dsZS5jbG91ZC5uZXRhcHAudjEu", + "Q2FjaGVQcmVQb3B1bGF0ZUID4EEBEiMKEXdyaXRlYmFja19lbmFibGVkGAIg", + "ASgIQgPgQQFIAIgBARIsChpjaWZzX2NoYW5nZV9ub3RpZnlfZW5hYmxlZBgF", + "IAEoCEID4EEBSAGIAQESYAoYY2FjaGVfcHJlX3BvcHVsYXRlX3N0YXRlGAYg", + "ASgOMjkuZ29vZ2xlLmNsb3VkLm5ldGFwcC52MS5DYWNoZUNvbmZpZy5DYWNo", + "ZVByZVBvcHVsYXRlU3RhdGVCA+BBAyJ7ChVDYWNoZVByZVBvcHVsYXRlU3Rh", + "dGUSKAokQ0FDSEVfUFJFX1BPUFVMQVRFX1NUQVRFX1VOU1BFQ0lGSUVEEAAS", + "DgoKTk9UX05FRURFRBABEg8KC0lOX1BST0dSRVNTEAISDAoIQ09NUExFVEUQ", + "AxIJCgVFUlJPUhAEQhQKEl93cml0ZWJhY2tfZW5hYmxlZEIdChtfY2lmc19j", + "aGFuZ2Vfbm90aWZ5X2VuYWJsZWQidQoQQ2FjaGVQcmVQb3B1bGF0ZRIWCglw", + "YXRoX2xpc3QYASADKAlCA+BBARIeChFleGNsdWRlX3BhdGhfbGlzdBgCIAMo", + "CUID4EEBEhsKCXJlY3Vyc2lvbhgDIAEoCEID4EEBSACIAQFCDAoKX3JlY3Vy", + "c2lvbiLnAQoLQmxvY2tEZXZpY2USFgoEbmFtZRgBIAEoCUID4EEBSACIAQES", + "PAoLaG9zdF9ncm91cHMYAiADKAlCJ+BBAfpBIQofbmV0YXBwLmdvb2dsZWFw", + "aXMuY29tL0hvc3RHcm91cBIXCgppZGVudGlmaWVyGAMgASgJQgPgQQMSGgoI", + "c2l6ZV9naWIYBCABKANCA+BBAUgBiAEBEjcKB29zX3R5cGUYBSABKA4yHi5n", + "b29nbGUuY2xvdWQubmV0YXBwLnYxLk9zVHlwZUIG4EEC4EEFQgcKBV9uYW1l", + "QgsKCV9zaXplX2dpYiLEAQoZUmVzdG9yZUJhY2t1cEZpbGVzUmVxdWVzdBIy", + "CgRuYW1lGAEgASgJQiTgQQL6QR4KHG5ldGFwcC5nb29nbGVhcGlzLmNvbS9W", + "b2x1bWUSNAoGYmFja3VwGAIgASgJQiTgQQL6QR4KHG5ldGFwcC5nb29nbGVh", + "cGlzLmNvbS9CYWNrdXASFgoJZmlsZV9saXN0GAMgAygJQgPgQQISJQoYcmVz", + "dG9yZV9kZXN0aW5hdGlvbl9wYXRoGAQgASgJQgPgQQEiHAoaUmVzdG9yZUJh", + "Y2t1cEZpbGVzUmVzcG9uc2UizgEKHUVzdGFibGlzaFZvbHVtZVBlZXJpbmdS", + "ZXF1ZXN0EjIKBG5hbWUYASABKAlCJOBBAvpBHgocbmV0YXBwLmdvb2dsZWFw", + "aXMuY29tL1ZvbHVtZRIeChFwZWVyX2NsdXN0ZXJfbmFtZRgCIAEoCUID4EEC", + "EhoKDXBlZXJfc3ZtX25hbWUYAyABKAlCA+BBAhIeChFwZWVyX2lwX2FkZHJl", + "c3NlcxgEIAMoCUID4EEBEh0KEHBlZXJfdm9sdW1lX25hbWUYBSABKAlCA+BB", + "AipQCglQcm90b2NvbHMSGQoVUFJPVE9DT0xTX1VOU1BFQ0lGSUVEEAASCQoF", + "TkZTVjMQARIJCgVORlNWNBACEgcKA1NNQhADEgkKBUlTQ1NJEAQqVwoKQWNj", + "ZXNzVHlwZRIbChdBQ0NFU1NfVFlQRV9VTlNQRUNJRklFRBAAEg0KCVJFQURf", + "T05MWRABEg4KClJFQURfV1JJVEUQAhINCglSRUFEX05PTkUQAyroAQoLU01C", + "U2V0dGluZ3MSHAoYU01CX1NFVFRJTkdTX1VOU1BFQ0lGSUVEEAASEAoMRU5D", + "UllQVF9EQVRBEAESDQoJQlJPV1NBQkxFEAISEQoNQ0hBTkdFX05PVElGWRAD", + "EhEKDU5PTl9CUk9XU0FCTEUQBBILCgdPUExPQ0tTEAUSEQoNU0hPV19TTkFQ", + "U0hPVBAGEhoKFlNIT1dfUFJFVklPVVNfVkVSU0lPTlMQBxIcChhBQ0NFU1Nf", + "QkFTRURfRU5VTUVSQVRJT04QCBIaChZDT05USU5VT1VTTFlfQVZBSUxBQkxF", + "EAkqQwoNU2VjdXJpdHlTdHlsZRIeChpTRUNVUklUWV9TVFlMRV9VTlNQRUNJ", + "RklFRBAAEggKBE5URlMQARIICgRVTklYEAIqQQoQUmVzdHJpY3RlZEFjdGlv", + "bhIhCh1SRVNUUklDVEVEX0FDVElPTl9VTlNQRUNJRklFRBAAEgoKBkRFTEVU", + "RRABQq0BChpjb20uZ29vZ2xlLmNsb3VkLm5ldGFwcC52MUILVm9sdW1lUHJv", + "dG9QAVoyY2xvdWQuZ29vZ2xlLmNvbS9nby9uZXRhcHAvYXBpdjEvbmV0YXBw", + "cGI7bmV0YXBwcGKqAhZHb29nbGUuQ2xvdWQuTmV0QXBwLlYxygIWR29vZ2xl", + "XENsb3VkXE5ldEFwcFxWMeoCGUdvb2dsZTo6Q2xvdWQ6Ok5ldEFwcDo6VjFi", + "BnByb3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.FieldInfoReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.NetApp.V1.CommonReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.NetApp.V1.Protocols), typeof(global::Google.Cloud.NetApp.V1.AccessType), typeof(global::Google.Cloud.NetApp.V1.SMBSettings), typeof(global::Google.Cloud.NetApp.V1.SecurityStyle), typeof(global::Google.Cloud.NetApp.V1.RestrictedAction), }, null, new pbr::GeneratedClrTypeInfo[] { @@ -257,8 +260,9 @@ static VolumeReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.UpdateVolumeRequest), global::Google.Cloud.NetApp.V1.UpdateVolumeRequest.Parser, new[]{ "UpdateMask", "Volume" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.DeleteVolumeRequest), global::Google.Cloud.NetApp.V1.DeleteVolumeRequest.Parser, new[]{ "Name", "Force" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.RevertVolumeRequest), global::Google.Cloud.NetApp.V1.RevertVolumeRequest.Parser, new[]{ "Name", "SnapshotId" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.Volume), global::Google.Cloud.NetApp.V1.Volume.Parser, new[]{ "Name", "State", "StateDetails", "CreateTime", "ShareName", "PsaRange", "StoragePool", "Network", "ServiceLevel", "CapacityGib", "ExportPolicy", "Protocols", "SmbSettings", "MountOptions", "UnixPermissions", "Labels", "Description", "SnapshotPolicy", "SnapReserve", "SnapshotDirectory", "UsedGib", "SecurityStyle", "KerberosEnabled", "LdapEnabled", "ActiveDirectory", "RestoreParameters", "KmsConfig", "EncryptionType", "HasReplication", "BackupConfig", "RestrictedActions", "LargeCapacity", "MultipleEndpoints", "TieringPolicy", "ReplicaZone", "Zone", "ColdTierSizeGib", "HybridReplicationParameters", "ThroughputMibps", "CacheParameters", "HotTierSizeUsedGib", "BlockDevices", "CloneDetails" }, new[]{ "BackupConfig", "TieringPolicy" }, new[]{ typeof(global::Google.Cloud.NetApp.V1.Volume.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails), global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails.Parser, new[]{ "SourceSnapshot", "SourceVolume", "SharedSpaceGib" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.Volume), global::Google.Cloud.NetApp.V1.Volume.Parser, new[]{ "Name", "State", "StateDetails", "CreateTime", "ShareName", "PsaRange", "StoragePool", "Network", "ServiceLevel", "CapacityGib", "ExportPolicy", "Protocols", "SmbSettings", "MountOptions", "UnixPermissions", "Labels", "Description", "SnapshotPolicy", "SnapReserve", "SnapshotDirectory", "UsedGib", "SecurityStyle", "KerberosEnabled", "LdapEnabled", "ActiveDirectory", "RestoreParameters", "KmsConfig", "EncryptionType", "HasReplication", "BackupConfig", "RestrictedActions", "LargeCapacity", "MultipleEndpoints", "TieringPolicy", "ReplicaZone", "Zone", "ColdTierSizeGib", "HybridReplicationParameters", "ThroughputMibps", "CacheParameters", "HotTierSizeUsedGib", "BlockDevices", "LargeCapacityConfig", "CloneDetails" }, new[]{ "BackupConfig", "TieringPolicy" }, new[]{ typeof(global::Google.Cloud.NetApp.V1.Volume.Types.State) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails), global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails.Parser, new[]{ "SourceSnapshot", "SourceVolume", "SharedSpaceGib" }, null, null, null, null), null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.LargeCapacityConfig), global::Google.Cloud.NetApp.V1.LargeCapacityConfig.Parser, new[]{ "ConstituentCount" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.ExportPolicy), global::Google.Cloud.NetApp.V1.ExportPolicy.Parser, new[]{ "Rules" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.SimpleExportPolicyRule), global::Google.Cloud.NetApp.V1.SimpleExportPolicyRule.Parser, new[]{ "AllowedClients", "HasRootAccess", "AccessType", "Nfsv3", "Nfsv4", "Kerberos5ReadOnly", "Kerberos5ReadWrite", "Kerberos5IReadOnly", "Kerberos5IReadWrite", "Kerberos5PReadOnly", "Kerberos5PReadWrite", "SquashMode", "AnonUid" }, new[]{ "AllowedClients", "HasRootAccess", "AccessType", "Nfsv3", "Nfsv4", "Kerberos5ReadOnly", "Kerberos5ReadWrite", "Kerberos5IReadOnly", "Kerberos5IReadWrite", "Kerberos5PReadOnly", "Kerberos5PReadWrite", "SquashMode", "AnonUid" }, new[]{ typeof(global::Google.Cloud.NetApp.V1.SimpleExportPolicyRule.Types.SquashMode) }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.NetApp.V1.SnapshotPolicy), global::Google.Cloud.NetApp.V1.SnapshotPolicy.Parser, new[]{ "Enabled", "HourlySchedule", "DailySchedule", "WeeklySchedule", "MonthlySchedule" }, new[]{ "Enabled", "HourlySchedule", "DailySchedule", "WeeklySchedule", "MonthlySchedule" }, null, null, null), @@ -2380,6 +2384,7 @@ public Volume(Volume other) : this() { cacheParameters_ = other.cacheParameters_ != null ? other.cacheParameters_.Clone() : null; hotTierSizeUsedGib_ = other.hotTierSizeUsedGib_; blockDevices_ = other.blockDevices_.Clone(); + largeCapacityConfig_ = other.largeCapacityConfig_ != null ? other.largeCapacityConfig_.Clone() : null; cloneDetails_ = other.cloneDetails_ != null ? other.cloneDetails_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -2864,7 +2869,9 @@ public bool HasReplication { private bool largeCapacity_; /// /// Optional. Flag indicating if the volume will be a large capacity volume or - /// a regular volume. + /// a regular volume. This field is used for legacy FILE pools. For Unified + /// pools, use the `large_capacity_config` field instead. This field and + /// `large_capacity_config` are mutually exclusive. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -3029,6 +3036,25 @@ public long HotTierSizeUsedGib { get { return blockDevices_; } } + /// Field number for the "large_capacity_config" field. + public const int LargeCapacityConfigFieldNumber = 46; + private global::Google.Cloud.NetApp.V1.LargeCapacityConfig largeCapacityConfig_; + /// + /// Optional. Large capacity config for the volume. + /// Enables and configures large capacity for volumes in Unified pools with + /// File protocols. Not applicable for Block protocols in Unified pools. + /// This field and the legacy `large_capacity` boolean field + /// are mutually exclusive. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.NetApp.V1.LargeCapacityConfig LargeCapacityConfig { + get { return largeCapacityConfig_; } + set { + largeCapacityConfig_ = value; + } + } + /// Field number for the "clone_details" field. public const int CloneDetailsFieldNumber = 47; private global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails cloneDetails_; @@ -3102,6 +3128,7 @@ public bool Equals(Volume other) { if (!object.Equals(CacheParameters, other.CacheParameters)) return false; if (HotTierSizeUsedGib != other.HotTierSizeUsedGib) return false; if(!blockDevices_.Equals(other.blockDevices_)) return false; + if (!object.Equals(LargeCapacityConfig, other.LargeCapacityConfig)) return false; if (!object.Equals(CloneDetails, other.CloneDetails)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -3152,6 +3179,7 @@ public override int GetHashCode() { if (cacheParameters_ != null) hash ^= CacheParameters.GetHashCode(); if (HotTierSizeUsedGib != 0L) hash ^= HotTierSizeUsedGib.GetHashCode(); hash ^= blockDevices_.GetHashCode(); + if (largeCapacityConfig_ != null) hash ^= LargeCapacityConfig.GetHashCode(); if (cloneDetails_ != null) hash ^= CloneDetails.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -3321,6 +3349,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteInt64(HotTierSizeUsedGib); } blockDevices_.WriteTo(output, _repeated_blockDevices_codec); + if (largeCapacityConfig_ != null) { + output.WriteRawTag(242, 2); + output.WriteMessage(LargeCapacityConfig); + } if (cloneDetails_ != null) { output.WriteRawTag(250, 2); output.WriteMessage(CloneDetails); @@ -3485,6 +3517,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteInt64(HotTierSizeUsedGib); } blockDevices_.WriteTo(ref output, _repeated_blockDevices_codec); + if (largeCapacityConfig_ != null) { + output.WriteRawTag(242, 2); + output.WriteMessage(LargeCapacityConfig); + } if (cloneDetails_ != null) { output.WriteRawTag(250, 2); output.WriteMessage(CloneDetails); @@ -3613,6 +3649,9 @@ public int CalculateSize() { size += 2 + pb::CodedOutputStream.ComputeInt64Size(HotTierSizeUsedGib); } size += blockDevices_.CalculateSize(_repeated_blockDevices_codec); + if (largeCapacityConfig_ != null) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(LargeCapacityConfig); + } if (cloneDetails_ != null) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(CloneDetails); } @@ -3766,6 +3805,12 @@ public void MergeFrom(Volume other) { HotTierSizeUsedGib = other.HotTierSizeUsedGib; } blockDevices_.Add(other.blockDevices_); + if (other.largeCapacityConfig_ != null) { + if (largeCapacityConfig_ == null) { + LargeCapacityConfig = new global::Google.Cloud.NetApp.V1.LargeCapacityConfig(); + } + LargeCapacityConfig.MergeFrom(other.LargeCapacityConfig); + } if (other.cloneDetails_ != null) { if (cloneDetails_ == null) { CloneDetails = new global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails(); @@ -3986,6 +4031,13 @@ public void MergeFrom(pb::CodedInputStream input) { blockDevices_.AddEntriesFrom(input, _repeated_blockDevices_codec); break; } + case 370: { + if (largeCapacityConfig_ == null) { + LargeCapacityConfig = new global::Google.Cloud.NetApp.V1.LargeCapacityConfig(); + } + input.ReadMessage(LargeCapacityConfig); + break; + } case 378: { if (cloneDetails_ == null) { CloneDetails = new global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails(); @@ -4207,6 +4259,13 @@ public void MergeFrom(pb::CodedInputStream input) { blockDevices_.AddEntriesFrom(ref input, _repeated_blockDevices_codec); break; } + case 370: { + if (largeCapacityConfig_ == null) { + LargeCapacityConfig = new global::Google.Cloud.NetApp.V1.LargeCapacityConfig(); + } + input.ReadMessage(LargeCapacityConfig); + break; + } case 378: { if (cloneDetails_ == null) { CloneDetails = new global::Google.Cloud.NetApp.V1.Volume.Types.CloneDetails(); @@ -4566,6 +4625,213 @@ public void MergeFrom(pb::CodedInputStream input) { } + /// + /// Configuration for a Large Capacity Volume. A Large Capacity Volume + /// supports sizes ranging from 4.8 TiB to 20 PiB, it is composed of multiple + /// internal constituents, and must be created in a large capacity pool. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LargeCapacityConfig : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LargeCapacityConfig()); + 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.NetApp.V1.VolumeReflection.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 LargeCapacityConfig() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LargeCapacityConfig(LargeCapacityConfig other) : this() { + constituentCount_ = other.constituentCount_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LargeCapacityConfig Clone() { + return new LargeCapacityConfig(this); + } + + /// Field number for the "constituent_count" field. + public const int ConstituentCountFieldNumber = 1; + private int constituentCount_; + /// + /// Optional. The number of internal constituents (e.g., FlexVols) for this + /// large volume. The minimum number of constituents is 2. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int ConstituentCount { + get { return constituentCount_; } + set { + constituentCount_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LargeCapacityConfig); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LargeCapacityConfig other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ConstituentCount != other.ConstituentCount) 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 (ConstituentCount != 0) hash ^= ConstituentCount.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 (ConstituentCount != 0) { + output.WriteRawTag(8); + output.WriteInt32(ConstituentCount); + } + 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 (ConstituentCount != 0) { + output.WriteRawTag(8); + output.WriteInt32(ConstituentCount); + } + 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 (ConstituentCount != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(ConstituentCount); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LargeCapacityConfig other) { + if (other == null) { + return; + } + if (other.ConstituentCount != 0) { + ConstituentCount = other.ConstituentCount; + } + _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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ConstituentCount = 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) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ConstituentCount = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + /// /// Defines the export policy for the volume. /// @@ -4584,7 +4850,7 @@ public sealed partial class ExportPolicy : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[8]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[9]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4778,7 +5044,7 @@ public sealed partial class SimpleExportPolicyRule : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[10]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[11]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6127,7 +6393,7 @@ public sealed partial class HourlySchedule : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[11]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[12]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6404,7 +6670,7 @@ public sealed partial class DailySchedule : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[12]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[13]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6737,7 +7003,7 @@ public sealed partial class WeeklySchedule : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[13]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[14]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7124,7 +7390,7 @@ public sealed partial class MonthlySchedule : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[14]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[15]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7510,7 +7776,7 @@ public sealed partial class MountOption : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[15]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[16]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7874,7 +8140,7 @@ public sealed partial class RestoreParameters : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[16]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[17]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8186,7 +8452,7 @@ public sealed partial class BackupConfig : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[17]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[18]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8536,7 +8802,7 @@ public sealed partial class TieringPolicy : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[18]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[19]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8896,7 +9162,7 @@ public sealed partial class HybridReplicationParameters : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[20]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[21]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10186,7 +10452,7 @@ public sealed partial class CacheConfig : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[21]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[22]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10593,7 +10859,7 @@ public sealed partial class CachePrePopulate : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[22]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[23]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -10875,7 +11141,7 @@ public sealed partial class BlockDevice : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[23]; } + get { return global::Google.Cloud.NetApp.V1.VolumeReflection.Descriptor.MessageTypes[24]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -11272,7 +11538,7 @@ public sealed partial class RestoreBackupFilesRequest : pb::IMessage Date: Tue, 21 Apr 2026 07:10:53 +0000 Subject: [PATCH 3/3] regen: Regenerate Google.Shopping.Merchant.Products.V1 at API commit 4ae5f10 feat: a new optional field `video_links` is added to the `.google.shopping.merchant.products.v1.ProductAttributes` message feat: a new optional field `annual_percentage_rate` is added to the `.google.shopping.merchant.products.v1.ProductInstallment` message docs: A comment for field `gtins` in message `.google.shopping.merchant.products.v1.ProductAttributes` is changed docs: A comment for field `mpn` in message `.google.shopping.merchant.products.v1.ProductAttributes` is changed PiperOrigin-RevId: 902670459 Source-Link: https://github.com/googleapis/googleapis/commit/4ae5f100d449a987a6f593f328259cb8671ae9be --- .../ProductsCommon.g.cs | 597 ++++++++++-------- generator-input/pipeline-state.json | 2 +- 2 files changed, 344 insertions(+), 255 deletions(-) diff --git a/apis/Google.Shopping.Merchant.Products.V1/Google.Shopping.Merchant.Products.V1/ProductsCommon.g.cs b/apis/Google.Shopping.Merchant.Products.V1/Google.Shopping.Merchant.Products.V1/ProductsCommon.g.cs index 245526a7b887..26c58d2bc2f2 100644 --- a/apis/Google.Shopping.Merchant.Products.V1/Google.Shopping.Merchant.Products.V1/ProductsCommon.g.cs +++ b/apis/Google.Shopping.Merchant.Products.V1/Google.Shopping.Merchant.Products.V1/ProductsCommon.g.cs @@ -29,7 +29,7 @@ static ProductsCommonReflection() { "ZHVjdHMudjEaH2dvb2dsZS9hcGkvZmllbGRfYmVoYXZpb3IucHJvdG8aH2dv", "b2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8aIGdvb2dsZS9zaG9wcGlu", "Zy90eXBlL3R5cGVzLnByb3RvGhpnb29nbGUvdHlwZS9pbnRlcnZhbC5wcm90", - "byLxRAoRUHJvZHVjdEF0dHJpYnV0ZXMSHgoRaWRlbnRpZmllcl9leGlzdHMY", + "byKMRQoRUHJvZHVjdEF0dHJpYnV0ZXMSHgoRaWRlbnRpZmllcl9leGlzdHMY", "BCABKAhIAIgBARIWCglpc19idW5kbGUYBSABKAhIAYgBARISCgV0aXRsZRgG", "IAEoCUgCiAEBEhgKC2Rlc2NyaXB0aW9uGAcgASgJSAOIAQESEQoEbGluaxgI", "IAEoCUgEiAEBEhgKC21vYmlsZV9saW5rGAkgASgJSAWIAQESGwoOY2Fub25p", @@ -146,266 +146,268 @@ static ProductsCommonReflection() { "aW5nX21pbl9wcmljZRh8IAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlBy", "aWNlEmgKGXN1c3RhaW5hYmlsaXR5X2luY2VudGl2ZXMYigEgAygLMkQuZ29v", "Z2xlLnNob3BwaW5nLm1lcmNoYW50LnByb2R1Y3RzLnYxLlByb2R1Y3RTdXN0", - "YWluYWJpbGl0eUluY2VudGl2ZRpsChpTaGlwcGluZ0J1c2luZXNzRGF5c0Nv", - "bmZpZxIUCgdjb3VudHJ5GAEgASgJSACIAQESGgoNYnVzaW5lc3NfZGF5cxgC", - "IAEoCUgBiAEBQgoKCF9jb3VudHJ5QhAKDl9idXNpbmVzc19kYXlzGqEHCg9D", - "YXJyaWVyU2hpcHBpbmcSFAoHY291bnRyeRgBIAEoCUgAiAEBEhMKBnJlZ2lv", - "bhgCIAEoCUgBiAEBEhgKC3Bvc3RhbF9jb2RlGAMgASgJSAKIAQESHwoSb3Jp", - "Z2luX3Bvc3RhbF9jb2RlGAQgASgJSAOIAQESNAoKZmxhdF9wcmljZRgFIAEo", - "CzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlSASIAQESZgoNY2Fycmll", - "cl9wcmljZRgGIAEoDjJKLmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9k", - "dWN0cy52MS5Qcm9kdWN0QXR0cmlidXRlcy5DYXJyaWVyUHJpY2VPcHRpb25I", - "BYgBARJHCh1jYXJyaWVyX3ByaWNlX2ZsYXRfYWRqdXN0bWVudBgHIAEoCzIb", - "Lmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlSAaIAQESMAojY2Fycmllcl9w", - "cmljZV9wZXJjZW50YWdlX2FkanVzdG1lbnQYCCABKAFIB4gBARIeChFtaW5f", - "aGFuZGxpbmdfdGltZRgJIAEoA0gIiAEBEh4KEW1heF9oYW5kbGluZ190aW1l", - "GAogASgDSAmIAQESIwoWZml4ZWRfbWluX3RyYW5zaXRfdGltZRgLIAEoA0gK", - "iAEBEiMKFmZpeGVkX21heF90cmFuc2l0X3RpbWUYDCABKANIC4gBARJhChRj", - "YXJyaWVyX3RyYW5zaXRfdGltZRgNIAEoDjI+Lmdvb2dsZS5zaG9wcGluZy5t", - "ZXJjaGFudC5wcm9kdWN0cy52MS5DYXJyaWVyVHJhbnNpdFRpbWVPcHRpb25I", - "DIgBAUIKCghfY291bnRyeUIJCgdfcmVnaW9uQg4KDF9wb3N0YWxfY29kZUIV", - "ChNfb3JpZ2luX3Bvc3RhbF9jb2RlQg0KC19mbGF0X3ByaWNlQhAKDl9jYXJy", - "aWVyX3ByaWNlQiAKHl9jYXJyaWVyX3ByaWNlX2ZsYXRfYWRqdXN0bWVudEIm", - "CiRfY2Fycmllcl9wcmljZV9wZXJjZW50YWdlX2FkanVzdG1lbnRCFAoSX21p", - "bl9oYW5kbGluZ190aW1lQhQKEl9tYXhfaGFuZGxpbmdfdGltZUIZChdfZml4", - "ZWRfbWluX3RyYW5zaXRfdGltZUIZChdfZml4ZWRfbWF4X3RyYW5zaXRfdGlt", - "ZUIXChVfY2Fycmllcl90cmFuc2l0X3RpbWUiiAwKEkNhcnJpZXJQcmljZU9w", - "dGlvbhIkCiBDQVJSSUVSX1BSSUNFX09QVElPTl9VTlNQRUNJRklFRBAAEhoK", - "FkFVU1RSQUxJQV9QT1NUX1JFR1VMQVIQARIaChZBVVNUUkFMSUFfUE9TVF9F", - "WFBSRVNTEAISHAoYQVVTVFJBTElBX1BPU1RfUkVHVUxBUl9TEAMSHAoYQVVT", - "VFJBTElBX1BPU1RfUkVHVUxBUl9NEAQSHAoYQVVTVFJBTElBX1BPU1RfUkVH", - "VUxBUl9MEAUSHQoZQVVTVFJBTElBX1BPU1RfUkVHVUxBUl9YTBAGEhwKGEFV", - "U1RSQUxJQV9QT1NUX0VYUFJFU1NfUxAHEhwKGEFVU1RSQUxJQV9QT1NUX0VY", - "UFJFU1NfTRAIEhwKGEFVU1RSQUxJQV9QT1NUX0VYUFJFU1NfTBAJEh0KGUFV", - "U1RSQUxJQV9QT1NUX0VYUFJFU1NfWEwQChIUChBUTlRfUk9BRF9FWFBSRVNT", - "EAsSGQoVVE5UX09WRVJOSUdIVF9FWFBSRVNTEAwSFgoSVE9MTF9ST0FEX0RF", - "TElWRVJZEA0SGwoXVE9MTF9PVkVSTklHSFRfUFJJT1JJVFkQDhINCglESExf", - "UEFLRVQQDxIQCgxESExfUEFDS0NIRU4QEBISCg5EUERfRVhQUkVTU18xMhAR", - "Eg8KC0RQRF9FWFBSRVNTEBISFgoSRFBEX0NMQVNTSUNfUEFSQ0VMEBMSEwoP", - "SEVSTUVTX1BBQ0tDSEVOEBQSGAoUSEVSTUVTX1BBS0VUS0xBU1NFX1MQFRIY", - "ChRIRVJNRVNfUEFLRVRLTEFTU0VfTRAWEhgKFEhFUk1FU19QQUtFVEtMQVNT", - "RV9MEBcSDwoLVVBTX0VYUFJFU1MQGBIVChFVUFNfRVhQUkVTU19TQVZFUhAZ", - "EhgKFFVQU19FWFBSRVNTX1NUQU5EQVJEEBoSDwoLREhMX0VYUFJFU1MQGxIS", - "Cg5ESExfRVhQUkVTU18xMhAcEhAKDERQRF9ORVhUX0RBWRAdEhkKFURQRF9T", - "VEFOREFSRF9ORVhUX0RBWRAeEhgKFERQRF9TVEFOREFSRF9UV09fREFZEB8S", - "FwoTUk1HXzFTVF9DTEFTU19TTUFMTBAgEhgKFFJNR18xU1RfQ0xBU1NfTUVE", - "SVVNECESFwoTUk1HXzJORF9DTEFTU19TTUFMTBAiEhgKFFJNR18yTkRfQ0xB", - "U1NfTUVESVVNECMSDwoLVE5UX0VYUFJFU1MQJBISCg5UTlRfRVhQUkVTU18x", - "MBAlEhIKDlROVF9FWFBSRVNTXzEyECYSEgoOWU9ERUxfQjJDXzQ4SFIQJxIS", - "Cg5ZT0RFTF9CMkNfNzJIUhAoEhQKEFlPREVMX0IyQ19QQUNLRVQQKRIQCgxG", - "RURFWF9HUk9VTkQQKhIXChNGRURFWF9IT01FX0RFTElWRVJZECsSFwoTRkVE", - "RVhfRVhQUkVTU19TQVZFUhAsEhkKFUZFREVYX0ZJUlNUX09WRVJOSUdIVBAt", - "EhwKGEZFREVYX1BSSU9SSVRZX09WRVJOSUdIVBAuEhwKGEZFREVYX1NUQU5E", - "QVJEX09WRVJOSUdIVBAvEg4KCkZFREVYXzJEQVkQMBIQCgxVUFNfU1RBTkRB", - "UkQQMRITCg9VUFNfMk5EX0RBWV9BSVIQMhISCg5VUFNfMk5EX0RBWV9BTRAz", - "EhQKEFVQU18zX0RBWV9TRUxFQ1QQNBIOCgpVUFNfR1JPVU5EEDUSFAoQVVBT", - "X05FWFRfREFZX0FJUhA2Eh0KGVVQU19ORVhUX0RBWV9BSVJfRUFSTFlfQU0Q", - "NxIaChZVUFNfTkVYVF9EQVlfQUlSX1NBVkVSEDgSHgoaVVNQU19QUklPUklU", - "WV9NQUlMX0VYUFJFU1MQORITCg9VU1BTX01FRElBX01BSUwQOhIgChxVU1BT", - "X0dST1VORF9BRFZBTlRBR0VfUkVUQUlMEDsSFgoSVVNQU19QUklPUklUWV9N", - "QUlMEDwSJAogVVNQU19HUk9VTkRfQURWQU5UQUdFX0NPTU1FUkNJQUwQPUIU", - "ChJfaWRlbnRpZmllcl9leGlzdHNCDAoKX2lzX2J1bmRsZUIICgZfdGl0bGVC", - "DgoMX2Rlc2NyaXB0aW9uQgcKBV9saW5rQg4KDF9tb2JpbGVfbGlua0IRCg9f", - "Y2Fub25pY2FsX2xpbmtCDQoLX2ltYWdlX2xpbmtCCAoGX2FkdWx0QgwKCl9h", - "Z2VfZ3JvdXBCDwoNX2F2YWlsYWJpbGl0eUIICgZfYnJhbmRCCAoGX2NvbG9y", - "QgwKCl9jb25kaXRpb25CCQoHX2dlbmRlckIaChhfZ29vZ2xlX3Byb2R1Y3Rf", - "Y2F0ZWdvcnlCEAoOX2l0ZW1fZ3JvdXBfaWRCCwoJX21hdGVyaWFsQgYKBF9t", - "cG5CCgoIX3BhdHRlcm5CGgoYX3NlbGxfb25fZ29vZ2xlX3F1YW50aXR5QhQK", - "El9tYXhfaGFuZGxpbmdfdGltZUIUChJfbWluX2hhbmRsaW5nX3RpbWVCEQoP", - "X3NoaXBwaW5nX2xhYmVsQhYKFF9yZXR1cm5fcG9saWN5X2xhYmVsQhUKE190", - "cmFuc2l0X3RpbWVfbGFiZWxCBwoFX3NpemVCDgoMX3NpemVfc3lzdGVtQhoK", - "GF9lbmVyZ3lfZWZmaWNpZW5jeV9jbGFzc0IeChxfbWluX2VuZXJneV9lZmZp", - "Y2llbmN5X2NsYXNzQh4KHF9tYXhfZW5lcmd5X2VmZmljaWVuY3lfY2xhc3NC", - "DAoKX211bHRpcGFja0IPCg1fYWRzX2dyb3VwaW5nQg8KDV9hZHNfcmVkaXJl", - "Y3RCEQoPX2Rpc3BsYXlfYWRzX2lkQhQKEl9kaXNwbGF5X2Fkc190aXRsZUIT", - "ChFfZGlzcGxheV9hZHNfbGlua0IUChJfZGlzcGxheV9hZHNfdmFsdWVCEAoO", - "X3BpY2t1cF9tZXRob2RCDQoLX3BpY2t1cF9zbGFCEAoOX2xpbmtfdGVtcGxh", - "dGVCFwoVX21vYmlsZV9saW5rX3RlbXBsYXRlQhEKD19jdXN0b21fbGFiZWxf", - "MEIRCg9fY3VzdG9tX2xhYmVsXzFCEQoPX2N1c3RvbV9sYWJlbF8yQhEKD19j", - "dXN0b21fbGFiZWxfM0IRCg9fY3VzdG9tX2xhYmVsXzRCFQoTX2V4dGVybmFs", - "X3NlbGxlcl9pZEIICgZfcGF1c2VCFQoTX3ZpcnR1YWxfbW9kZWxfbGlua0IT", - "ChFfc3RydWN0dXJlZF90aXRsZUIZChdfc3RydWN0dXJlZF9kZXNjcmlwdGlv", - "biItCg5TaGlwcGluZ1dlaWdodBINCgV2YWx1ZRgBIAEoARIMCgR1bml0GAIg", - "ASgJIjAKEVNoaXBwaW5nRGltZW5zaW9uEg0KBXZhbHVlGAEgASgBEgwKBHVu", - "aXQYAiABKAkiNQoWVW5pdFByaWNpbmdCYXNlTWVhc3VyZRINCgV2YWx1ZRgB", - "IAEoAxIMCgR1bml0GAIgASgJIjEKElVuaXRQcmljaW5nTWVhc3VyZRINCgV2", - "YWx1ZRgBIAEoARIMCgR1bml0GAIgASgJIqABChBTdWJzY3JpcHRpb25Db3N0", - "EkgKBnBlcmlvZBgBIAEoDjI4Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5w", - "cm9kdWN0cy52MS5TdWJzY3JpcHRpb25QZXJpb2QSFQoNcGVyaW9kX2xlbmd0", - "aBgCIAEoAxIrCgZhbW91bnQYAyABKAsyGy5nb29nbGUuc2hvcHBpbmcudHlw", - "ZS5QcmljZSL0AQoSUHJvZHVjdEluc3RhbGxtZW50Eg4KBm1vbnRocxgBIAEo", - "AxIrCgZhbW91bnQYAiABKAsyGy5nb29nbGUuc2hvcHBpbmcudHlwZS5Qcmlj", - "ZRI1Cgtkb3ducGF5bWVudBgDIAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBl", - "LlByaWNlSACIAQESSgoLY3JlZGl0X3R5cGUYBCABKA4yMC5nb29nbGUuc2hv", - "cHBpbmcubWVyY2hhbnQucHJvZHVjdHMudjEuQ3JlZGl0VHlwZUgBiAEBQg4K", - "DF9kb3ducGF5bWVudEIOCgxfY3JlZGl0X3R5cGUiQgoNTG95YWx0eVBvaW50", - "cxIMCgRuYW1lGAEgASgJEhQKDHBvaW50c192YWx1ZRgCIAEoAxINCgVyYXRp", - "bxgDIAEoASLBAwoOTG95YWx0eVByb2dyYW0SGgoNcHJvZ3JhbV9sYWJlbBgB", - "IAEoCUgAiAEBEhcKCnRpZXJfbGFiZWwYAiABKAlIAYgBARIvCgVwcmljZRgD", - "IAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlSAKIAQESQQoXY2Fz", - "aGJhY2tfZm9yX2Z1dHVyZV91c2UYBCABKAsyGy5nb29nbGUuc2hvcHBpbmcu", - "dHlwZS5QcmljZUgDiAEBEhsKDmxveWFsdHlfcG9pbnRzGAUgASgDSASIAQES", - "PwobbWVtYmVyX3ByaWNlX2VmZmVjdGl2ZV9kYXRlGAYgASgLMhUuZ29vZ2xl", - "LnR5cGUuSW50ZXJ2YWxIBYgBARIbCg5zaGlwcGluZ19sYWJlbBgHIAEoCUgG", - "iAEBQhAKDl9wcm9ncmFtX2xhYmVsQg0KC190aWVyX2xhYmVsQggKBl9wcmlj", - "ZUIaChhfY2FzaGJhY2tfZm9yX2Z1dHVyZV91c2VCEQoPX2xveWFsdHlfcG9p", - "bnRzQh4KHF9tZW1iZXJfcHJpY2VfZWZmZWN0aXZlX2RhdGVCEQoPX3NoaXBw", - "aW5nX2xhYmVsIoMECghTaGlwcGluZxIqCgVwcmljZRgBIAEoCzIbLmdvb2ds", - "ZS5zaG9wcGluZy50eXBlLlByaWNlEg8KB2NvdW50cnkYAiABKAkSDgoGcmVn", - "aW9uGAMgASgJEg8KB3NlcnZpY2UYBCABKAkSEwoLbG9jYXRpb25faWQYBSAB", - "KAMSGwoTbG9jYXRpb25fZ3JvdXBfbmFtZRgGIAEoCRITCgtwb3N0YWxfY29k", - "ZRgHIAEoCRIeChFtaW5faGFuZGxpbmdfdGltZRgIIAEoA0gAiAEBEh4KEW1h", - "eF9oYW5kbGluZ190aW1lGAkgASgDSAGIAQESHQoQbWluX3RyYW5zaXRfdGlt", - "ZRgKIAEoA0gCiAEBEh0KEG1heF90cmFuc2l0X3RpbWUYCyABKANIA4gBARIh", - "ChRoYW5kbGluZ19jdXRvZmZfdGltZRgMIAEoCUgEiAEBEiUKGGhhbmRsaW5n", - "X2N1dG9mZl90aW1lem9uZRgNIAEoCUgFiAEBQhQKEl9taW5faGFuZGxpbmdf", - "dGltZUIUChJfbWF4X2hhbmRsaW5nX3RpbWVCEwoRX21pbl90cmFuc2l0X3Rp", - "bWVCEwoRX21heF90cmFuc2l0X3RpbWVCFwoVX2hhbmRsaW5nX2N1dG9mZl90", - "aW1lQhsKGV9oYW5kbGluZ19jdXRvZmZfdGltZXpvbmUiiAEKFUZyZWVTaGlw", - "cGluZ1RocmVzaG9sZBIUCgdjb3VudHJ5GAEgASgJSACIAQESOQoPcHJpY2Vf", - "dGhyZXNob2xkGAIgASgLMhsuZ29vZ2xlLnNob3BwaW5nLnR5cGUuUHJpY2VI", - "AYgBAUIKCghfY291bnRyeUISChBfcHJpY2VfdGhyZXNob2xkIlYKDVByb2R1", - "Y3REZXRhaWwSFAoMc2VjdGlvbl9uYW1lGAEgASgJEhYKDmF0dHJpYnV0ZV9u", - "YW1lGAIgASgJEhcKD2F0dHJpYnV0ZV92YWx1ZRgDIAEoCSL5AgoUUHJvZHVj", - "dENlcnRpZmljYXRpb24SYgoXY2VydGlmaWNhdGlvbl9hdXRob3JpdHkYASAB", - "KA4yPC5nb29nbGUuc2hvcHBpbmcubWVyY2hhbnQucHJvZHVjdHMudjEuQ2Vy", - "dGlmaWNhdGlvbkF1dGhvcml0eUgAiAEBElgKEmNlcnRpZmljYXRpb25fbmFt", - "ZRgCIAEoDjI3Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9kdWN0cy52", - "MS5DZXJ0aWZpY2F0aW9uTmFtZUgBiAEBEh8KEmNlcnRpZmljYXRpb25fY29k", - "ZRgDIAEoCUgCiAEBEiAKE2NlcnRpZmljYXRpb25fdmFsdWUYBCABKAlIA4gB", - "AUIaChhfY2VydGlmaWNhdGlvbl9hdXRob3JpdHlCFQoTX2NlcnRpZmljYXRp", - "b25fbmFtZUIVChNfY2VydGlmaWNhdGlvbl9jb2RlQhYKFF9jZXJ0aWZpY2F0", - "aW9uX3ZhbHVlIqYBCg9TdHJ1Y3R1cmVkVGl0bGUSWQoTZGlnaXRhbF9zb3Vy", - "Y2VfdHlwZRgBIAEoDjI3Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9k", - "dWN0cy52MS5EaWdpdGFsU291cmNlVHlwZUgAiAEBEhQKB2NvbnRlbnQYAiAB", - "KAlIAYgBAUIWChRfZGlnaXRhbF9zb3VyY2VfdHlwZUIKCghfY29udGVudCKs", - "AQoVU3RydWN0dXJlZERlc2NyaXB0aW9uElkKE2RpZ2l0YWxfc291cmNlX3R5", - "cGUYASABKA4yNy5nb29nbGUuc2hvcHBpbmcubWVyY2hhbnQucHJvZHVjdHMu", - "djEuRGlnaXRhbFNvdXJjZVR5cGVIAIgBARIUCgdjb250ZW50GAIgASgJSAGI", - "AQFCFgoUX2RpZ2l0YWxfc291cmNlX3R5cGVCCgoIX2NvbnRlbnQiOQoQUHJv", - "ZHVjdERpbWVuc2lvbhISCgV2YWx1ZRgBIAEoAUID4EECEhEKBHVuaXQYAiAB", - "KAlCA+BBAiI2Cg1Qcm9kdWN0V2VpZ2h0EhIKBXZhbHVlGAEgASgBQgPgQQIS", - "EQoEdW5pdBgCIAEoCUID4EECIusHCg1Qcm9kdWN0U3RhdHVzEmMKFGRlc3Rp", - "bmF0aW9uX3N0YXR1c2VzGAMgAygLMkUuZ29vZ2xlLnNob3BwaW5nLm1lcmNo", - "YW50LnByb2R1Y3RzLnYxLlByb2R1Y3RTdGF0dXMuRGVzdGluYXRpb25TdGF0", - "dXMSXQoRaXRlbV9sZXZlbF9pc3N1ZXMYBCADKAsyQi5nb29nbGUuc2hvcHBp", - "bmcubWVyY2hhbnQucHJvZHVjdHMudjEuUHJvZHVjdFN0YXR1cy5JdGVtTGV2", - "ZWxJc3N1ZRIxCg1jcmVhdGlvbl9kYXRlGAUgASgLMhouZ29vZ2xlLnByb3Rv", - "YnVmLlRpbWVzdGFtcBI0ChBsYXN0X3VwZGF0ZV9kYXRlGAYgASgLMhouZ29v", - "Z2xlLnByb3RvYnVmLlRpbWVzdGFtcBI6ChZnb29nbGVfZXhwaXJhdGlvbl9k", - "YXRlGAcgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBrBAQoRRGVz", - "dGluYXRpb25TdGF0dXMSVgoRcmVwb3J0aW5nX2NvbnRleHQYASABKA4yOy5n", - "b29nbGUuc2hvcHBpbmcudHlwZS5SZXBvcnRpbmdDb250ZXh0LlJlcG9ydGlu", - "Z0NvbnRleHRFbnVtEhoKEmFwcHJvdmVkX2NvdW50cmllcxgCIAMoCRIZChFw", - "ZW5kaW5nX2NvdW50cmllcxgDIAMoCRIdChVkaXNhcHByb3ZlZF9jb3VudHJp", - "ZXMYBCADKAkarAMKDkl0ZW1MZXZlbElzc3VlEgwKBGNvZGUYASABKAkSXQoI", - "c2V2ZXJpdHkYAiABKA4ySy5nb29nbGUuc2hvcHBpbmcubWVyY2hhbnQucHJv", - "ZHVjdHMudjEuUHJvZHVjdFN0YXR1cy5JdGVtTGV2ZWxJc3N1ZS5TZXZlcml0", - "eRISCgpyZXNvbHV0aW9uGAMgASgJEhEKCWF0dHJpYnV0ZRgEIAEoCRJWChFy", - "ZXBvcnRpbmdfY29udGV4dBgFIAEoDjI7Lmdvb2dsZS5zaG9wcGluZy50eXBl", - "LlJlcG9ydGluZ0NvbnRleHQuUmVwb3J0aW5nQ29udGV4dEVudW0SEwoLZGVz", - "Y3JpcHRpb24YBiABKAkSDgoGZGV0YWlsGAcgASgJEhUKDWRvY3VtZW50YXRp", - "b24YCCABKAkSHAoUYXBwbGljYWJsZV9jb3VudHJpZXMYCSADKAkiVAoIU2V2", - "ZXJpdHkSGAoUU0VWRVJJVFlfVU5TUEVDSUZJRUQQABIQCgxOT1RfSU1QQUNU", - "RUQQARILCgdERU1PVEVEEAISDwoLRElTQVBQUk9WRUQQAyKlAgofQ2xvdWRF", - "eHBvcnRBZGRpdGlvbmFsUHJvcGVydGllcxIaCg1wcm9wZXJ0eV9uYW1lGAEg", - "ASgJSACIAQESEgoKdGV4dF92YWx1ZRgCIAMoCRIXCgpib29sX3ZhbHVlGAMg", - "ASgISAGIAQESEQoJaW50X3ZhbHVlGAQgAygDEhMKC2Zsb2F0X3ZhbHVlGAUg", - "AygCEhYKCW1pbl92YWx1ZRgGIAEoAkgCiAEBEhYKCW1heF92YWx1ZRgHIAEo", - "AkgDiAEBEhYKCXVuaXRfY29kZRgIIAEoCUgEiAEBQhAKDl9wcm9wZXJ0eV9u", - "YW1lQg0KC19ib29sX3ZhbHVlQgwKCl9taW5fdmFsdWVCDAoKX21heF92YWx1", - "ZUIMCgpfdW5pdF9jb2RlIp0CCh5Qcm9kdWN0U3VzdGFpbmFiaWxpdHlJbmNl", - "bnRpdmUSLQoGYW1vdW50GAIgASgLMhsuZ29vZ2xlLnNob3BwaW5nLnR5cGUu", - "UHJpY2VIABIUCgpwZXJjZW50YWdlGAMgASgBSAASXAoEdHlwZRgBIAEoDjJJ", - "Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9kdWN0cy52MS5Qcm9kdWN0", - "U3VzdGFpbmFiaWxpdHlJbmNlbnRpdmUuVHlwZUgBiAEBIkYKBFR5cGUSFAoQ", - "VFlQRV9VTlNQRUNJRklFRBAAEhEKDUVWX1RBWF9DUkVESVQQARIVChFFVl9Q", - "UklDRV9ESVNDT1VOVBACQgcKBXZhbHVlQgcKBV90eXBlIrQBChJBdXRvbWF0", - "ZWREaXNjb3VudHMSMAoLcHJpb3JfcHJpY2UYASABKAsyGy5nb29nbGUuc2hv", - "cHBpbmcudHlwZS5QcmljZRI8Chdwcmlvcl9wcmljZV9wcm9ncmVzc2l2ZRgC", - "IAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlEi4KCWdhZF9wcmlj", - "ZRgDIAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlIuABChJIYW5k", - "bGluZ0N1dG9mZlRpbWUSFAoHY291bnRyeRgBIAEoCUgAiAEBEhgKC2N1dG9m", - "Zl90aW1lGAIgASgJSAGIAQESHAoPY3V0b2ZmX3RpbWV6b25lGAMgASgJSAKI", - "AQESKgodZGlzYWJsZV9kZWxpdmVyeV9hZnRlcl9jdXRvZmYYBCABKAhIA4gB", - "AUIKCghfY291bnRyeUIOCgxfY3V0b2ZmX3RpbWVCEgoQX2N1dG9mZl90aW1l", - "em9uZUIgCh5fZGlzYWJsZV9kZWxpdmVyeV9hZnRlcl9jdXRvZmYqWAoSU3Vi", - "c2NyaXB0aW9uUGVyaW9kEiMKH1NVQlNDUklQVElPTl9QRVJJT0RfVU5TUEVD", - "SUZJRUQQABIJCgVNT05USBABEggKBFlFQVIQAhIICgRXRUVLEAMqYAoIQWdl", - "R3JvdXASGQoVQUdFX0dST1VQX1VOU1BFQ0lGSUVEEAASCQoFQURVTFQQARII", - "CgRLSURTEAISCwoHVE9ERExFUhADEgoKBklORkFOVBAEEgsKB05FV0JPUk4Q", - "BSqDAQoMQXZhaWxhYmlsaXR5EhwKGEFWQUlMQUJJTElUWV9VTlNQRUNJRklF", - "RBAAEgwKCElOX1NUT0NLEAESEAoMT1VUX09GX1NUT0NLEAISDAoIUFJFT1JE", - "RVIQAxIYChRMSU1JVEVEX0FWQUlMQUJJTElUWRAEEg0KCUJBQ0tPUkRFUhAF", - "KkoKCUNvbmRpdGlvbhIZChVDT05ESVRJT05fVU5TUEVDSUZJRUQQABIHCgNO", - "RVcQARIICgRVU0VEEAISDwoLUkVGVVJCSVNIRUQQAypCCgZHZW5kZXISFgoS", - "R0VOREVSX1VOU1BFQ0lGSUVEEAASCAoETUFMRRABEgoKBkZFTUFMRRACEgoK", - "BlVOSVNFWBADKkEKCkNyZWRpdFR5cGUSGwoXQ1JFRElUX1RZUEVfVU5TUEVD", - "SUZJRUQQABILCgdGSU5BTkNFEAESCQoFTEVBU0UQAiqCAQoKU2l6ZVN5c3Rl", - "bRIbChdTSVpFX1NZU1RFTV9VTlNQRUNJRklFRBAAEgYKAkFVEAESBgoCQlIQ", - "AhIGCgJDThADEgYKAkRFEAQSBgoCRVUQBRIGCgJGUhAGEgYKAklUEAcSBgoC", - "SlAQCBIHCgNNRVgQCRIGCgJVSxAKEgYKAlVTEAsqagoIU2l6ZVR5cGUSGQoV", - "U0laRV9UWVBFX1VOU1BFQ0lGSUVEEAASCwoHUkVHVUxBUhABEgoKBlBFVElU", - "RRACEg0KCU1BVEVSTklUWRADEgcKA0JJRxAEEggKBFRBTEwQBRIICgRQTFVT", - "EAYqjAEKFUVuZXJneUVmZmljaWVuY3lDbGFzcxInCiNFTkVSR1lfRUZGSUNJ", - "RU5DWV9DTEFTU19VTlNQRUNJRklFRBAAEggKBEFQUFAQARIHCgNBUFAQAhIG", - "CgJBUBADEgUKAUEQBBIFCgFCEAUSBQoBQxAGEgUKAUQQBxIFCgFFEAgSBQoB", - "RhAJEgUKAUcQCippCgxQaWNrdXBNZXRob2QSHQoZUElDS1VQX01FVEhPRF9V", - "TlNQRUNJRklFRBAAEhEKDU5PVF9TVVBQT1JURUQQARIHCgNCVVkQAhILCgdS", - "RVNFUlZFEAMSEQoNU0hJUF9UT19TVE9SRRAEKpgBCglQaWNrdXBTbGESGgoW", - "UElDS1VQX1NMQV9VTlNQRUNJRklFRBAAEgwKCFNBTUVfREFZEAESDAoITkVY", - "VF9EQVkQAhILCgdUV09fREFZEAMSDQoJVEhSRUVfREFZEAQSDAoIRk9VUl9E", - "QVkQBRIMCghGSVZFX0RBWRAGEgsKB1NJWF9EQVkQBxIOCgpNVUxUSV9XRUVL", - "EAgqMAoFUGF1c2USFQoRUEFVU0VfVU5TUEVDSUZJRUQQABIHCgNBRFMQARIH", - "CgNBTEwQAipnChZDZXJ0aWZpY2F0aW9uQXV0aG9yaXR5EicKI0NFUlRJRklD", - "QVRJT05fQVVUSE9SSVRZX1VOU1BFQ0lGSUVEEAASCQoFQURFTUUQARIICgRC", - "TVdLEAISBwoDRVBBEAMSBgoCRUMQBCrVAQoRQ2VydGlmaWNhdGlvbk5hbWUS", - "IgoeQ0VSVElGSUNBVElPTl9OQU1FX1VOU1BFQ0lGSUVEEAASDwoLRU5FUkdZ", - "X1NUQVIQARIeChpFTkVSR1lfU1RBUl9NT1NUX0VGRklDSUVOVBACEgkKBUVQ", - "UkVMEAMSDwoLRVVfRUNPTEFCRUwQBBIdChlWRUhJQ0xFX0VORVJHWV9FRkZJ", - "Q0lFTkNZEAUSMAosVkVISUNMRV9FTkVSR1lfRUZGSUNJRU5DWV9ESVNDSEFS", - "R0VEX0JBVFRFUlkQBipkChFEaWdpdGFsU291cmNlVHlwZRIjCh9ESUdJVEFM", - "X1NPVVJDRV9UWVBFX1VOU1BFQ0lGSUVEEAASHQoZVFJBSU5FRF9BTEdPUklU", - "SE1JQ19NRURJQRABEgsKB0RFRkFVTFQQAirIBwoYQ2FycmllclRyYW5zaXRU", - "aW1lT3B0aW9uEisKJ0NBUlJJRVJfVFJBTlNJVF9USU1FX09QVElPTl9VTlNQ", - "RUNJRklFRBAAEg0KCURITF9QQUtFVBABEhAKDERITF9QQUNLQ0hFThACEhMK", - "D0RITF9FWFBSRVNTRUFTWRADEg8KC0RQRF9FWFBSRVNTEAQSFgoSRFBEX0NM", - "QVNTSUNfUEFSQ0VMEAUSEgoOSEVSTUVTX0hBVVNUVVIQBhIUChBIRVJNRVNf", - "UEFLRVRTSE9QEAcSEAoMR0xTX0JVU0lORVNTEAgSDwoLR0xTX0VYUFJFU1MQ", - "CRIPCgtHTFNfUFJJVkFURRAKEhYKEkNPTElTU0lNT19ET01JQ0lMRRALEhQK", - "EERITF9FWFBSRVNTXzEyQU0QDBITCg9ESExfRVhQUkVTU185QU0QDRISCg5H", - "RU9ESVNfRVhQUkVTUxAOEhIKDkdFT0RJU19QQUNLXzMwEA8SEwoPR0VPRElT", - "X1NBTUVfREFZEBASEQoNR0VPRElTX1RPUF8yNBAREhUKEVROVF9FU1NFTlRJ", - "RUxfMjRIEBISHQoZVE5UX0VTU0VOVElFTF9GTEVYSUJJTElURRATEhAKDEZF", - "REVYX0dST1VORBAUEhcKE0ZFREVYX0hPTUVfREVMSVZFUlkQFRIXChNGRURF", - "WF9FWFBSRVNTX1NBVkVSEBYSGQoVRkVERVhfRklSU1RfT1ZFUk5JR0hUEBcS", - "HAoYRkVERVhfUFJJT1JJVFlfT1ZFUk5JR0hUEBgSHAoYRkVERVhfU1RBTkRB", - "UkRfT1ZFUk5JR0hUEBkSDgoKRkVERVhfMkRBWRAaEhMKD1VQU18yTkRfREFZ", - "X0FJUhAbEhIKDlVQU18yTkRfREFZX0FNEBwSFAoQVVBTXzNfREFZX1NFTEVD", - "VBAdEg4KClVQU19HUk9VTkQQHhIUChBVUFNfTkVYVF9EQVlfQUlSEB8SHQoZ", - "VVBTX05FWFRfREFZX0FJUl9FQVJMWV9BTRAgEhoKFlVQU19ORVhUX0RBWV9B", - "SVJfU0FWRVIQIRIeChpVU1BTX1BSSU9SSVRZX01BSUxfRVhQUkVTUxAiEhMK", - "D1VTUFNfTUVESUFfTUFJTBAjEiAKHFVTUFNfR1JPVU5EX0FEVkFOVEFHRV9S", - "RVRBSUwQJBIWChJVU1BTX1BSSU9SSVRZX01BSUwQJRIkCiBVU1BTX0dST1VO", - "RF9BRFZBTlRBR0VfQ09NTUVSQ0lBTBAmEhkKFVVTUFNfRklSU1RfQ0xBU1Nf", - "TUFJTBAnQoYCCihjb20uZ29vZ2xlLnNob3BwaW5nLm1lcmNoYW50LnByb2R1", - "Y3RzLnYxQhNQcm9kdWN0c0NvbW1vblByb3RvUAFaSmNsb3VkLmdvb2dsZS5j", - "b20vZ28vc2hvcHBpbmcvbWVyY2hhbnQvcHJvZHVjdHMvYXBpdjEvcHJvZHVj", - "dHNwYjtwcm9kdWN0c3BiqgIkR29vZ2xlLlNob3BwaW5nLk1lcmNoYW50LlBy", - "b2R1Y3RzLlYxygIkR29vZ2xlXFNob3BwaW5nXE1lcmNoYW50XFByb2R1Y3Rz", - "XFYx6gIoR29vZ2xlOjpTaG9wcGluZzo6TWVyY2hhbnQ6OlByb2R1Y3RzOjpW", - "MWIGcHJvdG8z")); + "YWluYWJpbGl0eUluY2VudGl2ZRIZCgt2aWRlb19saW5rcxipASADKAlCA+BB", + "ARpsChpTaGlwcGluZ0J1c2luZXNzRGF5c0NvbmZpZxIUCgdjb3VudHJ5GAEg", + "ASgJSACIAQESGgoNYnVzaW5lc3NfZGF5cxgCIAEoCUgBiAEBQgoKCF9jb3Vu", + "dHJ5QhAKDl9idXNpbmVzc19kYXlzGqEHCg9DYXJyaWVyU2hpcHBpbmcSFAoH", + "Y291bnRyeRgBIAEoCUgAiAEBEhMKBnJlZ2lvbhgCIAEoCUgBiAEBEhgKC3Bv", + "c3RhbF9jb2RlGAMgASgJSAKIAQESHwoSb3JpZ2luX3Bvc3RhbF9jb2RlGAQg", + "ASgJSAOIAQESNAoKZmxhdF9wcmljZRgFIAEoCzIbLmdvb2dsZS5zaG9wcGlu", + "Zy50eXBlLlByaWNlSASIAQESZgoNY2Fycmllcl9wcmljZRgGIAEoDjJKLmdv", + "b2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9kdWN0cy52MS5Qcm9kdWN0QXR0", + "cmlidXRlcy5DYXJyaWVyUHJpY2VPcHRpb25IBYgBARJHCh1jYXJyaWVyX3By", + "aWNlX2ZsYXRfYWRqdXN0bWVudBgHIAEoCzIbLmdvb2dsZS5zaG9wcGluZy50", + "eXBlLlByaWNlSAaIAQESMAojY2Fycmllcl9wcmljZV9wZXJjZW50YWdlX2Fk", + "anVzdG1lbnQYCCABKAFIB4gBARIeChFtaW5faGFuZGxpbmdfdGltZRgJIAEo", + "A0gIiAEBEh4KEW1heF9oYW5kbGluZ190aW1lGAogASgDSAmIAQESIwoWZml4", + "ZWRfbWluX3RyYW5zaXRfdGltZRgLIAEoA0gKiAEBEiMKFmZpeGVkX21heF90", + "cmFuc2l0X3RpbWUYDCABKANIC4gBARJhChRjYXJyaWVyX3RyYW5zaXRfdGlt", + "ZRgNIAEoDjI+Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9kdWN0cy52", + "MS5DYXJyaWVyVHJhbnNpdFRpbWVPcHRpb25IDIgBAUIKCghfY291bnRyeUIJ", + "CgdfcmVnaW9uQg4KDF9wb3N0YWxfY29kZUIVChNfb3JpZ2luX3Bvc3RhbF9j", + "b2RlQg0KC19mbGF0X3ByaWNlQhAKDl9jYXJyaWVyX3ByaWNlQiAKHl9jYXJy", + "aWVyX3ByaWNlX2ZsYXRfYWRqdXN0bWVudEImCiRfY2Fycmllcl9wcmljZV9w", + "ZXJjZW50YWdlX2FkanVzdG1lbnRCFAoSX21pbl9oYW5kbGluZ190aW1lQhQK", + "El9tYXhfaGFuZGxpbmdfdGltZUIZChdfZml4ZWRfbWluX3RyYW5zaXRfdGlt", + "ZUIZChdfZml4ZWRfbWF4X3RyYW5zaXRfdGltZUIXChVfY2Fycmllcl90cmFu", + "c2l0X3RpbWUiiAwKEkNhcnJpZXJQcmljZU9wdGlvbhIkCiBDQVJSSUVSX1BS", + "SUNFX09QVElPTl9VTlNQRUNJRklFRBAAEhoKFkFVU1RSQUxJQV9QT1NUX1JF", + "R1VMQVIQARIaChZBVVNUUkFMSUFfUE9TVF9FWFBSRVNTEAISHAoYQVVTVFJB", + "TElBX1BPU1RfUkVHVUxBUl9TEAMSHAoYQVVTVFJBTElBX1BPU1RfUkVHVUxB", + "Ul9NEAQSHAoYQVVTVFJBTElBX1BPU1RfUkVHVUxBUl9MEAUSHQoZQVVTVFJB", + "TElBX1BPU1RfUkVHVUxBUl9YTBAGEhwKGEFVU1RSQUxJQV9QT1NUX0VYUFJF", + "U1NfUxAHEhwKGEFVU1RSQUxJQV9QT1NUX0VYUFJFU1NfTRAIEhwKGEFVU1RS", + "QUxJQV9QT1NUX0VYUFJFU1NfTBAJEh0KGUFVU1RSQUxJQV9QT1NUX0VYUFJF", + "U1NfWEwQChIUChBUTlRfUk9BRF9FWFBSRVNTEAsSGQoVVE5UX09WRVJOSUdI", + "VF9FWFBSRVNTEAwSFgoSVE9MTF9ST0FEX0RFTElWRVJZEA0SGwoXVE9MTF9P", + "VkVSTklHSFRfUFJJT1JJVFkQDhINCglESExfUEFLRVQQDxIQCgxESExfUEFD", + "S0NIRU4QEBISCg5EUERfRVhQUkVTU18xMhAREg8KC0RQRF9FWFBSRVNTEBIS", + "FgoSRFBEX0NMQVNTSUNfUEFSQ0VMEBMSEwoPSEVSTUVTX1BBQ0tDSEVOEBQS", + "GAoUSEVSTUVTX1BBS0VUS0xBU1NFX1MQFRIYChRIRVJNRVNfUEFLRVRLTEFT", + "U0VfTRAWEhgKFEhFUk1FU19QQUtFVEtMQVNTRV9MEBcSDwoLVVBTX0VYUFJF", + "U1MQGBIVChFVUFNfRVhQUkVTU19TQVZFUhAZEhgKFFVQU19FWFBSRVNTX1NU", + "QU5EQVJEEBoSDwoLREhMX0VYUFJFU1MQGxISCg5ESExfRVhQUkVTU18xMhAc", + "EhAKDERQRF9ORVhUX0RBWRAdEhkKFURQRF9TVEFOREFSRF9ORVhUX0RBWRAe", + "EhgKFERQRF9TVEFOREFSRF9UV09fREFZEB8SFwoTUk1HXzFTVF9DTEFTU19T", + "TUFMTBAgEhgKFFJNR18xU1RfQ0xBU1NfTUVESVVNECESFwoTUk1HXzJORF9D", + "TEFTU19TTUFMTBAiEhgKFFJNR18yTkRfQ0xBU1NfTUVESVVNECMSDwoLVE5U", + "X0VYUFJFU1MQJBISCg5UTlRfRVhQUkVTU18xMBAlEhIKDlROVF9FWFBSRVNT", + "XzEyECYSEgoOWU9ERUxfQjJDXzQ4SFIQJxISCg5ZT0RFTF9CMkNfNzJIUhAo", + "EhQKEFlPREVMX0IyQ19QQUNLRVQQKRIQCgxGRURFWF9HUk9VTkQQKhIXChNG", + "RURFWF9IT01FX0RFTElWRVJZECsSFwoTRkVERVhfRVhQUkVTU19TQVZFUhAs", + "EhkKFUZFREVYX0ZJUlNUX09WRVJOSUdIVBAtEhwKGEZFREVYX1BSSU9SSVRZ", + "X09WRVJOSUdIVBAuEhwKGEZFREVYX1NUQU5EQVJEX09WRVJOSUdIVBAvEg4K", + "CkZFREVYXzJEQVkQMBIQCgxVUFNfU1RBTkRBUkQQMRITCg9VUFNfMk5EX0RB", + "WV9BSVIQMhISCg5VUFNfMk5EX0RBWV9BTRAzEhQKEFVQU18zX0RBWV9TRUxF", + "Q1QQNBIOCgpVUFNfR1JPVU5EEDUSFAoQVVBTX05FWFRfREFZX0FJUhA2Eh0K", + "GVVQU19ORVhUX0RBWV9BSVJfRUFSTFlfQU0QNxIaChZVUFNfTkVYVF9EQVlf", + "QUlSX1NBVkVSEDgSHgoaVVNQU19QUklPUklUWV9NQUlMX0VYUFJFU1MQORIT", + "Cg9VU1BTX01FRElBX01BSUwQOhIgChxVU1BTX0dST1VORF9BRFZBTlRBR0Vf", + "UkVUQUlMEDsSFgoSVVNQU19QUklPUklUWV9NQUlMEDwSJAogVVNQU19HUk9V", + "TkRfQURWQU5UQUdFX0NPTU1FUkNJQUwQPUIUChJfaWRlbnRpZmllcl9leGlz", + "dHNCDAoKX2lzX2J1bmRsZUIICgZfdGl0bGVCDgoMX2Rlc2NyaXB0aW9uQgcK", + "BV9saW5rQg4KDF9tb2JpbGVfbGlua0IRCg9fY2Fub25pY2FsX2xpbmtCDQoL", + "X2ltYWdlX2xpbmtCCAoGX2FkdWx0QgwKCl9hZ2VfZ3JvdXBCDwoNX2F2YWls", + "YWJpbGl0eUIICgZfYnJhbmRCCAoGX2NvbG9yQgwKCl9jb25kaXRpb25CCQoH", + "X2dlbmRlckIaChhfZ29vZ2xlX3Byb2R1Y3RfY2F0ZWdvcnlCEAoOX2l0ZW1f", + "Z3JvdXBfaWRCCwoJX21hdGVyaWFsQgYKBF9tcG5CCgoIX3BhdHRlcm5CGgoY", + "X3NlbGxfb25fZ29vZ2xlX3F1YW50aXR5QhQKEl9tYXhfaGFuZGxpbmdfdGlt", + "ZUIUChJfbWluX2hhbmRsaW5nX3RpbWVCEQoPX3NoaXBwaW5nX2xhYmVsQhYK", + "FF9yZXR1cm5fcG9saWN5X2xhYmVsQhUKE190cmFuc2l0X3RpbWVfbGFiZWxC", + "BwoFX3NpemVCDgoMX3NpemVfc3lzdGVtQhoKGF9lbmVyZ3lfZWZmaWNpZW5j", + "eV9jbGFzc0IeChxfbWluX2VuZXJneV9lZmZpY2llbmN5X2NsYXNzQh4KHF9t", + "YXhfZW5lcmd5X2VmZmljaWVuY3lfY2xhc3NCDAoKX211bHRpcGFja0IPCg1f", + "YWRzX2dyb3VwaW5nQg8KDV9hZHNfcmVkaXJlY3RCEQoPX2Rpc3BsYXlfYWRz", + "X2lkQhQKEl9kaXNwbGF5X2Fkc190aXRsZUITChFfZGlzcGxheV9hZHNfbGlu", + "a0IUChJfZGlzcGxheV9hZHNfdmFsdWVCEAoOX3BpY2t1cF9tZXRob2RCDQoL", + "X3BpY2t1cF9zbGFCEAoOX2xpbmtfdGVtcGxhdGVCFwoVX21vYmlsZV9saW5r", + "X3RlbXBsYXRlQhEKD19jdXN0b21fbGFiZWxfMEIRCg9fY3VzdG9tX2xhYmVs", + "XzFCEQoPX2N1c3RvbV9sYWJlbF8yQhEKD19jdXN0b21fbGFiZWxfM0IRCg9f", + "Y3VzdG9tX2xhYmVsXzRCFQoTX2V4dGVybmFsX3NlbGxlcl9pZEIICgZfcGF1", + "c2VCFQoTX3ZpcnR1YWxfbW9kZWxfbGlua0ITChFfc3RydWN0dXJlZF90aXRs", + "ZUIZChdfc3RydWN0dXJlZF9kZXNjcmlwdGlvbiItCg5TaGlwcGluZ1dlaWdo", + "dBINCgV2YWx1ZRgBIAEoARIMCgR1bml0GAIgASgJIjAKEVNoaXBwaW5nRGlt", + "ZW5zaW9uEg0KBXZhbHVlGAEgASgBEgwKBHVuaXQYAiABKAkiNQoWVW5pdFBy", + "aWNpbmdCYXNlTWVhc3VyZRINCgV2YWx1ZRgBIAEoAxIMCgR1bml0GAIgASgJ", + "IjEKElVuaXRQcmljaW5nTWVhc3VyZRINCgV2YWx1ZRgBIAEoARIMCgR1bml0", + "GAIgASgJIqABChBTdWJzY3JpcHRpb25Db3N0EkgKBnBlcmlvZBgBIAEoDjI4", + "Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9kdWN0cy52MS5TdWJzY3Jp", + "cHRpb25QZXJpb2QSFQoNcGVyaW9kX2xlbmd0aBgCIAEoAxIrCgZhbW91bnQY", + "AyABKAsyGy5nb29nbGUuc2hvcHBpbmcudHlwZS5QcmljZSK5AgoSUHJvZHVj", + "dEluc3RhbGxtZW50Eg4KBm1vbnRocxgBIAEoAxIrCgZhbW91bnQYAiABKAsy", + "Gy5nb29nbGUuc2hvcHBpbmcudHlwZS5QcmljZRI1Cgtkb3ducGF5bWVudBgD", + "IAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlSACIAQESSgoLY3Jl", + "ZGl0X3R5cGUYBCABKA4yMC5nb29nbGUuc2hvcHBpbmcubWVyY2hhbnQucHJv", + "ZHVjdHMudjEuQ3JlZGl0VHlwZUgBiAEBEigKFmFubnVhbF9wZXJjZW50YWdl", + "X3JhdGUYBSABKAFCA+BBAUgCiAEBQg4KDF9kb3ducGF5bWVudEIOCgxfY3Jl", + "ZGl0X3R5cGVCGQoXX2FubnVhbF9wZXJjZW50YWdlX3JhdGUiQgoNTG95YWx0", + "eVBvaW50cxIMCgRuYW1lGAEgASgJEhQKDHBvaW50c192YWx1ZRgCIAEoAxIN", + "CgVyYXRpbxgDIAEoASLBAwoOTG95YWx0eVByb2dyYW0SGgoNcHJvZ3JhbV9s", + "YWJlbBgBIAEoCUgAiAEBEhcKCnRpZXJfbGFiZWwYAiABKAlIAYgBARIvCgVw", + "cmljZRgDIAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlSAKIAQES", + "QQoXY2FzaGJhY2tfZm9yX2Z1dHVyZV91c2UYBCABKAsyGy5nb29nbGUuc2hv", + "cHBpbmcudHlwZS5QcmljZUgDiAEBEhsKDmxveWFsdHlfcG9pbnRzGAUgASgD", + "SASIAQESPwobbWVtYmVyX3ByaWNlX2VmZmVjdGl2ZV9kYXRlGAYgASgLMhUu", + "Z29vZ2xlLnR5cGUuSW50ZXJ2YWxIBYgBARIbCg5zaGlwcGluZ19sYWJlbBgH", + "IAEoCUgGiAEBQhAKDl9wcm9ncmFtX2xhYmVsQg0KC190aWVyX2xhYmVsQggK", + "Bl9wcmljZUIaChhfY2FzaGJhY2tfZm9yX2Z1dHVyZV91c2VCEQoPX2xveWFs", + "dHlfcG9pbnRzQh4KHF9tZW1iZXJfcHJpY2VfZWZmZWN0aXZlX2RhdGVCEQoP", + "X3NoaXBwaW5nX2xhYmVsIoMECghTaGlwcGluZxIqCgVwcmljZRgBIAEoCzIb", + "Lmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlEg8KB2NvdW50cnkYAiABKAkS", + "DgoGcmVnaW9uGAMgASgJEg8KB3NlcnZpY2UYBCABKAkSEwoLbG9jYXRpb25f", + "aWQYBSABKAMSGwoTbG9jYXRpb25fZ3JvdXBfbmFtZRgGIAEoCRITCgtwb3N0", + "YWxfY29kZRgHIAEoCRIeChFtaW5faGFuZGxpbmdfdGltZRgIIAEoA0gAiAEB", + "Eh4KEW1heF9oYW5kbGluZ190aW1lGAkgASgDSAGIAQESHQoQbWluX3RyYW5z", + "aXRfdGltZRgKIAEoA0gCiAEBEh0KEG1heF90cmFuc2l0X3RpbWUYCyABKANI", + "A4gBARIhChRoYW5kbGluZ19jdXRvZmZfdGltZRgMIAEoCUgEiAEBEiUKGGhh", + "bmRsaW5nX2N1dG9mZl90aW1lem9uZRgNIAEoCUgFiAEBQhQKEl9taW5faGFu", + "ZGxpbmdfdGltZUIUChJfbWF4X2hhbmRsaW5nX3RpbWVCEwoRX21pbl90cmFu", + "c2l0X3RpbWVCEwoRX21heF90cmFuc2l0X3RpbWVCFwoVX2hhbmRsaW5nX2N1", + "dG9mZl90aW1lQhsKGV9oYW5kbGluZ19jdXRvZmZfdGltZXpvbmUiiAEKFUZy", + "ZWVTaGlwcGluZ1RocmVzaG9sZBIUCgdjb3VudHJ5GAEgASgJSACIAQESOQoP", + "cHJpY2VfdGhyZXNob2xkGAIgASgLMhsuZ29vZ2xlLnNob3BwaW5nLnR5cGUu", + "UHJpY2VIAYgBAUIKCghfY291bnRyeUISChBfcHJpY2VfdGhyZXNob2xkIlYK", + "DVByb2R1Y3REZXRhaWwSFAoMc2VjdGlvbl9uYW1lGAEgASgJEhYKDmF0dHJp", + "YnV0ZV9uYW1lGAIgASgJEhcKD2F0dHJpYnV0ZV92YWx1ZRgDIAEoCSL5AgoU", + "UHJvZHVjdENlcnRpZmljYXRpb24SYgoXY2VydGlmaWNhdGlvbl9hdXRob3Jp", + "dHkYASABKA4yPC5nb29nbGUuc2hvcHBpbmcubWVyY2hhbnQucHJvZHVjdHMu", + "djEuQ2VydGlmaWNhdGlvbkF1dGhvcml0eUgAiAEBElgKEmNlcnRpZmljYXRp", + "b25fbmFtZRgCIAEoDjI3Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9k", + "dWN0cy52MS5DZXJ0aWZpY2F0aW9uTmFtZUgBiAEBEh8KEmNlcnRpZmljYXRp", + "b25fY29kZRgDIAEoCUgCiAEBEiAKE2NlcnRpZmljYXRpb25fdmFsdWUYBCAB", + "KAlIA4gBAUIaChhfY2VydGlmaWNhdGlvbl9hdXRob3JpdHlCFQoTX2NlcnRp", + "ZmljYXRpb25fbmFtZUIVChNfY2VydGlmaWNhdGlvbl9jb2RlQhYKFF9jZXJ0", + "aWZpY2F0aW9uX3ZhbHVlIqYBCg9TdHJ1Y3R1cmVkVGl0bGUSWQoTZGlnaXRh", + "bF9zb3VyY2VfdHlwZRgBIAEoDjI3Lmdvb2dsZS5zaG9wcGluZy5tZXJjaGFu", + "dC5wcm9kdWN0cy52MS5EaWdpdGFsU291cmNlVHlwZUgAiAEBEhQKB2NvbnRl", + "bnQYAiABKAlIAYgBAUIWChRfZGlnaXRhbF9zb3VyY2VfdHlwZUIKCghfY29u", + "dGVudCKsAQoVU3RydWN0dXJlZERlc2NyaXB0aW9uElkKE2RpZ2l0YWxfc291", + "cmNlX3R5cGUYASABKA4yNy5nb29nbGUuc2hvcHBpbmcubWVyY2hhbnQucHJv", + "ZHVjdHMudjEuRGlnaXRhbFNvdXJjZVR5cGVIAIgBARIUCgdjb250ZW50GAIg", + "ASgJSAGIAQFCFgoUX2RpZ2l0YWxfc291cmNlX3R5cGVCCgoIX2NvbnRlbnQi", + "OQoQUHJvZHVjdERpbWVuc2lvbhISCgV2YWx1ZRgBIAEoAUID4EECEhEKBHVu", + "aXQYAiABKAlCA+BBAiI2Cg1Qcm9kdWN0V2VpZ2h0EhIKBXZhbHVlGAEgASgB", + "QgPgQQISEQoEdW5pdBgCIAEoCUID4EECIusHCg1Qcm9kdWN0U3RhdHVzEmMK", + "FGRlc3RpbmF0aW9uX3N0YXR1c2VzGAMgAygLMkUuZ29vZ2xlLnNob3BwaW5n", + "Lm1lcmNoYW50LnByb2R1Y3RzLnYxLlByb2R1Y3RTdGF0dXMuRGVzdGluYXRp", + "b25TdGF0dXMSXQoRaXRlbV9sZXZlbF9pc3N1ZXMYBCADKAsyQi5nb29nbGUu", + "c2hvcHBpbmcubWVyY2hhbnQucHJvZHVjdHMudjEuUHJvZHVjdFN0YXR1cy5J", + "dGVtTGV2ZWxJc3N1ZRIxCg1jcmVhdGlvbl9kYXRlGAUgASgLMhouZ29vZ2xl", + "LnByb3RvYnVmLlRpbWVzdGFtcBI0ChBsYXN0X3VwZGF0ZV9kYXRlGAYgASgL", + "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBI6ChZnb29nbGVfZXhwaXJh", + "dGlvbl9kYXRlGAcgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBrB", + "AQoRRGVzdGluYXRpb25TdGF0dXMSVgoRcmVwb3J0aW5nX2NvbnRleHQYASAB", + "KA4yOy5nb29nbGUuc2hvcHBpbmcudHlwZS5SZXBvcnRpbmdDb250ZXh0LlJl", + "cG9ydGluZ0NvbnRleHRFbnVtEhoKEmFwcHJvdmVkX2NvdW50cmllcxgCIAMo", + "CRIZChFwZW5kaW5nX2NvdW50cmllcxgDIAMoCRIdChVkaXNhcHByb3ZlZF9j", + "b3VudHJpZXMYBCADKAkarAMKDkl0ZW1MZXZlbElzc3VlEgwKBGNvZGUYASAB", + "KAkSXQoIc2V2ZXJpdHkYAiABKA4ySy5nb29nbGUuc2hvcHBpbmcubWVyY2hh", + "bnQucHJvZHVjdHMudjEuUHJvZHVjdFN0YXR1cy5JdGVtTGV2ZWxJc3N1ZS5T", + "ZXZlcml0eRISCgpyZXNvbHV0aW9uGAMgASgJEhEKCWF0dHJpYnV0ZRgEIAEo", + "CRJWChFyZXBvcnRpbmdfY29udGV4dBgFIAEoDjI7Lmdvb2dsZS5zaG9wcGlu", + "Zy50eXBlLlJlcG9ydGluZ0NvbnRleHQuUmVwb3J0aW5nQ29udGV4dEVudW0S", + "EwoLZGVzY3JpcHRpb24YBiABKAkSDgoGZGV0YWlsGAcgASgJEhUKDWRvY3Vt", + "ZW50YXRpb24YCCABKAkSHAoUYXBwbGljYWJsZV9jb3VudHJpZXMYCSADKAki", + "VAoIU2V2ZXJpdHkSGAoUU0VWRVJJVFlfVU5TUEVDSUZJRUQQABIQCgxOT1Rf", + "SU1QQUNURUQQARILCgdERU1PVEVEEAISDwoLRElTQVBQUk9WRUQQAyKlAgof", + "Q2xvdWRFeHBvcnRBZGRpdGlvbmFsUHJvcGVydGllcxIaCg1wcm9wZXJ0eV9u", + "YW1lGAEgASgJSACIAQESEgoKdGV4dF92YWx1ZRgCIAMoCRIXCgpib29sX3Zh", + "bHVlGAMgASgISAGIAQESEQoJaW50X3ZhbHVlGAQgAygDEhMKC2Zsb2F0X3Zh", + "bHVlGAUgAygCEhYKCW1pbl92YWx1ZRgGIAEoAkgCiAEBEhYKCW1heF92YWx1", + "ZRgHIAEoAkgDiAEBEhYKCXVuaXRfY29kZRgIIAEoCUgEiAEBQhAKDl9wcm9w", + "ZXJ0eV9uYW1lQg0KC19ib29sX3ZhbHVlQgwKCl9taW5fdmFsdWVCDAoKX21h", + "eF92YWx1ZUIMCgpfdW5pdF9jb2RlIp0CCh5Qcm9kdWN0U3VzdGFpbmFiaWxp", + "dHlJbmNlbnRpdmUSLQoGYW1vdW50GAIgASgLMhsuZ29vZ2xlLnNob3BwaW5n", + "LnR5cGUuUHJpY2VIABIUCgpwZXJjZW50YWdlGAMgASgBSAASXAoEdHlwZRgB", + "IAEoDjJJLmdvb2dsZS5zaG9wcGluZy5tZXJjaGFudC5wcm9kdWN0cy52MS5Q", + "cm9kdWN0U3VzdGFpbmFiaWxpdHlJbmNlbnRpdmUuVHlwZUgBiAEBIkYKBFR5", + "cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEhEKDUVWX1RBWF9DUkVESVQQARIV", + "ChFFVl9QUklDRV9ESVNDT1VOVBACQgcKBXZhbHVlQgcKBV90eXBlIrQBChJB", + "dXRvbWF0ZWREaXNjb3VudHMSMAoLcHJpb3JfcHJpY2UYASABKAsyGy5nb29n", + "bGUuc2hvcHBpbmcudHlwZS5QcmljZRI8Chdwcmlvcl9wcmljZV9wcm9ncmVz", + "c2l2ZRgCIAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlEi4KCWdh", + "ZF9wcmljZRgDIAEoCzIbLmdvb2dsZS5zaG9wcGluZy50eXBlLlByaWNlIuAB", + "ChJIYW5kbGluZ0N1dG9mZlRpbWUSFAoHY291bnRyeRgBIAEoCUgAiAEBEhgK", + "C2N1dG9mZl90aW1lGAIgASgJSAGIAQESHAoPY3V0b2ZmX3RpbWV6b25lGAMg", + "ASgJSAKIAQESKgodZGlzYWJsZV9kZWxpdmVyeV9hZnRlcl9jdXRvZmYYBCAB", + "KAhIA4gBAUIKCghfY291bnRyeUIOCgxfY3V0b2ZmX3RpbWVCEgoQX2N1dG9m", + "Zl90aW1lem9uZUIgCh5fZGlzYWJsZV9kZWxpdmVyeV9hZnRlcl9jdXRvZmYq", + "WAoSU3Vic2NyaXB0aW9uUGVyaW9kEiMKH1NVQlNDUklQVElPTl9QRVJJT0Rf", + "VU5TUEVDSUZJRUQQABIJCgVNT05USBABEggKBFlFQVIQAhIICgRXRUVLEAMq", + "YAoIQWdlR3JvdXASGQoVQUdFX0dST1VQX1VOU1BFQ0lGSUVEEAASCQoFQURV", + "TFQQARIICgRLSURTEAISCwoHVE9ERExFUhADEgoKBklORkFOVBAEEgsKB05F", + "V0JPUk4QBSqDAQoMQXZhaWxhYmlsaXR5EhwKGEFWQUlMQUJJTElUWV9VTlNQ", + "RUNJRklFRBAAEgwKCElOX1NUT0NLEAESEAoMT1VUX09GX1NUT0NLEAISDAoI", + "UFJFT1JERVIQAxIYChRMSU1JVEVEX0FWQUlMQUJJTElUWRAEEg0KCUJBQ0tP", + "UkRFUhAFKkoKCUNvbmRpdGlvbhIZChVDT05ESVRJT05fVU5TUEVDSUZJRUQQ", + "ABIHCgNORVcQARIICgRVU0VEEAISDwoLUkVGVVJCSVNIRUQQAypCCgZHZW5k", + "ZXISFgoSR0VOREVSX1VOU1BFQ0lGSUVEEAASCAoETUFMRRABEgoKBkZFTUFM", + "RRACEgoKBlVOSVNFWBADKkEKCkNyZWRpdFR5cGUSGwoXQ1JFRElUX1RZUEVf", + "VU5TUEVDSUZJRUQQABILCgdGSU5BTkNFEAESCQoFTEVBU0UQAiqCAQoKU2l6", + "ZVN5c3RlbRIbChdTSVpFX1NZU1RFTV9VTlNQRUNJRklFRBAAEgYKAkFVEAES", + "BgoCQlIQAhIGCgJDThADEgYKAkRFEAQSBgoCRVUQBRIGCgJGUhAGEgYKAklU", + "EAcSBgoCSlAQCBIHCgNNRVgQCRIGCgJVSxAKEgYKAlVTEAsqagoIU2l6ZVR5", + "cGUSGQoVU0laRV9UWVBFX1VOU1BFQ0lGSUVEEAASCwoHUkVHVUxBUhABEgoK", + "BlBFVElURRACEg0KCU1BVEVSTklUWRADEgcKA0JJRxAEEggKBFRBTEwQBRII", + "CgRQTFVTEAYqjAEKFUVuZXJneUVmZmljaWVuY3lDbGFzcxInCiNFTkVSR1lf", + "RUZGSUNJRU5DWV9DTEFTU19VTlNQRUNJRklFRBAAEggKBEFQUFAQARIHCgNB", + "UFAQAhIGCgJBUBADEgUKAUEQBBIFCgFCEAUSBQoBQxAGEgUKAUQQBxIFCgFF", + "EAgSBQoBRhAJEgUKAUcQCippCgxQaWNrdXBNZXRob2QSHQoZUElDS1VQX01F", + "VEhPRF9VTlNQRUNJRklFRBAAEhEKDU5PVF9TVVBQT1JURUQQARIHCgNCVVkQ", + "AhILCgdSRVNFUlZFEAMSEQoNU0hJUF9UT19TVE9SRRAEKpgBCglQaWNrdXBT", + "bGESGgoWUElDS1VQX1NMQV9VTlNQRUNJRklFRBAAEgwKCFNBTUVfREFZEAES", + "DAoITkVYVF9EQVkQAhILCgdUV09fREFZEAMSDQoJVEhSRUVfREFZEAQSDAoI", + "Rk9VUl9EQVkQBRIMCghGSVZFX0RBWRAGEgsKB1NJWF9EQVkQBxIOCgpNVUxU", + "SV9XRUVLEAgqMAoFUGF1c2USFQoRUEFVU0VfVU5TUEVDSUZJRUQQABIHCgNB", + "RFMQARIHCgNBTEwQAipnChZDZXJ0aWZpY2F0aW9uQXV0aG9yaXR5EicKI0NF", + "UlRJRklDQVRJT05fQVVUSE9SSVRZX1VOU1BFQ0lGSUVEEAASCQoFQURFTUUQ", + "ARIICgRCTVdLEAISBwoDRVBBEAMSBgoCRUMQBCrVAQoRQ2VydGlmaWNhdGlv", + "bk5hbWUSIgoeQ0VSVElGSUNBVElPTl9OQU1FX1VOU1BFQ0lGSUVEEAASDwoL", + "RU5FUkdZX1NUQVIQARIeChpFTkVSR1lfU1RBUl9NT1NUX0VGRklDSUVOVBAC", + "EgkKBUVQUkVMEAMSDwoLRVVfRUNPTEFCRUwQBBIdChlWRUhJQ0xFX0VORVJH", + "WV9FRkZJQ0lFTkNZEAUSMAosVkVISUNMRV9FTkVSR1lfRUZGSUNJRU5DWV9E", + "SVNDSEFSR0VEX0JBVFRFUlkQBipkChFEaWdpdGFsU291cmNlVHlwZRIjCh9E", + "SUdJVEFMX1NPVVJDRV9UWVBFX1VOU1BFQ0lGSUVEEAASHQoZVFJBSU5FRF9B", + "TEdPUklUSE1JQ19NRURJQRABEgsKB0RFRkFVTFQQAirIBwoYQ2FycmllclRy", + "YW5zaXRUaW1lT3B0aW9uEisKJ0NBUlJJRVJfVFJBTlNJVF9USU1FX09QVElP", + "Tl9VTlNQRUNJRklFRBAAEg0KCURITF9QQUtFVBABEhAKDERITF9QQUNLQ0hF", + "ThACEhMKD0RITF9FWFBSRVNTRUFTWRADEg8KC0RQRF9FWFBSRVNTEAQSFgoS", + "RFBEX0NMQVNTSUNfUEFSQ0VMEAUSEgoOSEVSTUVTX0hBVVNUVVIQBhIUChBI", + "RVJNRVNfUEFLRVRTSE9QEAcSEAoMR0xTX0JVU0lORVNTEAgSDwoLR0xTX0VY", + "UFJFU1MQCRIPCgtHTFNfUFJJVkFURRAKEhYKEkNPTElTU0lNT19ET01JQ0lM", + "RRALEhQKEERITF9FWFBSRVNTXzEyQU0QDBITCg9ESExfRVhQUkVTU185QU0Q", + "DRISCg5HRU9ESVNfRVhQUkVTUxAOEhIKDkdFT0RJU19QQUNLXzMwEA8SEwoP", + "R0VPRElTX1NBTUVfREFZEBASEQoNR0VPRElTX1RPUF8yNBAREhUKEVROVF9F", + "U1NFTlRJRUxfMjRIEBISHQoZVE5UX0VTU0VOVElFTF9GTEVYSUJJTElURRAT", + "EhAKDEZFREVYX0dST1VORBAUEhcKE0ZFREVYX0hPTUVfREVMSVZFUlkQFRIX", + "ChNGRURFWF9FWFBSRVNTX1NBVkVSEBYSGQoVRkVERVhfRklSU1RfT1ZFUk5J", + "R0hUEBcSHAoYRkVERVhfUFJJT1JJVFlfT1ZFUk5JR0hUEBgSHAoYRkVERVhf", + "U1RBTkRBUkRfT1ZFUk5JR0hUEBkSDgoKRkVERVhfMkRBWRAaEhMKD1VQU18y", + "TkRfREFZX0FJUhAbEhIKDlVQU18yTkRfREFZX0FNEBwSFAoQVVBTXzNfREFZ", + "X1NFTEVDVBAdEg4KClVQU19HUk9VTkQQHhIUChBVUFNfTkVYVF9EQVlfQUlS", + "EB8SHQoZVVBTX05FWFRfREFZX0FJUl9FQVJMWV9BTRAgEhoKFlVQU19ORVhU", + "X0RBWV9BSVJfU0FWRVIQIRIeChpVU1BTX1BSSU9SSVRZX01BSUxfRVhQUkVT", + "UxAiEhMKD1VTUFNfTUVESUFfTUFJTBAjEiAKHFVTUFNfR1JPVU5EX0FEVkFO", + "VEFHRV9SRVRBSUwQJBIWChJVU1BTX1BSSU9SSVRZX01BSUwQJRIkCiBVU1BT", + "X0dST1VORF9BRFZBTlRBR0VfQ09NTUVSQ0lBTBAmEhkKFVVTUFNfRklSU1Rf", + "Q0xBU1NfTUFJTBAnQoYCCihjb20uZ29vZ2xlLnNob3BwaW5nLm1lcmNoYW50", + "LnByb2R1Y3RzLnYxQhNQcm9kdWN0c0NvbW1vblByb3RvUAFaSmNsb3VkLmdv", + "b2dsZS5jb20vZ28vc2hvcHBpbmcvbWVyY2hhbnQvcHJvZHVjdHMvYXBpdjEv", + "cHJvZHVjdHNwYjtwcm9kdWN0c3BiqgIkR29vZ2xlLlNob3BwaW5nLk1lcmNo", + "YW50LlByb2R1Y3RzLlYxygIkR29vZ2xlXFNob3BwaW5nXE1lcmNoYW50XFBy", + "b2R1Y3RzXFYx6gIoR29vZ2xlOjpTaG9wcGluZzo6TWVyY2hhbnQ6OlByb2R1", + "Y3RzOjpWMWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Shopping.Type.TypesReflection.Descriptor, global::Google.Type.IntervalReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Shopping.Merchant.Products.V1.SubscriptionPeriod), typeof(global::Google.Shopping.Merchant.Products.V1.AgeGroup), typeof(global::Google.Shopping.Merchant.Products.V1.Availability), typeof(global::Google.Shopping.Merchant.Products.V1.Condition), typeof(global::Google.Shopping.Merchant.Products.V1.Gender), typeof(global::Google.Shopping.Merchant.Products.V1.CreditType), typeof(global::Google.Shopping.Merchant.Products.V1.SizeSystem), typeof(global::Google.Shopping.Merchant.Products.V1.SizeType), typeof(global::Google.Shopping.Merchant.Products.V1.EnergyEfficiencyClass), typeof(global::Google.Shopping.Merchant.Products.V1.PickupMethod), typeof(global::Google.Shopping.Merchant.Products.V1.PickupSla), typeof(global::Google.Shopping.Merchant.Products.V1.Pause), typeof(global::Google.Shopping.Merchant.Products.V1.CertificationAuthority), typeof(global::Google.Shopping.Merchant.Products.V1.CertificationName), typeof(global::Google.Shopping.Merchant.Products.V1.DigitalSourceType), typeof(global::Google.Shopping.Merchant.Products.V1.CarrierTransitTimeOption), }, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes), global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Parser, new[]{ "IdentifierExists", "IsBundle", "Title", "Description", "Link", "MobileLink", "CanonicalLink", "ImageLink", "AdditionalImageLinks", "ExpirationDate", "DisclosureDate", "Adult", "AgeGroup", "Availability", "AvailabilityDate", "Brand", "Color", "Condition", "Gender", "GoogleProductCategory", "Gtins", "ItemGroupId", "Material", "Mpn", "Pattern", "Price", "MaximumRetailPrice", "Installment", "SubscriptionCost", "LoyaltyPoints", "LoyaltyPrograms", "ProductTypes", "SalePrice", "SalePriceEffectiveDate", "SellOnGoogleQuantity", "ProductHeight", "ProductLength", "ProductWidth", "ProductWeight", "Shipping", "CarrierShipping", "FreeShippingThreshold", "ShippingWeight", "ShippingLength", "ShippingWidth", "ShippingHeight", "MaxHandlingTime", "MinHandlingTime", "ShippingHandlingBusinessDays", "ShippingTransitBusinessDays", "HandlingCutoffTimes", "ShippingLabel", "ReturnPolicyLabel", "TransitTimeLabel", "Size", "SizeSystem", "SizeTypes", "EnergyEfficiencyClass", "MinEnergyEfficiencyClass", "MaxEnergyEfficiencyClass", "UnitPricingMeasure", "UnitPricingBaseMeasure", "Multipack", "AdsGrouping", "AdsLabels", "AdsRedirect", "CostOfGoodsSold", "ProductDetails", "ProductHighlights", "DisplayAdsId", "DisplayAdsSimilarIds", "DisplayAdsTitle", "DisplayAdsLink", "DisplayAdsValue", "PromotionIds", "PickupMethod", "PickupSla", "LinkTemplate", "MobileLinkTemplate", "CustomLabel0", "CustomLabel1", "CustomLabel2", "CustomLabel3", "CustomLabel4", "IncludedDestinations", "ExcludedDestinations", "ShoppingAdsExcludedCountries", "ExternalSellerId", "Pause", "LifestyleImageLinks", "CloudExportAdditionalProperties", "VirtualModelLink", "Certifications", "StructuredTitle", "StructuredDescription", "AutoPricingMinPrice", "SustainabilityIncentives" }, new[]{ "IdentifierExists", "IsBundle", "Title", "Description", "Link", "MobileLink", "CanonicalLink", "ImageLink", "Adult", "AgeGroup", "Availability", "Brand", "Color", "Condition", "Gender", "GoogleProductCategory", "ItemGroupId", "Material", "Mpn", "Pattern", "SellOnGoogleQuantity", "MaxHandlingTime", "MinHandlingTime", "ShippingLabel", "ReturnPolicyLabel", "TransitTimeLabel", "Size", "SizeSystem", "EnergyEfficiencyClass", "MinEnergyEfficiencyClass", "MaxEnergyEfficiencyClass", "Multipack", "AdsGrouping", "AdsRedirect", "DisplayAdsId", "DisplayAdsTitle", "DisplayAdsLink", "DisplayAdsValue", "PickupMethod", "PickupSla", "LinkTemplate", "MobileLinkTemplate", "CustomLabel0", "CustomLabel1", "CustomLabel2", "CustomLabel3", "CustomLabel4", "ExternalSellerId", "Pause", "VirtualModelLink", "StructuredTitle", "StructuredDescription" }, new[]{ typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.CarrierPriceOption) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.ShippingBusinessDaysConfig), global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.ShippingBusinessDaysConfig.Parser, new[]{ "Country", "BusinessDays" }, new[]{ "Country", "BusinessDays" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes), global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Parser, new[]{ "IdentifierExists", "IsBundle", "Title", "Description", "Link", "MobileLink", "CanonicalLink", "ImageLink", "AdditionalImageLinks", "ExpirationDate", "DisclosureDate", "Adult", "AgeGroup", "Availability", "AvailabilityDate", "Brand", "Color", "Condition", "Gender", "GoogleProductCategory", "Gtins", "ItemGroupId", "Material", "Mpn", "Pattern", "Price", "MaximumRetailPrice", "Installment", "SubscriptionCost", "LoyaltyPoints", "LoyaltyPrograms", "ProductTypes", "SalePrice", "SalePriceEffectiveDate", "SellOnGoogleQuantity", "ProductHeight", "ProductLength", "ProductWidth", "ProductWeight", "Shipping", "CarrierShipping", "FreeShippingThreshold", "ShippingWeight", "ShippingLength", "ShippingWidth", "ShippingHeight", "MaxHandlingTime", "MinHandlingTime", "ShippingHandlingBusinessDays", "ShippingTransitBusinessDays", "HandlingCutoffTimes", "ShippingLabel", "ReturnPolicyLabel", "TransitTimeLabel", "Size", "SizeSystem", "SizeTypes", "EnergyEfficiencyClass", "MinEnergyEfficiencyClass", "MaxEnergyEfficiencyClass", "UnitPricingMeasure", "UnitPricingBaseMeasure", "Multipack", "AdsGrouping", "AdsLabels", "AdsRedirect", "CostOfGoodsSold", "ProductDetails", "ProductHighlights", "DisplayAdsId", "DisplayAdsSimilarIds", "DisplayAdsTitle", "DisplayAdsLink", "DisplayAdsValue", "PromotionIds", "PickupMethod", "PickupSla", "LinkTemplate", "MobileLinkTemplate", "CustomLabel0", "CustomLabel1", "CustomLabel2", "CustomLabel3", "CustomLabel4", "IncludedDestinations", "ExcludedDestinations", "ShoppingAdsExcludedCountries", "ExternalSellerId", "Pause", "LifestyleImageLinks", "CloudExportAdditionalProperties", "VirtualModelLink", "Certifications", "StructuredTitle", "StructuredDescription", "AutoPricingMinPrice", "SustainabilityIncentives", "VideoLinks" }, new[]{ "IdentifierExists", "IsBundle", "Title", "Description", "Link", "MobileLink", "CanonicalLink", "ImageLink", "Adult", "AgeGroup", "Availability", "Brand", "Color", "Condition", "Gender", "GoogleProductCategory", "ItemGroupId", "Material", "Mpn", "Pattern", "SellOnGoogleQuantity", "MaxHandlingTime", "MinHandlingTime", "ShippingLabel", "ReturnPolicyLabel", "TransitTimeLabel", "Size", "SizeSystem", "EnergyEfficiencyClass", "MinEnergyEfficiencyClass", "MaxEnergyEfficiencyClass", "Multipack", "AdsGrouping", "AdsRedirect", "DisplayAdsId", "DisplayAdsTitle", "DisplayAdsLink", "DisplayAdsValue", "PickupMethod", "PickupSla", "LinkTemplate", "MobileLinkTemplate", "CustomLabel0", "CustomLabel1", "CustomLabel2", "CustomLabel3", "CustomLabel4", "ExternalSellerId", "Pause", "VirtualModelLink", "StructuredTitle", "StructuredDescription" }, new[]{ typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.CarrierPriceOption) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.ShippingBusinessDaysConfig), global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.ShippingBusinessDaysConfig.Parser, new[]{ "Country", "BusinessDays" }, new[]{ "Country", "BusinessDays" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.CarrierShipping), global::Google.Shopping.Merchant.Products.V1.ProductAttributes.Types.CarrierShipping.Parser, new[]{ "Country", "Region", "PostalCode", "OriginPostalCode", "FlatPrice", "CarrierPrice", "CarrierPriceFlatAdjustment", "CarrierPricePercentageAdjustment", "MinHandlingTime", "MaxHandlingTime", "FixedMinTransitTime", "FixedMaxTransitTime", "CarrierTransitTime" }, new[]{ "Country", "Region", "PostalCode", "OriginPostalCode", "FlatPrice", "CarrierPrice", "CarrierPriceFlatAdjustment", "CarrierPricePercentageAdjustment", "MinHandlingTime", "MaxHandlingTime", "FixedMinTransitTime", "FixedMaxTransitTime", "CarrierTransitTime" }, null, null, null)}), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ShippingWeight), global::Google.Shopping.Merchant.Products.V1.ShippingWeight.Parser, new[]{ "Value", "Unit" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ShippingDimension), global::Google.Shopping.Merchant.Products.V1.ShippingDimension.Parser, new[]{ "Value", "Unit" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.UnitPricingBaseMeasure), global::Google.Shopping.Merchant.Products.V1.UnitPricingBaseMeasure.Parser, new[]{ "Value", "Unit" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.UnitPricingMeasure), global::Google.Shopping.Merchant.Products.V1.UnitPricingMeasure.Parser, new[]{ "Value", "Unit" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.SubscriptionCost), global::Google.Shopping.Merchant.Products.V1.SubscriptionCost.Parser, new[]{ "Period", "PeriodLength", "Amount" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductInstallment), global::Google.Shopping.Merchant.Products.V1.ProductInstallment.Parser, new[]{ "Months", "Amount", "Downpayment", "CreditType" }, new[]{ "Downpayment", "CreditType" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.ProductInstallment), global::Google.Shopping.Merchant.Products.V1.ProductInstallment.Parser, new[]{ "Months", "Amount", "Downpayment", "CreditType", "AnnualPercentageRate" }, new[]{ "Downpayment", "CreditType", "AnnualPercentageRate" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.LoyaltyPoints), global::Google.Shopping.Merchant.Products.V1.LoyaltyPoints.Parser, new[]{ "Name", "PointsValue", "Ratio" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.LoyaltyProgram), global::Google.Shopping.Merchant.Products.V1.LoyaltyProgram.Parser, new[]{ "ProgramLabel", "TierLabel", "Price", "CashbackForFutureUse", "LoyaltyPoints", "MemberPriceEffectiveDate", "ShippingLabel" }, new[]{ "ProgramLabel", "TierLabel", "Price", "CashbackForFutureUse", "LoyaltyPoints", "MemberPriceEffectiveDate", "ShippingLabel" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Shopping.Merchant.Products.V1.Shipping), global::Google.Shopping.Merchant.Products.V1.Shipping.Parser, new[]{ "Price", "Country", "Region", "Service", "LocationId", "LocationGroupName", "PostalCode", "MinHandlingTime", "MaxHandlingTime", "MinTransitTime", "MaxTransitTime", "HandlingCutoffTime", "HandlingCutoffTimezone" }, new[]{ "MinHandlingTime", "MaxHandlingTime", "MinTransitTime", "MaxTransitTime", "HandlingCutoffTime", "HandlingCutoffTimezone" }, null, null, null), @@ -1210,6 +1212,7 @@ public ProductAttributes(ProductAttributes other) : this() { structuredDescription_ = other.structuredDescription_ != null ? other.structuredDescription_.Clone() : null; autoPricingMinPrice_ = other.autoPricingMinPrice_ != null ? other.autoPricingMinPrice_.Clone() : null; sustainabilityIncentives_ = other.sustainabilityIncentives_.Clone(); + videoLinks_ = other.videoLinks_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -1780,7 +1783,7 @@ public void ClearGoogleProductCategory() { private readonly pbc::RepeatedField gtins_ = new pbc::RepeatedField(); /// /// Global Trade Item Numbers - /// ([GTIN](https://support.google.com/merchants/answer/188494#gtin)) of the + /// ([GTIN](https://support.google.com/merchants/answer/6324461)) of the /// item. /// You can provide up to 10 GTINs. /// @@ -1856,7 +1859,7 @@ public void ClearMaterial() { private string mpn_; /// /// Manufacturer Part Number - /// ([MPN](https://support.google.com/merchants/answer/188494#mpn)) of the + /// ([MPN](https://support.google.com/merchants/answer/6324482)) of the /// item. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -3489,6 +3492,23 @@ public void ClearVirtualModelLink() { get { return sustainabilityIncentives_; } } + /// Field number for the "video_links" field. + public const int VideoLinksFieldNumber = 169; + private static readonly pb::FieldCodec _repeated_videoLinks_codec + = pb::FieldCodec.ForString(1354); + private readonly pbc::RepeatedField videoLinks_ = new pbc::RepeatedField(); + /// + /// Optional. A list of video URLs for the item. Use this attribute to provide + /// more visuals for your product beyond your image attributes. See the [Help + /// Center article](https://support.google.com/merchants/answer/15216925) for + /// more information. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField VideoLinks { + get { return videoLinks_; } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -3601,6 +3621,7 @@ public bool Equals(ProductAttributes other) { if (!object.Equals(StructuredDescription, other.StructuredDescription)) return false; if (!object.Equals(AutoPricingMinPrice, other.AutoPricingMinPrice)) return false; if(!sustainabilityIncentives_.Equals(other.sustainabilityIncentives_)) return false; + if(!videoLinks_.Equals(other.videoLinks_)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -3705,6 +3726,7 @@ public override int GetHashCode() { if (structuredDescription_ != null) hash ^= StructuredDescription.GetHashCode(); if (autoPricingMinPrice_ != null) hash ^= AutoPricingMinPrice.GetHashCode(); hash ^= sustainabilityIncentives_.GetHashCode(); + hash ^= videoLinks_.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4038,6 +4060,7 @@ public void WriteTo(pb::CodedOutputStream output) { carrierShipping_.WriteTo(output, _repeated_carrierShipping_codec); shippingHandlingBusinessDays_.WriteTo(output, _repeated_shippingHandlingBusinessDays_codec); shippingTransitBusinessDays_.WriteTo(output, _repeated_shippingTransitBusinessDays_codec); + videoLinks_.WriteTo(output, _repeated_videoLinks_codec); if (HasReturnPolicyLabel) { output.WriteRawTag(210, 10); output.WriteString(ReturnPolicyLabel); @@ -4367,6 +4390,7 @@ public void WriteTo(pb::CodedOutputStream output) { carrierShipping_.WriteTo(ref output, _repeated_carrierShipping_codec); shippingHandlingBusinessDays_.WriteTo(ref output, _repeated_shippingHandlingBusinessDays_codec); shippingTransitBusinessDays_.WriteTo(ref output, _repeated_shippingTransitBusinessDays_codec); + videoLinks_.WriteTo(ref output, _repeated_videoLinks_codec); if (HasReturnPolicyLabel) { output.WriteRawTag(210, 10); output.WriteString(ReturnPolicyLabel); @@ -4626,6 +4650,7 @@ public int CalculateSize() { size += 2 + pb::CodedOutputStream.ComputeMessageSize(AutoPricingMinPrice); } size += sustainabilityIncentives_.CalculateSize(_repeated_sustainabilityIncentives_codec); + size += videoLinks_.CalculateSize(_repeated_videoLinks_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -4955,6 +4980,7 @@ public void MergeFrom(ProductAttributes other) { AutoPricingMinPrice.MergeFrom(other.AutoPricingMinPrice); } sustainabilityIncentives_.Add(other.sustainabilityIncentives_); + videoLinks_.Add(other.videoLinks_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -5433,6 +5459,10 @@ public void MergeFrom(pb::CodedInputStream input) { shippingTransitBusinessDays_.AddEntriesFrom(input, _repeated_shippingTransitBusinessDays_codec); break; } + case 1354: { + videoLinks_.AddEntriesFrom(input, _repeated_videoLinks_codec); + break; + } case 1362: { ReturnPolicyLabel = input.ReadString(); break; @@ -5915,6 +5945,10 @@ public void MergeFrom(pb::CodedInputStream input) { shippingTransitBusinessDays_.AddEntriesFrom(ref input, _repeated_shippingTransitBusinessDays_codec); break; } + case 1354: { + videoLinks_.AddEntriesFrom(ref input, _repeated_videoLinks_codec); + break; + } case 1362: { ReturnPolicyLabel = input.ReadString(); break; @@ -8725,6 +8759,7 @@ public ProductInstallment(ProductInstallment other) : this() { amount_ = other.amount_ != null ? other.amount_.Clone() : null; downpayment_ = other.downpayment_ != null ? other.downpayment_.Clone() : null; creditType_ = other.creditType_; + annualPercentageRate_ = other.annualPercentageRate_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -8809,6 +8844,36 @@ public void ClearCreditType() { _hasBits0 &= ~1; } + /// Field number for the "annual_percentage_rate" field. + public const int AnnualPercentageRateFieldNumber = 5; + private readonly static double AnnualPercentageRateDefaultValue = 0D; + + private double annualPercentageRate_; + /// + /// Optional. Annual percentage rate for `credit_type` finance + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public double AnnualPercentageRate { + get { if ((_hasBits0 & 2) != 0) { return annualPercentageRate_; } else { return AnnualPercentageRateDefaultValue; } } + set { + _hasBits0 |= 2; + annualPercentageRate_ = value; + } + } + /// Gets whether the "annual_percentage_rate" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAnnualPercentageRate { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "annual_percentage_rate" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAnnualPercentageRate() { + _hasBits0 &= ~2; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -8828,6 +8893,7 @@ public bool Equals(ProductInstallment other) { if (!object.Equals(Amount, other.Amount)) return false; if (!object.Equals(Downpayment, other.Downpayment)) return false; if (CreditType != other.CreditType) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(AnnualPercentageRate, other.AnnualPercentageRate)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8839,6 +8905,7 @@ public override int GetHashCode() { if (amount_ != null) hash ^= Amount.GetHashCode(); if (downpayment_ != null) hash ^= Downpayment.GetHashCode(); if (HasCreditType) hash ^= CreditType.GetHashCode(); + if (HasAnnualPercentageRate) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(AnnualPercentageRate); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8873,6 +8940,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(32); output.WriteEnum((int) CreditType); } + if (HasAnnualPercentageRate) { + output.WriteRawTag(41); + output.WriteDouble(AnnualPercentageRate); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8899,6 +8970,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(32); output.WriteEnum((int) CreditType); } + if (HasAnnualPercentageRate) { + output.WriteRawTag(41); + output.WriteDouble(AnnualPercentageRate); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8921,6 +8996,9 @@ public int CalculateSize() { if (HasCreditType) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) CreditType); } + if (HasAnnualPercentageRate) { + size += 1 + 8; + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8951,6 +9029,9 @@ public void MergeFrom(ProductInstallment other) { if (other.HasCreditType) { CreditType = other.CreditType; } + if (other.HasAnnualPercentageRate) { + AnnualPercentageRate = other.AnnualPercentageRate; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8992,6 +9073,10 @@ public void MergeFrom(pb::CodedInputStream input) { CreditType = (global::Google.Shopping.Merchant.Products.V1.CreditType) input.ReadEnum(); break; } + case 41: { + AnnualPercentageRate = input.ReadDouble(); + break; + } } } #endif @@ -9033,6 +9118,10 @@ public void MergeFrom(pb::CodedInputStream input) { CreditType = (global::Google.Shopping.Merchant.Products.V1.CreditType) input.ReadEnum(); break; } + case 41: { + AnnualPercentageRate = input.ReadDouble(); + break; + } } } } diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json index 75405be5350e..0041d2765187 100644 --- a/generator-input/pipeline-state.json +++ b/generator-input/pipeline-state.json @@ -4626,7 +4626,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-04-13T15:50:43.612636026Z", - "lastGeneratedCommit": "2aba48492ae471bfb717f5e9c5a190b7cc1c6636", + "lastGeneratedCommit": "4ae5f100d449a987a6f593f328259cb8671ae9be", "lastReleasedCommit": "2aba48492ae471bfb717f5e9c5a190b7cc1c6636", "apiPaths": [ "google/shopping/merchant/products/v1"