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/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 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 57bc7bccfac3..0041d2765187 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" @@ -2228,7 +2228,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-03-30T14:19:37.634844764Z", - "lastGeneratedCommit": "a90dc55a699b916cbff59aa8112e067f6bab5bd4", + "lastGeneratedCommit": "4ad1b6750926701f94ae8a88525395fd17b42cfe", "lastReleasedCommit": "a90dc55a699b916cbff59aa8112e067f6bab5bd4", "apiPaths": [ "google/cloud/netapp/v1" @@ -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"