diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/ChatServiceClient.FindGroupChatsRequestObjectAsyncSnippet.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/ChatServiceClient.FindGroupChatsRequestObjectAsyncSnippet.g.cs new file mode 100644 index 000000000000..9febc0a0e035 --- /dev/null +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/ChatServiceClient.FindGroupChatsRequestObjectAsyncSnippet.g.cs @@ -0,0 +1,82 @@ +// 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 chat_v1_generated_ChatService_FindGroupChats_async] + using Google.Api.Gax; + using Google.Apps.Chat.V1; + using System; + using System.Threading.Tasks; + + public sealed partial class GeneratedChatServiceClientSnippets + { + /// Snippet for FindGroupChatsAsync + /// + /// 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 FindGroupChatsRequestObjectAsync() + { + // Create client + ChatServiceClient chatServiceClient = await ChatServiceClient.CreateAsync(); + // Initialize request argument(s) + FindGroupChatsRequest request = new FindGroupChatsRequest + { + SpaceView = SpaceView.Unspecified, + Users = { "", }, + }; + // Make the request + PagedAsyncEnumerable response = chatServiceClient.FindGroupChatsAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await foreach (Space item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + await foreach (FindGroupChatsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Space item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Space item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END chat_v1_generated_ChatService_FindGroupChats_async] +} diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/ChatServiceClient.FindGroupChatsRequestObjectSnippet.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/ChatServiceClient.FindGroupChatsRequestObjectSnippet.g.cs new file mode 100644 index 000000000000..d934a4aadd63 --- /dev/null +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/ChatServiceClient.FindGroupChatsRequestObjectSnippet.g.cs @@ -0,0 +1,81 @@ +// 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 chat_v1_generated_ChatService_FindGroupChats_sync] + using Google.Api.Gax; + using Google.Apps.Chat.V1; + using System; + + public sealed partial class GeneratedChatServiceClientSnippets + { + /// Snippet for FindGroupChats + /// + /// 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 FindGroupChatsRequestObject() + { + // Create client + ChatServiceClient chatServiceClient = ChatServiceClient.Create(); + // Initialize request argument(s) + FindGroupChatsRequest request = new FindGroupChatsRequest + { + SpaceView = SpaceView.Unspecified, + Users = { "", }, + }; + // Make the request + PagedEnumerable response = chatServiceClient.FindGroupChats(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (Space item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (FindGroupChatsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Space item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Space item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + } + } + // [END chat_v1_generated_ChatService_FindGroupChats_sync] +} diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/snippet_metadata_google.chat.v1.json b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/snippet_metadata_google.chat.v1.json index 19f08f3b1734..abad8f9d8a5b 100644 --- a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/snippet_metadata_google.chat.v1.json +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.GeneratedSnippets/snippet_metadata_google.chat.v1.json @@ -4063,6 +4063,103 @@ } ] }, + { + "regionTag": "chat_v1_generated_ChatService_FindGroupChats_sync", + "title": "FindGroupChatsRequestObject", + "description": "Snippet for FindGroupChats", + "file": "ChatServiceClient.FindGroupChatsRequestObjectSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "FindGroupChats", + "fullName": "Google.Apps.Chat.V1.ChatServiceClient.FindGroupChats", + "parameters": [ + { + "type": "Google.Apps.Chat.V1.FindGroupChatsRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedEnumerable", + "client": { + "shortName": "ChatServiceClient", + "fullName": "Google.Apps.Chat.V1.ChatServiceClient" + }, + "method": { + "shortName": "FindGroupChats", + "fullName": "google.chat.v1.ChatService.FindGroupChats", + "service": { + "shortName": "ChatService", + "fullName": "google.chat.v1.ChatService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 79, + "type": "FULL" + }, + { + "start": 36, + "end": 77, + "type": "SHORT" + } + ] + }, + { + "regionTag": "chat_v1_generated_ChatService_FindGroupChats_async", + "title": "FindGroupChatsRequestObjectAsync", + "description": "Snippet for FindGroupChatsAsync", + "file": "ChatServiceClient.FindGroupChatsRequestObjectAsyncSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "FindGroupChatsAsync", + "fullName": "Google.Apps.Chat.V1.ChatServiceClient.FindGroupChatsAsync", + "async": true, + "parameters": [ + { + "type": "Google.Apps.Chat.V1.FindGroupChatsRequest", + "name": "request" + }, + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + } + ], + "resultType": "Google.Api.Gax.PagedAsyncEnumerable", + "client": { + "shortName": "ChatServiceClient", + "fullName": "Google.Apps.Chat.V1.ChatServiceClient" + }, + "method": { + "shortName": "FindGroupChats", + "fullName": "google.chat.v1.ChatService.FindGroupChats", + "service": { + "shortName": "ChatService", + "fullName": "google.chat.v1.ChatService" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 80, + "type": "FULL" + }, + { + "start": 37, + "end": 78, + "type": "SHORT" + } + ] + }, { "regionTag": "chat_v1_generated_ChatService_CreateMembership_sync", "title": "CreateMembershipRequestObject", diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.Snippets/ChatServiceClientSnippets.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.Snippets/ChatServiceClientSnippets.g.cs index bae7ba1655ad..8ab1d6aa6ce9 100644 --- a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.Snippets/ChatServiceClientSnippets.g.cs +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1.Snippets/ChatServiceClientSnippets.g.cs @@ -1912,6 +1912,104 @@ public async Task FindDirectMessageRequestObjectAsync() // End snippet } + /// Snippet for FindGroupChats + public void FindGroupChatsRequestObject() + { + // Snippet: FindGroupChats(FindGroupChatsRequest, CallSettings) + // Create client + ChatServiceClient chatServiceClient = ChatServiceClient.Create(); + // Initialize request argument(s) + FindGroupChatsRequest request = new FindGroupChatsRequest + { + SpaceView = SpaceView.Unspecified, + Users = { "", }, + }; + // Make the request + PagedEnumerable response = chatServiceClient.FindGroupChats(request); + + // Iterate over all response items, lazily performing RPCs as required + foreach (Space item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + foreach (FindGroupChatsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Space item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = response.ReadPage(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Space item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + + /// Snippet for FindGroupChatsAsync + public async Task FindGroupChatsRequestObjectAsync() + { + // Snippet: FindGroupChatsAsync(FindGroupChatsRequest, CallSettings) + // Create client + ChatServiceClient chatServiceClient = await ChatServiceClient.CreateAsync(); + // Initialize request argument(s) + FindGroupChatsRequest request = new FindGroupChatsRequest + { + SpaceView = SpaceView.Unspecified, + Users = { "", }, + }; + // Make the request + PagedAsyncEnumerable response = chatServiceClient.FindGroupChatsAsync(request); + + // Iterate over all response items, lazily performing RPCs as required + await foreach (Space item in response) + { + // Do something with each item + Console.WriteLine(item); + } + + // Or iterate over pages (of server-defined size), performing one RPC per page + await foreach (FindGroupChatsResponse page in response.AsRawResponses()) + { + // Do something with each page of items + Console.WriteLine("A page of results:"); + foreach (Space item in page) + { + // Do something with each item + Console.WriteLine(item); + } + } + + // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required + int pageSize = 10; + Page singlePage = await response.ReadPageAsync(pageSize); + // Do something with the page of items + Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); + foreach (Space item in singlePage) + { + // Do something with each item + Console.WriteLine(item); + } + // Store the pageToken, for when the next page is required. + string nextPageToken = singlePage.NextPageToken; + // End snippet + } + /// Snippet for CreateMembership public void CreateMembershipRequestObject() { diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatService.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatService.g.cs index 135fb0561884..deaef5833972 100644 --- a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatService.g.cs +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatService.g.cs @@ -35,7 +35,7 @@ static ChatServiceReflection() { "X3NldHRpbmcucHJvdG8aJWdvb2dsZS9jaGF0L3YxL3NwYWNlX3JlYWRfc3Rh", "dGUucHJvdG8aIGdvb2dsZS9jaGF0L3YxL3NwYWNlX3NldHVwLnByb3RvGiZn", "b29nbGUvY2hhdC92MS90aHJlYWRfcmVhZF9zdGF0ZS5wcm90bxobZ29vZ2xl", - "L3Byb3RvYnVmL2VtcHR5LnByb3RvMsw/CgtDaGF0U2VydmljZRKbAQoNQ3Jl", + "L3Byb3RvYnVmL2VtcHR5LnByb3RvMtFACgtDaGF0U2VydmljZRKbAQoNQ3Jl", "YXRlTWVzc2FnZRIkLmdvb2dsZS5jaGF0LnYxLkNyZWF0ZU1lc3NhZ2VSZXF1", "ZXN0GhcuZ29vZ2xlLmNoYXQudjEuTWVzc2FnZSJL2kEZcGFyZW50LG1lc3Nh", "Z2UsbWVzc2FnZV9pZILT5JMCKSIeL3YxL3twYXJlbnQ9c3BhY2VzLyp9L21l", @@ -89,138 +89,141 @@ static ChatServiceReflection() { "YW1lPXNwYWNlcy8qfTpjb21wbGV0ZUltcG9ydDoBKhJ6ChFGaW5kRGlyZWN0", "TWVzc2FnZRIoLmdvb2dsZS5jaGF0LnYxLkZpbmREaXJlY3RNZXNzYWdlUmVx", "dWVzdBoVLmdvb2dsZS5jaGF0LnYxLlNwYWNlIiSC0+STAh4SHC92MS9zcGFj", - "ZXM6ZmluZERpcmVjdE1lc3NhZ2USngEKEENyZWF0ZU1lbWJlcnNoaXASJy5n", - "b29nbGUuY2hhdC52MS5DcmVhdGVNZW1iZXJzaGlwUmVxdWVzdBoaLmdvb2ds", - "ZS5jaGF0LnYxLk1lbWJlcnNoaXAiRdpBEXBhcmVudCxtZW1iZXJzaGlwgtPk", - "kwIrIh0vdjEve3BhcmVudD1zcGFjZXMvKn0vbWVtYmVyczoKbWVtYmVyc2hp", - "cBKuAQoQVXBkYXRlTWVtYmVyc2hpcBInLmdvb2dsZS5jaGF0LnYxLlVwZGF0", - "ZU1lbWJlcnNoaXBSZXF1ZXN0GhouZ29vZ2xlLmNoYXQudjEuTWVtYmVyc2hp", - "cCJV2kEWbWVtYmVyc2hpcCx1cGRhdGVfbWFza4LT5JMCNjIoL3YxL3ttZW1i", - "ZXJzaGlwLm5hbWU9c3BhY2VzLyovbWVtYmVycy8qfToKbWVtYmVyc2hpcBKF", - "AQoQRGVsZXRlTWVtYmVyc2hpcBInLmdvb2dsZS5jaGF0LnYxLkRlbGV0ZU1l", - "bWJlcnNoaXBSZXF1ZXN0GhouZ29vZ2xlLmNoYXQudjEuTWVtYmVyc2hpcCIs", - "2kEEbmFtZYLT5JMCHyodL3YxL3tuYW1lPXNwYWNlcy8qL21lbWJlcnMvKn0S", - "oQEKDkNyZWF0ZVJlYWN0aW9uEiUuZ29vZ2xlLmNoYXQudjEuQ3JlYXRlUmVh", - "Y3Rpb25SZXF1ZXN0GhguZ29vZ2xlLmNoYXQudjEuUmVhY3Rpb24iTtpBD3Bh", - "cmVudCxyZWFjdGlvboLT5JMCNiIqL3YxL3twYXJlbnQ9c3BhY2VzLyovbWVz", - "c2FnZXMvKn0vcmVhY3Rpb25zOghyZWFjdGlvbhKZAQoNTGlzdFJlYWN0aW9u", - "cxIkLmdvb2dsZS5jaGF0LnYxLkxpc3RSZWFjdGlvbnNSZXF1ZXN0GiUuZ29v", - "Z2xlLmNoYXQudjEuTGlzdFJlYWN0aW9uc1Jlc3BvbnNlIjvaQQZwYXJlbnSC", - "0+STAiwSKi92MS97cGFyZW50PXNwYWNlcy8qL21lc3NhZ2VzLyp9L3JlYWN0", - "aW9ucxKKAQoORGVsZXRlUmVhY3Rpb24SJS5nb29nbGUuY2hhdC52MS5EZWxl", - "dGVSZWFjdGlvblJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiOdpB", - "BG5hbWWC0+STAiwqKi92MS97bmFtZT1zcGFjZXMvKi9tZXNzYWdlcy8qL3Jl", - "YWN0aW9ucy8qfRKRAQoRQ3JlYXRlQ3VzdG9tRW1vamkSKC5nb29nbGUuY2hh", - "dC52MS5DcmVhdGVDdXN0b21FbW9qaVJlcXVlc3QaGy5nb29nbGUuY2hhdC52", - "MS5DdXN0b21FbW9qaSI12kEMY3VzdG9tX2Vtb2ppgtPkkwIgIhAvdjEvY3Vz", - "dG9tRW1vamlzOgxjdXN0b21fZW1vamkSfgoOR2V0Q3VzdG9tRW1vamkSJS5n", - "b29nbGUuY2hhdC52MS5HZXRDdXN0b21FbW9qaVJlcXVlc3QaGy5nb29nbGUu", - "Y2hhdC52MS5DdXN0b21FbW9qaSIo2kEEbmFtZYLT5JMCGxIZL3YxL3tuYW1l", - "PWN1c3RvbUVtb2ppcy8qfRKCAQoQTGlzdEN1c3RvbUVtb2ppcxInLmdvb2ds", - "ZS5jaGF0LnYxLkxpc3RDdXN0b21FbW9qaXNSZXF1ZXN0GiguZ29vZ2xlLmNo", - "YXQudjEuTGlzdEN1c3RvbUVtb2ppc1Jlc3BvbnNlIhvaQQCC0+STAhISEC92", - "MS9jdXN0b21FbW9qaXMSfwoRRGVsZXRlQ3VzdG9tRW1vamkSKC5nb29nbGUu", - "Y2hhdC52MS5EZWxldGVDdXN0b21FbW9qaVJlcXVlc3QaFi5nb29nbGUucHJv", - "dG9idWYuRW1wdHkiKNpBBG5hbWWC0+STAhsqGS92MS97bmFtZT1jdXN0b21F", - "bW9qaXMvKn0SmAEKEUdldFNwYWNlUmVhZFN0YXRlEiguZ29vZ2xlLmNoYXQu", - "djEuR2V0U3BhY2VSZWFkU3RhdGVSZXF1ZXN0Gh4uZ29vZ2xlLmNoYXQudjEu", - "U3BhY2VSZWFkU3RhdGUiOdpBBG5hbWWC0+STAiwSKi92MS97bmFtZT11c2Vy", - "cy8qL3NwYWNlcy8qL3NwYWNlUmVhZFN0YXRlfRLZAQoUVXBkYXRlU3BhY2VS", - "ZWFkU3RhdGUSKy5nb29nbGUuY2hhdC52MS5VcGRhdGVTcGFjZVJlYWRTdGF0", - "ZVJlcXVlc3QaHi5nb29nbGUuY2hhdC52MS5TcGFjZVJlYWRTdGF0ZSJ02kEc", - "c3BhY2VfcmVhZF9zdGF0ZSx1cGRhdGVfbWFza4LT5JMCTzI7L3YxL3tzcGFj", - "ZV9yZWFkX3N0YXRlLm5hbWU9dXNlcnMvKi9zcGFjZXMvKi9zcGFjZVJlYWRT", - "dGF0ZX06EHNwYWNlX3JlYWRfc3RhdGUSpgEKEkdldFRocmVhZFJlYWRTdGF0", - "ZRIpLmdvb2dsZS5jaGF0LnYxLkdldFRocmVhZFJlYWRTdGF0ZVJlcXVlc3Qa", - "Hy5nb29nbGUuY2hhdC52MS5UaHJlYWRSZWFkU3RhdGUiRNpBBG5hbWWC0+ST", - "AjcSNS92MS97bmFtZT11c2Vycy8qL3NwYWNlcy8qL3RocmVhZHMvKi90aHJl", - "YWRSZWFkU3RhdGV9EoMBCg1HZXRTcGFjZUV2ZW50EiQuZ29vZ2xlLmNoYXQu", - "djEuR2V0U3BhY2VFdmVudFJlcXVlc3QaGi5nb29nbGUuY2hhdC52MS5TcGFj", - "ZUV2ZW50IjDaQQRuYW1lgtPkkwIjEiEvdjEve25hbWU9c3BhY2VzLyovc3Bh", - "Y2VFdmVudHMvKn0SnQEKD0xpc3RTcGFjZUV2ZW50cxImLmdvb2dsZS5jaGF0", - "LnYxLkxpc3RTcGFjZUV2ZW50c1JlcXVlc3QaJy5nb29nbGUuY2hhdC52MS5M", - "aXN0U3BhY2VFdmVudHNSZXNwb25zZSI52kENcGFyZW50LGZpbHRlcoLT5JMC", - "IxIhL3YxL3twYXJlbnQ9c3BhY2VzLyp9L3NwYWNlRXZlbnRzEsABChtHZXRT", - "cGFjZU5vdGlmaWNhdGlvblNldHRpbmcSMi5nb29nbGUuY2hhdC52MS5HZXRT", - "cGFjZU5vdGlmaWNhdGlvblNldHRpbmdSZXF1ZXN0GiguZ29vZ2xlLmNoYXQu", - "djEuU3BhY2VOb3RpZmljYXRpb25TZXR0aW5nIkPaQQRuYW1lgtPkkwI2EjQv", - "djEve25hbWU9dXNlcnMvKi9zcGFjZXMvKi9zcGFjZU5vdGlmaWNhdGlvblNl", - "dHRpbmd9EqACCh5VcGRhdGVTcGFjZU5vdGlmaWNhdGlvblNldHRpbmcSNS5n", - "b29nbGUuY2hhdC52MS5VcGRhdGVTcGFjZU5vdGlmaWNhdGlvblNldHRpbmdS", - "ZXF1ZXN0GiguZ29vZ2xlLmNoYXQudjEuU3BhY2VOb3RpZmljYXRpb25TZXR0", - "aW5nIpwB2kEmc3BhY2Vfbm90aWZpY2F0aW9uX3NldHRpbmcsdXBkYXRlX21h", - "c2uC0+STAm0yTy92MS97c3BhY2Vfbm90aWZpY2F0aW9uX3NldHRpbmcubmFt", - "ZT11c2Vycy8qL3NwYWNlcy8qL3NwYWNlTm90aWZpY2F0aW9uU2V0dGluZ306", - "GnNwYWNlX25vdGlmaWNhdGlvbl9zZXR0aW5nEo8BCg1DcmVhdGVTZWN0aW9u", - "EiQuZ29vZ2xlLmNoYXQudjEuQ3JlYXRlU2VjdGlvblJlcXVlc3QaFy5nb29n", - "bGUuY2hhdC52MS5TZWN0aW9uIj/aQQ5wYXJlbnQsc2VjdGlvboLT5JMCKCId", - "L3YxL3twYXJlbnQ9dXNlcnMvKn0vc2VjdGlvbnM6B3NlY3Rpb24SewoNRGVs", - "ZXRlU2VjdGlvbhIkLmdvb2dsZS5jaGF0LnYxLkRlbGV0ZVNlY3Rpb25SZXF1", - "ZXN0GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5IizaQQRuYW1lgtPkkwIfKh0v", - "djEve25hbWU9dXNlcnMvKi9zZWN0aW9ucy8qfRKcAQoNVXBkYXRlU2VjdGlv", - "bhIkLmdvb2dsZS5jaGF0LnYxLlVwZGF0ZVNlY3Rpb25SZXF1ZXN0GhcuZ29v", - "Z2xlLmNoYXQudjEuU2VjdGlvbiJM2kETc2VjdGlvbix1cGRhdGVfbWFza4LT", - "5JMCMDIlL3YxL3tzZWN0aW9uLm5hbWU9dXNlcnMvKi9zZWN0aW9ucy8qfToH", - "c2VjdGlvbhKJAQoMTGlzdFNlY3Rpb25zEiMuZ29vZ2xlLmNoYXQudjEuTGlz", - "dFNlY3Rpb25zUmVxdWVzdBokLmdvb2dsZS5jaGF0LnYxLkxpc3RTZWN0aW9u", - "c1Jlc3BvbnNlIi7aQQZwYXJlbnSC0+STAh8SHS92MS97cGFyZW50PXVzZXJz", - "Lyp9L3NlY3Rpb25zEpUBCg9Qb3NpdGlvblNlY3Rpb24SJi5nb29nbGUuY2hh", - "dC52MS5Qb3NpdGlvblNlY3Rpb25SZXF1ZXN0GicuZ29vZ2xlLmNoYXQudjEu", - "UG9zaXRpb25TZWN0aW9uUmVzcG9uc2UiMYLT5JMCKyImL3YxL3tuYW1lPXVz", - "ZXJzLyovc2VjdGlvbnMvKn06cG9zaXRpb246ASoSnQEKEExpc3RTZWN0aW9u", - "SXRlbXMSJy5nb29nbGUuY2hhdC52MS5MaXN0U2VjdGlvbkl0ZW1zUmVxdWVz", - "dBooLmdvb2dsZS5jaGF0LnYxLkxpc3RTZWN0aW9uSXRlbXNSZXNwb25zZSI2", - "2kEGcGFyZW50gtPkkwInEiUvdjEve3BhcmVudD11c2Vycy8qL3NlY3Rpb25z", - "Lyp9L2l0ZW1zEq8BCg9Nb3ZlU2VjdGlvbkl0ZW0SJi5nb29nbGUuY2hhdC52", - "MS5Nb3ZlU2VjdGlvbkl0ZW1SZXF1ZXN0GicuZ29vZ2xlLmNoYXQudjEuTW92", - "ZVNlY3Rpb25JdGVtUmVzcG9uc2UiS9pBE25hbWUsdGFyZ2V0X3NlY3Rpb26C", - "0+STAi8iKi92MS97bmFtZT11c2Vycy8qL3NlY3Rpb25zLyovaXRlbXMvKn06", - "bW92ZToBKhq+DspBE2NoYXQuZ29vZ2xlYXBpcy5jb23SQaQOaHR0cHM6Ly93", - "d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFkbWluLmRlbGV0ZSxodHRw", - "czovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuYWRtaW4ubWVtYmVy", - "c2hpcHMsaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFk", - "bWluLm1lbWJlcnNoaXBzLnJlYWRvbmx5LGh0dHBzOi8vd3d3Lmdvb2dsZWFw", - "aXMuY29tL2F1dGgvY2hhdC5hZG1pbi5zcGFjZXMsaHR0cHM6Ly93d3cuZ29v", - "Z2xlYXBpcy5jb20vYXV0aC9jaGF0LmFkbWluLnNwYWNlcy5yZWFkb25seSxo", - "dHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuYXBwLmRlbGV0", - "ZSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuYXBwLm1l", - "bWJlcnNoaXBzLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hh", - "dC5hcHAubWVtYmVyc2hpcHMucmVhZG9ubHksaHR0cHM6Ly93d3cuZ29vZ2xl", - "YXBpcy5jb20vYXV0aC9jaGF0LmFwcC5tZXNzYWdlcy5yZWFkb25seSxodHRw", - "czovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuYXBwLnNwYWNlcyxo", - "dHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuYXBwLnNwYWNl", - "cy5jcmVhdGUsaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0", - "LmFwcC5zcGFjZXMucmVhZG9ubHksaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5j", - "b20vYXV0aC9jaGF0LmJvdCxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9h", - "dXRoL2NoYXQuY3VzdG9tZW1vamlzLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMu", - "Y29tL2F1dGgvY2hhdC5jdXN0b21lbW9qaXMucmVhZG9ubHksaHR0cHM6Ly93", - "d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmRlbGV0ZSxodHRwczovL3d3", - "dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuaW1wb3J0LGh0dHBzOi8vd3d3", - "Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5tZW1iZXJzaGlwcyxodHRwczov", - "L3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQubWVtYmVyc2hpcHMuYXBw", - "LGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5tZW1iZXJz", - "aGlwcy5yZWFkb25seSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRo", - "L2NoYXQubWVzc2FnZXMsaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0", - "aC9jaGF0Lm1lc3NhZ2VzLmNyZWF0ZSxodHRwczovL3d3dy5nb29nbGVhcGlz", - "LmNvbS9hdXRoL2NoYXQubWVzc2FnZXMucmVhY3Rpb25zLGh0dHBzOi8vd3d3", - "Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5tZXNzYWdlcy5yZWFjdGlvbnMu", - "Y3JlYXRlLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5t", - "ZXNzYWdlcy5yZWFjdGlvbnMucmVhZG9ubHksaHR0cHM6Ly93d3cuZ29vZ2xl", - "YXBpcy5jb20vYXV0aC9jaGF0Lm1lc3NhZ2VzLnJlYWRvbmx5LGh0dHBzOi8v", - "d3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5zcGFjZXMsaHR0cHM6Ly93", - "d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LnNwYWNlcy5jcmVhdGUsaHR0", - "cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LnNwYWNlcy5yZWFk", - "b25seSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQudXNl", - "cnMucmVhZHN0YXRlLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgv", - "Y2hhdC51c2Vycy5yZWFkc3RhdGUucmVhZG9ubHksaHR0cHM6Ly93d3cuZ29v", - "Z2xlYXBpcy5jb20vYXV0aC9jaGF0LnVzZXJzLnNlY3Rpb25zLGh0dHBzOi8v", - "d3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC51c2Vycy5zZWN0aW9ucy5y", - "ZWFkb25seSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQu", - "dXNlcnMuc3BhY2VzZXR0aW5nc0KpAQoSY29tLmdvb2dsZS5jaGF0LnYxQhBD", - "aGF0U2VydmljZVByb3RvUAFaLGNsb3VkLmdvb2dsZS5jb20vZ28vY2hhdC9h", - "cGl2MS9jaGF0cGI7Y2hhdHBiogILRFlOQVBJUHJvdG+qAhNHb29nbGUuQXBw", - "cy5DaGF0LlYxygITR29vZ2xlXEFwcHNcQ2hhdFxWMeoCFkdvb2dsZTo6QXBw", - "czo6Q2hhdDo6VjFiBnByb3RvMw==")); + "ZXM6ZmluZERpcmVjdE1lc3NhZ2USggEKDkZpbmRHcm91cENoYXRzEiUuZ29v", + "Z2xlLmNoYXQudjEuRmluZEdyb3VwQ2hhdHNSZXF1ZXN0GiYuZ29vZ2xlLmNo", + "YXQudjEuRmluZEdyb3VwQ2hhdHNSZXNwb25zZSIhgtPkkwIbEhkvdjEvc3Bh", + "Y2VzOmZpbmRHcm91cENoYXRzEp4BChBDcmVhdGVNZW1iZXJzaGlwEicuZ29v", + "Z2xlLmNoYXQudjEuQ3JlYXRlTWVtYmVyc2hpcFJlcXVlc3QaGi5nb29nbGUu", + "Y2hhdC52MS5NZW1iZXJzaGlwIkXaQRFwYXJlbnQsbWVtYmVyc2hpcILT5JMC", + "KyIdL3YxL3twYXJlbnQ9c3BhY2VzLyp9L21lbWJlcnM6Cm1lbWJlcnNoaXAS", + "rgEKEFVwZGF0ZU1lbWJlcnNoaXASJy5nb29nbGUuY2hhdC52MS5VcGRhdGVN", + "ZW1iZXJzaGlwUmVxdWVzdBoaLmdvb2dsZS5jaGF0LnYxLk1lbWJlcnNoaXAi", + "VdpBFm1lbWJlcnNoaXAsdXBkYXRlX21hc2uC0+STAjYyKC92MS97bWVtYmVy", + "c2hpcC5uYW1lPXNwYWNlcy8qL21lbWJlcnMvKn06Cm1lbWJlcnNoaXAShQEK", + "EERlbGV0ZU1lbWJlcnNoaXASJy5nb29nbGUuY2hhdC52MS5EZWxldGVNZW1i", + "ZXJzaGlwUmVxdWVzdBoaLmdvb2dsZS5jaGF0LnYxLk1lbWJlcnNoaXAiLNpB", + "BG5hbWWC0+STAh8qHS92MS97bmFtZT1zcGFjZXMvKi9tZW1iZXJzLyp9EqEB", + "Cg5DcmVhdGVSZWFjdGlvbhIlLmdvb2dsZS5jaGF0LnYxLkNyZWF0ZVJlYWN0", + "aW9uUmVxdWVzdBoYLmdvb2dsZS5jaGF0LnYxLlJlYWN0aW9uIk7aQQ9wYXJl", + "bnQscmVhY3Rpb26C0+STAjYiKi92MS97cGFyZW50PXNwYWNlcy8qL21lc3Nh", + "Z2VzLyp9L3JlYWN0aW9uczoIcmVhY3Rpb24SmQEKDUxpc3RSZWFjdGlvbnMS", + "JC5nb29nbGUuY2hhdC52MS5MaXN0UmVhY3Rpb25zUmVxdWVzdBolLmdvb2ds", + "ZS5jaGF0LnYxLkxpc3RSZWFjdGlvbnNSZXNwb25zZSI72kEGcGFyZW50gtPk", + "kwIsEiovdjEve3BhcmVudD1zcGFjZXMvKi9tZXNzYWdlcy8qfS9yZWFjdGlv", + "bnMSigEKDkRlbGV0ZVJlYWN0aW9uEiUuZ29vZ2xlLmNoYXQudjEuRGVsZXRl", + "UmVhY3Rpb25SZXF1ZXN0GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5IjnaQQRu", + "YW1lgtPkkwIsKiovdjEve25hbWU9c3BhY2VzLyovbWVzc2FnZXMvKi9yZWFj", + "dGlvbnMvKn0SkQEKEUNyZWF0ZUN1c3RvbUVtb2ppEiguZ29vZ2xlLmNoYXQu", + "djEuQ3JlYXRlQ3VzdG9tRW1vamlSZXF1ZXN0GhsuZ29vZ2xlLmNoYXQudjEu", + "Q3VzdG9tRW1vamkiNdpBDGN1c3RvbV9lbW9qaYLT5JMCICIQL3YxL2N1c3Rv", + "bUVtb2ppczoMY3VzdG9tX2Vtb2ppEn4KDkdldEN1c3RvbUVtb2ppEiUuZ29v", + "Z2xlLmNoYXQudjEuR2V0Q3VzdG9tRW1vamlSZXF1ZXN0GhsuZ29vZ2xlLmNo", + "YXQudjEuQ3VzdG9tRW1vamkiKNpBBG5hbWWC0+STAhsSGS92MS97bmFtZT1j", + "dXN0b21FbW9qaXMvKn0SggEKEExpc3RDdXN0b21FbW9qaXMSJy5nb29nbGUu", + "Y2hhdC52MS5MaXN0Q3VzdG9tRW1vamlzUmVxdWVzdBooLmdvb2dsZS5jaGF0", + "LnYxLkxpc3RDdXN0b21FbW9qaXNSZXNwb25zZSIb2kEAgtPkkwISEhAvdjEv", + "Y3VzdG9tRW1vamlzEn8KEURlbGV0ZUN1c3RvbUVtb2ppEiguZ29vZ2xlLmNo", + "YXQudjEuRGVsZXRlQ3VzdG9tRW1vamlSZXF1ZXN0GhYuZ29vZ2xlLnByb3Rv", + "YnVmLkVtcHR5IijaQQRuYW1lgtPkkwIbKhkvdjEve25hbWU9Y3VzdG9tRW1v", + "amlzLyp9EpgBChFHZXRTcGFjZVJlYWRTdGF0ZRIoLmdvb2dsZS5jaGF0LnYx", + "LkdldFNwYWNlUmVhZFN0YXRlUmVxdWVzdBoeLmdvb2dsZS5jaGF0LnYxLlNw", + "YWNlUmVhZFN0YXRlIjnaQQRuYW1lgtPkkwIsEiovdjEve25hbWU9dXNlcnMv", + "Ki9zcGFjZXMvKi9zcGFjZVJlYWRTdGF0ZX0S2QEKFFVwZGF0ZVNwYWNlUmVh", + "ZFN0YXRlEisuZ29vZ2xlLmNoYXQudjEuVXBkYXRlU3BhY2VSZWFkU3RhdGVS", + "ZXF1ZXN0Gh4uZ29vZ2xlLmNoYXQudjEuU3BhY2VSZWFkU3RhdGUidNpBHHNw", + "YWNlX3JlYWRfc3RhdGUsdXBkYXRlX21hc2uC0+STAk8yOy92MS97c3BhY2Vf", + "cmVhZF9zdGF0ZS5uYW1lPXVzZXJzLyovc3BhY2VzLyovc3BhY2VSZWFkU3Rh", + "dGV9OhBzcGFjZV9yZWFkX3N0YXRlEqYBChJHZXRUaHJlYWRSZWFkU3RhdGUS", + "KS5nb29nbGUuY2hhdC52MS5HZXRUaHJlYWRSZWFkU3RhdGVSZXF1ZXN0Gh8u", + "Z29vZ2xlLmNoYXQudjEuVGhyZWFkUmVhZFN0YXRlIkTaQQRuYW1lgtPkkwI3", + "EjUvdjEve25hbWU9dXNlcnMvKi9zcGFjZXMvKi90aHJlYWRzLyovdGhyZWFk", + "UmVhZFN0YXRlfRKDAQoNR2V0U3BhY2VFdmVudBIkLmdvb2dsZS5jaGF0LnYx", + "LkdldFNwYWNlRXZlbnRSZXF1ZXN0GhouZ29vZ2xlLmNoYXQudjEuU3BhY2VF", + "dmVudCIw2kEEbmFtZYLT5JMCIxIhL3YxL3tuYW1lPXNwYWNlcy8qL3NwYWNl", + "RXZlbnRzLyp9Ep0BCg9MaXN0U3BhY2VFdmVudHMSJi5nb29nbGUuY2hhdC52", + "MS5MaXN0U3BhY2VFdmVudHNSZXF1ZXN0GicuZ29vZ2xlLmNoYXQudjEuTGlz", + "dFNwYWNlRXZlbnRzUmVzcG9uc2UiOdpBDXBhcmVudCxmaWx0ZXKC0+STAiMS", + "IS92MS97cGFyZW50PXNwYWNlcy8qfS9zcGFjZUV2ZW50cxLAAQobR2V0U3Bh", + "Y2VOb3RpZmljYXRpb25TZXR0aW5nEjIuZ29vZ2xlLmNoYXQudjEuR2V0U3Bh", + "Y2VOb3RpZmljYXRpb25TZXR0aW5nUmVxdWVzdBooLmdvb2dsZS5jaGF0LnYx", + "LlNwYWNlTm90aWZpY2F0aW9uU2V0dGluZyJD2kEEbmFtZYLT5JMCNhI0L3Yx", + "L3tuYW1lPXVzZXJzLyovc3BhY2VzLyovc3BhY2VOb3RpZmljYXRpb25TZXR0", + "aW5nfRKgAgoeVXBkYXRlU3BhY2VOb3RpZmljYXRpb25TZXR0aW5nEjUuZ29v", + "Z2xlLmNoYXQudjEuVXBkYXRlU3BhY2VOb3RpZmljYXRpb25TZXR0aW5nUmVx", + "dWVzdBooLmdvb2dsZS5jaGF0LnYxLlNwYWNlTm90aWZpY2F0aW9uU2V0dGlu", + "ZyKcAdpBJnNwYWNlX25vdGlmaWNhdGlvbl9zZXR0aW5nLHVwZGF0ZV9tYXNr", + "gtPkkwJtMk8vdjEve3NwYWNlX25vdGlmaWNhdGlvbl9zZXR0aW5nLm5hbWU9", + "dXNlcnMvKi9zcGFjZXMvKi9zcGFjZU5vdGlmaWNhdGlvblNldHRpbmd9Ohpz", + "cGFjZV9ub3RpZmljYXRpb25fc2V0dGluZxKPAQoNQ3JlYXRlU2VjdGlvbhIk", + "Lmdvb2dsZS5jaGF0LnYxLkNyZWF0ZVNlY3Rpb25SZXF1ZXN0GhcuZ29vZ2xl", + "LmNoYXQudjEuU2VjdGlvbiI/2kEOcGFyZW50LHNlY3Rpb26C0+STAigiHS92", + "MS97cGFyZW50PXVzZXJzLyp9L3NlY3Rpb25zOgdzZWN0aW9uEnsKDURlbGV0", + "ZVNlY3Rpb24SJC5nb29nbGUuY2hhdC52MS5EZWxldGVTZWN0aW9uUmVxdWVz", + "dBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSIs2kEEbmFtZYLT5JMCHyodL3Yx", + "L3tuYW1lPXVzZXJzLyovc2VjdGlvbnMvKn0SnAEKDVVwZGF0ZVNlY3Rpb24S", + "JC5nb29nbGUuY2hhdC52MS5VcGRhdGVTZWN0aW9uUmVxdWVzdBoXLmdvb2ds", + "ZS5jaGF0LnYxLlNlY3Rpb24iTNpBE3NlY3Rpb24sdXBkYXRlX21hc2uC0+ST", + "AjAyJS92MS97c2VjdGlvbi5uYW1lPXVzZXJzLyovc2VjdGlvbnMvKn06B3Nl", + "Y3Rpb24SiQEKDExpc3RTZWN0aW9ucxIjLmdvb2dsZS5jaGF0LnYxLkxpc3RT", + "ZWN0aW9uc1JlcXVlc3QaJC5nb29nbGUuY2hhdC52MS5MaXN0U2VjdGlvbnNS", + "ZXNwb25zZSIu2kEGcGFyZW50gtPkkwIfEh0vdjEve3BhcmVudD11c2Vycy8q", + "fS9zZWN0aW9ucxKVAQoPUG9zaXRpb25TZWN0aW9uEiYuZ29vZ2xlLmNoYXQu", + "djEuUG9zaXRpb25TZWN0aW9uUmVxdWVzdBonLmdvb2dsZS5jaGF0LnYxLlBv", + "c2l0aW9uU2VjdGlvblJlc3BvbnNlIjGC0+STAisiJi92MS97bmFtZT11c2Vy", + "cy8qL3NlY3Rpb25zLyp9OnBvc2l0aW9uOgEqEp0BChBMaXN0U2VjdGlvbkl0", + "ZW1zEicuZ29vZ2xlLmNoYXQudjEuTGlzdFNlY3Rpb25JdGVtc1JlcXVlc3Qa", + "KC5nb29nbGUuY2hhdC52MS5MaXN0U2VjdGlvbkl0ZW1zUmVzcG9uc2UiNtpB", + "BnBhcmVudILT5JMCJxIlL3YxL3twYXJlbnQ9dXNlcnMvKi9zZWN0aW9ucy8q", + "fS9pdGVtcxKvAQoPTW92ZVNlY3Rpb25JdGVtEiYuZ29vZ2xlLmNoYXQudjEu", + "TW92ZVNlY3Rpb25JdGVtUmVxdWVzdBonLmdvb2dsZS5jaGF0LnYxLk1vdmVT", + "ZWN0aW9uSXRlbVJlc3BvbnNlIkvaQRNuYW1lLHRhcmdldF9zZWN0aW9ugtPk", + "kwIvIiovdjEve25hbWU9dXNlcnMvKi9zZWN0aW9ucy8qL2l0ZW1zLyp9Om1v", + "dmU6ASoavg7KQRNjaGF0Lmdvb2dsZWFwaXMuY29t0kGkDmh0dHBzOi8vd3d3", + "Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5hZG1pbi5kZWxldGUsaHR0cHM6", + "Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFkbWluLm1lbWJlcnNo", + "aXBzLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5hZG1p", + "bi5tZW1iZXJzaGlwcy5yZWFkb25seSxodHRwczovL3d3dy5nb29nbGVhcGlz", + "LmNvbS9hdXRoL2NoYXQuYWRtaW4uc3BhY2VzLGh0dHBzOi8vd3d3Lmdvb2ds", + "ZWFwaXMuY29tL2F1dGgvY2hhdC5hZG1pbi5zcGFjZXMucmVhZG9ubHksaHR0", + "cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFwcC5kZWxldGUs", + "aHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFwcC5tZW1i", + "ZXJzaGlwcyxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQu", + "YXBwLm1lbWJlcnNoaXBzLnJlYWRvbmx5LGh0dHBzOi8vd3d3Lmdvb2dsZWFw", + "aXMuY29tL2F1dGgvY2hhdC5hcHAubWVzc2FnZXMucmVhZG9ubHksaHR0cHM6", + "Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFwcC5zcGFjZXMsaHR0", + "cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmFwcC5zcGFjZXMu", + "Y3JlYXRlLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5h", + "cHAuc3BhY2VzLnJlYWRvbmx5LGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29t", + "L2F1dGgvY2hhdC5ib3QsaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0", + "aC9jaGF0LmN1c3RvbWVtb2ppcyxodHRwczovL3d3dy5nb29nbGVhcGlzLmNv", + "bS9hdXRoL2NoYXQuY3VzdG9tZW1vamlzLnJlYWRvbmx5LGh0dHBzOi8vd3d3", + "Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5kZWxldGUsaHR0cHM6Ly93d3cu", + "Z29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LmltcG9ydCxodHRwczovL3d3dy5n", + "b29nbGVhcGlzLmNvbS9hdXRoL2NoYXQubWVtYmVyc2hpcHMsaHR0cHM6Ly93", + "d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0Lm1lbWJlcnNoaXBzLmFwcCxo", + "dHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQubWVtYmVyc2hp", + "cHMucmVhZG9ubHksaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9j", + "aGF0Lm1lc3NhZ2VzLGh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgv", + "Y2hhdC5tZXNzYWdlcy5jcmVhdGUsaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5j", + "b20vYXV0aC9jaGF0Lm1lc3NhZ2VzLnJlYWN0aW9ucyxodHRwczovL3d3dy5n", + "b29nbGVhcGlzLmNvbS9hdXRoL2NoYXQubWVzc2FnZXMucmVhY3Rpb25zLmNy", + "ZWF0ZSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQubWVz", + "c2FnZXMucmVhY3Rpb25zLnJlYWRvbmx5LGh0dHBzOi8vd3d3Lmdvb2dsZWFw", + "aXMuY29tL2F1dGgvY2hhdC5tZXNzYWdlcy5yZWFkb25seSxodHRwczovL3d3", + "dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQuc3BhY2VzLGh0dHBzOi8vd3d3", + "Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5zcGFjZXMuY3JlYXRlLGh0dHBz", + "Oi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2hhdC5zcGFjZXMucmVhZG9u", + "bHksaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LnVzZXJz", + "LnJlYWRzdGF0ZSxodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2No", + "YXQudXNlcnMucmVhZHN0YXRlLnJlYWRvbmx5LGh0dHBzOi8vd3d3Lmdvb2ds", + "ZWFwaXMuY29tL2F1dGgvY2hhdC51c2Vycy5zZWN0aW9ucyxodHRwczovL3d3", + "dy5nb29nbGVhcGlzLmNvbS9hdXRoL2NoYXQudXNlcnMuc2VjdGlvbnMucmVh", + "ZG9ubHksaHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jaGF0LnVz", + "ZXJzLnNwYWNlc2V0dGluZ3NCqQEKEmNvbS5nb29nbGUuY2hhdC52MUIQQ2hh", + "dFNlcnZpY2VQcm90b1ABWixjbG91ZC5nb29nbGUuY29tL2dvL2NoYXQvYXBp", + "djEvY2hhdHBiO2NoYXRwYqICC0RZTkFQSVByb3RvqgITR29vZ2xlLkFwcHMu", + "Q2hhdC5WMcoCE0dvb2dsZVxBcHBzXENoYXRcVjHqAhZHb29nbGU6OkFwcHM6", + "OkNoYXQ6OlYxYgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Apps.Chat.V1.AttachmentReflection.Descriptor, global::Google.Apps.Chat.V1.MembershipReflection.Descriptor, global::Google.Apps.Chat.V1.MessageReflection.Descriptor, global::Google.Apps.Chat.V1.ReactionReflection.Descriptor, global::Google.Apps.Chat.V1.SectionReflection.Descriptor, global::Google.Apps.Chat.V1.SpaceReflection.Descriptor, global::Google.Apps.Chat.V1.SpaceEventReflection.Descriptor, global::Google.Apps.Chat.V1.SpaceNotificationSettingReflection.Descriptor, global::Google.Apps.Chat.V1.SpaceReadStateReflection.Descriptor, global::Google.Apps.Chat.V1.SpaceSetupReflection.Descriptor, global::Google.Apps.Chat.V1.ThreadReadStateReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, null)); diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceClient.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceClient.g.cs index e592b5d8ba69..25c67abdf02b 100644 --- a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceClient.g.cs +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceClient.g.cs @@ -64,6 +64,7 @@ private ChatServiceSettings(ChatServiceSettings existing) : base(existing) DeleteSpaceSettings = existing.DeleteSpaceSettings; CompleteImportSpaceSettings = existing.CompleteImportSpaceSettings; FindDirectMessageSettings = existing.FindDirectMessageSettings; + FindGroupChatsSettings = existing.FindGroupChatsSettings; CreateMembershipSettings = existing.CreateMembershipSettings; UpdateMembershipSettings = existing.UpdateMembershipSettings; DeleteMembershipSettings = existing.DeleteMembershipSettings; @@ -417,6 +418,24 @@ private ChatServiceSettings(ChatServiceSettings existing) : base(existing) /// public gaxgrpc::CallSettings FindDirectMessageSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(30000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + /// + /// for synchronous and asynchronous calls to + /// ChatServiceClient.FindGroupChats and ChatServiceClient.FindGroupChatsAsync. + /// + /// + /// + /// Initial retry delay: 1000 milliseconds. + /// Retry delay multiplier: 1.3 + /// Retry maximum delay: 10000 milliseconds. + /// Maximum attempts: 5 + /// + /// Retriable status codes: . + /// + /// Timeout: 30 seconds. + /// + /// + public gaxgrpc::CallSettings FindGroupChatsSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(30000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + /// /// for synchronous and asynchronous calls to /// ChatServiceClient.CreateMembership and ChatServiceClient.CreateMembershipAsync. @@ -6217,6 +6236,62 @@ public virtual Space FindDirectMessage(FindDirectMessageRequest request, gaxgrpc public virtual stt::Task FindDirectMessageAsync(FindDirectMessageRequest request, st::CancellationToken cancellationToken) => FindDirectMessageAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public virtual gax::PagedEnumerable FindGroupChats(FindGroupChatsRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public virtual gax::PagedAsyncEnumerable FindGroupChatsAsync(FindGroupChatsRequest request, gaxgrpc::CallSettings callSettings = null) => + throw new sys::NotImplementedException(); + /// /// Creates a membership for the calling Chat app, a user, or a Google Group. /// Creating memberships for other Chat apps isn't supported. @@ -13008,6 +13083,8 @@ public sealed partial class ChatServiceClientImpl : ChatServiceClient private readonly gaxgrpc::ApiCall _callFindDirectMessage; + private readonly gaxgrpc::ApiCall _callFindGroupChats; + private readonly gaxgrpc::ApiCall _callCreateMembership; private readonly gaxgrpc::ApiCall _callUpdateMembership; @@ -13125,6 +13202,9 @@ public ChatServiceClientImpl(ChatService.ChatServiceClient grpcClient, ChatServi _callFindDirectMessage = clientHelper.BuildApiCall("FindDirectMessage", grpcClient.FindDirectMessageAsync, grpcClient.FindDirectMessage, effectiveSettings.FindDirectMessageSettings); Modify_ApiCall(ref _callFindDirectMessage); Modify_FindDirectMessageApiCall(ref _callFindDirectMessage); + _callFindGroupChats = clientHelper.BuildApiCall("FindGroupChats", grpcClient.FindGroupChatsAsync, grpcClient.FindGroupChats, effectiveSettings.FindGroupChatsSettings); + Modify_ApiCall(ref _callFindGroupChats); + Modify_FindGroupChatsApiCall(ref _callFindGroupChats); _callCreateMembership = clientHelper.BuildApiCall("CreateMembership", grpcClient.CreateMembershipAsync, grpcClient.CreateMembership, effectiveSettings.CreateMembershipSettings).WithGoogleRequestParam("parent", request => request.Parent); Modify_ApiCall(ref _callCreateMembership); Modify_CreateMembershipApiCall(ref _callCreateMembership); @@ -13238,6 +13318,8 @@ public ChatServiceClientImpl(ChatService.ChatServiceClient grpcClient, ChatServi partial void Modify_FindDirectMessageApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_FindGroupChatsApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_CreateMembershipApiCall(ref gaxgrpc::ApiCall call); partial void Modify_UpdateMembershipApiCall(ref gaxgrpc::ApiCall call); @@ -13327,6 +13409,8 @@ public ChatServiceClientImpl(ChatService.ChatServiceClient grpcClient, ChatServi partial void Modify_FindDirectMessageRequest(ref FindDirectMessageRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_FindGroupChatsRequest(ref FindGroupChatsRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_CreateMembershipRequest(ref CreateMembershipRequest request, ref gaxgrpc::CallSettings settings); partial void Modify_UpdateMembershipRequest(ref UpdateMembershipRequest request, ref gaxgrpc::CallSettings settings); @@ -14773,6 +14857,68 @@ public override Space FindDirectMessage(FindDirectMessageRequest request, gaxgrp return _callFindDirectMessage.Async(request, callSettings); } + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable sequence of resources. + public override gax::PagedEnumerable FindGroupChats(FindGroupChatsRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_FindGroupChatsRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedEnumerable(_callFindGroupChats, request, callSettings); + } + + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// The request object containing all of the parameters for the API call. + /// If not null, applies overrides to this RPC call. + /// A pageable asynchronous sequence of resources. + public override gax::PagedAsyncEnumerable FindGroupChatsAsync(FindGroupChatsRequest request, gaxgrpc::CallSettings callSettings = null) + { + Modify_FindGroupChatsRequest(ref request, ref callSettings); + return new gaxgrpc::GrpcPagedAsyncEnumerable(_callFindGroupChats, request, callSettings); + } + /// /// Creates a membership for the calling Chat app, a user, or a Google Group. /// Creating memberships for other Chat apps isn't supported. @@ -16174,6 +16320,10 @@ public partial class SearchSpacesRequest : gaxgrpc::IPageRequest { } + public partial class FindGroupChatsRequest : gaxgrpc::IPageRequest + { + } + public partial class ListReactionsRequest : gaxgrpc::IPageRequest { } @@ -16226,6 +16376,14 @@ public partial class SearchSpacesResponse : gaxgrpc::IPageResponse sc::IEnumerator sc::IEnumerable.GetEnumerator() => GetEnumerator(); } + public partial class FindGroupChatsResponse : gaxgrpc::IPageResponse + { + /// Returns an enumerator that iterates through the resources in this response. + public scg::IEnumerator GetEnumerator() => Spaces.GetEnumerator(); + + sc::IEnumerator sc::IEnumerable.GetEnumerator() => GetEnumerator(); + } + public partial class ListReactionsResponse : gaxgrpc::IPageResponse { /// Returns an enumerator that iterates through the resources in this response. diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceGrpc.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceGrpc.g.cs index 9d82193a429d..788cf8cd02a4 100644 --- a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceGrpc.g.cs +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/ChatServiceGrpc.g.cs @@ -123,6 +123,10 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_chat_v1_FindDirectMessageRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Apps.Chat.V1.FindDirectMessageRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_chat_v1_FindGroupChatsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Apps.Chat.V1.FindGroupChatsRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_chat_v1_FindGroupChatsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Apps.Chat.V1.FindGroupChatsResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_chat_v1_CreateMembershipRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Apps.Chat.V1.CreateMembershipRequest.Parser)); [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Marshaller __Marshaller_google_chat_v1_UpdateMembershipRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Apps.Chat.V1.UpdateMembershipRequest.Parser)); @@ -343,6 +347,14 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl __Marshaller_google_chat_v1_FindDirectMessageRequest, __Marshaller_google_chat_v1_Space); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_FindGroupChats = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "FindGroupChats", + __Marshaller_google_chat_v1_FindGroupChatsRequest, + __Marshaller_google_chat_v1_FindGroupChatsResponse); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] static readonly grpc::Method __Method_CreateMembership = new grpc::Method( grpc::MethodType.Unary, @@ -1244,6 +1256,37 @@ public abstract partial class ChatServiceBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// 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 FindGroupChats(global::Google.Apps.Chat.V1.FindGroupChatsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + /// /// Creates a membership for the calling Chat app, a user, or a Google Group. /// Creating memberships for other Chat apps isn't supported. @@ -4762,6 +4805,130 @@ protected ChatServiceClient(ClientBaseConfiguration configuration) : base(config return CallInvoker.AsyncUnaryCall(__Method_FindDirectMessage, null, options, request); } /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// 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.Apps.Chat.V1.FindGroupChatsResponse FindGroupChats(global::Google.Apps.Chat.V1.FindGroupChatsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return FindGroupChats(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// 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.Apps.Chat.V1.FindGroupChatsResponse FindGroupChats(global::Google.Apps.Chat.V1.FindGroupChatsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_FindGroupChats, null, options, request); + } + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// 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 FindGroupChatsAsync(global::Google.Apps.Chat.V1.FindGroupChatsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return FindGroupChatsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Returns all spaces with `spaceType == GROUP_CHAT`, whose + /// human memberships contain exactly the calling user, and the users specified + /// in `FindGroupChatsRequest.users`. Only members that have joined the + /// conversation are supported. For an example, see [Find group + /// chats](https://developers.google.com/workspace/chat/find-group-chats). + /// + /// If the calling user blocks, or is blocked by, some users, and no spaces + /// with the entire specified set of users are found, this method returns + /// spaces that don't include the blocked or blocking users. + /// + /// The specified set of users must contain only human (non-app) memberships. + /// A request that contains non-human users doesn't return any spaces. + /// + /// Requires [user + /// authentication](https://developers.google.com/workspace/chat/authenticate-authorize-chat-user) + /// with one of the following [authorization + /// scopes](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes): + /// + /// - `https://www.googleapis.com/auth/chat.memberships.readonly` + /// - `https://www.googleapis.com/auth/chat.memberships` + /// + /// 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 FindGroupChatsAsync(global::Google.Apps.Chat.V1.FindGroupChatsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_FindGroupChats, null, options, request); + } + /// /// Creates a membership for the calling Chat app, a user, or a Google Group. /// Creating memberships for other Chat apps isn't supported. /// When creating a membership, if the specified member has their auto-accept @@ -7561,6 +7728,7 @@ protected override ChatServiceClient NewInstance(ClientBaseConfiguration configu .AddMethod(__Method_DeleteSpace, serviceImpl.DeleteSpace) .AddMethod(__Method_CompleteImportSpace, serviceImpl.CompleteImportSpace) .AddMethod(__Method_FindDirectMessage, serviceImpl.FindDirectMessage) + .AddMethod(__Method_FindGroupChats, serviceImpl.FindGroupChats) .AddMethod(__Method_CreateMembership, serviceImpl.CreateMembership) .AddMethod(__Method_UpdateMembership, serviceImpl.UpdateMembership) .AddMethod(__Method_DeleteMembership, serviceImpl.DeleteMembership) @@ -7612,6 +7780,7 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, ChatServic serviceBinder.AddMethod(__Method_DeleteSpace, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.DeleteSpace)); serviceBinder.AddMethod(__Method_CompleteImportSpace, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CompleteImportSpace)); serviceBinder.AddMethod(__Method_FindDirectMessage, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.FindDirectMessage)); + serviceBinder.AddMethod(__Method_FindGroupChats, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.FindGroupChats)); serviceBinder.AddMethod(__Method_CreateMembership, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CreateMembership)); serviceBinder.AddMethod(__Method_UpdateMembership, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.UpdateMembership)); serviceBinder.AddMethod(__Method_DeleteMembership, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.DeleteMembership)); diff --git a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/Space.g.cs b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/Space.g.cs index 5efae10d073f..15d51e3cf1b9 100644 --- a/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/Space.g.cs +++ b/apis/Google.Apps.Chat.V1/Google.Apps.Chat.V1/Space.g.cs @@ -102,28 +102,35 @@ static SpaceReflection() { "ZXRTcGFjZVJlcXVlc3QSLwoEbmFtZRgBIAEoCUIh4EEC+kEbChljaGF0Lmdv", "b2dsZWFwaXMuY29tL1NwYWNlEh0KEHVzZV9hZG1pbl9hY2Nlc3MYAiABKAhC", "A+BBASItChhGaW5kRGlyZWN0TWVzc2FnZVJlcXVlc3QSEQoEbmFtZRgBIAEo", - "CUID4EECIpQBChJVcGRhdGVTcGFjZVJlcXVlc3QSKQoFc3BhY2UYASABKAsy", - "FS5nb29nbGUuY2hhdC52MS5TcGFjZUID4EECEjQKC3VwZGF0ZV9tYXNrGAIg", - "ASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFza0ID4EECEh0KEHVzZV9h", - "ZG1pbl9hY2Nlc3MYAyABKAhCA+BBASKBAQoTU2VhcmNoU3BhY2VzUmVxdWVz", - "dBIYChB1c2VfYWRtaW5fYWNjZXNzGAEgASgIEhEKCXBhZ2Vfc2l6ZRgCIAEo", - "BRISCgpwYWdlX3Rva2VuGAMgASgJEhIKBXF1ZXJ5GAQgASgJQgPgQQISFQoI", - "b3JkZXJfYnkYBSABKAlCA+BBASJqChRTZWFyY2hTcGFjZXNSZXNwb25zZRIl", - "CgZzcGFjZXMYASADKAsyFS5nb29nbGUuY2hhdC52MS5TcGFjZRIXCg9uZXh0", - "X3BhZ2VfdG9rZW4YAiABKAkSEgoKdG90YWxfc2l6ZRgDIAEoBSJkChJEZWxl", - "dGVTcGFjZVJlcXVlc3QSLwoEbmFtZRgBIAEoCUIh4EEC+kEbChljaGF0Lmdv", - "b2dsZWFwaXMuY29tL1NwYWNlEh0KEHVzZV9hZG1pbl9hY2Nlc3MYAiABKAhC", - "A+BBASJNChpDb21wbGV0ZUltcG9ydFNwYWNlUmVxdWVzdBIvCgRuYW1lGAEg", - "ASgJQiHgQQL6QRsKGWNoYXQuZ29vZ2xlYXBpcy5jb20vU3BhY2UiQwobQ29t", - "cGxldGVJbXBvcnRTcGFjZVJlc3BvbnNlEiQKBXNwYWNlGAEgASgLMhUuZ29v", - "Z2xlLmNoYXQudjEuU3BhY2VCowEKEmNvbS5nb29nbGUuY2hhdC52MUIKU3Bh", - "Y2VQcm90b1ABWixjbG91ZC5nb29nbGUuY29tL2dvL2NoYXQvYXBpdjEvY2hh", - "dHBiO2NoYXRwYqICC0RZTkFQSVByb3RvqgITR29vZ2xlLkFwcHMuQ2hhdC5W", - "McoCE0dvb2dsZVxBcHBzXENoYXRcVjHqAhZHb29nbGU6OkFwcHM6OkNoYXQ6", - "OlYxYgZwcm90bzM=")); + "CUID4EECIosBChVGaW5kR3JvdXBDaGF0c1JlcXVlc3QSEgoFdXNlcnMYBSAD", + "KAlCA+BBARIWCglwYWdlX3NpemUYAiABKAVCA+BBARIXCgpwYWdlX3Rva2Vu", + "GAMgASgJQgPgQQESLQoKc3BhY2VfdmlldxgEIAEoDjIZLmdvb2dsZS5jaGF0", + "LnYxLlNwYWNlVmlldyJYChZGaW5kR3JvdXBDaGF0c1Jlc3BvbnNlEiUKBnNw", + "YWNlcxgBIAMoCzIVLmdvb2dsZS5jaGF0LnYxLlNwYWNlEhcKD25leHRfcGFn", + "ZV90b2tlbhgCIAEoCSKUAQoSVXBkYXRlU3BhY2VSZXF1ZXN0EikKBXNwYWNl", + "GAEgASgLMhUuZ29vZ2xlLmNoYXQudjEuU3BhY2VCA+BBAhI0Cgt1cGRhdGVf", + "bWFzaxgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE1hc2tCA+BBAhId", + "ChB1c2VfYWRtaW5fYWNjZXNzGAMgASgIQgPgQQEigQEKE1NlYXJjaFNwYWNl", + "c1JlcXVlc3QSGAoQdXNlX2FkbWluX2FjY2VzcxgBIAEoCBIRCglwYWdlX3Np", + "emUYAiABKAUSEgoKcGFnZV90b2tlbhgDIAEoCRISCgVxdWVyeRgEIAEoCUID", + "4EECEhUKCG9yZGVyX2J5GAUgASgJQgPgQQEiagoUU2VhcmNoU3BhY2VzUmVz", + "cG9uc2USJQoGc3BhY2VzGAEgAygLMhUuZ29vZ2xlLmNoYXQudjEuU3BhY2US", + "FwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJEhIKCnRvdGFsX3NpemUYAyABKAUi", + "ZAoSRGVsZXRlU3BhY2VSZXF1ZXN0Ei8KBG5hbWUYASABKAlCIeBBAvpBGwoZ", + "Y2hhdC5nb29nbGVhcGlzLmNvbS9TcGFjZRIdChB1c2VfYWRtaW5fYWNjZXNz", + "GAIgASgIQgPgQQEiTQoaQ29tcGxldGVJbXBvcnRTcGFjZVJlcXVlc3QSLwoE", + "bmFtZRgBIAEoCUIh4EEC+kEbChljaGF0Lmdvb2dsZWFwaXMuY29tL1NwYWNl", + "IkMKG0NvbXBsZXRlSW1wb3J0U3BhY2VSZXNwb25zZRIkCgVzcGFjZRgBIAEo", + "CzIVLmdvb2dsZS5jaGF0LnYxLlNwYWNlKmMKCVNwYWNlVmlldxIaChZTUEFD", + "RV9WSUVXX1VOU1BFQ0lGSUVEEAASIQodU1BBQ0VfVklFV19SRVNPVVJDRV9O", + "QU1FX09OTFkQAxIXChNTUEFDRV9WSUVXX0VYUEFOREVEEARCowEKEmNvbS5n", + "b29nbGUuY2hhdC52MUIKU3BhY2VQcm90b1ABWixjbG91ZC5nb29nbGUuY29t", + "L2dvL2NoYXQvYXBpdjEvY2hhdHBiO2NoYXRwYqICC0RZTkFQSVByb3RvqgIT", + "R29vZ2xlLkFwcHMuQ2hhdC5WMcoCE0dvb2dsZVxBcHBzXENoYXRcVjHqAhZH", + "b29nbGU6OkFwcHM6OkNoYXQ6OlYxYgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Apps.Chat.V1.HistoryStateReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, - new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Apps.Chat.V1.SpaceView), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.Space), global::Google.Apps.Chat.V1.Space.Parser, new[]{ "Name", "Type", "SpaceType", "SingleUserBotDm", "Threaded", "DisplayName", "ExternalUserAllowed", "SpaceThreadingState", "SpaceDetails", "SpaceHistoryState", "ImportMode", "CreateTime", "LastActiveTime", "AdminInstalled", "MembershipCount", "AccessSettings", "Customer", "SpaceUri", "PredefinedPermissionSettings", "PermissionSettings", "ImportModeExpireTime" }, new[]{ "SpacePermissionSettings", "Customer" }, new[]{ typeof(global::Google.Apps.Chat.V1.Space.Types.Type), typeof(global::Google.Apps.Chat.V1.Space.Types.SpaceType), typeof(global::Google.Apps.Chat.V1.Space.Types.SpaceThreadingState), typeof(global::Google.Apps.Chat.V1.Space.Types.PredefinedPermissionSettings) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.Space.Types.SpaceDetails), global::Google.Apps.Chat.V1.Space.Types.SpaceDetails.Parser, new[]{ "Description", "Guidelines" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.Space.Types.MembershipCount), global::Google.Apps.Chat.V1.Space.Types.MembershipCount.Parser, new[]{ "JoinedDirectHumanUserCount", "JoinedGroupCount" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.Space.Types.AccessSettings), global::Google.Apps.Chat.V1.Space.Types.AccessSettings.Parser, new[]{ "AccessState", "Audience" }, null, new[]{ typeof(global::Google.Apps.Chat.V1.Space.Types.AccessSettings.Types.AccessState) }, null, null), @@ -134,6 +141,8 @@ static SpaceReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.ListSpacesResponse), global::Google.Apps.Chat.V1.ListSpacesResponse.Parser, new[]{ "Spaces", "NextPageToken" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.GetSpaceRequest), global::Google.Apps.Chat.V1.GetSpaceRequest.Parser, new[]{ "Name", "UseAdminAccess" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.FindDirectMessageRequest), global::Google.Apps.Chat.V1.FindDirectMessageRequest.Parser, new[]{ "Name" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.FindGroupChatsRequest), global::Google.Apps.Chat.V1.FindGroupChatsRequest.Parser, new[]{ "Users", "PageSize", "PageToken", "SpaceView" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.FindGroupChatsResponse), global::Google.Apps.Chat.V1.FindGroupChatsResponse.Parser, new[]{ "Spaces", "NextPageToken" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.UpdateSpaceRequest), global::Google.Apps.Chat.V1.UpdateSpaceRequest.Parser, new[]{ "Space", "UpdateMask", "UseAdminAccess" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.SearchSpacesRequest), global::Google.Apps.Chat.V1.SearchSpacesRequest.Parser, new[]{ "UseAdminAccess", "PageSize", "PageToken", "Query", "OrderBy" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Apps.Chat.V1.SearchSpacesResponse), global::Google.Apps.Chat.V1.SearchSpacesResponse.Parser, new[]{ "Spaces", "NextPageToken", "TotalSize" }, null, null, null, null), @@ -145,6 +154,36 @@ static SpaceReflection() { #endregion } + #region Enums + /// + /// A view that specifies which fields should be populated on the + /// [`Space`](https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces) + /// resource. + /// To ensure compatibility with future releases, we recommend that your code + /// account for additional values. + /// + public enum SpaceView { + /// + /// The default / unset value. + /// + [pbr::OriginalName("SPACE_VIEW_UNSPECIFIED")] Unspecified = 0, + /// + /// Populates only the Space resource name. + /// + [pbr::OriginalName("SPACE_VIEW_RESOURCE_NAME_ONLY")] ResourceNameOnly = 3, + /// + /// Populates Space resource fields. Note: the `permissionSettings` field + /// will not be populated. + /// Requests that specify SPACE_VIEW_EXPANDED must include scopes that allow + /// reading space data, for example, + /// https://www.googleapis.com/auth/chat.spaces or + /// https://www.googleapis.com/auth/chat.spaces.readonly. + /// + [pbr::OriginalName("SPACE_VIEW_EXPANDED")] Expanded = 4, + } + + #endregion + #region Messages /// /// A space in Google Chat. Spaces are conversations between two or more users @@ -4439,19 +4478,19 @@ public void MergeFrom(pb::CodedInputStream input) { } /// - /// A request to update a single space. + /// A request to get group chat spaces based on user resources. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class UpdateSpaceRequest : pb::IMessage + public sealed partial class FindGroupChatsRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateSpaceRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FindGroupChatsRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -4467,7 +4506,7 @@ public sealed partial class UpdateSpaceRequest : pb::IMessageField number for the "space" field. - public const int SpaceFieldNumber = 1; - private global::Google.Apps.Chat.V1.Space space_; + /// Field number for the "users" field. + public const int UsersFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_users_codec + = pb::FieldCodec.ForString(42); + private readonly pbc::RepeatedField users_ = new pbc::RepeatedField(); /// - /// Required. Space with fields to be updated. `Space.name` must be - /// populated in the form of `spaces/{space}`. Only fields - /// specified by `update_mask` are updated. + /// Optional. Resource names of all human users in group chat with the calling + /// user. Chat apps can't be included in the request. + /// + /// The maximum number of users that can be specified in a single request is + /// `49`. + /// + /// Format: `users/{user}`, where `{user}` is either the `id` for the + /// [person](https://developers.google.com/people/api/rest/v1/people) from the + /// People API, or the `id` for the + /// [user](https://developers.google.com/admin-sdk/directory/reference/rest/v1/users) + /// in the Directory API. For example, to find all group chats with the calling + /// user and two other users, with People API profile IDs `123456789` and + /// `987654321`, you can use `users/123456789` and `users/987654321`. + /// You can also use the email as an alias for `{user}`. For example, + /// `users/example@gmail.com` where `example@gmail.com` is the email of the + /// Google Chat user. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::Google.Apps.Chat.V1.Space Space { - get { return space_; } - set { - space_ = value; - } + public pbc::RepeatedField Users { + get { return users_; } } - /// Field number for the "update_mask" field. - public const int UpdateMaskFieldNumber = 2; - private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 2; + private int pageSize_; /// - /// Required. The updated field paths, comma separated if there are - /// multiple. - /// - /// You can update the following fields for a space: - /// - /// `space_details`: Updates the space's description and guidelines. You must - /// pass both description and guidelines in the update request as - /// [`SpaceDetails`][google.chat.v1.Space.SpaceDetails]. If you only want to - /// update one of the fields, pass the existing value for the other field. - /// - /// `display_name`: Only supports updating the display name for spaces where - /// `spaceType` field is `SPACE`. - /// If you receive the error message `ALREADY_EXISTS`, try a different - /// value. An existing space within the - /// Google Workspace organization might already use this display name. - /// - /// `space_type`: Only supports changing a `GROUP_CHAT` space type to - /// `SPACE`. Include `display_name` together - /// with `space_type` in the update mask and ensure that the specified space - /// has a non-empty display name and the `SPACE` space type. Including the - /// `space_type` mask and the `SPACE` type in the specified space when updating - /// the display name is optional if the existing space already has the `SPACE` - /// type. Trying to update the space type in other ways results in an invalid - /// argument error. - /// `space_type` is not supported with `useAdminAccess`. - /// - /// `space_history_state`: Updates [space history - /// settings](https://support.google.com/chat/answer/7664687) by turning - /// history on or off for the space. Only supported if history settings are - /// enabled for the Google Workspace organization. To update the - /// space history state, you must omit all other field masks in your request. - /// `space_history_state` is not supported with `useAdminAccess`. + /// Optional. The maximum number of spaces to return. The service might return + /// fewer than this value. /// - /// `access_settings.audience`: Updates the [access - /// setting](https://support.google.com/chat/answer/11971020) of who can - /// discover the space, join the space, and preview the messages in named space - /// where `spaceType` field is `SPACE`. If the existing space has a - /// target audience, you can remove the audience and restrict space access by - /// omitting a value for this field mask. To update access settings for a - /// space, the authenticating user must be a space manager and omit all other - /// field masks in your request. You can't update this field if the space is in - /// [import - /// mode](https://developers.google.com/workspace/chat/import-data-overview). - /// To learn more, see [Make a space discoverable to specific - /// users](https://developers.google.com/workspace/chat/space-target-audience). - /// `access_settings.audience` is not supported with `useAdminAccess`. + /// If unspecified, at most 10 spaces are returned. /// - /// `permission_settings`: Supports changing the - /// [permission settings](https://support.google.com/chat/answer/13340792) - /// of a space. - /// When updating permission settings, you can only specify - /// `permissionSettings` field masks; you cannot update other field masks - /// at the same time. - /// The supported field masks include: + /// The maximum value is 30. If you use a value more than 30, it's + /// automatically changed to 30. /// - /// - `permission_settings.manageMembersAndGroups` - /// - `permission_settings.modifySpaceDetails` - /// - `permission_settings.toggleHistory` - /// - `permission_settings.useAtMentionAll` - /// - `permission_settings.manageApps` - /// - `permission_settings.manageWebhooks` - /// - `permission_settings.replyMessages` + /// Negative values return an `INVALID_ARGUMENT` error. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { - get { return updateMask_; } + public int PageSize { + get { return pageSize_; } set { - updateMask_ = value; + pageSize_ = value; } } - /// Field number for the "use_admin_access" field. - public const int UseAdminAccessFieldNumber = 3; - private bool useAdminAccess_; + /// Field number for the "page_token" field. + public const int PageTokenFieldNumber = 3; + private string pageToken_ = ""; /// - /// Optional. When `true`, the method runs using the user's Google Workspace - /// administrator privileges. - /// - /// The calling user must be a Google Workspace administrator with the - /// [manage chat and spaces conversations - /// privilege](https://support.google.com/a/answer/13369245). - /// - /// Requires the `chat.admin.spaces` [OAuth 2.0 - /// scope](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes). + /// Optional. A page token, received from a previous call to find group chats. + /// Provide this parameter to retrieve the subsequent page. /// - /// Some `FieldMask` values are not supported using admin access. For details, - /// see the description of `update_mask`. + /// When paginating, all other parameters provided should match the call that + /// provided the token. Passing different values may lead to unexpected + /// results. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool UseAdminAccess { - get { return useAdminAccess_; } + public string PageToken { + get { return pageToken_; } set { - useAdminAccess_ = value; + pageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "space_view" field. + public const int SpaceViewFieldNumber = 4; + private global::Google.Apps.Chat.V1.SpaceView spaceView_ = global::Google.Apps.Chat.V1.SpaceView.Unspecified; + /// + /// Requested space view type. If unset, defaults to + /// `SPACE_VIEW_RESOURCE_NAME_ONLY`. Requests that specify + /// `SPACE_VIEW_EXPANDED` must include scopes that allow reading space data, + /// for example, + /// https://www.googleapis.com/auth/chat.spaces or + /// https://www.googleapis.com/auth/chat.spaces.readonly. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Apps.Chat.V1.SpaceView SpaceView { + get { return spaceView_; } + set { + spaceView_ = value; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as UpdateSpaceRequest); + return Equals(other as FindGroupChatsRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(UpdateSpaceRequest other) { + public bool Equals(FindGroupChatsRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Space, other.Space)) return false; - if (!object.Equals(UpdateMask, other.UpdateMask)) return false; - if (UseAdminAccess != other.UseAdminAccess) return false; + if(!users_.Equals(other.users_)) return false; + if (PageSize != other.PageSize) return false; + if (PageToken != other.PageToken) return false; + if (SpaceView != other.SpaceView) return false; return Equals(_unknownFields, other._unknownFields); } @@ -4632,9 +4646,10 @@ public bool Equals(UpdateSpaceRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (space_ != null) hash ^= Space.GetHashCode(); - if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); - if (UseAdminAccess != false) hash ^= UseAdminAccess.GetHashCode(); + hash ^= users_.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (PageToken.Length != 0) hash ^= PageToken.GetHashCode(); + if (SpaceView != global::Google.Apps.Chat.V1.SpaceView.Unspecified) hash ^= SpaceView.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4653,18 +4668,19 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (space_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Space); + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); } - if (updateMask_ != null) { - output.WriteRawTag(18); - output.WriteMessage(UpdateMask); + if (PageToken.Length != 0) { + output.WriteRawTag(26); + output.WriteString(PageToken); } - if (UseAdminAccess != false) { - output.WriteRawTag(24); - output.WriteBool(UseAdminAccess); + if (SpaceView != global::Google.Apps.Chat.V1.SpaceView.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) SpaceView); } + users_.WriteTo(output, _repeated_users_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -4675,18 +4691,19 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (space_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Space); + if (PageSize != 0) { + output.WriteRawTag(16); + output.WriteInt32(PageSize); } - if (updateMask_ != null) { - output.WriteRawTag(18); - output.WriteMessage(UpdateMask); + if (PageToken.Length != 0) { + output.WriteRawTag(26); + output.WriteString(PageToken); } - if (UseAdminAccess != false) { - output.WriteRawTag(24); - output.WriteBool(UseAdminAccess); + if (SpaceView != global::Google.Apps.Chat.V1.SpaceView.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) SpaceView); } + users_.WriteTo(ref output, _repeated_users_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -4697,14 +4714,15 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (space_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Space); + size += users_.CalculateSize(_repeated_users_codec); + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); } - if (updateMask_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateMask); + if (PageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PageToken); } - if (UseAdminAccess != false) { - size += 1 + 1; + if (SpaceView != global::Google.Apps.Chat.V1.SpaceView.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) SpaceView); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -4714,24 +4732,19 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(UpdateSpaceRequest other) { + public void MergeFrom(FindGroupChatsRequest other) { if (other == null) { return; } - if (other.space_ != null) { - if (space_ == null) { - Space = new global::Google.Apps.Chat.V1.Space(); - } - Space.MergeFrom(other.Space); + users_.Add(other.users_); + if (other.PageSize != 0) { + PageSize = other.PageSize; } - if (other.updateMask_ != null) { - if (updateMask_ == null) { - UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); - } - UpdateMask.MergeFrom(other.UpdateMask); + if (other.PageToken.Length != 0) { + PageToken = other.PageToken; } - if (other.UseAdminAccess != false) { - UseAdminAccess = other.UseAdminAccess; + if (other.SpaceView != global::Google.Apps.Chat.V1.SpaceView.Unspecified) { + SpaceView = other.SpaceView; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -4752,22 +4765,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: { - if (space_ == null) { - Space = new global::Google.Apps.Chat.V1.Space(); - } - input.ReadMessage(Space); + case 16: { + PageSize = input.ReadInt32(); break; } - case 18: { - if (updateMask_ == null) { - UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); - } - input.ReadMessage(UpdateMask); + case 26: { + PageToken = input.ReadString(); break; } - case 24: { - UseAdminAccess = input.ReadBool(); + case 32: { + SpaceView = (global::Google.Apps.Chat.V1.SpaceView) input.ReadEnum(); + break; + } + case 42: { + users_.AddEntriesFrom(input, _repeated_users_codec); break; } } @@ -4789,19 +4800,628 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: { - if (space_ == null) { - Space = new global::Google.Apps.Chat.V1.Space(); - } - input.ReadMessage(Space); + case 16: { + PageSize = input.ReadInt32(); break; } - case 18: { - if (updateMask_ == null) { - UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); - } - input.ReadMessage(UpdateMask); - break; + case 26: { + PageToken = input.ReadString(); + break; + } + case 32: { + SpaceView = (global::Google.Apps.Chat.V1.SpaceView) input.ReadEnum(); + break; + } + case 42: { + users_.AddEntriesFrom(ref input, _repeated_users_codec); + break; + } + } + } + } + #endif + + } + + /// + /// A response containing group chat spaces with exactly the calling user and the + /// requested users. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class FindGroupChatsResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FindGroupChatsResponse()); + 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.Apps.Chat.V1.SpaceReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FindGroupChatsResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FindGroupChatsResponse(FindGroupChatsResponse other) : this() { + spaces_ = other.spaces_.Clone(); + nextPageToken_ = other.nextPageToken_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FindGroupChatsResponse Clone() { + return new FindGroupChatsResponse(this); + } + + /// Field number for the "spaces" field. + public const int SpacesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_spaces_codec + = pb::FieldCodec.ForMessage(10, global::Google.Apps.Chat.V1.Space.Parser); + private readonly pbc::RepeatedField spaces_ = new pbc::RepeatedField(); + /// + /// List of spaces in the requested (or first) page. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Spaces { + get { return spaces_; } + } + + /// Field number for the "next_page_token" field. + public const int NextPageTokenFieldNumber = 2; + private string nextPageToken_ = ""; + /// + /// A token that you can send as `pageToken` to retrieve the next page of + /// results. If empty, there are no subsequent pages. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string NextPageToken { + get { return nextPageToken_; } + set { + nextPageToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as FindGroupChatsResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(FindGroupChatsResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!spaces_.Equals(other.spaces_)) return false; + if (NextPageToken != other.NextPageToken) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= spaces_.GetHashCode(); + if (NextPageToken.Length != 0) hash ^= NextPageToken.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + spaces_.WriteTo(output, _repeated_spaces_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + spaces_.WriteTo(ref output, _repeated_spaces_codec); + if (NextPageToken.Length != 0) { + output.WriteRawTag(18); + output.WriteString(NextPageToken); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += spaces_.CalculateSize(_repeated_spaces_codec); + if (NextPageToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NextPageToken); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(FindGroupChatsResponse other) { + if (other == null) { + return; + } + spaces_.Add(other.spaces_); + if (other.NextPageToken.Length != 0) { + NextPageToken = other.NextPageToken; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + spaces_.AddEntriesFrom(input, _repeated_spaces_codec); + break; + } + case 18: { + NextPageToken = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + spaces_.AddEntriesFrom(ref input, _repeated_spaces_codec); + break; + } + case 18: { + NextPageToken = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// A request to update a single space. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class UpdateSpaceRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateSpaceRequest()); + 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.Apps.Chat.V1.SpaceReflection.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 UpdateSpaceRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateSpaceRequest(UpdateSpaceRequest other) : this() { + space_ = other.space_ != null ? other.space_.Clone() : null; + updateMask_ = other.updateMask_ != null ? other.updateMask_.Clone() : null; + useAdminAccess_ = other.useAdminAccess_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateSpaceRequest Clone() { + return new UpdateSpaceRequest(this); + } + + /// Field number for the "space" field. + public const int SpaceFieldNumber = 1; + private global::Google.Apps.Chat.V1.Space space_; + /// + /// Required. Space with fields to be updated. `Space.name` must be + /// populated in the form of `spaces/{space}`. Only fields + /// specified by `update_mask` are updated. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Apps.Chat.V1.Space Space { + get { return space_; } + set { + space_ = value; + } + } + + /// Field number for the "update_mask" field. + public const int UpdateMaskFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.FieldMask updateMask_; + /// + /// Required. The updated field paths, comma separated if there are + /// multiple. + /// + /// You can update the following fields for a space: + /// + /// `space_details`: Updates the space's description and guidelines. You must + /// pass both description and guidelines in the update request as + /// [`SpaceDetails`][google.chat.v1.Space.SpaceDetails]. If you only want to + /// update one of the fields, pass the existing value for the other field. + /// + /// `display_name`: Only supports updating the display name for spaces where + /// `spaceType` field is `SPACE`. + /// If you receive the error message `ALREADY_EXISTS`, try a different + /// value. An existing space within the + /// Google Workspace organization might already use this display name. + /// + /// `space_type`: Only supports changing a `GROUP_CHAT` space type to + /// `SPACE`. Include `display_name` together + /// with `space_type` in the update mask and ensure that the specified space + /// has a non-empty display name and the `SPACE` space type. Including the + /// `space_type` mask and the `SPACE` type in the specified space when updating + /// the display name is optional if the existing space already has the `SPACE` + /// type. Trying to update the space type in other ways results in an invalid + /// argument error. + /// `space_type` is not supported with `useAdminAccess`. + /// + /// `space_history_state`: Updates [space history + /// settings](https://support.google.com/chat/answer/7664687) by turning + /// history on or off for the space. Only supported if history settings are + /// enabled for the Google Workspace organization. To update the + /// space history state, you must omit all other field masks in your request. + /// `space_history_state` is not supported with `useAdminAccess`. + /// + /// `access_settings.audience`: Updates the [access + /// setting](https://support.google.com/chat/answer/11971020) of who can + /// discover the space, join the space, and preview the messages in named space + /// where `spaceType` field is `SPACE`. If the existing space has a + /// target audience, you can remove the audience and restrict space access by + /// omitting a value for this field mask. To update access settings for a + /// space, the authenticating user must be a space manager and omit all other + /// field masks in your request. You can't update this field if the space is in + /// [import + /// mode](https://developers.google.com/workspace/chat/import-data-overview). + /// To learn more, see [Make a space discoverable to specific + /// users](https://developers.google.com/workspace/chat/space-target-audience). + /// `access_settings.audience` is not supported with `useAdminAccess`. + /// + /// `permission_settings`: Supports changing the + /// [permission settings](https://support.google.com/chat/answer/13340792) + /// of a space. + /// When updating permission settings, you can only specify + /// `permissionSettings` field masks; you cannot update other field masks + /// at the same time. + /// The supported field masks include: + /// + /// - `permission_settings.manageMembersAndGroups` + /// - `permission_settings.modifySpaceDetails` + /// - `permission_settings.toggleHistory` + /// - `permission_settings.useAtMentionAll` + /// - `permission_settings.manageApps` + /// - `permission_settings.manageWebhooks` + /// - `permission_settings.replyMessages` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.FieldMask UpdateMask { + get { return updateMask_; } + set { + updateMask_ = value; + } + } + + /// Field number for the "use_admin_access" field. + public const int UseAdminAccessFieldNumber = 3; + private bool useAdminAccess_; + /// + /// Optional. When `true`, the method runs using the user's Google Workspace + /// administrator privileges. + /// + /// The calling user must be a Google Workspace administrator with the + /// [manage chat and spaces conversations + /// privilege](https://support.google.com/a/answer/13369245). + /// + /// Requires the `chat.admin.spaces` [OAuth 2.0 + /// scope](https://developers.google.com/workspace/chat/authenticate-authorize#chat-api-scopes). + /// + /// Some `FieldMask` values are not supported using admin access. For details, + /// see the description of `update_mask`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool UseAdminAccess { + get { return useAdminAccess_; } + set { + useAdminAccess_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as UpdateSpaceRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(UpdateSpaceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Space, other.Space)) return false; + if (!object.Equals(UpdateMask, other.UpdateMask)) return false; + if (UseAdminAccess != other.UseAdminAccess) 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 (space_ != null) hash ^= Space.GetHashCode(); + if (updateMask_ != null) hash ^= UpdateMask.GetHashCode(); + if (UseAdminAccess != false) hash ^= UseAdminAccess.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 (space_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Space); + } + if (updateMask_ != null) { + output.WriteRawTag(18); + output.WriteMessage(UpdateMask); + } + if (UseAdminAccess != false) { + output.WriteRawTag(24); + output.WriteBool(UseAdminAccess); + } + 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 (space_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Space); + } + if (updateMask_ != null) { + output.WriteRawTag(18); + output.WriteMessage(UpdateMask); + } + if (UseAdminAccess != false) { + output.WriteRawTag(24); + output.WriteBool(UseAdminAccess); + } + 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 (space_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Space); + } + if (updateMask_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UpdateMask); + } + if (UseAdminAccess != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(UpdateSpaceRequest other) { + if (other == null) { + return; + } + if (other.space_ != null) { + if (space_ == null) { + Space = new global::Google.Apps.Chat.V1.Space(); + } + Space.MergeFrom(other.Space); + } + if (other.updateMask_ != null) { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + UpdateMask.MergeFrom(other.UpdateMask); + } + if (other.UseAdminAccess != false) { + UseAdminAccess = other.UseAdminAccess; + } + _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 (space_ == null) { + Space = new global::Google.Apps.Chat.V1.Space(); + } + input.ReadMessage(Space); + break; + } + case 18: { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); + break; + } + case 24: { + UseAdminAccess = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + 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 (space_ == null) { + Space = new global::Google.Apps.Chat.V1.Space(); + } + input.ReadMessage(Space); + break; + } + case 18: { + if (updateMask_ == null) { + UpdateMask = new global::Google.Protobuf.WellKnownTypes.FieldMask(); + } + input.ReadMessage(UpdateMask); + break; } case 24: { UseAdminAccess = input.ReadBool(); @@ -4832,7 +5452,7 @@ public sealed partial class SearchSpacesRequest : pb::IMessageField number for the "edition" field. + public const int EditionFieldNumber = 14; + private global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition edition_ = global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition.Unspecified; + /// + /// Optional. The edition of the instance. See + /// [Edition][google.bigtable.admin.v2.Instance.Edition] for details. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition Edition { + get { return edition_; } + set { + edition_ = value; + } + } + /// Field number for the "labels" field. public const int LabelsFieldNumber = 5; private static readonly pbc::MapField.Codec _map_labels_codec @@ -425,6 +445,7 @@ public bool Equals(Instance other) { if (DisplayName != other.DisplayName) return false; if (State != other.State) return false; if (Type != other.Type) return false; + if (Edition != other.Edition) return false; if (!Labels.Equals(other.Labels)) return false; if (!object.Equals(CreateTime, other.CreateTime)) return false; if (SatisfiesPzs != other.SatisfiesPzs) return false; @@ -441,6 +462,7 @@ public override int GetHashCode() { if (DisplayName.Length != 0) hash ^= DisplayName.GetHashCode(); if (State != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.State.NotKnown) hash ^= State.GetHashCode(); if (Type != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Type.Unspecified) hash ^= Type.GetHashCode(); + if (Edition != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition.Unspecified) hash ^= Edition.GetHashCode(); hash ^= Labels.GetHashCode(); if (createTime_ != null) hash ^= CreateTime.GetHashCode(); if (HasSatisfiesPzs) hash ^= SatisfiesPzs.GetHashCode(); @@ -494,6 +516,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteBool(SatisfiesPzi); } tags_.WriteTo(output, _map_tags_codec); + if (Edition != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition.Unspecified) { + output.WriteRawTag(112); + output.WriteEnum((int) Edition); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -534,6 +560,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteBool(SatisfiesPzi); } tags_.WriteTo(ref output, _map_tags_codec); + if (Edition != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition.Unspecified) { + output.WriteRawTag(112); + output.WriteEnum((int) Edition); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -556,6 +586,9 @@ public int CalculateSize() { if (Type != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Type.Unspecified) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); } + if (Edition != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Edition); + } size += labels_.CalculateSize(_map_labels_codec); if (createTime_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(CreateTime); @@ -591,6 +624,9 @@ public void MergeFrom(Instance other) { if (other.Type != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Type.Unspecified) { Type = other.Type; } + if (other.Edition != global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition.Unspecified) { + Edition = other.Edition; + } labels_.MergeFrom(other.labels_); if (other.createTime_ != null) { if (createTime_ == null) { @@ -663,6 +699,10 @@ public void MergeFrom(pb::CodedInputStream input) { tags_.AddEntriesFrom(input, _map_tags_codec); break; } + case 112: { + Edition = (global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition) input.ReadEnum(); + break; + } } } #endif @@ -721,6 +761,10 @@ public void MergeFrom(pb::CodedInputStream input) { tags_.AddEntriesFrom(ref input, _map_tags_codec); break; } + case 112: { + Edition = (global::Google.Cloud.Bigtable.Admin.V2.Instance.Types.Edition) input.ReadEnum(); + break; + } } } } @@ -773,6 +817,35 @@ public enum Type { [pbr::OriginalName("DEVELOPMENT")] Development = 2, } + /// + /// Possible editions of an instance. + /// + /// An edition is a specific tier of Cloud Bigtable. Each edition is tailored + /// to different customer needs. Higher tiers offer more features and better + /// performance. + /// + public enum Edition { + /// + /// The edition is unspecified. This is treated as `ENTERPRISE`. + /// + [pbr::OriginalName("EDITION_UNSPECIFIED")] Unspecified = 0, + /// + /// The Enterprise edition. This is the default offering that is designed to + /// meet the needs of most enterprise workloads. + /// + [pbr::OriginalName("ENTERPRISE")] Enterprise = 1, + /// + /// The Enterprise Plus edition. This is a premium tier that is designed for + /// demanding, multi-tenant workloads requiring the highest levels of + /// performance, scale, and global availability. + /// + /// The nodes in the Enterprise Plus tier come at a higher cost than the + /// Enterprise tier. Any Enterprise Plus features must be disabled before + /// downgrading to Enterprise. + /// + [pbr::OriginalName("ENTERPRISE_PLUS")] EnterprisePlus = 2, + } + } #endregion diff --git a/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/HsmManagement.g.cs b/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/HsmManagement.g.cs index cdb911f6710f..fa83bff67860 100644 --- a/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/HsmManagement.g.cs +++ b/apis/Google.Cloud.Kms.V1/Google.Cloud.Kms.V1/HsmManagement.g.cs @@ -429,7 +429,7 @@ public string Name { /// /// Output only. The system-defined duration that an instance can remain /// unrefreshed until it is automatically disabled. This will have a value of - /// 120 days. + /// 730 days. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json index 9e46334c9576..e9a3a2e47506 100644 --- a/generator-input/pipeline-state.json +++ b/generator-input/pipeline-state.json @@ -97,7 +97,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-04-06T14:05:42.074440080Z", - "lastGeneratedCommit": "8d52a0bd5332bec365647fd792102a25a665e9fe", + "lastGeneratedCommit": "13ca8dbc797515144104ee799e429f8e29b45c08", "lastReleasedCommit": "8d52a0bd5332bec365647fd792102a25a665e9fe", "apiPaths": [ "google/chat/v1" @@ -797,7 +797,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-03-30T14:08:07.737787757Z", - "lastGeneratedCommit": "5993bc685e72fbda796378c146533f7ef6e95d8a", + "lastGeneratedCommit": "9761131b283e506d8b45fe5e0a174bee9f9bc828", "lastReleasedCommit": "5993bc685e72fbda796378c146533f7ef6e95d8a", "apiPaths": [ "google/bigtable/admin/v2" @@ -1912,7 +1912,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-04-13T15:47:02.473384817Z", - "lastGeneratedCommit": "7fbf256c9ee4e580bc2ffa825d8d41263d9462d3", + "lastGeneratedCommit": "bcfcbdad6f3a2662af191141515eee3d44fccd98", "lastReleasedCommit": "7fbf256c9ee4e580bc2ffa825d8d41263d9462d3", "apiPaths": [ "google/cloud/kms/v1"