diff --git a/.github/renovate.json b/.github/renovate.json index 222934594cf3..7cd3c129440a 100644 --- a/.github/renovate.json +++ b/.github/renovate.json @@ -370,8 +370,7 @@ "System.Collections.Immutable", "dotnet-sdk" ], - "allowedVersions": "<9.0.0", - "minimumReleaseAge": "7 days" + "allowedVersions": "<9.0.0" }, { "matchPaths": [ diff --git a/apis/Google.Cloud.AlloyDb.V1/Google.Cloud.AlloyDb.V1/Resources.g.cs b/apis/Google.Cloud.AlloyDb.V1/Google.Cloud.AlloyDb.V1/Resources.g.cs index 88bbbd1a2dde..6338ea8400c1 100644 --- a/apis/Google.Cloud.AlloyDb.V1/Google.Cloud.AlloyDb.V1/Resources.g.cs +++ b/apis/Google.Cloud.AlloyDb.V1/Google.Cloud.AlloyDb.V1/Resources.g.cs @@ -369,27 +369,28 @@ static ResourcesReflection() { "E0lOU1RBTkNFX1ZJRVdfQkFTSUMQARIWChJJTlNUQU5DRV9WSUVXX0ZVTEwQ", "AipnCgtDbHVzdGVyVmlldxIcChhDTFVTVEVSX1ZJRVdfVU5TUEVDSUZJRUQQ", "ABIWChJDTFVTVEVSX1ZJRVdfQkFTSUMQARIiCh5DTFVTVEVSX1ZJRVdfQ09O", - "VElOVU9VU19CQUNLVVAQAiqMAQoPRGF0YWJhc2VWZXJzaW9uEiAKHERBVEFC", + "VElOVU9VU19CQUNLVVAQAiqdAQoPRGF0YWJhc2VWZXJzaW9uEiAKHERBVEFC", "QVNFX1ZFUlNJT05fVU5TUEVDSUZJRUQQABITCgtQT1NUR1JFU18xMxABGgII", "ARIPCgtQT1NUR1JFU18xNBACEg8KC1BPU1RHUkVTXzE1EAMSDwoLUE9TVEdS", - "RVNfMTYQBBIPCgtQT1NUR1JFU18xNxAFKk4KEFN1YnNjcmlwdGlvblR5cGUS", - "IQodU1VCU0NSSVBUSU9OX1RZUEVfVU5TUEVDSUZJRUQQABIMCghTVEFOREFS", - "RBABEgkKBVRSSUFMEAJCpwUKG2NvbS5nb29nbGUuY2xvdWQuYWxsb3lkYi52", - "MUIOUmVzb3VyY2VzUHJvdG9QAVo1Y2xvdWQuZ29vZ2xlLmNvbS9nby9hbGxv", - "eWRiL2FwaXYxL2FsbG95ZGJwYjthbGxveWRicGKqAhdHb29nbGUuQ2xvdWQu", - "QWxsb3lEYi5WMcoCF0dvb2dsZVxDbG91ZFxBbGxveURiXFYx6gIaR29vZ2xl", - "OjpDbG91ZDo6QWxsb3lEQjo6VjHqQaYBCihjbG91ZGttcy5nb29nbGVhcGlz", - "LmNvbS9DcnlwdG9LZXlWZXJzaW9uEnpwcm9qZWN0cy97cHJvamVjdH0vbG9j", - "YXRpb25zL3tsb2NhdGlvbn0va2V5UmluZ3Mve2tleV9yaW5nfS9jcnlwdG9L", - "ZXlzL3tjcnlwdG9fa2V5fS9jcnlwdG9LZXlWZXJzaW9ucy97Y3J5cHRvX2tl", - "eV92ZXJzaW9ufepBTgoeY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9OZXR3b3Jr", - "Eixwcm9qZWN0cy97cHJvamVjdH0vZ2xvYmFsL25ldHdvcmtzL3tuZXR3b3Jr", - "fepBeAohY2xvdWRrbXMuZ29vZ2xlYXBpcy5jb20vQ3J5cHRvS2V5ElNwcm9q", - "ZWN0cy97cHJvamVjdH0vbG9jYXRpb25zL3tsb2NhdGlvbn0va2V5UmluZ3Mv", - "e2tleV9yaW5nfS9jcnlwdG9LZXlzL3tjcnlwdG9fa2V5fepBdwooY29tcHV0", - "ZS5nb29nbGVhcGlzLmNvbS9TZXJ2aWNlQXR0YWNobWVudBJLcHJvamVjdHMv", - "e3Byb2plY3R9L3JlZ2lvbnMve3JlZ2lvbn0vc2VydmljZUF0dGFjaG1lbnRz", - "L3tzZXJ2aWNlX2F0dGFjaG1lbnR9YgZwcm90bzM=")); + "RVNfMTYQBBIPCgtQT1NUR1JFU18xNxAFEg8KC1BPU1RHUkVTXzE4EAYqTgoQ", + "U3Vic2NyaXB0aW9uVHlwZRIhCh1TVUJTQ1JJUFRJT05fVFlQRV9VTlNQRUNJ", + "RklFRBAAEgwKCFNUQU5EQVJEEAESCQoFVFJJQUwQAkKnBQobY29tLmdvb2ds", + "ZS5jbG91ZC5hbGxveWRiLnYxQg5SZXNvdXJjZXNQcm90b1ABWjVjbG91ZC5n", + "b29nbGUuY29tL2dvL2FsbG95ZGIvYXBpdjEvYWxsb3lkYnBiO2FsbG95ZGJw", + "YqoCF0dvb2dsZS5DbG91ZC5BbGxveURiLlYxygIXR29vZ2xlXENsb3VkXEFs", + "bG95RGJcVjHqAhpHb29nbGU6OkNsb3VkOjpBbGxveURCOjpWMepBpgEKKGNs", + "b3Vka21zLmdvb2dsZWFwaXMuY29tL0NyeXB0b0tleVZlcnNpb24SenByb2pl", + "Y3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xvY2F0aW9ufS9rZXlSaW5ncy97", + "a2V5X3Jpbmd9L2NyeXB0b0tleXMve2NyeXB0b19rZXl9L2NyeXB0b0tleVZl", + "cnNpb25zL3tjcnlwdG9fa2V5X3ZlcnNpb2596kFOCh5jb21wdXRlLmdvb2ds", + "ZWFwaXMuY29tL05ldHdvcmsSLHByb2plY3RzL3twcm9qZWN0fS9nbG9iYWwv", + "bmV0d29ya3Mve25ldHdvcmt96kF4CiFjbG91ZGttcy5nb29nbGVhcGlzLmNv", + "bS9DcnlwdG9LZXkSU3Byb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xv", + "Y2F0aW9ufS9rZXlSaW5ncy97a2V5X3Jpbmd9L2NyeXB0b0tleXMve2NyeXB0", + "b19rZXl96kF3Cihjb21wdXRlLmdvb2dsZWFwaXMuY29tL1NlcnZpY2VBdHRh", + "Y2htZW50Ektwcm9qZWN0cy97cHJvamVjdH0vcmVnaW9ucy97cmVnaW9ufS9z", + "ZXJ2aWNlQXR0YWNobWVudHMve3NlcnZpY2VfYXR0YWNobWVudH1iBnByb3Rv", + "Mw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.FieldInfoReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.AlloyDb.V1.CsqlResourcesReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor, global::Google.Type.DateReflection.Descriptor, global::Google.Type.DayofweekReflection.Descriptor, global::Google.Type.TimeofdayReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.AlloyDb.V1.InstanceView), typeof(global::Google.Cloud.AlloyDb.V1.ClusterView), typeof(global::Google.Cloud.AlloyDb.V1.DatabaseVersion), typeof(global::Google.Cloud.AlloyDb.V1.SubscriptionType), }, null, new pbr::GeneratedClrTypeInfo[] { @@ -515,6 +516,10 @@ public enum DatabaseVersion { /// The database version is Postgres 17. /// [pbr::OriginalName("POSTGRES_17")] Postgres17 = 5, + /// + /// The database version is Postgres 18. + /// + [pbr::OriginalName("POSTGRES_18")] Postgres18 = 6, } /// diff --git a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectAsyncSnippet.g.cs index 603f91cb8e9b..d4d767093c66 100644 --- a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectAsyncSnippet.g.cs +++ b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectAsyncSnippet.g.cs @@ -45,6 +45,7 @@ public async Task VerifyAttestationRequestObjectAsync() TdCcel = new TdxCcelAttestation(), Attester = "", NvidiaAttestation = new NvidiaAttestation(), + InstanceAsInstanceName = InstanceName.FromProjectZoneInstance("[PROJECT]", "[ZONE]", "[INSTANCE]"), }; // Make the request VerifyAttestationResponse response = await confidentialComputingClient.VerifyAttestationAsync(request); diff --git a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectSnippet.g.cs b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectSnippet.g.cs index 38f1cff41f73..09f392fdbc91 100644 --- a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectSnippet.g.cs +++ b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/ConfidentialComputingClient.VerifyAttestationRequestObjectSnippet.g.cs @@ -44,6 +44,7 @@ public void VerifyAttestationRequestObject() TdCcel = new TdxCcelAttestation(), Attester = "", NvidiaAttestation = new NvidiaAttestation(), + InstanceAsInstanceName = InstanceName.FromProjectZoneInstance("[PROJECT]", "[ZONE]", "[INSTANCE]"), }; // Make the request VerifyAttestationResponse response = confidentialComputingClient.VerifyAttestation(request); diff --git a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/snippet_metadata_google.cloud.confidentialcomputing.v1.json b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/snippet_metadata_google.cloud.confidentialcomputing.v1.json index b69d4c890f32..ca4626108715 100644 --- a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/snippet_metadata_google.cloud.confidentialcomputing.v1.json +++ b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.GeneratedSnippets/snippet_metadata_google.cloud.confidentialcomputing.v1.json @@ -351,12 +351,12 @@ "segments": [ { "start": 20, - "end": 51, + "end": 52, "type": "FULL" }, { "start": 34, - "end": 49, + "end": 50, "type": "SHORT" } ] @@ -400,12 +400,12 @@ "segments": [ { "start": 20, - "end": 52, + "end": 53, "type": "FULL" }, { "start": 35, - "end": 50, + "end": 51, "type": "SHORT" } ] diff --git a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.Snippets/ConfidentialComputingClientSnippets.g.cs b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.Snippets/ConfidentialComputingClientSnippets.g.cs index 27e9cedcf385..8c8a84d46c64 100644 --- a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.Snippets/ConfidentialComputingClientSnippets.g.cs +++ b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1.Snippets/ConfidentialComputingClientSnippets.g.cs @@ -133,6 +133,7 @@ public void VerifyAttestationRequestObject() TdCcel = new TdxCcelAttestation(), Attester = "", NvidiaAttestation = new NvidiaAttestation(), + InstanceAsInstanceName = InstanceName.FromProjectZoneInstance("[PROJECT]", "[ZONE]", "[INSTANCE]"), }; // Make the request VerifyAttestationResponse response = confidentialComputingClient.VerifyAttestation(request); @@ -157,6 +158,7 @@ public async Task VerifyAttestationRequestObjectAsync() TdCcel = new TdxCcelAttestation(), Attester = "", NvidiaAttestation = new NvidiaAttestation(), + InstanceAsInstanceName = InstanceName.FromProjectZoneInstance("[PROJECT]", "[ZONE]", "[INSTANCE]"), }; // Make the request VerifyAttestationResponse response = await confidentialComputingClient.VerifyAttestationAsync(request); diff --git a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/Service.g.cs b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/Service.g.cs index 6c44e0799f09..846009cbbe69 100644 --- a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/Service.g.cs +++ b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/Service.g.cs @@ -40,7 +40,7 @@ static ServiceReflection() { "ZXN0EjkKBnBhcmVudBgBIAEoCUIp4EEC+kEjCiFsb2NhdGlvbnMuZ29vZ2xl", "YXBpcy5jb20vTG9jYXRpb24SSAoJY2hhbGxlbmdlGAIgASgLMjAuZ29vZ2xl", "LmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5DaGFsbGVuZ2VCA+BB", - "AiKSBgoYVmVyaWZ5QXR0ZXN0YXRpb25SZXF1ZXN0ElEKB3RkX2NjZWwYBiAB", + "AiLNBgoYVmVyaWZ5QXR0ZXN0YXRpb25SZXF1ZXN0ElEKB3RkX2NjZWwYBiAB", "KAsyOS5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlRk", "eENjZWxBdHRlc3RhdGlvbkID4EEBSAASXAoTc2V2X3NucF9hdHRlc3RhdGlv", "bhgHIAEoCzI4Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcu", @@ -56,167 +56,170 @@ static ServiceReflection() { "bGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLkNvbmZpZGVudGlh", "bFNwYWNlSW5mb0ID4EEBEk8KDXRva2VuX29wdGlvbnMYBSABKAsyMy5nb29n", "bGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlRva2VuT3B0aW9u", - "c0ID4EEBEhUKCGF0dGVzdGVyGAggASgJQgPgQQFCEQoPdGVlX2F0dGVzdGF0", - "aW9uQhQKEmRldmljZV9hdHRlc3RhdGlvbiK7CgoRTnZpZGlhQXR0ZXN0YXRp", - "b24SZAoDc3B0GAEgASgLMlUuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNv", - "bXB1dGluZy52MS5OdmlkaWFBdHRlc3RhdGlvbi5TaW5nbGVQYXNzdGhyb3Vn", - "aEF0dGVzdGF0aW9uSAASYgoFcHBjaWUYAiABKAsyUS5nb29nbGUuY2xvdWQu", - "Y29uZmlkZW50aWFsY29tcHV0aW5nLnYxLk52aWRpYUF0dGVzdGF0aW9uLlBy", - "b3RlY3RlZFBjaWVBdHRlc3RhdGlvbkgAEmwKA21wdBgDIAEoCzJdLmdvb2ds", + "c0ID4EEBEhUKCGF0dGVzdGVyGAggASgJQgPgQQESOQoIaW5zdGFuY2UYCiAB", + "KAlCJ+BBAfpBIQofY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9JbnN0YW5jZUIR", + "Cg90ZWVfYXR0ZXN0YXRpb25CFAoSZGV2aWNlX2F0dGVzdGF0aW9uIrsKChFO", + "dmlkaWFBdHRlc3RhdGlvbhJkCgNzcHQYASABKAsyVS5nb29nbGUuY2xvdWQu", + "Y29uZmlkZW50aWFsY29tcHV0aW5nLnYxLk52aWRpYUF0dGVzdGF0aW9uLlNp", + "bmdsZVBhc3N0aHJvdWdoQXR0ZXN0YXRpb25IABJiCgVwcGNpZRgCIAEoCzJR", + "Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuTnZpZGlh", + "QXR0ZXN0YXRpb24uUHJvdGVjdGVkUGNpZUF0dGVzdGF0aW9uSAASbAoDbXB0", + "GAMgASgLMl0uZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52", + "MS5OdmlkaWFBdHRlc3RhdGlvbi5NdWx0aUdwdVNlY3VyZVBhc3N0aHJvdWdo", + "QXR0ZXN0YXRpb25IABqUAgoHR3B1SW5mbxIRCgR1dWlkGAEgASgJQgPgQQES", + "GwoOZHJpdmVyX3ZlcnNpb24YAiABKAlCA+BBARIaCg12Ymlvc192ZXJzaW9u", + "GAMgASgJQgPgQQEScAoVZ3B1X2FyY2hpdGVjdHVyZV90eXBlGAQgASgOMkwu", + "Z29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5OdmlkaWFB", + "dHRlc3RhdGlvbi5HcHVBcmNoaXRlY3R1cmVUeXBlQgPgQQESKgodYXR0ZXN0", + "YXRpb25fY2VydGlmaWNhdGVfY2hhaW4YBSABKAxCA+BBARIfChJhdHRlc3Rh", + "dGlvbl9yZXBvcnQYBiABKAxCA+BBARpsCgpTd2l0Y2hJbmZvEhEKBHV1aWQY", + "ASABKAlCA+BBARIqCh1hdHRlc3RhdGlvbl9jZXJ0aWZpY2F0ZV9jaGFpbhgC", + "IAEoDEID4EEBEh8KEmF0dGVzdGF0aW9uX3JlcG9ydBgDIAEoDEID4EEBGngK", + "HFNpbmdsZVBhc3N0aHJvdWdoQXR0ZXN0YXRpb24SWAoJZ3B1X3F1b3RlGAEg", + "ASgLMkAuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5O", + "dmlkaWFBdHRlc3RhdGlvbi5HcHVJbmZvQgPgQQEa1gEKGFByb3RlY3RlZFBj", + "aWVBdHRlc3RhdGlvbhJZCgpncHVfcXVvdGVzGAEgAygLMkAuZ29vZ2xlLmNs", + "b3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5OdmlkaWFBdHRlc3RhdGlv", + "bi5HcHVJbmZvQgPgQQESXwoNc3dpdGNoX3F1b3RlcxgCIAMoCzJDLmdvb2ds", "ZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuTnZpZGlhQXR0ZXN0", - "YXRpb24uTXVsdGlHcHVTZWN1cmVQYXNzdGhyb3VnaEF0dGVzdGF0aW9uSAAa", - "lAIKB0dwdUluZm8SEQoEdXVpZBgBIAEoCUID4EEBEhsKDmRyaXZlcl92ZXJz", - "aW9uGAIgASgJQgPgQQESGgoNdmJpb3NfdmVyc2lvbhgDIAEoCUID4EEBEnAK", - "FWdwdV9hcmNoaXRlY3R1cmVfdHlwZRgEIAEoDjJMLmdvb2dsZS5jbG91ZC5j", - "b25maWRlbnRpYWxjb21wdXRpbmcudjEuTnZpZGlhQXR0ZXN0YXRpb24uR3B1", - "QXJjaGl0ZWN0dXJlVHlwZUID4EEBEioKHWF0dGVzdGF0aW9uX2NlcnRpZmlj", - "YXRlX2NoYWluGAUgASgMQgPgQQESHwoSYXR0ZXN0YXRpb25fcmVwb3J0GAYg", - "ASgMQgPgQQEabAoKU3dpdGNoSW5mbxIRCgR1dWlkGAEgASgJQgPgQQESKgod", - "YXR0ZXN0YXRpb25fY2VydGlmaWNhdGVfY2hhaW4YAiABKAxCA+BBARIfChJh", - "dHRlc3RhdGlvbl9yZXBvcnQYAyABKAxCA+BBARp4ChxTaW5nbGVQYXNzdGhy", - "b3VnaEF0dGVzdGF0aW9uElgKCWdwdV9xdW90ZRgBIAEoCzJALmdvb2dsZS5j", - "bG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuTnZpZGlhQXR0ZXN0YXRp", - "b24uR3B1SW5mb0ID4EEBGtYBChhQcm90ZWN0ZWRQY2llQXR0ZXN0YXRpb24S", - "WQoKZ3B1X3F1b3RlcxgBIAMoCzJALmdvb2dsZS5jbG91ZC5jb25maWRlbnRp", - "YWxjb21wdXRpbmcudjEuTnZpZGlhQXR0ZXN0YXRpb24uR3B1SW5mb0ID4EEB", - "El8KDXN3aXRjaF9xdW90ZXMYAiADKAsyQy5nb29nbGUuY2xvdWQuY29uZmlk", - "ZW50aWFsY29tcHV0aW5nLnYxLk52aWRpYUF0dGVzdGF0aW9uLlN3aXRjaElu", - "Zm9CA+BBARqBAQokTXVsdGlHcHVTZWN1cmVQYXNzdGhyb3VnaEF0dGVzdGF0", - "aW9uElkKCmdwdV9xdW90ZXMYASADKAsyQC5nb29nbGUuY2xvdWQuY29uZmlk", - "ZW50aWFsY29tcHV0aW5nLnYxLk52aWRpYUF0dGVzdGF0aW9uLkdwdUluZm9C", - "A+BBASKDAQoTR3B1QXJjaGl0ZWN0dXJlVHlwZRIlCiFHUFVfQVJDSElURUNU", - "VVJFX1RZUEVfVU5TUEVDSUZJRUQQABIgChxHUFVfQVJDSElURUNUVVJFX1RZ", - "UEVfSE9QUEVSEAgSIwofR1BVX0FSQ0hJVEVDVFVSRV9UWVBFX0JMQUNLV0VM", - "TBAKQgwKCmNjX2ZlYXR1cmUigwEKElRkeENjZWxBdHRlc3RhdGlvbhIcCg9j", - "Y2VsX2FjcGlfdGFibGUYASABKAxCA+BBARIWCgljY2VsX2RhdGEYAiABKAxC", - "A+BBARIgChNjYW5vbmljYWxfZXZlbnRfbG9nGAMgASgMQgPgQQESFQoIdGRf", - "cXVvdGUYBCABKAxCA+BBASI/ChFTZXZTbnBBdHRlc3RhdGlvbhITCgZyZXBv", - "cnQYASABKAxCA+BBARIVCghhdXhfYmxvYhgCIAEoDEID4EEBImwKGVZlcmlm", - "eUF0dGVzdGF0aW9uUmVzcG9uc2USHgoRb2lkY19jbGFpbXNfdG9rZW4YAiAB", - "KAlCA+BBAxIvCg5wYXJ0aWFsX2Vycm9ycxgDIAMoCzISLmdvb2dsZS5ycGMu", - "U3RhdHVzQgPgQQMiMwoOR2NwQ3JlZGVudGlhbHMSIQoZc2VydmljZV9hY2Nv", - "dW50X2lkX3Rva2VucxgCIAMoCSKFAgoMVG9rZW5PcHRpb25zEmkKGmF3c19w", - "cmluY2lwYWxfdGFnc19vcHRpb25zGAQgASgLMj4uZ29vZ2xlLmNsb3VkLmNv", - "bmZpZGVudGlhbGNvbXB1dGluZy52MS5Bd3NQcmluY2lwYWxUYWdzT3B0aW9u", - "c0ID4EEBSAASFQoIYXVkaWVuY2UYASABKAlCA+BBARISCgVub25jZRgCIAMo", - "CUID4EEBEkkKCnRva2VuX3R5cGUYAyABKA4yMC5nb29nbGUuY2xvdWQuY29u", - "ZmlkZW50aWFsY29tcHV0aW5nLnYxLlRva2VuVHlwZUID4EEBQhQKEnRva2Vu", - "X3R5cGVfb3B0aW9ucyL2AgoXQXdzUHJpbmNpcGFsVGFnc09wdGlvbnMSeAoW", - "YWxsb3dlZF9wcmluY2lwYWxfdGFncxgBIAEoCzJTLmdvb2dsZS5jbG91ZC5j", - "b25maWRlbnRpYWxjb21wdXRpbmcudjEuQXdzUHJpbmNpcGFsVGFnc09wdGlv", - "bnMuQWxsb3dlZFByaW5jaXBhbFRhZ3NCA+BBARrgAQoUQWxsb3dlZFByaW5j", - "aXBhbFRhZ3MSlQEKGmNvbnRhaW5lcl9pbWFnZV9zaWduYXR1cmVzGAEgASgL", - "MmwuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5Bd3NQ", - "cmluY2lwYWxUYWdzT3B0aW9ucy5BbGxvd2VkUHJpbmNpcGFsVGFncy5Db250", - "YWluZXJJbWFnZVNpZ25hdHVyZXNCA+BBARowChhDb250YWluZXJJbWFnZVNp", - "Z25hdHVyZXMSFAoHa2V5X2lkcxgBIAMoCUID4EEBIo8DCg5UcG1BdHRlc3Rh", - "dGlvbhJLCgZxdW90ZXMYASADKAsyOy5nb29nbGUuY2xvdWQuY29uZmlkZW50", - "aWFsY29tcHV0aW5nLnYxLlRwbUF0dGVzdGF0aW9uLlF1b3RlEhUKDXRjZ19l", - "dmVudF9sb2cYAiABKAwSGwoTY2Fub25pY2FsX2V2ZW50X2xvZxgDIAEoDBIP", - "Cgdha19jZXJ0GAQgASgMEhIKCmNlcnRfY2hhaW4YBSADKAwa1gEKBVF1b3Rl", - "EhEKCWhhc2hfYWxnbxgBIAEoBRJeCgpwY3JfdmFsdWVzGAIgAygLMkouZ29v", - "Z2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5UcG1BdHRlc3Rh", - "dGlvbi5RdW90ZS5QY3JWYWx1ZXNFbnRyeRIRCglyYXdfcXVvdGUYAyABKAwS", - "FQoNcmF3X3NpZ25hdHVyZRgEIAEoDBowCg5QY3JWYWx1ZXNFbnRyeRILCgNr", - "ZXkYASABKAUSDQoFdmFsdWUYAiABKAw6AjgBImoKFUNvbmZpZGVudGlhbFNw", - "YWNlSW5mbxJRCg9zaWduZWRfZW50aXRpZXMYASADKAsyMy5nb29nbGUuY2xv", - "dWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlNpZ25lZEVudGl0eUID4EEB", - "IncKDFNpZ25lZEVudGl0eRJnChpjb250YWluZXJfaW1hZ2Vfc2lnbmF0dXJl", - "cxgBIAMoCzI+Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcu", - "djEuQ29udGFpbmVySW1hZ2VTaWduYXR1cmVCA+BBASKvAQoXQ29udGFpbmVy", - "SW1hZ2VTaWduYXR1cmUSFAoHcGF5bG9hZBgBIAEoDEID4EEBEhYKCXNpZ25h", - "dHVyZRgCIAEoDEID4EEBEhcKCnB1YmxpY19rZXkYAyABKAxCA+BBARJNCgdz", - "aWdfYWxnGAQgASgOMjcuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1", - "dGluZy52MS5TaWduaW5nQWxnb3JpdGhtQgPgQQEi8QgKHlZlcmlmeUNvbmZp", - "ZGVudGlhbFNwYWNlUmVxdWVzdBJRCgd0ZF9jY2VsGAMgASgLMjkuZ29vZ2xl", - "LmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5UZHhDY2VsQXR0ZXN0", - "YXRpb25CA+BBBEgAElUKD3RwbV9hdHRlc3RhdGlvbhgEIAEoCzI1Lmdvb2ds", - "ZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuVHBtQXR0ZXN0YXRp", - "b25CA+BBBEgAEkkKCWNoYWxsZW5nZRgBIAEoCUI24EEC+kEwCi5jb25maWRl", - "bnRpYWxjb21wdXRpbmcuZ29vZ2xlYXBpcy5jb20vQ2hhbGxlbmdlElMKD2dj", - "cF9jcmVkZW50aWFscxgCIAEoCzI1Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRp", - "YWxjb21wdXRpbmcudjEuR2NwQ3JlZGVudGlhbHNCA+BBARJRCg9zaWduZWRf", - "ZW50aXRpZXMYBSADKAsyMy5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29t", - "cHV0aW5nLnYxLlNpZ25lZEVudGl0eUID4EEBEl4KFWdjZV9zaGllbGRlZF9p", - "ZGVudGl0eRgGIAEoCzI6Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21w", - "dXRpbmcudjEuR2NlU2hpZWxkZWRJZGVudGl0eUID4EEBEnQKB29wdGlvbnMY", - "ByABKAsyXi5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYx", - "LlZlcmlmeUNvbmZpZGVudGlhbFNwYWNlUmVxdWVzdC5Db25maWRlbnRpYWxT", - "cGFjZU9wdGlvbnNCA+BBARJZChJudmlkaWFfYXR0ZXN0YXRpb24YCCABKAsy", - "OC5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLk52aWRp", - "YUF0dGVzdGF0aW9uQgPgQQEa7QIKGENvbmZpZGVudGlhbFNwYWNlT3B0aW9u", - "cxJpChphd3NfcHJpbmNpcGFsX3RhZ3Nfb3B0aW9ucxgFIAEoCzI+Lmdvb2ds", - "ZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuQXdzUHJpbmNpcGFs", - "VGFnc09wdGlvbnNCA+BBAUgAEhUKCGF1ZGllbmNlGAEgASgJQgPgQQESTwoN", - "dG9rZW5fcHJvZmlsZRgCIAEoDjIzLmdvb2dsZS5jbG91ZC5jb25maWRlbnRp", - "YWxjb21wdXRpbmcudjEuVG9rZW5Qcm9maWxlQgPgQQESEgoFbm9uY2UYAyAD", - "KAlCA+BBARJRCg5zaWduYXR1cmVfdHlwZRgEIAEoDjI0Lmdvb2dsZS5jbG91", - "ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuU2lnbmF0dXJlVHlwZUID4EEB", - "QhcKFXRva2VuX3Byb2ZpbGVfb3B0aW9uc0IRCg90ZWVfYXR0ZXN0YXRpb24i", - "RwoTR2NlU2hpZWxkZWRJZGVudGl0eRIUCgdha19jZXJ0GAEgASgMQgPgQQES", - "GgoNYWtfY2VydF9jaGFpbhgCIAMoDEID4EEBInIKH1ZlcmlmeUNvbmZpZGVu", - "dGlhbFNwYWNlUmVzcG9uc2USHgoRYXR0ZXN0YXRpb25fdG9rZW4YASABKAlC", - "A+BBAxIvCg5wYXJ0aWFsX2Vycm9ycxgCIAMoCzISLmdvb2dsZS5ycGMuU3Rh", - "dHVzQgPgQQMi2QMKHFZlcmlmeUNvbmZpZGVudGlhbEdrZVJlcXVlc3QSUAoP", - "dHBtX2F0dGVzdGF0aW9uGAIgASgLMjUuZ29vZ2xlLmNsb3VkLmNvbmZpZGVu", - "dGlhbGNvbXB1dGluZy52MS5UcG1BdHRlc3RhdGlvbkgAEkkKCWNoYWxsZW5n", - "ZRgBIAEoCUI24EEC+kEwCi5jb25maWRlbnRpYWxjb21wdXRpbmcuZ29vZ2xl", - "YXBpcy5jb20vQ2hhbGxlbmdlEnAKB29wdGlvbnMYAyABKAsyWi5nb29nbGUu", - "Y2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlZlcmlmeUNvbmZpZGVu", - "dGlhbEdrZVJlcXVlc3QuQ29uZmlkZW50aWFsR2tlT3B0aW9uc0ID4EEBGpYB", - "ChZDb25maWRlbnRpYWxHa2VPcHRpb25zEhUKCGF1ZGllbmNlGAEgASgJQgPg", - "QQESEgoFbm9uY2UYAyADKAlCA+BBARJRCg5zaWduYXR1cmVfdHlwZRgEIAEo", - "DjI0Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuU2ln", - "bmF0dXJlVHlwZUID4EEBQhEKD3RlZV9hdHRlc3RhdGlvbiI/Ch1WZXJpZnlD", - "b25maWRlbnRpYWxHa2VSZXNwb25zZRIeChFhdHRlc3RhdGlvbl90b2tlbhgB", - "IAEoCUID4EEDKn8KEFNpZ25pbmdBbGdvcml0aG0SIQodU0lHTklOR19BTEdP", - "UklUSE1fVU5TUEVDSUZJRUQQABIVChFSU0FTU0FfUFNTX1NIQTI1NhABEhoK", - "FlJTQVNTQV9QS0NTMVYxNV9TSEEyNTYQAhIVChFFQ0RTQV9QMjU2X1NIQTI1", - "NhADKo4BCglUb2tlblR5cGUSGgoWVE9LRU5fVFlQRV9VTlNQRUNJRklFRBAA", - "EhMKD1RPS0VOX1RZUEVfT0lEQxABEhIKDlRPS0VOX1RZUEVfUEtJEAISGgoW", - "VE9LRU5fVFlQRV9MSU1JVEVEX0FXUxADEiAKHFRPS0VOX1RZUEVfQVdTX1BS", - "SU5DSVBBTFRBR1MQBCpgCg1TaWduYXR1cmVUeXBlEh4KGlNJR05BVFVSRV9U", - "WVBFX1VOU1BFQ0lGSUVEEAASFwoTU0lHTkFUVVJFX1RZUEVfT0lEQxABEhYK", - "ElNJR05BVFVSRV9UWVBFX1BLSRACKmMKDFRva2VuUHJvZmlsZRIdChlUT0tF", - "Tl9QUk9GSUxFX1VOU1BFQ0lGSUVEEAASHQoZVE9LRU5fUFJPRklMRV9ERUZB", - "VUxUX0VBVBABEhUKEVRPS0VOX1BST0ZJTEVfQVdTEAIytQgKFUNvbmZpZGVu", - "dGlhbENvbXB1dGluZxLYAQoPQ3JlYXRlQ2hhbGxlbmdlEj0uZ29vZ2xlLmNs", - "b3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5DcmVhdGVDaGFsbGVuZ2VS", - "ZXF1ZXN0GjAuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52", - "MS5DaGFsbGVuZ2UiVNpBEHBhcmVudCxjaGFsbGVuZ2WC0+STAjsiLi92MS97", - "cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zLyp9L2NoYWxsZW5nZXM6CWNo", - "YWxsZW5nZRLoAQoRVmVyaWZ5QXR0ZXN0YXRpb24SPy5nb29nbGUuY2xvdWQu", - "Y29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlZlcmlmeUF0dGVzdGF0aW9uUmVx", - "dWVzdBpALmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEu", - "VmVyaWZ5QXR0ZXN0YXRpb25SZXNwb25zZSJQgtPkkwJKIkUvdjEve2NoYWxs", - "ZW5nZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL2NoYWxsZW5nZXMvKn06dmVy", - "aWZ5QXR0ZXN0YXRpb246ASoSgAIKF1ZlcmlmeUNvbmZpZGVudGlhbFNwYWNl", - "EkUuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5WZXJp", - "ZnlDb25maWRlbnRpYWxTcGFjZVJlcXVlc3QaRi5nb29nbGUuY2xvdWQuY29u", - "ZmlkZW50aWFsY29tcHV0aW5nLnYxLlZlcmlmeUNvbmZpZGVudGlhbFNwYWNl", - "UmVzcG9uc2UiVoLT5JMCUCJLL3YxL3tjaGFsbGVuZ2U9cHJvamVjdHMvKi9s", - "b2NhdGlvbnMvKi9jaGFsbGVuZ2VzLyp9OnZlcmlmeUNvbmZpZGVudGlhbFNw", - "YWNlOgEqEvgBChVWZXJpZnlDb25maWRlbnRpYWxHa2USQy5nb29nbGUuY2xv", - "dWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlZlcmlmeUNvbmZpZGVudGlh", - "bEdrZVJlcXVlc3QaRC5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0", - "aW5nLnYxLlZlcmlmeUNvbmZpZGVudGlhbEdrZVJlc3BvbnNlIlSC0+STAk4i", - "SS92MS97Y2hhbGxlbmdlPXByb2plY3RzLyovbG9jYXRpb25zLyovY2hhbGxl", - "bmdlcy8qfTp2ZXJpZnlDb25maWRlbnRpYWxHa2U6ASoaWMpBJGNvbmZpZGVu", - "dGlhbGNvbXB1dGluZy5nb29nbGVhcGlzLmNvbdJBLmh0dHBzOi8vd3d3Lmdv", - "b2dsZWFwaXMuY29tL2F1dGgvY2xvdWQtcGxhdGZvcm1ClwIKKWNvbS5nb29n", - "bGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxQgxTZXJ2aWNlUHJv", - "dG9QAVpfY2xvdWQuZ29vZ2xlLmNvbS9nby9jb25maWRlbnRpYWxjb21wdXRp", - "bmcvYXBpdjEvY29uZmlkZW50aWFsY29tcHV0aW5ncGI7Y29uZmlkZW50aWFs", - "Y29tcHV0aW5ncGKqAiVHb29nbGUuQ2xvdWQuQ29uZmlkZW50aWFsQ29tcHV0", - "aW5nLlYxygIlR29vZ2xlXENsb3VkXENvbmZpZGVudGlhbENvbXB1dGluZ1xW", - "MeoCKEdvb2dsZTo6Q2xvdWQ6OkNvbmZpZGVudGlhbENvbXB1dGluZzo6VjFi", - "BnByb3RvMw==")); + "YXRpb24uU3dpdGNoSW5mb0ID4EEBGoEBCiRNdWx0aUdwdVNlY3VyZVBhc3N0", + "aHJvdWdoQXR0ZXN0YXRpb24SWQoKZ3B1X3F1b3RlcxgBIAMoCzJALmdvb2ds", + "ZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuTnZpZGlhQXR0ZXN0", + "YXRpb24uR3B1SW5mb0ID4EEBIoMBChNHcHVBcmNoaXRlY3R1cmVUeXBlEiUK", + "IUdQVV9BUkNISVRFQ1RVUkVfVFlQRV9VTlNQRUNJRklFRBAAEiAKHEdQVV9B", + "UkNISVRFQ1RVUkVfVFlQRV9IT1BQRVIQCBIjCh9HUFVfQVJDSElURUNUVVJF", + "X1RZUEVfQkxBQ0tXRUxMEApCDAoKY2NfZmVhdHVyZSKDAQoSVGR4Q2NlbEF0", + "dGVzdGF0aW9uEhwKD2NjZWxfYWNwaV90YWJsZRgBIAEoDEID4EEBEhYKCWNj", + "ZWxfZGF0YRgCIAEoDEID4EEBEiAKE2Nhbm9uaWNhbF9ldmVudF9sb2cYAyAB", + "KAxCA+BBARIVCgh0ZF9xdW90ZRgEIAEoDEID4EEBIj8KEVNldlNucEF0dGVz", + "dGF0aW9uEhMKBnJlcG9ydBgBIAEoDEID4EEBEhUKCGF1eF9ibG9iGAIgASgM", + "QgPgQQEibAoZVmVyaWZ5QXR0ZXN0YXRpb25SZXNwb25zZRIeChFvaWRjX2Ns", + "YWltc190b2tlbhgCIAEoCUID4EEDEi8KDnBhcnRpYWxfZXJyb3JzGAMgAygL", + "MhIuZ29vZ2xlLnJwYy5TdGF0dXNCA+BBAyIzCg5HY3BDcmVkZW50aWFscxIh", + "ChlzZXJ2aWNlX2FjY291bnRfaWRfdG9rZW5zGAIgAygJIoUCCgxUb2tlbk9w", + "dGlvbnMSaQoaYXdzX3ByaW5jaXBhbF90YWdzX29wdGlvbnMYBCABKAsyPi5n", + "b29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLkF3c1ByaW5j", + "aXBhbFRhZ3NPcHRpb25zQgPgQQFIABIVCghhdWRpZW5jZRgBIAEoCUID4EEB", + "EhIKBW5vbmNlGAIgAygJQgPgQQESSQoKdG9rZW5fdHlwZRgDIAEoDjIwLmdv", + "b2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuVG9rZW5UeXBl", + "QgPgQQFCFAoSdG9rZW5fdHlwZV9vcHRpb25zIvYCChdBd3NQcmluY2lwYWxU", + "YWdzT3B0aW9ucxJ4ChZhbGxvd2VkX3ByaW5jaXBhbF90YWdzGAEgASgLMlMu", + "Z29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5Bd3NQcmlu", + "Y2lwYWxUYWdzT3B0aW9ucy5BbGxvd2VkUHJpbmNpcGFsVGFnc0ID4EEBGuAB", + "ChRBbGxvd2VkUHJpbmNpcGFsVGFncxKVAQoaY29udGFpbmVyX2ltYWdlX3Np", + "Z25hdHVyZXMYASABKAsybC5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29t", + "cHV0aW5nLnYxLkF3c1ByaW5jaXBhbFRhZ3NPcHRpb25zLkFsbG93ZWRQcmlu", + "Y2lwYWxUYWdzLkNvbnRhaW5lckltYWdlU2lnbmF0dXJlc0ID4EEBGjAKGENv", + "bnRhaW5lckltYWdlU2lnbmF0dXJlcxIUCgdrZXlfaWRzGAEgAygJQgPgQQEi", + "jwMKDlRwbUF0dGVzdGF0aW9uEksKBnF1b3RlcxgBIAMoCzI7Lmdvb2dsZS5j", + "bG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuVHBtQXR0ZXN0YXRpb24u", + "UXVvdGUSFQoNdGNnX2V2ZW50X2xvZxgCIAEoDBIbChNjYW5vbmljYWxfZXZl", + "bnRfbG9nGAMgASgMEg8KB2FrX2NlcnQYBCABKAwSEgoKY2VydF9jaGFpbhgF", + "IAMoDBrWAQoFUXVvdGUSEQoJaGFzaF9hbGdvGAEgASgFEl4KCnBjcl92YWx1", + "ZXMYAiADKAsySi5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5n", + "LnYxLlRwbUF0dGVzdGF0aW9uLlF1b3RlLlBjclZhbHVlc0VudHJ5EhEKCXJh", + "d19xdW90ZRgDIAEoDBIVCg1yYXdfc2lnbmF0dXJlGAQgASgMGjAKDlBjclZh", + "bHVlc0VudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoDDoCOAEiagoV", + "Q29uZmlkZW50aWFsU3BhY2VJbmZvElEKD3NpZ25lZF9lbnRpdGllcxgBIAMo", + "CzIzLmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuU2ln", + "bmVkRW50aXR5QgPgQQEidwoMU2lnbmVkRW50aXR5EmcKGmNvbnRhaW5lcl9p", + "bWFnZV9zaWduYXR1cmVzGAEgAygLMj4uZ29vZ2xlLmNsb3VkLmNvbmZpZGVu", + "dGlhbGNvbXB1dGluZy52MS5Db250YWluZXJJbWFnZVNpZ25hdHVyZUID4EEB", + "Iq8BChdDb250YWluZXJJbWFnZVNpZ25hdHVyZRIUCgdwYXlsb2FkGAEgASgM", + "QgPgQQESFgoJc2lnbmF0dXJlGAIgASgMQgPgQQESFwoKcHVibGljX2tleRgD", + "IAEoDEID4EEBEk0KB3NpZ19hbGcYBCABKA4yNy5nb29nbGUuY2xvdWQuY29u", + "ZmlkZW50aWFsY29tcHV0aW5nLnYxLlNpZ25pbmdBbGdvcml0aG1CA+BBASLx", + "CAoeVmVyaWZ5Q29uZmlkZW50aWFsU3BhY2VSZXF1ZXN0ElEKB3RkX2NjZWwY", + "AyABKAsyOS5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYx", + "LlRkeENjZWxBdHRlc3RhdGlvbkID4EEESAASVQoPdHBtX2F0dGVzdGF0aW9u", + "GAQgASgLMjUuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52", + "MS5UcG1BdHRlc3RhdGlvbkID4EEESAASSQoJY2hhbGxlbmdlGAEgASgJQjbg", + "QQL6QTAKLmNvbmZpZGVudGlhbGNvbXB1dGluZy5nb29nbGVhcGlzLmNvbS9D", + "aGFsbGVuZ2USUwoPZ2NwX2NyZWRlbnRpYWxzGAIgASgLMjUuZ29vZ2xlLmNs", + "b3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5HY3BDcmVkZW50aWFsc0ID", + "4EEBElEKD3NpZ25lZF9lbnRpdGllcxgFIAMoCzIzLmdvb2dsZS5jbG91ZC5j", + "b25maWRlbnRpYWxjb21wdXRpbmcudjEuU2lnbmVkRW50aXR5QgPgQQESXgoV", + "Z2NlX3NoaWVsZGVkX2lkZW50aXR5GAYgASgLMjouZ29vZ2xlLmNsb3VkLmNv", + "bmZpZGVudGlhbGNvbXB1dGluZy52MS5HY2VTaGllbGRlZElkZW50aXR5QgPg", + "QQESdAoHb3B0aW9ucxgHIAEoCzJeLmdvb2dsZS5jbG91ZC5jb25maWRlbnRp", + "YWxjb21wdXRpbmcudjEuVmVyaWZ5Q29uZmlkZW50aWFsU3BhY2VSZXF1ZXN0", + "LkNvbmZpZGVudGlhbFNwYWNlT3B0aW9uc0ID4EEBElkKEm52aWRpYV9hdHRl", + "c3RhdGlvbhgIIAEoCzI4Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21w", + "dXRpbmcudjEuTnZpZGlhQXR0ZXN0YXRpb25CA+BBARrtAgoYQ29uZmlkZW50", + "aWFsU3BhY2VPcHRpb25zEmkKGmF3c19wcmluY2lwYWxfdGFnc19vcHRpb25z", + "GAUgASgLMj4uZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52", + "MS5Bd3NQcmluY2lwYWxUYWdzT3B0aW9uc0ID4EEBSAASFQoIYXVkaWVuY2UY", + "ASABKAlCA+BBARJPCg10b2tlbl9wcm9maWxlGAIgASgOMjMuZ29vZ2xlLmNs", + "b3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5Ub2tlblByb2ZpbGVCA+BB", + "ARISCgVub25jZRgDIAMoCUID4EEBElEKDnNpZ25hdHVyZV90eXBlGAQgASgO", + "MjQuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNvbXB1dGluZy52MS5TaWdu", + "YXR1cmVUeXBlQgPgQQFCFwoVdG9rZW5fcHJvZmlsZV9vcHRpb25zQhEKD3Rl", + "ZV9hdHRlc3RhdGlvbiJHChNHY2VTaGllbGRlZElkZW50aXR5EhQKB2FrX2Nl", + "cnQYASABKAxCA+BBARIaCg1ha19jZXJ0X2NoYWluGAIgAygMQgPgQQEicgof", + "VmVyaWZ5Q29uZmlkZW50aWFsU3BhY2VSZXNwb25zZRIeChFhdHRlc3RhdGlv", + "bl90b2tlbhgBIAEoCUID4EEDEi8KDnBhcnRpYWxfZXJyb3JzGAIgAygLMhIu", + "Z29vZ2xlLnJwYy5TdGF0dXNCA+BBAyLZAwocVmVyaWZ5Q29uZmlkZW50aWFs", + "R2tlUmVxdWVzdBJQCg90cG1fYXR0ZXN0YXRpb24YAiABKAsyNS5nb29nbGUu", + "Y2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLlRwbUF0dGVzdGF0aW9u", + "SAASSQoJY2hhbGxlbmdlGAEgASgJQjbgQQL6QTAKLmNvbmZpZGVudGlhbGNv", + "bXB1dGluZy5nb29nbGVhcGlzLmNvbS9DaGFsbGVuZ2UScAoHb3B0aW9ucxgD", + "IAEoCzJaLmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEu", + "VmVyaWZ5Q29uZmlkZW50aWFsR2tlUmVxdWVzdC5Db25maWRlbnRpYWxHa2VP", + "cHRpb25zQgPgQQEalgEKFkNvbmZpZGVudGlhbEdrZU9wdGlvbnMSFQoIYXVk", + "aWVuY2UYASABKAlCA+BBARISCgVub25jZRgDIAMoCUID4EEBElEKDnNpZ25h", + "dHVyZV90eXBlGAQgASgOMjQuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlhbGNv", + "bXB1dGluZy52MS5TaWduYXR1cmVUeXBlQgPgQQFCEQoPdGVlX2F0dGVzdGF0", + "aW9uIj8KHVZlcmlmeUNvbmZpZGVudGlhbEdrZVJlc3BvbnNlEh4KEWF0dGVz", + "dGF0aW9uX3Rva2VuGAEgASgJQgPgQQMqfwoQU2lnbmluZ0FsZ29yaXRobRIh", + "Ch1TSUdOSU5HX0FMR09SSVRITV9VTlNQRUNJRklFRBAAEhUKEVJTQVNTQV9Q", + "U1NfU0hBMjU2EAESGgoWUlNBU1NBX1BLQ1MxVjE1X1NIQTI1NhACEhUKEUVD", + "RFNBX1AyNTZfU0hBMjU2EAMqjgEKCVRva2VuVHlwZRIaChZUT0tFTl9UWVBF", + "X1VOU1BFQ0lGSUVEEAASEwoPVE9LRU5fVFlQRV9PSURDEAESEgoOVE9LRU5f", + "VFlQRV9QS0kQAhIaChZUT0tFTl9UWVBFX0xJTUlURURfQVdTEAMSIAocVE9L", + "RU5fVFlQRV9BV1NfUFJJTkNJUEFMVEFHUxAEKmAKDVNpZ25hdHVyZVR5cGUS", + "HgoaU0lHTkFUVVJFX1RZUEVfVU5TUEVDSUZJRUQQABIXChNTSUdOQVRVUkVf", + "VFlQRV9PSURDEAESFgoSU0lHTkFUVVJFX1RZUEVfUEtJEAIqYwoMVG9rZW5Q", + "cm9maWxlEh0KGVRPS0VOX1BST0ZJTEVfVU5TUEVDSUZJRUQQABIdChlUT0tF", + "Tl9QUk9GSUxFX0RFRkFVTFRfRUFUEAESFQoRVE9LRU5fUFJPRklMRV9BV1MQ", + "AjK1CAoVQ29uZmlkZW50aWFsQ29tcHV0aW5nEtgBCg9DcmVhdGVDaGFsbGVu", + "Z2USPS5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29tcHV0aW5nLnYxLkNy", + "ZWF0ZUNoYWxsZW5nZVJlcXVlc3QaMC5nb29nbGUuY2xvdWQuY29uZmlkZW50", + "aWFsY29tcHV0aW5nLnYxLkNoYWxsZW5nZSJU2kEQcGFyZW50LGNoYWxsZW5n", + "ZYLT5JMCOyIuL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9sb2NhdGlvbnMvKn0v", + "Y2hhbGxlbmdlczoJY2hhbGxlbmdlEugBChFWZXJpZnlBdHRlc3RhdGlvbhI/", + "Lmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuVmVyaWZ5", + "QXR0ZXN0YXRpb25SZXF1ZXN0GkAuZ29vZ2xlLmNsb3VkLmNvbmZpZGVudGlh", + "bGNvbXB1dGluZy52MS5WZXJpZnlBdHRlc3RhdGlvblJlc3BvbnNlIlCC0+ST", + "AkoiRS92MS97Y2hhbGxlbmdlPXByb2plY3RzLyovbG9jYXRpb25zLyovY2hh", + "bGxlbmdlcy8qfTp2ZXJpZnlBdHRlc3RhdGlvbjoBKhKAAgoXVmVyaWZ5Q29u", + "ZmlkZW50aWFsU3BhY2USRS5nb29nbGUuY2xvdWQuY29uZmlkZW50aWFsY29t", + "cHV0aW5nLnYxLlZlcmlmeUNvbmZpZGVudGlhbFNwYWNlUmVxdWVzdBpGLmdv", + "b2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuVmVyaWZ5Q29u", + "ZmlkZW50aWFsU3BhY2VSZXNwb25zZSJWgtPkkwJQIksvdjEve2NoYWxsZW5n", + "ZT1wcm9qZWN0cy8qL2xvY2F0aW9ucy8qL2NoYWxsZW5nZXMvKn06dmVyaWZ5", + "Q29uZmlkZW50aWFsU3BhY2U6ASoS+AEKFVZlcmlmeUNvbmZpZGVudGlhbEdr", + "ZRJDLmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcudjEuVmVy", + "aWZ5Q29uZmlkZW50aWFsR2tlUmVxdWVzdBpELmdvb2dsZS5jbG91ZC5jb25m", + "aWRlbnRpYWxjb21wdXRpbmcudjEuVmVyaWZ5Q29uZmlkZW50aWFsR2tlUmVz", + "cG9uc2UiVILT5JMCTiJJL3YxL3tjaGFsbGVuZ2U9cHJvamVjdHMvKi9sb2Nh", + "dGlvbnMvKi9jaGFsbGVuZ2VzLyp9OnZlcmlmeUNvbmZpZGVudGlhbEdrZToB", + "KhpYykEkY29uZmlkZW50aWFsY29tcHV0aW5nLmdvb2dsZWFwaXMuY29t0kEu", + "aHR0cHM6Ly93d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9jbG91ZC1wbGF0Zm9y", + "bUKGAwopY29tLmdvb2dsZS5jbG91ZC5jb25maWRlbnRpYWxjb21wdXRpbmcu", + "djFCDFNlcnZpY2VQcm90b1ABWl9jbG91ZC5nb29nbGUuY29tL2dvL2NvbmZp", + "ZGVudGlhbGNvbXB1dGluZy9hcGl2MS9jb25maWRlbnRpYWxjb21wdXRpbmdw", + "Yjtjb25maWRlbnRpYWxjb21wdXRpbmdwYqoCJUdvb2dsZS5DbG91ZC5Db25m", + "aWRlbnRpYWxDb21wdXRpbmcuVjHKAiVHb29nbGVcQ2xvdWRcQ29uZmlkZW50", + "aWFsQ29tcHV0aW5nXFYx6gIoR29vZ2xlOjpDbG91ZDo6Q29uZmlkZW50aWFs", + "Q29tcHV0aW5nOjpWMepBbAofY29tcHV0ZS5nb29nbGVhcGlzLmNvbS9JbnN0", + "YW5jZRI0cHJvamVjdHMve3Byb2plY3R9L3pvbmVzL3t6b25lfS9pbnN0YW5j", + "ZXMve2luc3RhbmNlfSoJaW5zdGFuY2VzMghpbnN0YW5jZWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Rpc.StatusReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.ConfidentialComputing.V1.SigningAlgorithm), typeof(global::Google.Cloud.ConfidentialComputing.V1.TokenType), typeof(global::Google.Cloud.ConfidentialComputing.V1.SignatureType), typeof(global::Google.Cloud.ConfidentialComputing.V1.TokenProfile), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.Challenge), global::Google.Cloud.ConfidentialComputing.V1.Challenge.Parser, new[]{ "Name", "CreateTime", "ExpireTime", "Used", "TpmNonce" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.CreateChallengeRequest), global::Google.Cloud.ConfidentialComputing.V1.CreateChallengeRequest.Parser, new[]{ "Parent", "Challenge" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.VerifyAttestationRequest), global::Google.Cloud.ConfidentialComputing.V1.VerifyAttestationRequest.Parser, new[]{ "TdCcel", "SevSnpAttestation", "NvidiaAttestation", "Challenge", "GcpCredentials", "TpmAttestation", "ConfidentialSpaceInfo", "TokenOptions", "Attester" }, new[]{ "TeeAttestation", "DeviceAttestation" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.VerifyAttestationRequest), global::Google.Cloud.ConfidentialComputing.V1.VerifyAttestationRequest.Parser, new[]{ "TdCcel", "SevSnpAttestation", "NvidiaAttestation", "Challenge", "GcpCredentials", "TpmAttestation", "ConfidentialSpaceInfo", "TokenOptions", "Attester", "Instance" }, new[]{ "TeeAttestation", "DeviceAttestation" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation), global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Parser, new[]{ "Spt", "Ppcie", "Mpt" }, new[]{ "CcFeature" }, new[]{ typeof(global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.GpuArchitectureType) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.GpuInfo), global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.GpuInfo.Parser, new[]{ "Uuid", "DriverVersion", "VbiosVersion", "GpuArchitectureType", "AttestationCertificateChain", "AttestationReport" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.SwitchInfo), global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.SwitchInfo.Parser, new[]{ "Uuid", "AttestationCertificateChain", "AttestationReport" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.SinglePassthroughAttestation), global::Google.Cloud.ConfidentialComputing.V1.NvidiaAttestation.Types.SinglePassthroughAttestation.Parser, new[]{ "GpuQuote" }, null, null, null, null), @@ -1015,6 +1018,7 @@ public VerifyAttestationRequest(VerifyAttestationRequest other) : this() { confidentialSpaceInfo_ = other.confidentialSpaceInfo_ != null ? other.confidentialSpaceInfo_.Clone() : null; tokenOptions_ = other.tokenOptions_ != null ? other.tokenOptions_.Clone() : null; attester_ = other.attester_; + instance_ = other.instance_; switch (other.TeeAttestationCase) { case TeeAttestationOneofCase.TdCcel: TdCcel = other.TdCcel.Clone(); @@ -1180,6 +1184,23 @@ public string Attester { } } + /// Field number for the "instance" field. + public const int InstanceFieldNumber = 10; + private string instance_ = ""; + /// + /// Optional. Optional resource link of the Compute Engine instance. + /// Format: + /// `projects/{project_number}/zones/{zone}/instances/{instance_id}` + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Instance { + get { return instance_; } + set { + instance_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + private object teeAttestation_; /// Enum of possible cases for the "tee_attestation" oneof. public enum TeeAttestationOneofCase { @@ -1245,6 +1266,7 @@ public bool Equals(VerifyAttestationRequest other) { if (!object.Equals(ConfidentialSpaceInfo, other.ConfidentialSpaceInfo)) return false; if (!object.Equals(TokenOptions, other.TokenOptions)) return false; if (Attester != other.Attester) return false; + if (Instance != other.Instance) return false; if (TeeAttestationCase != other.TeeAttestationCase) return false; if (DeviceAttestationCase != other.DeviceAttestationCase) return false; return Equals(_unknownFields, other._unknownFields); @@ -1263,6 +1285,7 @@ public override int GetHashCode() { if (confidentialSpaceInfo_ != null) hash ^= ConfidentialSpaceInfo.GetHashCode(); if (tokenOptions_ != null) hash ^= TokenOptions.GetHashCode(); if (Attester.Length != 0) hash ^= Attester.GetHashCode(); + if (Instance.Length != 0) hash ^= Instance.GetHashCode(); hash ^= (int) teeAttestationCase_; hash ^= (int) deviceAttestationCase_; if (_unknownFields != null) { @@ -1319,6 +1342,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(74); output.WriteMessage(NvidiaAttestation); } + if (Instance.Length != 0) { + output.WriteRawTag(82); + output.WriteString(Instance); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -1365,6 +1392,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(74); output.WriteMessage(NvidiaAttestation); } + if (Instance.Length != 0) { + output.WriteRawTag(82); + output.WriteString(Instance); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -1402,6 +1433,9 @@ public int CalculateSize() { if (Attester.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Attester); } + if (Instance.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Instance); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -1444,6 +1478,9 @@ public void MergeFrom(VerifyAttestationRequest other) { if (other.Attester.Length != 0) { Attester = other.Attester; } + if (other.Instance.Length != 0) { + Instance = other.Instance; + } switch (other.TeeAttestationCase) { case TeeAttestationOneofCase.TdCcel: if (TdCcel == null) { @@ -1550,6 +1587,10 @@ public void MergeFrom(pb::CodedInputStream input) { NvidiaAttestation = subBuilder; break; } + case 82: { + Instance = input.ReadString(); + break; + } } } #endif @@ -1632,6 +1673,10 @@ public void MergeFrom(pb::CodedInputStream input) { NvidiaAttestation = subBuilder; break; } + case 82: { + Instance = input.ReadString(); + break; + } } } } diff --git a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/ServiceResourceNames.g.cs b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/ServiceResourceNames.g.cs index 8436bca49a0f..6aec4a67c053 100644 --- a/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/ServiceResourceNames.g.cs +++ b/apis/Google.Cloud.ConfidentialComputing.V1/Google.Cloud.ConfidentialComputing.V1/ServiceResourceNames.g.cs @@ -264,6 +264,248 @@ public override string ToString() public static bool operator !=(ChallengeName a, ChallengeName b) => !(a == b); } + /// Resource name for the Instance resource. + public sealed partial class InstanceName : gax::IResourceName, sys::IEquatable + { + /// The possible contents of . + public enum ResourceNameType + { + /// An unparsed resource name. + Unparsed = 0, + + /// + /// A resource name with pattern projects/{project}/zones/{zone}/instances/{instance}. + /// + ProjectZoneInstance = 1, + } + + private static gax::PathTemplate s_projectZoneInstance = new gax::PathTemplate("projects/{project}/zones/{zone}/instances/{instance}"); + + /// Creates a containing an unparsed resource name. + /// The unparsed resource name. Must not be null. + /// + /// A new instance of containing the provided + /// . + /// + public static InstanceName FromUnparsed(gax::UnparsedResourceName unparsedResourceName) => + new InstanceName(ResourceNameType.Unparsed, gax::GaxPreconditions.CheckNotNull(unparsedResourceName, nameof(unparsedResourceName))); + + /// + /// Creates a with the pattern + /// projects/{project}/zones/{zone}/instances/{instance}. + /// + /// The Project ID. Must not be null or empty. + /// The Zone ID. Must not be null or empty. + /// The Instance ID. Must not be null or empty. + /// A new instance of constructed from the provided ids. + public static InstanceName FromProjectZoneInstance(string projectId, string zoneId, string instanceId) => + new InstanceName(ResourceNameType.ProjectZoneInstance, projectId: gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), zoneId: gax::GaxPreconditions.CheckNotNullOrEmpty(zoneId, nameof(zoneId)), instanceId: gax::GaxPreconditions.CheckNotNullOrEmpty(instanceId, nameof(instanceId))); + + /// + /// Formats the IDs into the string representation of this with pattern + /// projects/{project}/zones/{zone}/instances/{instance}. + /// + /// The Project ID. Must not be null or empty. + /// The Zone ID. Must not be null or empty. + /// The Instance ID. Must not be null or empty. + /// + /// The string representation of this with pattern + /// projects/{project}/zones/{zone}/instances/{instance}. + /// + public static string Format(string projectId, string zoneId, string instanceId) => + FormatProjectZoneInstance(projectId, zoneId, instanceId); + + /// + /// Formats the IDs into the string representation of this with pattern + /// projects/{project}/zones/{zone}/instances/{instance}. + /// + /// The Project ID. Must not be null or empty. + /// The Zone ID. Must not be null or empty. + /// The Instance ID. Must not be null or empty. + /// + /// The string representation of this with pattern + /// projects/{project}/zones/{zone}/instances/{instance}. + /// + public static string FormatProjectZoneInstance(string projectId, string zoneId, string instanceId) => + s_projectZoneInstance.Expand(gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), gax::GaxPreconditions.CheckNotNullOrEmpty(zoneId, nameof(zoneId)), gax::GaxPreconditions.CheckNotNullOrEmpty(instanceId, nameof(instanceId))); + + /// Parses the given resource name string into a new instance. + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// projects/{project}/zones/{zone}/instances/{instance} + /// + /// + /// The resource name in string form. Must not be null. + /// The parsed if successful. + public static InstanceName Parse(string instanceName) => Parse(instanceName, false); + + /// + /// Parses the given resource name string into a new instance; optionally allowing an + /// unparseable resource name. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// projects/{project}/zones/{zone}/instances/{instance} + /// + /// Or may be in any format if is true. + /// + /// The resource name in string form. Must not be null. + /// + /// If true will successfully store an unparseable resource name into the + /// property; otherwise will throw an if an unparseable resource name is + /// specified. + /// + /// The parsed if successful. + public static InstanceName Parse(string instanceName, bool allowUnparsed) => + TryParse(instanceName, allowUnparsed, out InstanceName result) ? result : throw new sys::ArgumentException("The given resource-name matches no pattern."); + + /// + /// Tries to parse the given resource name string into a new instance. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// projects/{project}/zones/{zone}/instances/{instance} + /// + /// + /// The resource name in string form. Must not be null. + /// + /// When this method returns, the parsed , or null if parsing failed. + /// + /// true if the name was parsed successfully; false otherwise. + public static bool TryParse(string instanceName, out InstanceName result) => TryParse(instanceName, false, out result); + + /// + /// Tries to parse the given resource name string into a new instance; optionally + /// allowing an unparseable resource name. + /// + /// + /// To parse successfully, the resource name must be formatted as one of the following: + /// + /// projects/{project}/zones/{zone}/instances/{instance} + /// + /// Or may be in any format if is true. + /// + /// The resource name in string form. Must not be null. + /// + /// If true will successfully store an unparseable resource name into the + /// property; otherwise will throw an if an unparseable resource name is + /// specified. + /// + /// + /// When this method returns, the parsed , or null if parsing failed. + /// + /// true if the name was parsed successfully; false otherwise. + public static bool TryParse(string instanceName, bool allowUnparsed, out InstanceName result) + { + gax::GaxPreconditions.CheckNotNull(instanceName, nameof(instanceName)); + gax::TemplatedResourceName resourceName; + if (s_projectZoneInstance.TryParseName(instanceName, out resourceName)) + { + result = FromProjectZoneInstance(resourceName[0], resourceName[1], resourceName[2]); + return true; + } + if (allowUnparsed) + { + if (gax::UnparsedResourceName.TryParse(instanceName, out gax::UnparsedResourceName unparsedResourceName)) + { + result = FromUnparsed(unparsedResourceName); + return true; + } + } + result = null; + return false; + } + + private InstanceName(ResourceNameType type, gax::UnparsedResourceName unparsedResourceName = null, string instanceId = null, string projectId = null, string zoneId = null) + { + Type = type; + UnparsedResource = unparsedResourceName; + InstanceId = instanceId; + ProjectId = projectId; + ZoneId = zoneId; + } + + /// + /// Constructs a new instance of a class from the component parts of pattern + /// projects/{project}/zones/{zone}/instances/{instance} + /// + /// The Project ID. Must not be null or empty. + /// The Zone ID. Must not be null or empty. + /// The Instance ID. Must not be null or empty. + public InstanceName(string projectId, string zoneId, string instanceId) : this(ResourceNameType.ProjectZoneInstance, projectId: gax::GaxPreconditions.CheckNotNullOrEmpty(projectId, nameof(projectId)), zoneId: gax::GaxPreconditions.CheckNotNullOrEmpty(zoneId, nameof(zoneId)), instanceId: gax::GaxPreconditions.CheckNotNullOrEmpty(instanceId, nameof(instanceId))) + { + } + + /// The of the contained resource name. + public ResourceNameType Type { get; } + + /// + /// The contained . Only non-null if this instance contains an + /// unparsed resource name. + /// + public gax::UnparsedResourceName UnparsedResource { get; } + + /// + /// The Instance ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string InstanceId { get; } + + /// + /// The Project ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string ProjectId { get; } + + /// + /// The Zone ID. Will not be null, unless this instance contains an unparsed resource name. + /// + public string ZoneId { get; } + + /// Whether this instance contains a resource name with a known pattern. + public bool IsKnownPattern => Type != ResourceNameType.Unparsed; + + /// The string representation of the resource name. + /// The string representation of the resource name. + public override string ToString() + { + switch (Type) + { + case ResourceNameType.Unparsed: return UnparsedResource.ToString(); + case ResourceNameType.ProjectZoneInstance: return s_projectZoneInstance.Expand(ProjectId, ZoneId, InstanceId); + default: throw new sys::InvalidOperationException("Unrecognized resource-type."); + } + } + + /// Returns a hash code for this resource name. + public override int GetHashCode() => ToString().GetHashCode(); + + /// + public override bool Equals(object obj) => Equals(obj as InstanceName); + + /// + public bool Equals(InstanceName other) => ToString() == other?.ToString(); + + /// Determines whether two specified resource names have the same value. + /// The first resource name to compare, or null. + /// The second resource name to compare, or null. + /// + /// true if the value of is the same as the value of ; otherwise, + /// false. + /// + public static bool operator ==(InstanceName a, InstanceName b) => ReferenceEquals(a, b) || (a?.Equals(b) ?? false); + + /// Determines whether two specified resource names have different values. + /// The first resource name to compare, or null. + /// The second resource name to compare, or null. + /// + /// true if the value of is different from the value of ; otherwise, + /// false. + /// + public static bool operator !=(InstanceName a, InstanceName b) => !(a == b); + } + public partial class Challenge { /// @@ -298,6 +540,15 @@ public ChallengeName ChallengeAsChallengeName get => string.IsNullOrEmpty(Challenge) ? null : ChallengeName.Parse(Challenge, allowUnparsed: true); set => Challenge = value?.ToString() ?? ""; } + + /// + /// -typed view over the resource name property. + /// + public InstanceName InstanceAsInstanceName + { + get => string.IsNullOrEmpty(Instance) ? null : InstanceName.Parse(Instance, allowUnparsed: true); + set => Instance = value?.ToString() ?? ""; + } } public partial class VerifyConfidentialSpaceRequest diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/FirestoreClient.ExecutePipelineRequestObjectSnippet.g.cs b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/FirestoreClient.ExecutePipelineRequestObjectSnippet.g.cs index a2f55c414806..9e623d724048 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/FirestoreClient.ExecutePipelineRequestObjectSnippet.g.cs +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/FirestoreClient.ExecutePipelineRequestObjectSnippet.g.cs @@ -42,6 +42,7 @@ public async Task ExecutePipelineRequestObject() Database = "", StructuredPipeline = new StructuredPipeline(), Transaction = ByteString.Empty, + AutoCommitTransaction = false, }; // Make the request, returning a streaming response using FirestoreClient.ExecutePipelineStream response = firestoreClient.ExecutePipeline(request); diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/snippet_metadata_google.firestore.v1.json b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/snippet_metadata_google.firestore.v1.json index 1be4d716c3f6..4a092fb1540a 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/snippet_metadata_google.firestore.v1.json +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.GeneratedSnippets/snippet_metadata_google.firestore.v1.json @@ -1318,12 +1318,12 @@ "segments": [ { "start": 20, - "end": 59, + "end": 60, "type": "FULL" }, { "start": 37, - "end": 57, + "end": 58, "type": "SHORT" } ] diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.Snippets/FirestoreClientSnippets.g.cs b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.Snippets/FirestoreClientSnippets.g.cs index 0f62035bb43f..5f4654a33c13 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.Snippets/FirestoreClientSnippets.g.cs +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1.Snippets/FirestoreClientSnippets.g.cs @@ -563,6 +563,7 @@ public async Task ExecutePipelineRequestObject() Database = "", StructuredPipeline = new StructuredPipeline(), Transaction = ByteString.Empty, + AutoCommitTransaction = false, }; // Make the request, returning a streaming response using FirestoreClient.ExecutePipelineStream response = firestoreClient.ExecutePipeline(request); diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Common.g.cs b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Common.g.cs index 0543bed9d044..f910fd3a91ef 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Common.g.cs +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Common.g.cs @@ -25,28 +25,32 @@ static CommonReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "CiBnb29nbGUvZmlyZXN0b3JlL3YxL2NvbW1vbi5wcm90bxITZ29vZ2xlLmZp", - "cmVzdG9yZS52MRofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byIj", - "CgxEb2N1bWVudE1hc2sSEwoLZmllbGRfcGF0aHMYASADKAkiZQoMUHJlY29u", - "ZGl0aW9uEhAKBmV4aXN0cxgBIAEoCEgAEjEKC3VwZGF0ZV90aW1lGAIgASgL", - "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgAQhAKDmNvbmRpdGlvbl90", - "eXBlIqkCChJUcmFuc2FjdGlvbk9wdGlvbnMSRQoJcmVhZF9vbmx5GAIgASgL", - "MjAuZ29vZ2xlLmZpcmVzdG9yZS52MS5UcmFuc2FjdGlvbk9wdGlvbnMuUmVh", - "ZE9ubHlIABJHCgpyZWFkX3dyaXRlGAMgASgLMjEuZ29vZ2xlLmZpcmVzdG9y", - "ZS52MS5UcmFuc2FjdGlvbk9wdGlvbnMuUmVhZFdyaXRlSAAaJgoJUmVhZFdy", - "aXRlEhkKEXJldHJ5X3RyYW5zYWN0aW9uGAEgASgMGlMKCFJlYWRPbmx5Ei8K", - "CXJlYWRfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBI", - "AEIWChRjb25zaXN0ZW5jeV9zZWxlY3RvckIGCgRtb2RlQsMBChdjb20uZ29v", - "Z2xlLmZpcmVzdG9yZS52MUILQ29tbW9uUHJvdG9QAVo7Y2xvdWQuZ29vZ2xl", - "LmNvbS9nby9maXJlc3RvcmUvYXBpdjEvZmlyZXN0b3JlcGI7ZmlyZXN0b3Jl", - "cGKiAgRHQ0ZTqgIZR29vZ2xlLkNsb3VkLkZpcmVzdG9yZS5WMcoCGUdvb2ds", - "ZVxDbG91ZFxGaXJlc3RvcmVcVjHqAhxHb29nbGU6OkNsb3VkOjpGaXJlc3Rv", - "cmU6OlYxYgZwcm90bzM=")); + "cmVzdG9yZS52MRofZ29vZ2xlL2FwaS9maWVsZF9iZWhhdmlvci5wcm90bxof", + "Z29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byIjCgxEb2N1bWVudE1h", + "c2sSEwoLZmllbGRfcGF0aHMYASADKAkiZQoMUHJlY29uZGl0aW9uEhAKBmV4", + "aXN0cxgBIAEoCEgAEjEKC3VwZGF0ZV90aW1lGAIgASgLMhouZ29vZ2xlLnBy", + "b3RvYnVmLlRpbWVzdGFtcEgAQhAKDmNvbmRpdGlvbl90eXBlItcDChJUcmFu", + "c2FjdGlvbk9wdGlvbnMSRQoJcmVhZF9vbmx5GAIgASgLMjAuZ29vZ2xlLmZp", + "cmVzdG9yZS52MS5UcmFuc2FjdGlvbk9wdGlvbnMuUmVhZE9ubHlIABJHCgpy", + "ZWFkX3dyaXRlGAMgASgLMjEuZ29vZ2xlLmZpcmVzdG9yZS52MS5UcmFuc2Fj", + "dGlvbk9wdGlvbnMuUmVhZFdyaXRlSAAafgoJUmVhZFdyaXRlEhkKEXJldHJ5", + "X3RyYW5zYWN0aW9uGAEgASgMElYKEGNvbmN1cnJlbmN5X21vZGUYAiABKA4y", + "Ny5nb29nbGUuZmlyZXN0b3JlLnYxLlRyYW5zYWN0aW9uT3B0aW9ucy5Db25j", + "dXJyZW5jeU1vZGVCA+BBARpTCghSZWFkT25seRIvCglyZWFkX3RpbWUYAiAB", + "KAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSABCFgoUY29uc2lzdGVu", + "Y3lfc2VsZWN0b3IiVAoPQ29uY3VycmVuY3lNb2RlEiAKHENPTkNVUlJFTkNZ", + "X01PREVfVU5TUEVDSUZJRUQQABIOCgpPUFRJTUlTVElDEAESDwoLUEVTU0lN", + "SVNUSUMQAkIGCgRtb2RlQsMBChdjb20uZ29vZ2xlLmZpcmVzdG9yZS52MUIL", + "Q29tbW9uUHJvdG9QAVo7Y2xvdWQuZ29vZ2xlLmNvbS9nby9maXJlc3RvcmUv", + "YXBpdjEvZmlyZXN0b3JlcGI7ZmlyZXN0b3JlcGKiAgRHQ0ZTqgIZR29vZ2xl", + "LkNsb3VkLkZpcmVzdG9yZS5WMcoCGUdvb2dsZVxDbG91ZFxGaXJlc3RvcmVc", + "VjHqAhxHb29nbGU6OkNsb3VkOjpGaXJlc3RvcmU6OlYxYgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.DocumentMask), global::Google.Cloud.Firestore.V1.DocumentMask.Parser, new[]{ "FieldPaths" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.Precondition), global::Google.Cloud.Firestore.V1.Precondition.Parser, new[]{ "Exists", "UpdateTime" }, new[]{ "ConditionType" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.TransactionOptions), global::Google.Cloud.Firestore.V1.TransactionOptions.Parser, new[]{ "ReadOnly", "ReadWrite" }, new[]{ "Mode" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ReadWrite), global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ReadWrite.Parser, new[]{ "RetryTransaction" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.TransactionOptions), global::Google.Cloud.Firestore.V1.TransactionOptions.Parser, new[]{ "ReadOnly", "ReadWrite" }, new[]{ "Mode" }, new[]{ typeof(global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ReadWrite), global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ReadWrite.Parser, new[]{ "RetryTransaction", "ConcurrencyMode" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ReadOnly), global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ReadOnly.Parser, new[]{ "ReadTime" }, new[]{ "ConsistencySelector" }, null, null, null)}) })); } @@ -866,11 +870,26 @@ public void MergeFrom(pb::CodedInputStream input) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static partial class Types { + /// + /// The type of concurrency control mode for transactions. + /// + public enum ConcurrencyMode { + /// + /// Start the transaction with the database-level default concurrency mode. + /// + [pbr::OriginalName("CONCURRENCY_MODE_UNSPECIFIED")] Unspecified = 0, + /// + /// Use optimistic concurrency control for the new transaction. + /// + [pbr::OriginalName("OPTIMISTIC")] Optimistic = 1, + /// + /// Use pessimistic concurrency control for the new transaction. + /// + [pbr::OriginalName("PESSIMISTIC")] Pessimistic = 2, + } + /// /// Options for a transaction that can be used to read and write documents. - /// - /// Firestore does not allow 3rd party auth requests to create read-write. - /// transactions. /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] public sealed partial class ReadWrite : pb::IMessage @@ -908,6 +927,7 @@ public ReadWrite() { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public ReadWrite(ReadWrite other) : this() { retryTransaction_ = other.retryTransaction_; + concurrencyMode_ = other.concurrencyMode_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -932,6 +952,28 @@ public ReadWrite Clone() { } } + /// Field number for the "concurrency_mode" field. + public const int ConcurrencyModeFieldNumber = 2; + private global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode concurrencyMode_ = global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode.Unspecified; + /// + /// Optional. The concurrency control mode to use for this transaction. + /// + /// A database is able to use different concurrency modes for different + /// transactions simultaneously. + /// + /// 3rd party auth requests are only allowed to create optimistic + /// read-write transactions and must specify that here even if the + /// database-level setting is already configured to optimistic. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode ConcurrencyMode { + get { return concurrencyMode_; } + set { + concurrencyMode_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -948,6 +990,7 @@ public bool Equals(ReadWrite other) { return true; } if (RetryTransaction != other.RetryTransaction) return false; + if (ConcurrencyMode != other.ConcurrencyMode) return false; return Equals(_unknownFields, other._unknownFields); } @@ -956,6 +999,7 @@ public bool Equals(ReadWrite other) { public override int GetHashCode() { int hash = 1; if (RetryTransaction.Length != 0) hash ^= RetryTransaction.GetHashCode(); + if (ConcurrencyMode != global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode.Unspecified) hash ^= ConcurrencyMode.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -978,6 +1022,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteBytes(RetryTransaction); } + if (ConcurrencyMode != global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode.Unspecified) { + output.WriteRawTag(16); + output.WriteEnum((int) ConcurrencyMode); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -992,6 +1040,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteBytes(RetryTransaction); } + if (ConcurrencyMode != global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode.Unspecified) { + output.WriteRawTag(16); + output.WriteEnum((int) ConcurrencyMode); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -1005,6 +1057,9 @@ public int CalculateSize() { if (RetryTransaction.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeBytesSize(RetryTransaction); } + if (ConcurrencyMode != global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ConcurrencyMode); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -1020,6 +1075,9 @@ public void MergeFrom(ReadWrite other) { if (other.RetryTransaction.Length != 0) { RetryTransaction = other.RetryTransaction; } + if (other.ConcurrencyMode != global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode.Unspecified) { + ConcurrencyMode = other.ConcurrencyMode; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -1043,6 +1101,10 @@ public void MergeFrom(pb::CodedInputStream input) { RetryTransaction = input.ReadBytes(); break; } + case 16: { + ConcurrencyMode = (global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode) input.ReadEnum(); + break; + } } } #endif @@ -1066,6 +1128,10 @@ public void MergeFrom(pb::CodedInputStream input) { RetryTransaction = input.ReadBytes(); break; } + case 16: { + ConcurrencyMode = (global::Google.Cloud.Firestore.V1.TransactionOptions.Types.ConcurrencyMode) input.ReadEnum(); + break; + } } } } diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Firestore.g.cs b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Firestore.g.cs index 87966d835a7e..ff815fb057bb 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Firestore.g.cs +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Firestore.g.cs @@ -96,176 +96,177 @@ static FirestoreReflection() { "CXJlYWRfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAS", "FwoPc2tpcHBlZF9yZXN1bHRzGAQgASgFEg4KBGRvbmUYBiABKAhIABI8Cg9l", "eHBsYWluX21ldHJpY3MYCyABKAsyIy5nb29nbGUuZmlyZXN0b3JlLnYxLkV4", - "cGxhaW5NZXRyaWNzQhcKFWNvbnRpbnVhdGlvbl9zZWxlY3RvciKsAgoWRXhl", + "cGxhaW5NZXRyaWNzQhcKFWNvbnRpbnVhdGlvbl9zZWxlY3RvciLSAgoWRXhl", "Y3V0ZVBpcGVsaW5lUmVxdWVzdBIVCghkYXRhYmFzZRgBIAEoCUID4EECEkYK", "E3N0cnVjdHVyZWRfcGlwZWxpbmUYAiABKAsyJy5nb29nbGUuZmlyZXN0b3Jl", "LnYxLlN0cnVjdHVyZWRQaXBlbGluZUgAEhUKC3RyYW5zYWN0aW9uGAUgASgM", "SAESQgoPbmV3X3RyYW5zYWN0aW9uGAYgASgLMicuZ29vZ2xlLmZpcmVzdG9y", "ZS52MS5UcmFuc2FjdGlvbk9wdGlvbnNIARIvCglyZWFkX3RpbWUYByABKAsy", - "Gi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSAFCDwoNcGlwZWxpbmVfdHlw", - "ZUIWChRjb25zaXN0ZW5jeV9zZWxlY3RvciLMAQoXRXhlY3V0ZVBpcGVsaW5l", - "UmVzcG9uc2USEwoLdHJhbnNhY3Rpb24YASABKAwSLgoHcmVzdWx0cxgCIAMo", - "CzIdLmdvb2dsZS5maXJlc3RvcmUudjEuRG9jdW1lbnQSMgoOZXhlY3V0aW9u", - "X3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjgKDWV4", - "cGxhaW5fc3RhdHMYBCABKAsyIS5nb29nbGUuZmlyZXN0b3JlLnYxLkV4cGxh", - "aW5TdGF0cyL/AgoaUnVuQWdncmVnYXRpb25RdWVyeVJlcXVlc3QSEwoGcGFy", - "ZW50GAEgASgJQgPgQQISVwocc3RydWN0dXJlZF9hZ2dyZWdhdGlvbl9xdWVy", - "eRgCIAEoCzIvLmdvb2dsZS5maXJlc3RvcmUudjEuU3RydWN0dXJlZEFnZ3Jl", - "Z2F0aW9uUXVlcnlIABIVCgt0cmFuc2FjdGlvbhgEIAEoDEgBEkIKD25ld190", - "cmFuc2FjdGlvbhgFIAEoCzInLmdvb2dsZS5maXJlc3RvcmUudjEuVHJhbnNh", - "Y3Rpb25PcHRpb25zSAESLwoJcmVhZF90aW1lGAYgASgLMhouZ29vZ2xlLnBy", - "b3RvYnVmLlRpbWVzdGFtcEgBEkEKD2V4cGxhaW5fb3B0aW9ucxgIIAEoCzIj", - "Lmdvb2dsZS5maXJlc3RvcmUudjEuRXhwbGFpbk9wdGlvbnNCA+BBAUIMCgpx", - "dWVyeV90eXBlQhYKFGNvbnNpc3RlbmN5X3NlbGVjdG9yItcBChtSdW5BZ2dy", - "ZWdhdGlvblF1ZXJ5UmVzcG9uc2USNgoGcmVzdWx0GAEgASgLMiYuZ29vZ2xl", - "LmZpcmVzdG9yZS52MS5BZ2dyZWdhdGlvblJlc3VsdBITCgt0cmFuc2FjdGlv", - "bhgCIAEoDBItCglyZWFkX3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYu", - "VGltZXN0YW1wEjwKD2V4cGxhaW5fbWV0cmljcxgKIAEoCzIjLmdvb2dsZS5m", - "aXJlc3RvcmUudjEuRXhwbGFpbk1ldHJpY3MihQIKFVBhcnRpdGlvblF1ZXJ5", - "UmVxdWVzdBITCgZwYXJlbnQYASABKAlCA+BBAhJAChBzdHJ1Y3R1cmVkX3F1", - "ZXJ5GAIgASgLMiQuZ29vZ2xlLmZpcmVzdG9yZS52MS5TdHJ1Y3R1cmVkUXVl", - "cnlIABIXCg9wYXJ0aXRpb25fY291bnQYAyABKAMSEgoKcGFnZV90b2tlbhgE", - "IAEoCRIRCglwYWdlX3NpemUYBSABKAUSLwoJcmVhZF90aW1lGAYgASgLMhou", - "Z29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgBQgwKCnF1ZXJ5X3R5cGVCFgoU", - "Y29uc2lzdGVuY3lfc2VsZWN0b3IiYgoWUGFydGl0aW9uUXVlcnlSZXNwb25z", - "ZRIvCgpwYXJ0aXRpb25zGAEgAygLMhsuZ29vZ2xlLmZpcmVzdG9yZS52MS5D", - "dXJzb3ISFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJIugBCgxXcml0ZVJlcXVl", - "c3QSFQoIZGF0YWJhc2UYASABKAlCA+BBAhIRCglzdHJlYW1faWQYAiABKAkS", - "KgoGd3JpdGVzGAMgAygLMhouZ29vZ2xlLmZpcmVzdG9yZS52MS5Xcml0ZRIU", - "CgxzdHJlYW1fdG9rZW4YBCABKAwSPQoGbGFiZWxzGAUgAygLMi0uZ29vZ2xl", - "LmZpcmVzdG9yZS52MS5Xcml0ZVJlcXVlc3QuTGFiZWxzRW50cnkaLQoLTGFi", - "ZWxzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASKiAQoN", - "V3JpdGVSZXNwb25zZRIRCglzdHJlYW1faWQYASABKAkSFAoMc3RyZWFtX3Rv", - "a2VuGAIgASgMEjcKDXdyaXRlX3Jlc3VsdHMYAyADKAsyIC5nb29nbGUuZmly", - "ZXN0b3JlLnYxLldyaXRlUmVzdWx0Ei8KC2NvbW1pdF90aW1lGAQgASgLMhou", - "Z29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcCLyAQoNTGlzdGVuUmVxdWVzdBIV", - "CghkYXRhYmFzZRgBIAEoCUID4EECEjEKCmFkZF90YXJnZXQYAiABKAsyGy5n", - "b29nbGUuZmlyZXN0b3JlLnYxLlRhcmdldEgAEhcKDXJlbW92ZV90YXJnZXQY", - "AyABKAVIABI+CgZsYWJlbHMYBCADKAsyLi5nb29nbGUuZmlyZXN0b3JlLnYx", - "Lkxpc3RlblJlcXVlc3QuTGFiZWxzRW50cnkaLQoLTGFiZWxzRW50cnkSCwoD", - "a2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4AUIPCg10YXJnZXRfY2hhbmdl", - "ItUCCg5MaXN0ZW5SZXNwb25zZRI6Cg10YXJnZXRfY2hhbmdlGAIgASgLMiEu", - "Z29vZ2xlLmZpcmVzdG9yZS52MS5UYXJnZXRDaGFuZ2VIABI+Cg9kb2N1bWVu", - "dF9jaGFuZ2UYAyABKAsyIy5nb29nbGUuZmlyZXN0b3JlLnYxLkRvY3VtZW50", - "Q2hhbmdlSAASPgoPZG9jdW1lbnRfZGVsZXRlGAQgASgLMiMuZ29vZ2xlLmZp", - "cmVzdG9yZS52MS5Eb2N1bWVudERlbGV0ZUgAEj4KD2RvY3VtZW50X3JlbW92", - "ZRgGIAEoCzIjLmdvb2dsZS5maXJlc3RvcmUudjEuRG9jdW1lbnRSZW1vdmVI", - "ABI2CgZmaWx0ZXIYBSABKAsyJC5nb29nbGUuZmlyZXN0b3JlLnYxLkV4aXN0", - "ZW5jZUZpbHRlckgAQg8KDXJlc3BvbnNlX3R5cGUi1gMKBlRhcmdldBI4CgVx", - "dWVyeRgCIAEoCzInLmdvb2dsZS5maXJlc3RvcmUudjEuVGFyZ2V0LlF1ZXJ5", - "VGFyZ2V0SAASQAoJZG9jdW1lbnRzGAMgASgLMisuZ29vZ2xlLmZpcmVzdG9y", - "ZS52MS5UYXJnZXQuRG9jdW1lbnRzVGFyZ2V0SAASFgoMcmVzdW1lX3Rva2Vu", - "GAQgASgMSAESLwoJcmVhZF90aW1lGAsgASgLMhouZ29vZ2xlLnByb3RvYnVm", - "LlRpbWVzdGFtcEgBEhEKCXRhcmdldF9pZBgFIAEoBRIMCgRvbmNlGAYgASgI", - "EjMKDmV4cGVjdGVkX2NvdW50GAwgASgLMhsuZ29vZ2xlLnByb3RvYnVmLklu", - "dDMyVmFsdWUaJAoPRG9jdW1lbnRzVGFyZ2V0EhEKCWRvY3VtZW50cxgCIAMo", - "CRptCgtRdWVyeVRhcmdldBIOCgZwYXJlbnQYASABKAkSQAoQc3RydWN0dXJl", - "ZF9xdWVyeRgCIAEoCzIkLmdvb2dsZS5maXJlc3RvcmUudjEuU3RydWN0dXJl", - "ZFF1ZXJ5SABCDAoKcXVlcnlfdHlwZUINCgt0YXJnZXRfdHlwZUINCgtyZXN1", - "bWVfdHlwZSKqAgoMVGFyZ2V0Q2hhbmdlEk4KEnRhcmdldF9jaGFuZ2VfdHlw", - "ZRgBIAEoDjIyLmdvb2dsZS5maXJlc3RvcmUudjEuVGFyZ2V0Q2hhbmdlLlRh", - "cmdldENoYW5nZVR5cGUSEgoKdGFyZ2V0X2lkcxgCIAMoBRIhCgVjYXVzZRgD", - "IAEoCzISLmdvb2dsZS5ycGMuU3RhdHVzEhQKDHJlc3VtZV90b2tlbhgEIAEo", - "DBItCglyZWFkX3RpbWUYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", - "YW1wIk4KEFRhcmdldENoYW5nZVR5cGUSDQoJTk9fQ0hBTkdFEAASBwoDQURE", - "EAESCgoGUkVNT1ZFEAISCwoHQ1VSUkVOVBADEgkKBVJFU0VUEAQinwEKGExp", - "c3RDb2xsZWN0aW9uSWRzUmVxdWVzdBITCgZwYXJlbnQYASABKAlCA+BBAhIR", - "CglwYWdlX3NpemUYAiABKAUSEgoKcGFnZV90b2tlbhgDIAEoCRIvCglyZWFk", - "X3RpbWUYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSABCFgoU", - "Y29uc2lzdGVuY3lfc2VsZWN0b3IiTAoZTGlzdENvbGxlY3Rpb25JZHNSZXNw", - "b25zZRIWCg5jb2xsZWN0aW9uX2lkcxgBIAMoCRIXCg9uZXh0X3BhZ2VfdG9r", - "ZW4YAiABKAkiyQEKEUJhdGNoV3JpdGVSZXF1ZXN0EhUKCGRhdGFiYXNlGAEg", - "ASgJQgPgQQISKgoGd3JpdGVzGAIgAygLMhouZ29vZ2xlLmZpcmVzdG9yZS52", - "MS5Xcml0ZRJCCgZsYWJlbHMYAyADKAsyMi5nb29nbGUuZmlyZXN0b3JlLnYx", - "LkJhdGNoV3JpdGVSZXF1ZXN0LkxhYmVsc0VudHJ5Gi0KC0xhYmVsc0VudHJ5", - "EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEicQoSQmF0Y2hXcml0", - "ZVJlc3BvbnNlEjcKDXdyaXRlX3Jlc3VsdHMYASADKAsyIC5nb29nbGUuZmly", - "ZXN0b3JlLnYxLldyaXRlUmVzdWx0EiIKBnN0YXR1cxgCIAMoCzISLmdvb2ds", - "ZS5ycGMuU3RhdHVzMvsbCglGaXJlc3RvcmUSjwEKC0dldERvY3VtZW50Eicu", - "Z29vZ2xlLmZpcmVzdG9yZS52MS5HZXREb2N1bWVudFJlcXVlc3QaHS5nb29n", - "bGUuZmlyZXN0b3JlLnYxLkRvY3VtZW50IjiC0+STAjISMC92MS97bmFtZT1w", - "cm9qZWN0cy8qL2RhdGFiYXNlcy8qL2RvY3VtZW50cy8qLyoqfRL1AQoNTGlz", - "dERvY3VtZW50cxIpLmdvb2dsZS5maXJlc3RvcmUudjEuTGlzdERvY3VtZW50", - "c1JlcXVlc3QaKi5nb29nbGUuZmlyZXN0b3JlLnYxLkxpc3REb2N1bWVudHNS", - "ZXNwb25zZSKMAYLT5JMChQESQi92MS97cGFyZW50PXByb2plY3RzLyovZGF0", - "YWJhc2VzLyovZG9jdW1lbnRzLyovKip9L3tjb2xsZWN0aW9uX2lkfVo/Ej0v", - "djEve3BhcmVudD1wcm9qZWN0cy8qL2RhdGFiYXNlcy8qL2RvY3VtZW50c30v", - "e2NvbGxlY3Rpb25faWR9Er8BCg5VcGRhdGVEb2N1bWVudBIqLmdvb2dsZS5m", - "aXJlc3RvcmUudjEuVXBkYXRlRG9jdW1lbnRSZXF1ZXN0Gh0uZ29vZ2xlLmZp", - "cmVzdG9yZS52MS5Eb2N1bWVudCJi2kEUZG9jdW1lbnQsdXBkYXRlX21hc2uC", - "0+STAkUyOS92MS97ZG9jdW1lbnQubmFtZT1wcm9qZWN0cy8qL2RhdGFiYXNl", - "cy8qL2RvY3VtZW50cy8qLyoqfToIZG9jdW1lbnQSlQEKDkRlbGV0ZURvY3Vt", - "ZW50EiouZ29vZ2xlLmZpcmVzdG9yZS52MS5EZWxldGVEb2N1bWVudFJlcXVl", - "c3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiP9pBBG5hbWWC0+STAjIqMC92", - "MS97bmFtZT1wcm9qZWN0cy8qL2RhdGFiYXNlcy8qL2RvY3VtZW50cy8qLyoq", - "fRK5AQoRQmF0Y2hHZXREb2N1bWVudHMSLS5nb29nbGUuZmlyZXN0b3JlLnYx", - "LkJhdGNoR2V0RG9jdW1lbnRzUmVxdWVzdBouLmdvb2dsZS5maXJlc3RvcmUu", - "djEuQmF0Y2hHZXREb2N1bWVudHNSZXNwb25zZSJDgtPkkwI9IjgvdjEve2Rh", - "dGFiYXNlPXByb2plY3RzLyovZGF0YWJhc2VzLyp9L2RvY3VtZW50czpiYXRj", - "aEdldDoBKjABEscBChBCZWdpblRyYW5zYWN0aW9uEiwuZ29vZ2xlLmZpcmVz", - "dG9yZS52MS5CZWdpblRyYW5zYWN0aW9uUmVxdWVzdBotLmdvb2dsZS5maXJl", - "c3RvcmUudjEuQmVnaW5UcmFuc2FjdGlvblJlc3BvbnNlIlbaQQhkYXRhYmFz", - "ZYLT5JMCRSJAL3YxL3tkYXRhYmFzZT1wcm9qZWN0cy8qL2RhdGFiYXNlcy8q", - "fS9kb2N1bWVudHM6YmVnaW5UcmFuc2FjdGlvbjoBKhKmAQoGQ29tbWl0EiIu", - "Z29vZ2xlLmZpcmVzdG9yZS52MS5Db21taXRSZXF1ZXN0GiMuZ29vZ2xlLmZp", - "cmVzdG9yZS52MS5Db21taXRSZXNwb25zZSJT2kEPZGF0YWJhc2Usd3JpdGVz", - "gtPkkwI7IjYvdjEve2RhdGFiYXNlPXByb2plY3RzLyovZGF0YWJhc2VzLyp9", - "L2RvY3VtZW50czpjb21taXQ6ASoSpAEKCFJvbGxiYWNrEiQuZ29vZ2xlLmZp", - "cmVzdG9yZS52MS5Sb2xsYmFja1JlcXVlc3QaFi5nb29nbGUucHJvdG9idWYu", - "RW1wdHkiWtpBFGRhdGFiYXNlLHRyYW5zYWN0aW9ugtPkkwI9IjgvdjEve2Rh", - "dGFiYXNlPXByb2plY3RzLyovZGF0YWJhc2VzLyp9L2RvY3VtZW50czpyb2xs", - "YmFjazoBKhLfAQoIUnVuUXVlcnkSJC5nb29nbGUuZmlyZXN0b3JlLnYxLlJ1", - "blF1ZXJ5UmVxdWVzdBolLmdvb2dsZS5maXJlc3RvcmUudjEuUnVuUXVlcnlS", - "ZXNwb25zZSKDAYLT5JMCfSI2L3YxL3twYXJlbnQ9cHJvamVjdHMvKi9kYXRh", - "YmFzZXMvKi9kb2N1bWVudHN9OnJ1blF1ZXJ5OgEqWkAiOy92MS97cGFyZW50", - "PXByb2plY3RzLyovZGF0YWJhc2VzLyovZG9jdW1lbnRzLyovKip9OnJ1blF1", - "ZXJ5OgEqMAESngIKD0V4ZWN1dGVQaXBlbGluZRIrLmdvb2dsZS5maXJlc3Rv", - "cmUudjEuRXhlY3V0ZVBpcGVsaW5lUmVxdWVzdBosLmdvb2dsZS5maXJlc3Rv", - "cmUudjEuRXhlY3V0ZVBpcGVsaW5lUmVzcG9uc2UirQGC0+STAkQiPy92MS97", - "ZGF0YWJhc2U9cHJvamVjdHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1lbnRzOmV4", - "ZWN1dGVQaXBlbGluZToBKorT5JMCXRImCghkYXRhYmFzZRIacHJvamVjdHMv", - "e3Byb2plY3RfaWQ9Kn0vKioSMwoIZGF0YWJhc2USJ3Byb2plY3RzLyovZGF0", - "YWJhc2VzL3tkYXRhYmFzZV9pZD0qfS8qKjABEpcCChNSdW5BZ2dyZWdhdGlv", - "blF1ZXJ5Ei8uZ29vZ2xlLmZpcmVzdG9yZS52MS5SdW5BZ2dyZWdhdGlvblF1", - "ZXJ5UmVxdWVzdBowLmdvb2dsZS5maXJlc3RvcmUudjEuUnVuQWdncmVnYXRp", - "b25RdWVyeVJlc3BvbnNlIpoBgtPkkwKTASJBL3YxL3twYXJlbnQ9cHJvamVj", - "dHMvKi9kYXRhYmFzZXMvKi9kb2N1bWVudHN9OnJ1bkFnZ3JlZ2F0aW9uUXVl", - "cnk6ASpaSyJGL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9kYXRhYmFzZXMvKi9k", - "b2N1bWVudHMvKi8qKn06cnVuQWdncmVnYXRpb25RdWVyeToBKjABEvwBCg5Q", - "YXJ0aXRpb25RdWVyeRIqLmdvb2dsZS5maXJlc3RvcmUudjEuUGFydGl0aW9u", - "UXVlcnlSZXF1ZXN0GisuZ29vZ2xlLmZpcmVzdG9yZS52MS5QYXJ0aXRpb25R", - "dWVyeVJlc3BvbnNlIpABgtPkkwKJASI8L3YxL3twYXJlbnQ9cHJvamVjdHMv", - "Ki9kYXRhYmFzZXMvKi9kb2N1bWVudHN9OnBhcnRpdGlvblF1ZXJ5OgEqWkYi", - "QS92MS97cGFyZW50PXByb2plY3RzLyovZGF0YWJhc2VzLyovZG9jdW1lbnRz", - "LyovKip9OnBhcnRpdGlvblF1ZXJ5OgEqEpQBCgVXcml0ZRIhLmdvb2dsZS5m", - "aXJlc3RvcmUudjEuV3JpdGVSZXF1ZXN0GiIuZ29vZ2xlLmZpcmVzdG9yZS52", - "MS5Xcml0ZVJlc3BvbnNlIkCC0+STAjoiNS92MS97ZGF0YWJhc2U9cHJvamVj", - "dHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1lbnRzOndyaXRlOgEqKAEwARKYAQoG", - "TGlzdGVuEiIuZ29vZ2xlLmZpcmVzdG9yZS52MS5MaXN0ZW5SZXF1ZXN0GiMu", - "Z29vZ2xlLmZpcmVzdG9yZS52MS5MaXN0ZW5SZXNwb25zZSJBgtPkkwI7IjYv", - "djEve2RhdGFiYXNlPXByb2plY3RzLyovZGF0YWJhc2VzLyp9L2RvY3VtZW50", - "czpsaXN0ZW46ASooATABEpQCChFMaXN0Q29sbGVjdGlvbklkcxItLmdvb2ds", - "ZS5maXJlc3RvcmUudjEuTGlzdENvbGxlY3Rpb25JZHNSZXF1ZXN0Gi4uZ29v", - "Z2xlLmZpcmVzdG9yZS52MS5MaXN0Q29sbGVjdGlvbklkc1Jlc3BvbnNlIp8B", - "2kEGcGFyZW50gtPkkwKPASI/L3YxL3twYXJlbnQ9cHJvamVjdHMvKi9kYXRh", - "YmFzZXMvKi9kb2N1bWVudHN9Omxpc3RDb2xsZWN0aW9uSWRzOgEqWkkiRC92", - "MS97cGFyZW50PXByb2plY3RzLyovZGF0YWJhc2VzLyovZG9jdW1lbnRzLyov", - "Kip9Omxpc3RDb2xsZWN0aW9uSWRzOgEqEqQBCgpCYXRjaFdyaXRlEiYuZ29v", - "Z2xlLmZpcmVzdG9yZS52MS5CYXRjaFdyaXRlUmVxdWVzdBonLmdvb2dsZS5m", - "aXJlc3RvcmUudjEuQmF0Y2hXcml0ZVJlc3BvbnNlIkWC0+STAj8iOi92MS97", - "ZGF0YWJhc2U9cHJvamVjdHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1lbnRzOmJh", - "dGNoV3JpdGU6ASoSrwEKDkNyZWF0ZURvY3VtZW50EiouZ29vZ2xlLmZpcmVz", - "dG9yZS52MS5DcmVhdGVEb2N1bWVudFJlcXVlc3QaHS5nb29nbGUuZmlyZXN0", - "b3JlLnYxLkRvY3VtZW50IlKC0+STAkwiQC92MS97cGFyZW50PXByb2plY3Rz", - "LyovZGF0YWJhc2VzLyovZG9jdW1lbnRzLyoqfS97Y29sbGVjdGlvbl9pZH06", - "CGRvY3VtZW50GnbKQRhmaXJlc3RvcmUuZ29vZ2xlYXBpcy5jb23SQVhodHRw", - "czovL3d3dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtLGh0", - "dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvZGF0YXN0b3JlQr8BChdj", - "b20uZ29vZ2xlLmZpcmVzdG9yZS52MUIORmlyZXN0b3JlUHJvdG9QAVo7Y2xv", - "dWQuZ29vZ2xlLmNvbS9nby9maXJlc3RvcmUvYXBpdjEvZmlyZXN0b3JlcGI7", - "ZmlyZXN0b3JlcGKqAhlHb29nbGUuQ2xvdWQuRmlyZXN0b3JlLlYxygIZR29v", - "Z2xlXENsb3VkXEZpcmVzdG9yZVxWMeoCHEdvb2dsZTo6Q2xvdWQ6OkZpcmVz", - "dG9yZTo6VjFiBnByb3RvMw==")); + "Gi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSAESJAoXYXV0b19jb21taXRf", + "dHJhbnNhY3Rpb24YCSABKAhCA+BBAUIPCg1waXBlbGluZV90eXBlQhYKFGNv", + "bnNpc3RlbmN5X3NlbGVjdG9yIswBChdFeGVjdXRlUGlwZWxpbmVSZXNwb25z", + "ZRITCgt0cmFuc2FjdGlvbhgBIAEoDBIuCgdyZXN1bHRzGAIgAygLMh0uZ29v", + "Z2xlLmZpcmVzdG9yZS52MS5Eb2N1bWVudBIyCg5leGVjdXRpb25fdGltZRgD", + "IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASOAoNZXhwbGFpbl9z", + "dGF0cxgEIAEoCzIhLmdvb2dsZS5maXJlc3RvcmUudjEuRXhwbGFpblN0YXRz", + "Iv8CChpSdW5BZ2dyZWdhdGlvblF1ZXJ5UmVxdWVzdBITCgZwYXJlbnQYASAB", + "KAlCA+BBAhJXChxzdHJ1Y3R1cmVkX2FnZ3JlZ2F0aW9uX3F1ZXJ5GAIgASgL", + "Mi8uZ29vZ2xlLmZpcmVzdG9yZS52MS5TdHJ1Y3R1cmVkQWdncmVnYXRpb25R", + "dWVyeUgAEhUKC3RyYW5zYWN0aW9uGAQgASgMSAESQgoPbmV3X3RyYW5zYWN0", + "aW9uGAUgASgLMicuZ29vZ2xlLmZpcmVzdG9yZS52MS5UcmFuc2FjdGlvbk9w", + "dGlvbnNIARIvCglyZWFkX3RpbWUYBiABKAsyGi5nb29nbGUucHJvdG9idWYu", + "VGltZXN0YW1wSAESQQoPZXhwbGFpbl9vcHRpb25zGAggASgLMiMuZ29vZ2xl", + "LmZpcmVzdG9yZS52MS5FeHBsYWluT3B0aW9uc0ID4EEBQgwKCnF1ZXJ5X3R5", + "cGVCFgoUY29uc2lzdGVuY3lfc2VsZWN0b3Ii1wEKG1J1bkFnZ3JlZ2F0aW9u", + "UXVlcnlSZXNwb25zZRI2CgZyZXN1bHQYASABKAsyJi5nb29nbGUuZmlyZXN0", + "b3JlLnYxLkFnZ3JlZ2F0aW9uUmVzdWx0EhMKC3RyYW5zYWN0aW9uGAIgASgM", + "Ei0KCXJlYWRfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3Rh", + "bXASPAoPZXhwbGFpbl9tZXRyaWNzGAogASgLMiMuZ29vZ2xlLmZpcmVzdG9y", + "ZS52MS5FeHBsYWluTWV0cmljcyKFAgoVUGFydGl0aW9uUXVlcnlSZXF1ZXN0", + "EhMKBnBhcmVudBgBIAEoCUID4EECEkAKEHN0cnVjdHVyZWRfcXVlcnkYAiAB", + "KAsyJC5nb29nbGUuZmlyZXN0b3JlLnYxLlN0cnVjdHVyZWRRdWVyeUgAEhcK", + "D3BhcnRpdGlvbl9jb3VudBgDIAEoAxISCgpwYWdlX3Rva2VuGAQgASgJEhEK", + "CXBhZ2Vfc2l6ZRgFIAEoBRIvCglyZWFkX3RpbWUYBiABKAsyGi5nb29nbGUu", + "cHJvdG9idWYuVGltZXN0YW1wSAFCDAoKcXVlcnlfdHlwZUIWChRjb25zaXN0", + "ZW5jeV9zZWxlY3RvciJiChZQYXJ0aXRpb25RdWVyeVJlc3BvbnNlEi8KCnBh", + "cnRpdGlvbnMYASADKAsyGy5nb29nbGUuZmlyZXN0b3JlLnYxLkN1cnNvchIX", + "Cg9uZXh0X3BhZ2VfdG9rZW4YAiABKAki6AEKDFdyaXRlUmVxdWVzdBIVCghk", + "YXRhYmFzZRgBIAEoCUID4EECEhEKCXN0cmVhbV9pZBgCIAEoCRIqCgZ3cml0", + "ZXMYAyADKAsyGi5nb29nbGUuZmlyZXN0b3JlLnYxLldyaXRlEhQKDHN0cmVh", + "bV90b2tlbhgEIAEoDBI9CgZsYWJlbHMYBSADKAsyLS5nb29nbGUuZmlyZXN0", + "b3JlLnYxLldyaXRlUmVxdWVzdC5MYWJlbHNFbnRyeRotCgtMYWJlbHNFbnRy", + "eRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBIqIBCg1Xcml0ZVJl", + "c3BvbnNlEhEKCXN0cmVhbV9pZBgBIAEoCRIUCgxzdHJlYW1fdG9rZW4YAiAB", + "KAwSNwoNd3JpdGVfcmVzdWx0cxgDIAMoCzIgLmdvb2dsZS5maXJlc3RvcmUu", + "djEuV3JpdGVSZXN1bHQSLwoLY29tbWl0X3RpbWUYBCABKAsyGi5nb29nbGUu", + "cHJvdG9idWYuVGltZXN0YW1wIvIBCg1MaXN0ZW5SZXF1ZXN0EhUKCGRhdGFi", + "YXNlGAEgASgJQgPgQQISMQoKYWRkX3RhcmdldBgCIAEoCzIbLmdvb2dsZS5m", + "aXJlc3RvcmUudjEuVGFyZ2V0SAASFwoNcmVtb3ZlX3RhcmdldBgDIAEoBUgA", + "Ej4KBmxhYmVscxgEIAMoCzIuLmdvb2dsZS5maXJlc3RvcmUudjEuTGlzdGVu", + "UmVxdWVzdC5MYWJlbHNFbnRyeRotCgtMYWJlbHNFbnRyeRILCgNrZXkYASAB", + "KAkSDQoFdmFsdWUYAiABKAk6AjgBQg8KDXRhcmdldF9jaGFuZ2Ui1QIKDkxp", + "c3RlblJlc3BvbnNlEjoKDXRhcmdldF9jaGFuZ2UYAiABKAsyIS5nb29nbGUu", + "ZmlyZXN0b3JlLnYxLlRhcmdldENoYW5nZUgAEj4KD2RvY3VtZW50X2NoYW5n", + "ZRgDIAEoCzIjLmdvb2dsZS5maXJlc3RvcmUudjEuRG9jdW1lbnRDaGFuZ2VI", + "ABI+Cg9kb2N1bWVudF9kZWxldGUYBCABKAsyIy5nb29nbGUuZmlyZXN0b3Jl", + "LnYxLkRvY3VtZW50RGVsZXRlSAASPgoPZG9jdW1lbnRfcmVtb3ZlGAYgASgL", + "MiMuZ29vZ2xlLmZpcmVzdG9yZS52MS5Eb2N1bWVudFJlbW92ZUgAEjYKBmZp", + "bHRlchgFIAEoCzIkLmdvb2dsZS5maXJlc3RvcmUudjEuRXhpc3RlbmNlRmls", + "dGVySABCDwoNcmVzcG9uc2VfdHlwZSLWAwoGVGFyZ2V0EjgKBXF1ZXJ5GAIg", + "ASgLMicuZ29vZ2xlLmZpcmVzdG9yZS52MS5UYXJnZXQuUXVlcnlUYXJnZXRI", + "ABJACglkb2N1bWVudHMYAyABKAsyKy5nb29nbGUuZmlyZXN0b3JlLnYxLlRh", + "cmdldC5Eb2N1bWVudHNUYXJnZXRIABIWCgxyZXN1bWVfdG9rZW4YBCABKAxI", + "ARIvCglyZWFkX3RpbWUYCyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", + "YW1wSAESEQoJdGFyZ2V0X2lkGAUgASgFEgwKBG9uY2UYBiABKAgSMwoOZXhw", + "ZWN0ZWRfY291bnQYDCABKAsyGy5nb29nbGUucHJvdG9idWYuSW50MzJWYWx1", + "ZRokCg9Eb2N1bWVudHNUYXJnZXQSEQoJZG9jdW1lbnRzGAIgAygJGm0KC1F1", + "ZXJ5VGFyZ2V0Eg4KBnBhcmVudBgBIAEoCRJAChBzdHJ1Y3R1cmVkX3F1ZXJ5", + "GAIgASgLMiQuZ29vZ2xlLmZpcmVzdG9yZS52MS5TdHJ1Y3R1cmVkUXVlcnlI", + "AEIMCgpxdWVyeV90eXBlQg0KC3RhcmdldF90eXBlQg0KC3Jlc3VtZV90eXBl", + "IqoCCgxUYXJnZXRDaGFuZ2USTgoSdGFyZ2V0X2NoYW5nZV90eXBlGAEgASgO", + "MjIuZ29vZ2xlLmZpcmVzdG9yZS52MS5UYXJnZXRDaGFuZ2UuVGFyZ2V0Q2hh", + "bmdlVHlwZRISCgp0YXJnZXRfaWRzGAIgAygFEiEKBWNhdXNlGAMgASgLMhIu", + "Z29vZ2xlLnJwYy5TdGF0dXMSFAoMcmVzdW1lX3Rva2VuGAQgASgMEi0KCXJl", + "YWRfdGltZRgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiTgoQ", + "VGFyZ2V0Q2hhbmdlVHlwZRINCglOT19DSEFOR0UQABIHCgNBREQQARIKCgZS", + "RU1PVkUQAhILCgdDVVJSRU5UEAMSCQoFUkVTRVQQBCKfAQoYTGlzdENvbGxl", + "Y3Rpb25JZHNSZXF1ZXN0EhMKBnBhcmVudBgBIAEoCUID4EECEhEKCXBhZ2Vf", + "c2l6ZRgCIAEoBRISCgpwYWdlX3Rva2VuGAMgASgJEi8KCXJlYWRfdGltZRgE", + "IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBIAEIWChRjb25zaXN0", + "ZW5jeV9zZWxlY3RvciJMChlMaXN0Q29sbGVjdGlvbklkc1Jlc3BvbnNlEhYK", + "DmNvbGxlY3Rpb25faWRzGAEgAygJEhcKD25leHRfcGFnZV90b2tlbhgCIAEo", + "CSLJAQoRQmF0Y2hXcml0ZVJlcXVlc3QSFQoIZGF0YWJhc2UYASABKAlCA+BB", + "AhIqCgZ3cml0ZXMYAiADKAsyGi5nb29nbGUuZmlyZXN0b3JlLnYxLldyaXRl", + "EkIKBmxhYmVscxgDIAMoCzIyLmdvb2dsZS5maXJlc3RvcmUudjEuQmF0Y2hX", + "cml0ZVJlcXVlc3QuTGFiZWxzRW50cnkaLQoLTGFiZWxzRW50cnkSCwoDa2V5", + "GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASJxChJCYXRjaFdyaXRlUmVzcG9u", + "c2USNwoNd3JpdGVfcmVzdWx0cxgBIAMoCzIgLmdvb2dsZS5maXJlc3RvcmUu", + "djEuV3JpdGVSZXN1bHQSIgoGc3RhdHVzGAIgAygLMhIuZ29vZ2xlLnJwYy5T", + "dGF0dXMy+xsKCUZpcmVzdG9yZRKPAQoLR2V0RG9jdW1lbnQSJy5nb29nbGUu", + "ZmlyZXN0b3JlLnYxLkdldERvY3VtZW50UmVxdWVzdBodLmdvb2dsZS5maXJl", + "c3RvcmUudjEuRG9jdW1lbnQiOILT5JMCMhIwL3YxL3tuYW1lPXByb2plY3Rz", + "LyovZGF0YWJhc2VzLyovZG9jdW1lbnRzLyovKip9EvUBCg1MaXN0RG9jdW1l", + "bnRzEikuZ29vZ2xlLmZpcmVzdG9yZS52MS5MaXN0RG9jdW1lbnRzUmVxdWVz", + "dBoqLmdvb2dsZS5maXJlc3RvcmUudjEuTGlzdERvY3VtZW50c1Jlc3BvbnNl", + "IowBgtPkkwKFARJCL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9kYXRhYmFzZXMv", + "Ki9kb2N1bWVudHMvKi8qKn0ve2NvbGxlY3Rpb25faWR9Wj8SPS92MS97cGFy", + "ZW50PXByb2plY3RzLyovZGF0YWJhc2VzLyovZG9jdW1lbnRzfS97Y29sbGVj", + "dGlvbl9pZH0SvwEKDlVwZGF0ZURvY3VtZW50EiouZ29vZ2xlLmZpcmVzdG9y", + "ZS52MS5VcGRhdGVEb2N1bWVudFJlcXVlc3QaHS5nb29nbGUuZmlyZXN0b3Jl", + "LnYxLkRvY3VtZW50ImLaQRRkb2N1bWVudCx1cGRhdGVfbWFza4LT5JMCRTI5", + "L3YxL3tkb2N1bWVudC5uYW1lPXByb2plY3RzLyovZGF0YWJhc2VzLyovZG9j", + "dW1lbnRzLyovKip9Oghkb2N1bWVudBKVAQoORGVsZXRlRG9jdW1lbnQSKi5n", + "b29nbGUuZmlyZXN0b3JlLnYxLkRlbGV0ZURvY3VtZW50UmVxdWVzdBoWLmdv", + "b2dsZS5wcm90b2J1Zi5FbXB0eSI/2kEEbmFtZYLT5JMCMiowL3YxL3tuYW1l", + "PXByb2plY3RzLyovZGF0YWJhc2VzLyovZG9jdW1lbnRzLyovKip9ErkBChFC", + "YXRjaEdldERvY3VtZW50cxItLmdvb2dsZS5maXJlc3RvcmUudjEuQmF0Y2hH", + "ZXREb2N1bWVudHNSZXF1ZXN0Gi4uZ29vZ2xlLmZpcmVzdG9yZS52MS5CYXRj", + "aEdldERvY3VtZW50c1Jlc3BvbnNlIkOC0+STAj0iOC92MS97ZGF0YWJhc2U9", + "cHJvamVjdHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1lbnRzOmJhdGNoR2V0OgEq", + "MAESxwEKEEJlZ2luVHJhbnNhY3Rpb24SLC5nb29nbGUuZmlyZXN0b3JlLnYx", + "LkJlZ2luVHJhbnNhY3Rpb25SZXF1ZXN0Gi0uZ29vZ2xlLmZpcmVzdG9yZS52", + "MS5CZWdpblRyYW5zYWN0aW9uUmVzcG9uc2UiVtpBCGRhdGFiYXNlgtPkkwJF", + "IkAvdjEve2RhdGFiYXNlPXByb2plY3RzLyovZGF0YWJhc2VzLyp9L2RvY3Vt", + "ZW50czpiZWdpblRyYW5zYWN0aW9uOgEqEqYBCgZDb21taXQSIi5nb29nbGUu", + "ZmlyZXN0b3JlLnYxLkNvbW1pdFJlcXVlc3QaIy5nb29nbGUuZmlyZXN0b3Jl", + "LnYxLkNvbW1pdFJlc3BvbnNlIlPaQQ9kYXRhYmFzZSx3cml0ZXOC0+STAjsi", + "Ni92MS97ZGF0YWJhc2U9cHJvamVjdHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1l", + "bnRzOmNvbW1pdDoBKhKkAQoIUm9sbGJhY2sSJC5nb29nbGUuZmlyZXN0b3Jl", + "LnYxLlJvbGxiYWNrUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJa", + "2kEUZGF0YWJhc2UsdHJhbnNhY3Rpb26C0+STAj0iOC92MS97ZGF0YWJhc2U9", + "cHJvamVjdHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1lbnRzOnJvbGxiYWNrOgEq", + "Et8BCghSdW5RdWVyeRIkLmdvb2dsZS5maXJlc3RvcmUudjEuUnVuUXVlcnlS", + "ZXF1ZXN0GiUuZ29vZ2xlLmZpcmVzdG9yZS52MS5SdW5RdWVyeVJlc3BvbnNl", + "IoMBgtPkkwJ9IjYvdjEve3BhcmVudD1wcm9qZWN0cy8qL2RhdGFiYXNlcy8q", + "L2RvY3VtZW50c306cnVuUXVlcnk6ASpaQCI7L3YxL3twYXJlbnQ9cHJvamVj", + "dHMvKi9kYXRhYmFzZXMvKi9kb2N1bWVudHMvKi8qKn06cnVuUXVlcnk6ASow", + "ARKeAgoPRXhlY3V0ZVBpcGVsaW5lEisuZ29vZ2xlLmZpcmVzdG9yZS52MS5F", + "eGVjdXRlUGlwZWxpbmVSZXF1ZXN0GiwuZ29vZ2xlLmZpcmVzdG9yZS52MS5F", + "eGVjdXRlUGlwZWxpbmVSZXNwb25zZSKtAYLT5JMCRCI/L3YxL3tkYXRhYmFz", + "ZT1wcm9qZWN0cy8qL2RhdGFiYXNlcy8qfS9kb2N1bWVudHM6ZXhlY3V0ZVBp", + "cGVsaW5lOgEqitPkkwJdEiYKCGRhdGFiYXNlEhpwcm9qZWN0cy97cHJvamVj", + "dF9pZD0qfS8qKhIzCghkYXRhYmFzZRIncHJvamVjdHMvKi9kYXRhYmFzZXMv", + "e2RhdGFiYXNlX2lkPSp9LyoqMAESlwIKE1J1bkFnZ3JlZ2F0aW9uUXVlcnkS", + "Ly5nb29nbGUuZmlyZXN0b3JlLnYxLlJ1bkFnZ3JlZ2F0aW9uUXVlcnlSZXF1", + "ZXN0GjAuZ29vZ2xlLmZpcmVzdG9yZS52MS5SdW5BZ2dyZWdhdGlvblF1ZXJ5", + "UmVzcG9uc2UimgGC0+STApMBIkEvdjEve3BhcmVudD1wcm9qZWN0cy8qL2Rh", + "dGFiYXNlcy8qL2RvY3VtZW50c306cnVuQWdncmVnYXRpb25RdWVyeToBKlpL", + "IkYvdjEve3BhcmVudD1wcm9qZWN0cy8qL2RhdGFiYXNlcy8qL2RvY3VtZW50", + "cy8qLyoqfTpydW5BZ2dyZWdhdGlvblF1ZXJ5OgEqMAES/AEKDlBhcnRpdGlv", + "blF1ZXJ5EiouZ29vZ2xlLmZpcmVzdG9yZS52MS5QYXJ0aXRpb25RdWVyeVJl", + "cXVlc3QaKy5nb29nbGUuZmlyZXN0b3JlLnYxLlBhcnRpdGlvblF1ZXJ5UmVz", + "cG9uc2UikAGC0+STAokBIjwvdjEve3BhcmVudD1wcm9qZWN0cy8qL2RhdGFi", + "YXNlcy8qL2RvY3VtZW50c306cGFydGl0aW9uUXVlcnk6ASpaRiJBL3YxL3tw", + "YXJlbnQ9cHJvamVjdHMvKi9kYXRhYmFzZXMvKi9kb2N1bWVudHMvKi8qKn06", + "cGFydGl0aW9uUXVlcnk6ASoSlAEKBVdyaXRlEiEuZ29vZ2xlLmZpcmVzdG9y", + "ZS52MS5Xcml0ZVJlcXVlc3QaIi5nb29nbGUuZmlyZXN0b3JlLnYxLldyaXRl", + "UmVzcG9uc2UiQILT5JMCOiI1L3YxL3tkYXRhYmFzZT1wcm9qZWN0cy8qL2Rh", + "dGFiYXNlcy8qfS9kb2N1bWVudHM6d3JpdGU6ASooATABEpgBCgZMaXN0ZW4S", + "Ii5nb29nbGUuZmlyZXN0b3JlLnYxLkxpc3RlblJlcXVlc3QaIy5nb29nbGUu", + "ZmlyZXN0b3JlLnYxLkxpc3RlblJlc3BvbnNlIkGC0+STAjsiNi92MS97ZGF0", + "YWJhc2U9cHJvamVjdHMvKi9kYXRhYmFzZXMvKn0vZG9jdW1lbnRzOmxpc3Rl", + "bjoBKigBMAESlAIKEUxpc3RDb2xsZWN0aW9uSWRzEi0uZ29vZ2xlLmZpcmVz", + "dG9yZS52MS5MaXN0Q29sbGVjdGlvbklkc1JlcXVlc3QaLi5nb29nbGUuZmly", + "ZXN0b3JlLnYxLkxpc3RDb2xsZWN0aW9uSWRzUmVzcG9uc2UinwHaQQZwYXJl", + "bnSC0+STAo8BIj8vdjEve3BhcmVudD1wcm9qZWN0cy8qL2RhdGFiYXNlcy8q", + "L2RvY3VtZW50c306bGlzdENvbGxlY3Rpb25JZHM6ASpaSSJEL3YxL3twYXJl", + "bnQ9cHJvamVjdHMvKi9kYXRhYmFzZXMvKi9kb2N1bWVudHMvKi8qKn06bGlz", + "dENvbGxlY3Rpb25JZHM6ASoSpAEKCkJhdGNoV3JpdGUSJi5nb29nbGUuZmly", + "ZXN0b3JlLnYxLkJhdGNoV3JpdGVSZXF1ZXN0GicuZ29vZ2xlLmZpcmVzdG9y", + "ZS52MS5CYXRjaFdyaXRlUmVzcG9uc2UiRYLT5JMCPyI6L3YxL3tkYXRhYmFz", + "ZT1wcm9qZWN0cy8qL2RhdGFiYXNlcy8qfS9kb2N1bWVudHM6YmF0Y2hXcml0", + "ZToBKhKvAQoOQ3JlYXRlRG9jdW1lbnQSKi5nb29nbGUuZmlyZXN0b3JlLnYx", + "LkNyZWF0ZURvY3VtZW50UmVxdWVzdBodLmdvb2dsZS5maXJlc3RvcmUudjEu", + "RG9jdW1lbnQiUoLT5JMCTCJAL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9kYXRh", + "YmFzZXMvKi9kb2N1bWVudHMvKip9L3tjb2xsZWN0aW9uX2lkfToIZG9jdW1l", + "bnQadspBGGZpcmVzdG9yZS5nb29nbGVhcGlzLmNvbdJBWGh0dHBzOi8vd3d3", + "Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2xvdWQtcGxhdGZvcm0saHR0cHM6Ly93", + "d3cuZ29vZ2xlYXBpcy5jb20vYXV0aC9kYXRhc3RvcmVCvwEKF2NvbS5nb29n", + "bGUuZmlyZXN0b3JlLnYxQg5GaXJlc3RvcmVQcm90b1ABWjtjbG91ZC5nb29n", + "bGUuY29tL2dvL2ZpcmVzdG9yZS9hcGl2MS9maXJlc3RvcmVwYjtmaXJlc3Rv", + "cmVwYqoCGUdvb2dsZS5DbG91ZC5GaXJlc3RvcmUuVjHKAhlHb29nbGVcQ2xv", + "dWRcRmlyZXN0b3JlXFYx6gIcR29vZ2xlOjpDbG91ZDo6RmlyZXN0b3JlOjpW", + "MWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.RoutingReflection.Descriptor, global::Google.Cloud.Firestore.V1.AggregationResultReflection.Descriptor, global::Google.Cloud.Firestore.V1.CommonReflection.Descriptor, global::Google.Cloud.Firestore.V1.DocumentReflection.Descriptor, global::Google.Cloud.Firestore.V1.ExplainStatsReflection.Descriptor, global::Google.Cloud.Firestore.V1.PipelineReflection.Descriptor, global::Google.Cloud.Firestore.V1.QueryReflection.Descriptor, global::Google.Cloud.Firestore.V1.QueryProfileReflection.Descriptor, global::Google.Cloud.Firestore.V1.WriteReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor, global::Google.Rpc.StatusReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { @@ -284,7 +285,7 @@ static FirestoreReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.RollbackRequest), global::Google.Cloud.Firestore.V1.RollbackRequest.Parser, new[]{ "Database", "Transaction" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.RunQueryRequest), global::Google.Cloud.Firestore.V1.RunQueryRequest.Parser, new[]{ "Parent", "StructuredQuery", "Transaction", "NewTransaction", "ReadTime", "ExplainOptions" }, new[]{ "QueryType", "ConsistencySelector" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.RunQueryResponse), global::Google.Cloud.Firestore.V1.RunQueryResponse.Parser, new[]{ "Transaction", "Document", "ReadTime", "SkippedResults", "Done", "ExplainMetrics" }, new[]{ "ContinuationSelector" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.ExecutePipelineRequest), global::Google.Cloud.Firestore.V1.ExecutePipelineRequest.Parser, new[]{ "Database", "StructuredPipeline", "Transaction", "NewTransaction", "ReadTime" }, new[]{ "PipelineType", "ConsistencySelector" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.ExecutePipelineRequest), global::Google.Cloud.Firestore.V1.ExecutePipelineRequest.Parser, new[]{ "Database", "StructuredPipeline", "Transaction", "NewTransaction", "ReadTime", "AutoCommitTransaction" }, new[]{ "PipelineType", "ConsistencySelector" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.ExecutePipelineResponse), global::Google.Cloud.Firestore.V1.ExecutePipelineResponse.Parser, new[]{ "Transaction", "Results", "ExecutionTime", "ExplainStats" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.RunAggregationQueryRequest), global::Google.Cloud.Firestore.V1.RunAggregationQueryRequest.Parser, new[]{ "Parent", "StructuredAggregationQuery", "Transaction", "NewTransaction", "ReadTime", "ExplainOptions" }, new[]{ "QueryType", "ConsistencySelector" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Firestore.V1.RunAggregationQueryResponse), global::Google.Cloud.Firestore.V1.RunAggregationQueryResponse.Parser, new[]{ "Result", "Transaction", "ReadTime", "ExplainMetrics" }, null, null, null, null), @@ -5795,6 +5796,7 @@ public ExecutePipelineRequest() { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public ExecutePipelineRequest(ExecutePipelineRequest other) : this() { database_ = other.database_; + autoCommitTransaction_ = other.autoCommitTransaction_; switch (other.PipelineTypeCase) { case PipelineTypeOneofCase.StructuredPipeline: StructuredPipeline = other.StructuredPipeline.Clone(); @@ -5921,6 +5923,23 @@ public void ClearTransaction() { } } + /// Field number for the "auto_commit_transaction" field. + public const int AutoCommitTransactionFieldNumber = 9; + private bool autoCommitTransaction_; + /// + /// Optional. Automatically commits the transaction after the pipeline has been + /// executed. Only permitted in combination with `transaction` or + /// `new_transaction`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool AutoCommitTransaction { + get { return autoCommitTransaction_; } + set { + autoCommitTransaction_ = value; + } + } + private object pipelineType_; /// Enum of possible cases for the "pipeline_type" oneof. public enum PipelineTypeOneofCase { @@ -5983,6 +6002,7 @@ public bool Equals(ExecutePipelineRequest other) { if (Transaction != other.Transaction) return false; if (!object.Equals(NewTransaction, other.NewTransaction)) return false; if (!object.Equals(ReadTime, other.ReadTime)) return false; + if (AutoCommitTransaction != other.AutoCommitTransaction) return false; if (PipelineTypeCase != other.PipelineTypeCase) return false; if (ConsistencySelectorCase != other.ConsistencySelectorCase) return false; return Equals(_unknownFields, other._unknownFields); @@ -5997,6 +6017,7 @@ public override int GetHashCode() { if (HasTransaction) hash ^= Transaction.GetHashCode(); if (consistencySelectorCase_ == ConsistencySelectorOneofCase.NewTransaction) hash ^= NewTransaction.GetHashCode(); if (consistencySelectorCase_ == ConsistencySelectorOneofCase.ReadTime) hash ^= ReadTime.GetHashCode(); + if (AutoCommitTransaction != false) hash ^= AutoCommitTransaction.GetHashCode(); hash ^= (int) pipelineTypeCase_; hash ^= (int) consistencySelectorCase_; if (_unknownFields != null) { @@ -6037,6 +6058,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(58); output.WriteMessage(ReadTime); } + if (AutoCommitTransaction != false) { + output.WriteRawTag(72); + output.WriteBool(AutoCommitTransaction); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -6067,6 +6092,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(58); output.WriteMessage(ReadTime); } + if (AutoCommitTransaction != false) { + output.WriteRawTag(72); + output.WriteBool(AutoCommitTransaction); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -6092,6 +6121,9 @@ public int CalculateSize() { if (consistencySelectorCase_ == ConsistencySelectorOneofCase.ReadTime) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(ReadTime); } + if (AutoCommitTransaction != false) { + size += 1 + 1; + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -6107,6 +6139,9 @@ public void MergeFrom(ExecutePipelineRequest other) { if (other.Database.Length != 0) { Database = other.Database; } + if (other.AutoCommitTransaction != false) { + AutoCommitTransaction = other.AutoCommitTransaction; + } switch (other.PipelineTypeCase) { case PipelineTypeOneofCase.StructuredPipeline: if (StructuredPipeline == null) { @@ -6188,6 +6223,10 @@ public void MergeFrom(pb::CodedInputStream input) { ReadTime = subBuilder; break; } + case 72: { + AutoCommitTransaction = input.ReadBool(); + break; + } } } #endif @@ -6242,6 +6281,10 @@ public void MergeFrom(pb::CodedInputStream input) { ReadTime = subBuilder; break; } + case 72: { + AutoCommitTransaction = input.ReadBool(); + break; + } } } } @@ -11447,6 +11490,9 @@ public ListCollectionIdsRequest Clone() { /// `projects/{project_id}/databases/{database_id}/documents/{document_path}`. /// For example: /// `projects/my-project/databases/my-database/documents/chatrooms/my-chatroom` + /// + /// Use `projects/{project_id}/databases/{database_id}/documents` to list + /// top-level collections. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/FirestoreClient.g.cs b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/FirestoreClient.g.cs index 0e4bfb914c0f..bc9c52760922 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/FirestoreClient.g.cs +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/FirestoreClient.g.cs @@ -1147,6 +1147,9 @@ public virtual ListenStream Listen(gaxgrpc::CallSettings callSettings = null, ga /// `projects/{project_id}/databases/{database_id}/documents/{document_path}`. /// For example: /// `projects/my-project/databases/my-database/documents/chatrooms/my-chatroom` + /// + /// Use `projects/{project_id}/databases/{database_id}/documents` to list + /// top-level collections. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first @@ -1183,6 +1186,9 @@ public virtual ListenStream Listen(gaxgrpc::CallSettings callSettings = null, ga /// `projects/{project_id}/databases/{database_id}/documents/{document_path}`. /// For example: /// `projects/my-project/databases/my-database/documents/chatrooms/my-chatroom` + /// + /// Use `projects/{project_id}/databases/{database_id}/documents` to list + /// top-level collections. /// /// /// The token returned from the previous request. A value of null or an empty string retrieves the first diff --git a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Query.g.cs b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Query.g.cs index 2185310a84c8..d12bbe3fc4df 100644 --- a/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Query.g.cs +++ b/apis/Google.Cloud.Firestore.V1/Google.Cloud.Firestore.V1/Query.g.cs @@ -249,9 +249,12 @@ public StructuredQuery Clone() { /// /// The order to apply to the query results. /// - /// Firestore allows callers to provide a full ordering, a partial ordering, or - /// no ordering at all. In all cases, Firestore guarantees a stable ordering - /// through the following rules: + /// Callers can provide a full ordering, a partial ordering, or no ordering at + /// all. While Firestore will always respect the provided order, the behavior + /// for queries without a full ordering is different per database edition: + /// + /// In Standard edition, Firestore guarantees a stable ordering through the + /// following rules: /// /// * The `order_by` is required to reference all fields used with an /// inequality filter. @@ -267,6 +270,13 @@ public StructuredQuery Clone() { /// * `WHERE a > 1` becomes `WHERE a > 1 ORDER BY a ASC, __name__ ASC` /// * `WHERE __name__ > ... AND a > 1` becomes /// `WHERE __name__ > ... AND a > 1 ORDER BY a ASC, __name__ ASC` + /// + /// In Enterprise edition, Firestore does not guarantee a stable ordering. + /// Instead it will pick the most efficient ordering based on the indexes + /// available at the time of query execution. This will result in a different + /// ordering for queries that are otherwise identical. To ensure a stable + /// ordering, always include a unique field in the `order_by` clause, such as + /// `__name__`. /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectAsyncSnippet.g.cs index 058eb3e0c502..617034434a53 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectAsyncSnippet.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectAsyncSnippet.g.cs @@ -41,6 +41,7 @@ public async Task SanitizeModelResponseRequestObjectAsync() ModelResponseData = new DataItem(), UserPrompt = "", MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeModelResponseResponse response = await modelArmorClient.SanitizeModelResponseAsync(request); diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectSnippet.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectSnippet.g.cs index c5f77e808f5c..038ddb0555f2 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectSnippet.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeModelResponseRequestObjectSnippet.g.cs @@ -40,6 +40,7 @@ public void SanitizeModelResponseRequestObject() ModelResponseData = new DataItem(), UserPrompt = "", MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeModelResponseResponse response = modelArmorClient.SanitizeModelResponse(request); diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectAsyncSnippet.g.cs index f071a8d24ed3..848b5f4934c4 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectAsyncSnippet.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectAsyncSnippet.g.cs @@ -40,6 +40,7 @@ public async Task SanitizeUserPromptRequestObjectAsync() TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), UserPromptData = new DataItem(), MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeUserPromptResponse response = await modelArmorClient.SanitizeUserPromptAsync(request); diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectSnippet.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectSnippet.g.cs index 4eaad51d6308..2dc0c873d7fe 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectSnippet.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.SanitizeUserPromptRequestObjectSnippet.g.cs @@ -39,6 +39,7 @@ public void SanitizeUserPromptRequestObject() TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), UserPromptData = new DataItem(), MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeUserPromptResponse response = modelArmorClient.SanitizeUserPrompt(request); diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.StreamSanitizeModelResponseSnippet.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.StreamSanitizeModelResponseSnippet.g.cs new file mode 100644 index 000000000000..e8b420f4bae8 --- /dev/null +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.StreamSanitizeModelResponseSnippet.g.cs @@ -0,0 +1,83 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Generated code. DO NOT EDIT! + +namespace GoogleCSharpSnippets +{ + // [START modelarmor_v1_generated_ModelArmor_StreamSanitizeModelResponse_sync] + using Google.Api.Gax.Grpc; + using Google.Cloud.ModelArmor.V1; + using System.Threading.Tasks; + + public sealed partial class GeneratedModelArmorClientSnippets + { + /// Snippet for StreamSanitizeModelResponse + /// + /// 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 StreamSanitizeModelResponse() + { + // Create client + ModelArmorClient modelArmorClient = ModelArmorClient.Create(); + // Initialize streaming call, retrieving the stream object + using ModelArmorClient.StreamSanitizeModelResponseStream response = modelArmorClient.StreamSanitizeModelResponse(); + + // Sending requests and retrieving responses can be arbitrarily interleaved + // Exact sequence will depend on client/server behavior + + // Create task to do something with responses from server + Task responseHandlerTask = Task.Run(async () => + { + // Note that C# 8 code can use await foreach + AsyncResponseStream responseStream = response.GetResponseStream(); + while (await responseStream.MoveNextAsync()) + { + SanitizeModelResponseResponse responseItem = responseStream.Current; + // Do something with streamed response + } + // The response stream has completed + }); + + // Send requests to the server + bool done = false; + while (!done) + { + // Initialize a request + SanitizeModelResponseRequest request = new SanitizeModelResponseRequest + { + TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), + ModelResponseData = new DataItem(), + UserPrompt = "", + MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, + }; + // Stream a request to the server + await response.WriteAsync(request); + // Set "done" to true when sending requests is complete + } + + // Complete writing requests to the stream + await response.WriteCompleteAsync(); + // Await the response handler + // This will complete once all server responses have been processed + await responseHandlerTask; + } + } + // [END modelarmor_v1_generated_ModelArmor_StreamSanitizeModelResponse_sync] +} diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.StreamSanitizeUserPromptSnippet.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.StreamSanitizeUserPromptSnippet.g.cs new file mode 100644 index 000000000000..bb325ac86ed9 --- /dev/null +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/ModelArmorClient.StreamSanitizeUserPromptSnippet.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 modelarmor_v1_generated_ModelArmor_StreamSanitizeUserPrompt_sync] + using Google.Api.Gax.Grpc; + using Google.Cloud.ModelArmor.V1; + using System.Threading.Tasks; + + public sealed partial class GeneratedModelArmorClientSnippets + { + /// Snippet for StreamSanitizeUserPrompt + /// + /// 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 StreamSanitizeUserPrompt() + { + // Create client + ModelArmorClient modelArmorClient = ModelArmorClient.Create(); + // Initialize streaming call, retrieving the stream object + using ModelArmorClient.StreamSanitizeUserPromptStream response = modelArmorClient.StreamSanitizeUserPrompt(); + + // Sending requests and retrieving responses can be arbitrarily interleaved + // Exact sequence will depend on client/server behavior + + // Create task to do something with responses from server + Task responseHandlerTask = Task.Run(async () => + { + // Note that C# 8 code can use await foreach + AsyncResponseStream responseStream = response.GetResponseStream(); + while (await responseStream.MoveNextAsync()) + { + SanitizeUserPromptResponse responseItem = responseStream.Current; + // Do something with streamed response + } + // The response stream has completed + }); + + // Send requests to the server + bool done = false; + while (!done) + { + // Initialize a request + SanitizeUserPromptRequest request = new SanitizeUserPromptRequest + { + TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), + UserPromptData = new DataItem(), + MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, + }; + // Stream a request to the server + await response.WriteAsync(request); + // Set "done" to true when sending requests is complete + } + + // Complete writing requests to the stream + await response.WriteCompleteAsync(); + // Await the response handler + // This will complete once all server responses have been processed + await responseHandlerTask; + } + } + // [END modelarmor_v1_generated_ModelArmor_StreamSanitizeUserPrompt_sync] +} diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/snippet_metadata_google.cloud.modelarmor.v1.json b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/snippet_metadata_google.cloud.modelarmor.v1.json index d7bd3c8ed4f7..8326bae94205 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/snippet_metadata_google.cloud.modelarmor.v1.json +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.GeneratedSnippets/snippet_metadata_google.cloud.modelarmor.v1.json @@ -1944,12 +1944,12 @@ "segments": [ { "start": 20, - "end": 46, + "end": 47, "type": "FULL" }, { "start": 34, - "end": 44, + "end": 45, "type": "SHORT" } ] @@ -1993,12 +1993,12 @@ "segments": [ { "start": 20, - "end": 47, + "end": 48, "type": "FULL" }, { "start": 35, - "end": 45, + "end": 46, "type": "SHORT" } ] @@ -2041,12 +2041,12 @@ "segments": [ { "start": 20, - "end": 47, + "end": 48, "type": "FULL" }, { "start": 34, - "end": 45, + "end": 46, "type": "SHORT" } ] @@ -2090,12 +2090,108 @@ "segments": [ { "start": 20, - "end": 48, + "end": 49, "type": "FULL" }, { "start": 35, - "end": 46, + "end": 47, + "type": "SHORT" + } + ] + }, + { + "regionTag": "modelarmor_v1_generated_ModelArmor_StreamSanitizeUserPrompt_sync", + "title": "StreamSanitizeUserPrompt", + "description": "Snippet for StreamSanitizeUserPrompt", + "file": "ModelArmorClient.StreamSanitizeUserPromptSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "StreamSanitizeUserPrompt", + "fullName": "Google.Cloud.ModelArmor.V1.ModelArmorClient.StreamSanitizeUserPrompt", + "parameters": [ + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + }, + { + "type": "Google.Api.Gax.Grpc.BidirectionalStreamingSettings", + "name": "streamingSettings" + } + ], + "resultType": "Google.Cloud.ModelArmor.V1.ModelArmorClient+StreamSanitizeUserPromptStream", + "client": { + "shortName": "ModelArmorClient", + "fullName": "Google.Cloud.ModelArmor.V1.ModelArmorClient" + }, + "method": { + "shortName": "StreamSanitizeUserPrompt", + "fullName": "google.cloud.modelarmor.v1.ModelArmor.StreamSanitizeUserPrompt", + "service": { + "shortName": "ModelArmor", + "fullName": "google.cloud.modelarmor.v1.ModelArmor" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 80, + "type": "FULL" + }, + { + "start": 36, + "end": 78, + "type": "SHORT" + } + ] + }, + { + "regionTag": "modelarmor_v1_generated_ModelArmor_StreamSanitizeModelResponse_sync", + "title": "StreamSanitizeModelResponse", + "description": "Snippet for StreamSanitizeModelResponse", + "file": "ModelArmorClient.StreamSanitizeModelResponseSnippet.g.cs", + "language": "C_SHARP", + "clientMethod": { + "shortName": "StreamSanitizeModelResponse", + "fullName": "Google.Cloud.ModelArmor.V1.ModelArmorClient.StreamSanitizeModelResponse", + "parameters": [ + { + "type": "Google.Api.Gax.Grpc.CallSettings", + "name": "callSettings" + }, + { + "type": "Google.Api.Gax.Grpc.BidirectionalStreamingSettings", + "name": "streamingSettings" + } + ], + "resultType": "Google.Cloud.ModelArmor.V1.ModelArmorClient+StreamSanitizeModelResponseStream", + "client": { + "shortName": "ModelArmorClient", + "fullName": "Google.Cloud.ModelArmor.V1.ModelArmorClient" + }, + "method": { + "shortName": "StreamSanitizeModelResponse", + "fullName": "google.cloud.modelarmor.v1.ModelArmor.StreamSanitizeModelResponse", + "service": { + "shortName": "ModelArmor", + "fullName": "google.cloud.modelarmor.v1.ModelArmor" + } + } + }, + "canonical": true, + "origin": "API_DEFINITION", + "segments": [ + { + "start": 20, + "end": 81, + "type": "FULL" + }, + { + "start": 36, + "end": 79, "type": "SHORT" } ] diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.Snippets/ModelArmorClientSnippets.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.Snippets/ModelArmorClientSnippets.g.cs index 645feb74855a..fb420fb10616 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.Snippets/ModelArmorClientSnippets.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1.Snippets/ModelArmorClientSnippets.g.cs @@ -17,6 +17,7 @@ namespace GoogleCSharpSnippets { using Google.Api.Gax; + using Google.Api.Gax.Grpc; using Google.Api.Gax.ResourceNames; using Google.Cloud.ModelArmor.V1; using Google.Protobuf.WellKnownTypes; @@ -812,6 +813,7 @@ public void SanitizeUserPromptRequestObject() TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), UserPromptData = new DataItem(), MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeUserPromptResponse response = modelArmorClient.SanitizeUserPrompt(request); @@ -831,6 +833,7 @@ public async Task SanitizeUserPromptRequestObjectAsync() TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), UserPromptData = new DataItem(), MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeUserPromptResponse response = await modelArmorClient.SanitizeUserPromptAsync(request); @@ -850,6 +853,7 @@ public void SanitizeModelResponseRequestObject() ModelResponseData = new DataItem(), UserPrompt = "", MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeModelResponseResponse response = modelArmorClient.SanitizeModelResponse(request); @@ -870,10 +874,112 @@ public async Task SanitizeModelResponseRequestObjectAsync() ModelResponseData = new DataItem(), UserPrompt = "", MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, }; // Make the request SanitizeModelResponseResponse response = await modelArmorClient.SanitizeModelResponseAsync(request); // End snippet } + + /// Snippet for StreamSanitizeUserPrompt + public async Task StreamSanitizeUserPrompt() + { + // Snippet: StreamSanitizeUserPrompt(CallSettings, BidirectionalStreamingSettings) + // Create client + ModelArmorClient modelArmorClient = ModelArmorClient.Create(); + // Initialize streaming call, retrieving the stream object + using ModelArmorClient.StreamSanitizeUserPromptStream response = modelArmorClient.StreamSanitizeUserPrompt(); + + // Sending requests and retrieving responses can be arbitrarily interleaved + // Exact sequence will depend on client/server behavior + + // Create task to do something with responses from server + Task responseHandlerTask = Task.Run(async () => + { + // Note that C# 8 code can use await foreach + AsyncResponseStream responseStream = response.GetResponseStream(); + while (await responseStream.MoveNextAsync()) + { + SanitizeUserPromptResponse responseItem = responseStream.Current; + // Do something with streamed response + } + // The response stream has completed + }); + + // Send requests to the server + bool done = false; + while (!done) + { + // Initialize a request + SanitizeUserPromptRequest request = new SanitizeUserPromptRequest + { + TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), + UserPromptData = new DataItem(), + MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, + }; + // Stream a request to the server + await response.WriteAsync(request); + // Set "done" to true when sending requests is complete + } + + // Complete writing requests to the stream + await response.WriteCompleteAsync(); + // Await the response handler + // This will complete once all server responses have been processed + await responseHandlerTask; + // End snippet + } + + /// Snippet for StreamSanitizeModelResponse + public async Task StreamSanitizeModelResponse() + { + // Snippet: StreamSanitizeModelResponse(CallSettings, BidirectionalStreamingSettings) + // Create client + ModelArmorClient modelArmorClient = ModelArmorClient.Create(); + // Initialize streaming call, retrieving the stream object + using ModelArmorClient.StreamSanitizeModelResponseStream response = modelArmorClient.StreamSanitizeModelResponse(); + + // Sending requests and retrieving responses can be arbitrarily interleaved + // Exact sequence will depend on client/server behavior + + // Create task to do something with responses from server + Task responseHandlerTask = Task.Run(async () => + { + // Note that C# 8 code can use await foreach + AsyncResponseStream responseStream = response.GetResponseStream(); + while (await responseStream.MoveNextAsync()) + { + SanitizeModelResponseResponse responseItem = responseStream.Current; + // Do something with streamed response + } + // The response stream has completed + }); + + // Send requests to the server + bool done = false; + while (!done) + { + // Initialize a request + SanitizeModelResponseRequest request = new SanitizeModelResponseRequest + { + TemplateName = TemplateName.FromProjectLocationTemplate("[PROJECT]", "[LOCATION]", "[TEMPLATE]"), + ModelResponseData = new DataItem(), + UserPrompt = "", + MultiLanguageDetectionMetadata = new MultiLanguageDetectionMetadata(), + StreamingMode = StreamingMode.Unspecified, + }; + // Stream a request to the server + await response.WriteAsync(request); + // Set "done" to true when sending requests is complete + } + + // Complete writing requests to the stream + await response.WriteCompleteAsync(); + // Await the response handler + // This will complete once all server responses have been processed + await responseHandlerTask; + // End snippet + } } } diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ModelArmorClient.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ModelArmorClient.g.cs index 5f9b42447d50..583027bce82a 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ModelArmorClient.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ModelArmorClient.g.cs @@ -57,6 +57,10 @@ private ModelArmorSettings(ModelArmorSettings existing) : base(existing) UpdateFloorSettingSettings = existing.UpdateFloorSettingSettings; SanitizeUserPromptSettings = existing.SanitizeUserPromptSettings; SanitizeModelResponseSettings = existing.SanitizeModelResponseSettings; + StreamSanitizeUserPromptSettings = existing.StreamSanitizeUserPromptSettings; + StreamSanitizeUserPromptStreamingSettings = existing.StreamSanitizeUserPromptStreamingSettings; + StreamSanitizeModelResponseSettings = existing.StreamSanitizeModelResponseSettings; + StreamSanitizeModelResponseStreamingSettings = existing.StreamSanitizeModelResponseStreamingSettings; LocationsSettings = existing.LocationsSettings; OnCopy(existing); } @@ -201,6 +205,46 @@ private ModelArmorSettings(ModelArmorSettings existing) : base(existing) /// public gaxgrpc::CallSettings SanitizeModelResponseSettings { get; set; } = gaxgrpc::CallSettingsExtensions.WithRetry(gaxgrpc::CallSettings.FromExpiration(gax::Expiration.FromTimeout(sys::TimeSpan.FromMilliseconds(60000))), gaxgrpc::RetrySettings.FromExponentialBackoff(maxAttempts: 5, initialBackoff: sys::TimeSpan.FromMilliseconds(1000), maxBackoff: sys::TimeSpan.FromMilliseconds(10000), backoffMultiplier: 1.3, retryFilter: gaxgrpc::RetrySettings.FilterForStatusCodes(grpccore::StatusCode.Unavailable))); + /// + /// for synchronous and asynchronous calls to + /// ModelArmorClient.StreamSanitizeUserPrompt and ModelArmorClient.StreamSanitizeUserPromptAsync. + /// + /// + /// + /// This call will not be retried. + /// No timeout is applied. + /// + /// + public gaxgrpc::CallSettings StreamSanitizeUserPromptSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None); + + /// + /// for calls to + /// ModelArmorClient.StreamSanitizeUserPrompt and ModelArmorClient.StreamSanitizeUserPromptAsync. + /// + /// The default local send queue size is 100. + public gaxgrpc::BidirectionalStreamingSettings StreamSanitizeUserPromptStreamingSettings { get; set; } = new gaxgrpc::BidirectionalStreamingSettings(100); + + /// + /// for synchronous and asynchronous calls to + /// ModelArmorClient.StreamSanitizeModelResponse and ModelArmorClient.StreamSanitizeModelResponseAsync + /// . + /// + /// + /// + /// This call will not be retried. + /// No timeout is applied. + /// + /// + public gaxgrpc::CallSettings StreamSanitizeModelResponseSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None); + + /// + /// for calls to + /// ModelArmorClient.StreamSanitizeModelResponse and ModelArmorClient.StreamSanitizeModelResponseAsync + /// . + /// + /// The default local send queue size is 100. + public gaxgrpc::BidirectionalStreamingSettings StreamSanitizeModelResponseStreamingSettings { get; set; } = new gaxgrpc::BidirectionalStreamingSettings(100); + /// /// The settings to use for the associated with the client. /// @@ -1212,6 +1256,40 @@ public virtual SanitizeModelResponseResponse SanitizeModelResponse(SanitizeModel /// A Task containing the RPC response. public virtual stt::Task SanitizeModelResponseAsync(SanitizeModelResponseRequest request, st::CancellationToken cancellationToken) => SanitizeModelResponseAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken)); + + /// + /// Bidirectional streaming methods for + /// . + /// + public abstract partial class StreamSanitizeUserPromptStream : gaxgrpc::BidirectionalStreamingBase + { + } + + /// + /// Streaming version of Sanitize User Prompt. + /// + /// If not null, applies overrides to this RPC call. + /// If not null, applies streaming overrides to this RPC call. + /// The client-server stream. + public virtual StreamSanitizeUserPromptStream StreamSanitizeUserPrompt(gaxgrpc::CallSettings callSettings = null, gaxgrpc::BidirectionalStreamingSettings streamingSettings = null) => + throw new sys::NotImplementedException(); + + /// + /// Bidirectional streaming methods for + /// . + /// + public abstract partial class StreamSanitizeModelResponseStream : gaxgrpc::BidirectionalStreamingBase + { + } + + /// + /// Streaming version of Sanitizes Model Response. + /// + /// If not null, applies overrides to this RPC call. + /// If not null, applies streaming overrides to this RPC call. + /// The client-server stream. + public virtual StreamSanitizeModelResponseStream StreamSanitizeModelResponse(gaxgrpc::CallSettings callSettings = null, gaxgrpc::BidirectionalStreamingSettings streamingSettings = null) => + throw new sys::NotImplementedException(); } /// ModelArmor client wrapper implementation, for convenient use. @@ -1238,6 +1316,10 @@ public sealed partial class ModelArmorClientImpl : ModelArmorClient private readonly gaxgrpc::ApiCall _callSanitizeModelResponse; + private readonly gaxgrpc::ApiBidirectionalStreamingCall _callStreamSanitizeUserPrompt; + + private readonly gaxgrpc::ApiBidirectionalStreamingCall _callStreamSanitizeModelResponse; + /// /// Constructs a client wrapper for the ModelArmor service, with the specified gRPC client and settings. /// @@ -1281,11 +1363,19 @@ public ModelArmorClientImpl(ModelArmor.ModelArmorClient grpcClient, ModelArmorSe _callSanitizeModelResponse = clientHelper.BuildApiCall("SanitizeModelResponse", grpcClient.SanitizeModelResponseAsync, grpcClient.SanitizeModelResponse, effectiveSettings.SanitizeModelResponseSettings).WithGoogleRequestParam("name", request => request.Name); Modify_ApiCall(ref _callSanitizeModelResponse); Modify_SanitizeModelResponseApiCall(ref _callSanitizeModelResponse); + _callStreamSanitizeUserPrompt = clientHelper.BuildApiCall("StreamSanitizeUserPrompt", grpcClient.StreamSanitizeUserPrompt, effectiveSettings.StreamSanitizeUserPromptSettings, effectiveSettings.StreamSanitizeUserPromptStreamingSettings); + Modify_ApiCall(ref _callStreamSanitizeUserPrompt); + Modify_StreamSanitizeUserPromptApiCall(ref _callStreamSanitizeUserPrompt); + _callStreamSanitizeModelResponse = clientHelper.BuildApiCall("StreamSanitizeModelResponse", grpcClient.StreamSanitizeModelResponse, effectiveSettings.StreamSanitizeModelResponseSettings, effectiveSettings.StreamSanitizeModelResponseStreamingSettings); + Modify_ApiCall(ref _callStreamSanitizeModelResponse); + Modify_StreamSanitizeModelResponseApiCall(ref _callStreamSanitizeModelResponse); OnConstruction(grpcClient, effectiveSettings, clientHelper); } partial void Modify_ApiCall(ref gaxgrpc::ApiCall call) where TRequest : class, proto::IMessage where TResponse : class, proto::IMessage; + partial void Modify_ApiCall(ref gaxgrpc::ApiBidirectionalStreamingCall call) where TRequest : class, proto::IMessage where TResponse : class, proto::IMessage; + partial void Modify_ListTemplatesApiCall(ref gaxgrpc::ApiCall call); partial void Modify_GetTemplateApiCall(ref gaxgrpc::ApiCall call); @@ -1304,6 +1394,10 @@ public ModelArmorClientImpl(ModelArmor.ModelArmorClient grpcClient, ModelArmorSe partial void Modify_SanitizeModelResponseApiCall(ref gaxgrpc::ApiCall call); + partial void Modify_StreamSanitizeUserPromptApiCall(ref gaxgrpc::ApiBidirectionalStreamingCall call); + + partial void Modify_StreamSanitizeModelResponseApiCall(ref gaxgrpc::ApiBidirectionalStreamingCall call); + partial void OnConstruction(ModelArmor.ModelArmorClient grpcClient, ModelArmorSettings effectiveSettings, gaxgrpc::ClientHelper clientHelper); /// The underlying gRPC ModelArmor client @@ -1330,6 +1424,14 @@ public ModelArmorClientImpl(ModelArmor.ModelArmorClient grpcClient, ModelArmorSe partial void Modify_SanitizeModelResponseRequest(ref SanitizeModelResponseRequest request, ref gaxgrpc::CallSettings settings); + partial void Modify_SanitizeUserPromptRequestCallSettings(ref gaxgrpc::CallSettings settings); + + partial void Modify_SanitizeUserPromptRequestRequest(ref SanitizeUserPromptRequest request); + + partial void Modify_SanitizeModelResponseRequestCallSettings(ref gaxgrpc::CallSettings settings); + + partial void Modify_SanitizeModelResponseRequestRequest(ref SanitizeModelResponseRequest request); + /// /// Lists Templates in a given project and location. /// @@ -1545,6 +1647,126 @@ public override SanitizeModelResponseResponse SanitizeModelResponse(SanitizeMode Modify_SanitizeModelResponseRequest(ref request, ref callSettings); return _callSanitizeModelResponse.Async(request, callSettings); } + + internal sealed partial class StreamSanitizeUserPromptStreamImpl : StreamSanitizeUserPromptStream + { + /// Construct the bidirectional streaming method for StreamSanitizeUserPrompt. + /// The service containing this streaming method. + /// The underlying gRPC duplex streaming call. + /// + /// The instance associated + /// with this streaming call. + /// + public StreamSanitizeUserPromptStreamImpl(ModelArmorClientImpl service, grpccore::AsyncDuplexStreamingCall call, gaxgrpc::BufferedClientStreamWriter writeBuffer) + { + _service = service; + GrpcCall = call; + _writeBuffer = writeBuffer; + } + + private ModelArmorClientImpl _service; + + private gaxgrpc::BufferedClientStreamWriter _writeBuffer; + + public override grpccore::AsyncDuplexStreamingCall GrpcCall { get; } + + private SanitizeUserPromptRequest ModifyRequest(SanitizeUserPromptRequest request) + { + _service.Modify_SanitizeUserPromptRequestRequest(ref request); + return request; + } + + public override stt::Task TryWriteAsync(SanitizeUserPromptRequest message) => + _writeBuffer.TryWriteAsync(ModifyRequest(message)); + + public override stt::Task WriteAsync(SanitizeUserPromptRequest message) => + _writeBuffer.WriteAsync(ModifyRequest(message)); + + public override stt::Task TryWriteAsync(SanitizeUserPromptRequest message, grpccore::WriteOptions options) => + _writeBuffer.TryWriteAsync(ModifyRequest(message), options); + + public override stt::Task WriteAsync(SanitizeUserPromptRequest message, grpccore::WriteOptions options) => + _writeBuffer.WriteAsync(ModifyRequest(message), options); + + public override stt::Task TryWriteCompleteAsync() => _writeBuffer.TryWriteCompleteAsync(); + + public override stt::Task WriteCompleteAsync() => _writeBuffer.WriteCompleteAsync(); + } + + /// + /// Streaming version of Sanitize User Prompt. + /// + /// If not null, applies overrides to this RPC call. + /// If not null, applies streaming overrides to this RPC call. + /// The client-server stream. + public override ModelArmorClient.StreamSanitizeUserPromptStream StreamSanitizeUserPrompt(gaxgrpc::CallSettings callSettings = null, gaxgrpc::BidirectionalStreamingSettings streamingSettings = null) + { + Modify_SanitizeUserPromptRequestCallSettings(ref callSettings); + gaxgrpc::BidirectionalStreamingSettings effectiveStreamingSettings = streamingSettings ?? _callStreamSanitizeUserPrompt.StreamingSettings; + grpccore::AsyncDuplexStreamingCall call = _callStreamSanitizeUserPrompt.Call(callSettings); + gaxgrpc::BufferedClientStreamWriter writeBuffer = new gaxgrpc::BufferedClientStreamWriter(call.RequestStream, effectiveStreamingSettings.BufferedClientWriterCapacity); + return new StreamSanitizeUserPromptStreamImpl(this, call, writeBuffer); + } + + internal sealed partial class StreamSanitizeModelResponseStreamImpl : StreamSanitizeModelResponseStream + { + /// Construct the bidirectional streaming method for StreamSanitizeModelResponse. + /// The service containing this streaming method. + /// The underlying gRPC duplex streaming call. + /// + /// The instance associated + /// with this streaming call. + /// + public StreamSanitizeModelResponseStreamImpl(ModelArmorClientImpl service, grpccore::AsyncDuplexStreamingCall call, gaxgrpc::BufferedClientStreamWriter writeBuffer) + { + _service = service; + GrpcCall = call; + _writeBuffer = writeBuffer; + } + + private ModelArmorClientImpl _service; + + private gaxgrpc::BufferedClientStreamWriter _writeBuffer; + + public override grpccore::AsyncDuplexStreamingCall GrpcCall { get; } + + private SanitizeModelResponseRequest ModifyRequest(SanitizeModelResponseRequest request) + { + _service.Modify_SanitizeModelResponseRequestRequest(ref request); + return request; + } + + public override stt::Task TryWriteAsync(SanitizeModelResponseRequest message) => + _writeBuffer.TryWriteAsync(ModifyRequest(message)); + + public override stt::Task WriteAsync(SanitizeModelResponseRequest message) => + _writeBuffer.WriteAsync(ModifyRequest(message)); + + public override stt::Task TryWriteAsync(SanitizeModelResponseRequest message, grpccore::WriteOptions options) => + _writeBuffer.TryWriteAsync(ModifyRequest(message), options); + + public override stt::Task WriteAsync(SanitizeModelResponseRequest message, grpccore::WriteOptions options) => + _writeBuffer.WriteAsync(ModifyRequest(message), options); + + public override stt::Task TryWriteCompleteAsync() => _writeBuffer.TryWriteCompleteAsync(); + + public override stt::Task WriteCompleteAsync() => _writeBuffer.WriteCompleteAsync(); + } + + /// + /// Streaming version of Sanitizes Model Response. + /// + /// If not null, applies overrides to this RPC call. + /// If not null, applies streaming overrides to this RPC call. + /// The client-server stream. + public override ModelArmorClient.StreamSanitizeModelResponseStream StreamSanitizeModelResponse(gaxgrpc::CallSettings callSettings = null, gaxgrpc::BidirectionalStreamingSettings streamingSettings = null) + { + Modify_SanitizeModelResponseRequestCallSettings(ref callSettings); + gaxgrpc::BidirectionalStreamingSettings effectiveStreamingSettings = streamingSettings ?? _callStreamSanitizeModelResponse.StreamingSettings; + grpccore::AsyncDuplexStreamingCall call = _callStreamSanitizeModelResponse.Call(callSettings); + gaxgrpc::BufferedClientStreamWriter writeBuffer = new gaxgrpc::BufferedClientStreamWriter(call.RequestStream, effectiveStreamingSettings.BufferedClientWriterCapacity); + return new StreamSanitizeModelResponseStreamImpl(this, call, writeBuffer); + } } public partial class ListTemplatesRequest : gaxgrpc::IPageRequest diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/Service.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/Service.g.cs index d2085519d747..5fb96cd5e320 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/Service.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/Service.g.cs @@ -30,341 +30,356 @@ static ServiceReflection() { "cGkvZmllbGRfYmVoYXZpb3IucHJvdG8aG2dvb2dsZS9hcGkvZmllbGRfaW5m", "by5wcm90bxoZZ29vZ2xlL2FwaS9yZXNvdXJjZS5wcm90bxobZ29vZ2xlL3By", "b3RvYnVmL2VtcHR5LnByb3RvGiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFz", - "ay5wcm90bxofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byL1CQoI", - "VGVtcGxhdGUSEQoEbmFtZRgBIAEoCUID4EEIEjQKC2NyZWF0ZV90aW1lGAIg", - "ASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEjQKC3VwZGF0", - "ZV90aW1lGAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EED", - "EkUKBmxhYmVscxgEIAMoCzIwLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYx", - "LlRlbXBsYXRlLkxhYmVsc0VudHJ5QgPgQQESRAoNZmlsdGVyX2NvbmZpZxgF", - "IAEoCzIoLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZpbHRlckNvbmZp", - "Z0ID4EECElUKEXRlbXBsYXRlX21ldGFkYXRhGAYgASgLMjUuZ29vZ2xlLmNs", - "b3VkLm1vZGVsYXJtb3IudjEuVGVtcGxhdGUuVGVtcGxhdGVNZXRhZGF0YUID", - "4EEBGtoFChBUZW1wbGF0ZU1ldGFkYXRhEi8KImlnbm9yZV9wYXJ0aWFsX2lu", - "dm9jYXRpb25fZmFpbHVyZXMYASABKAhCA+BBARIsCh9jdXN0b21fcHJvbXB0", - "X3NhZmV0eV9lcnJvcl9jb2RlGAIgASgFQgPgQQESLwoiY3VzdG9tX3Byb21w", - "dF9zYWZldHlfZXJyb3JfbWVzc2FnZRgDIAEoCUID4EEBEjIKJWN1c3RvbV9s", - "bG1fcmVzcG9uc2Vfc2FmZXR5X2Vycm9yX2NvZGUYBCABKAVCA+BBARI1Cihj", - "dXN0b21fbGxtX3Jlc3BvbnNlX3NhZmV0eV9lcnJvcl9tZXNzYWdlGAUgASgJ", - "QgPgQQESJAoXbG9nX3RlbXBsYXRlX29wZXJhdGlvbnMYBiABKAhCA+BBARIk", - "Chdsb2dfc2FuaXRpemVfb3BlcmF0aW9ucxgHIAEoCEID4EEBEmQKEGVuZm9y", - "Y2VtZW50X3R5cGUYCCABKA4yRS5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52", - "MS5UZW1wbGF0ZS5UZW1wbGF0ZU1ldGFkYXRhLkVuZm9yY2VtZW50VHlwZUID", - "4EEBEnMKGG11bHRpX2xhbmd1YWdlX2RldGVjdGlvbhgJIAEoCzJMLmdvb2ds", - "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLlRlbXBsYXRlLlRlbXBsYXRlTWV0YWRh", - "dGEuTXVsdGlMYW5ndWFnZURldGVjdGlvbkID4EEBGkYKFk11bHRpTGFuZ3Vh", - "Z2VEZXRlY3Rpb24SLAofZW5hYmxlX211bHRpX2xhbmd1YWdlX2RldGVjdGlv", - "bhgBIAEoCEID4EECIlwKD0VuZm9yY2VtZW50VHlwZRIgChxFTkZPUkNFTUVO", - "VF9UWVBFX1VOU1BFQ0lGSUVEEAASEAoMSU5TUEVDVF9PTkxZEAESFQoRSU5T", - "UEVDVF9BTkRfQkxPQ0sQAhotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkS", - "DQoFdmFsdWUYAiABKAk6AjgBOnrqQXcKIm1vZGVsYXJtb3IuZ29vZ2xlYXBp", - "cy5jb20vVGVtcGxhdGUSPHByb2plY3RzL3twcm9qZWN0fS9sb2NhdGlvbnMv", - "e2xvY2F0aW9ufS90ZW1wbGF0ZXMve3RlbXBsYXRlfSoJdGVtcGxhdGVzMgh0", - "ZW1wbGF0ZSKLCQoMRmxvb3JTZXR0aW5nEhEKBG5hbWUYASABKAlCA+BBCBI0", - "CgtjcmVhdGVfdGltZRgCIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3Rh", - "bXBCA+BBAxI0Cgt1cGRhdGVfdGltZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1", - "Zi5UaW1lc3RhbXBCA+BBAxJECg1maWx0ZXJfY29uZmlnGAQgASgLMiguZ29v", - "Z2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyQ29uZmlnQgPgQQISMgog", - "ZW5hYmxlX2Zsb29yX3NldHRpbmdfZW5mb3JjZW1lbnQYBSABKAhCA+BBAUgA", - "iAEBElwKE2ludGVncmF0ZWRfc2VydmljZXMYBiADKA4yOi5nb29nbGUuY2xv", - "dWQubW9kZWxhcm1vci52MS5GbG9vclNldHRpbmcuSW50ZWdyYXRlZFNlcnZp", - "Y2VCA+BBARJfChlhaV9wbGF0Zm9ybV9mbG9vcl9zZXR0aW5nGAcgASgLMjIu", - "Z29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuQWlQbGF0Zm9ybUZsb29yU2V0", - "dGluZ0ID4EEBSAGIAQESYgoWZmxvb3Jfc2V0dGluZ19tZXRhZGF0YRgIIAEo", - "CzI9Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZsb29yU2V0dGluZy5G", - "bG9vclNldHRpbmdNZXRhZGF0YUID4EEBGtsBChRGbG9vclNldHRpbmdNZXRh", - "ZGF0YRJ7ChhtdWx0aV9sYW5ndWFnZV9kZXRlY3Rpb24YASABKAsyVC5nb29n", - "bGUuY2xvdWQubW9kZWxhcm1vci52MS5GbG9vclNldHRpbmcuRmxvb3JTZXR0", - "aW5nTWV0YWRhdGEuTXVsdGlMYW5ndWFnZURldGVjdGlvbkID4EEBGkYKFk11", - "bHRpTGFuZ3VhZ2VEZXRlY3Rpb24SLAofZW5hYmxlX211bHRpX2xhbmd1YWdl", - "X2RldGVjdGlvbhgBIAEoCEID4EECIkgKEUludGVncmF0ZWRTZXJ2aWNlEiIK", - "HklOVEVHUkFURURfU0VSVklDRV9VTlNQRUNJRklFRBAAEg8KC0FJX1BMQVRG", - "T1JNEAE68wHqQe8BCiZtb2RlbGFybW9yLmdvb2dsZWFwaXMuY29tL0Zsb29y", - "U2V0dGluZxI0cHJvamVjdHMve3Byb2plY3R9L2xvY2F0aW9ucy97bG9jYXRp", - "b259L2Zsb29yU2V0dGluZxIyZm9sZGVycy97Zm9sZGVyfS9sb2NhdGlvbnMv", - "e2xvY2F0aW9ufS9mbG9vclNldHRpbmcSPm9yZ2FuaXphdGlvbnMve29yZ2Fu", - "aXphdGlvbn0vbG9jYXRpb25zL3tsb2NhdGlvbn0vZmxvb3JTZXR0aW5nKg1m", - "bG9vclNldHRpbmdzMgxmbG9vclNldHRpbmdCIwohX2VuYWJsZV9mbG9vcl9z", - "ZXR0aW5nX2VuZm9yY2VtZW50QhwKGl9haV9wbGF0Zm9ybV9mbG9vcl9zZXR0", - "aW5nIo4BChZBaVBsYXRmb3JtRmxvb3JTZXR0aW5nEhsKDGluc3BlY3Rfb25s", - "eRgBIAEoCEID4EEBSAASIAoRaW5zcGVjdF9hbmRfYmxvY2sYAiABKAhCA+BB", - "AUgAEiEKFGVuYWJsZV9jbG91ZF9sb2dnaW5nGAMgASgIQgPgQQFCEgoQZW5m", - "b3JjZW1lbnRfdHlwZSKvAQoUTGlzdFRlbXBsYXRlc1JlcXVlc3QSOgoGcGFy", - "ZW50GAEgASgJQirgQQL6QSQSIm1vZGVsYXJtb3IuZ29vZ2xlYXBpcy5jb20v", - "VGVtcGxhdGUSFgoJcGFnZV9zaXplGAIgASgFQgPgQQESFwoKcGFnZV90b2tl", - "bhgDIAEoCUID4EEBEhMKBmZpbHRlchgEIAEoCUID4EEBEhUKCG9yZGVyX2J5", - "GAUgASgJQgPgQQEifgoVTGlzdFRlbXBsYXRlc1Jlc3BvbnNlEjcKCXRlbXBs", - "YXRlcxgBIAMoCzIkLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlRlbXBs", - "YXRlEhcKD25leHRfcGFnZV90b2tlbhgCIAEoCRITCgt1bnJlYWNoYWJsZRgD", - "IAMoCSJOChJHZXRUZW1wbGF0ZVJlcXVlc3QSOAoEbmFtZRgBIAEoCUIq4EEC", - "+kEkCiJtb2RlbGFybW9yLmdvb2dsZWFwaXMuY29tL1RlbXBsYXRlIssBChVD", - "cmVhdGVUZW1wbGF0ZVJlcXVlc3QSOgoGcGFyZW50GAEgASgJQirgQQL6QSQS", - "Im1vZGVsYXJtb3IuZ29vZ2xlYXBpcy5jb20vVGVtcGxhdGUSGAoLdGVtcGxh", - "dGVfaWQYAiABKAlCA+BBAhI7Cgh0ZW1wbGF0ZRgDIAEoCzIkLmdvb2dsZS5j", - "bG91ZC5tb2RlbGFybW9yLnYxLlRlbXBsYXRlQgPgQQISHwoKcmVxdWVzdF9p", - "ZBgEIAEoCUIL4EEB4ozP1wgCCAEiqwEKFVVwZGF0ZVRlbXBsYXRlUmVxdWVz", - "dBI0Cgt1cGRhdGVfbWFzaxgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5GaWVs", - "ZE1hc2tCA+BBAhI7Cgh0ZW1wbGF0ZRgCIAEoCzIkLmdvb2dsZS5jbG91ZC5t", - "b2RlbGFybW9yLnYxLlRlbXBsYXRlQgPgQQISHwoKcmVxdWVzdF9pZBgDIAEo", - "CUIL4EEB4ozP1wgCCAEicgoVRGVsZXRlVGVtcGxhdGVSZXF1ZXN0EjgKBG5h", - "bWUYASABKAlCKuBBAvpBJAoibW9kZWxhcm1vci5nb29nbGVhcGlzLmNvbS9U", - "ZW1wbGF0ZRIfCgpyZXF1ZXN0X2lkGAIgASgJQgvgQQHijM/XCAIIASJWChZH", - "ZXRGbG9vclNldHRpbmdSZXF1ZXN0EjwKBG5hbWUYASABKAlCLuBBAvpBKAom", - "bW9kZWxhcm1vci5nb29nbGVhcGlzLmNvbS9GbG9vclNldHRpbmcilwEKGVVw", - "ZGF0ZUZsb29yU2V0dGluZ1JlcXVlc3QSRAoNZmxvb3Jfc2V0dGluZxgBIAEo", - "CzIoLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZsb29yU2V0dGluZ0ID", - "4EECEjQKC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLkZp", - "ZWxkTWFza0ID4EEBIu8CCgxGaWx0ZXJDb25maWcSSAoMcmFpX3NldHRpbmdz", - "GAEgASgLMi0uZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuUmFpRmlsdGVy", - "U2V0dGluZ3NCA+BBARJICgxzZHBfc2V0dGluZ3MYAiABKAsyLS5nb29nbGUu", - "Y2xvdWQubW9kZWxhcm1vci52MS5TZHBGaWx0ZXJTZXR0aW5nc0ID4EEBEmcK", - "IHBpX2FuZF9qYWlsYnJlYWtfZmlsdGVyX3NldHRpbmdzGAMgASgLMjguZ29v", - "Z2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuUGlBbmRKYWlsYnJlYWtGaWx0ZXJT", - "ZXR0aW5nc0ID4EEBEmIKHW1hbGljaW91c191cmlfZmlsdGVyX3NldHRpbmdz", - "GAQgASgLMjYuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuTWFsaWNpb3Vz", - "VXJpRmlsdGVyU2V0dGluZ3NCA+BBASLhAgocUGlBbmRKYWlsYnJlYWtGaWx0", - "ZXJTZXR0aW5ncxJ5ChJmaWx0ZXJfZW5mb3JjZW1lbnQYASABKA4yWC5nb29n", - "bGUuY2xvdWQubW9kZWxhcm1vci52MS5QaUFuZEphaWxicmVha0ZpbHRlclNl", - "dHRpbmdzLlBpQW5kSmFpbGJyZWFrRmlsdGVyRW5mb3JjZW1lbnRCA+BBARJT", - "ChBjb25maWRlbmNlX2xldmVsGAMgASgOMjQuZ29vZ2xlLmNsb3VkLm1vZGVs", - "YXJtb3IudjEuRGV0ZWN0aW9uQ29uZmlkZW5jZUxldmVsQgPgQQEicQofUGlB", - "bmRKYWlsYnJlYWtGaWx0ZXJFbmZvcmNlbWVudBIzCi9QSV9BTkRfSkFJTEJS", - "RUFLX0ZJTFRFUl9FTkZPUkNFTUVOVF9VTlNQRUNJRklFRBAAEgsKB0VOQUJM", - "RUQQARIMCghESVNBQkxFRBACIoECChpNYWxpY2lvdXNVcmlGaWx0ZXJTZXR0", - "aW5ncxJ1ChJmaWx0ZXJfZW5mb3JjZW1lbnQYASABKA4yVC5nb29nbGUuY2xv", - "dWQubW9kZWxhcm1vci52MS5NYWxpY2lvdXNVcmlGaWx0ZXJTZXR0aW5ncy5N", - "YWxpY2lvdXNVcmlGaWx0ZXJFbmZvcmNlbWVudEID4EEBImwKHU1hbGljaW91", - "c1VyaUZpbHRlckVuZm9yY2VtZW50EjAKLE1BTElDSU9VU19VUklfRklMVEVS", - "X0VORk9SQ0VNRU5UX1VOU1BFQ0lGSUVEEAASCwoHRU5BQkxFRBABEgwKCERJ", - "U0FCTEVEEAIijgIKEVJhaUZpbHRlclNldHRpbmdzElEKC3JhaV9maWx0ZXJz", - "GAEgAygLMjcuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuUmFpRmlsdGVy", - "U2V0dGluZ3MuUmFpRmlsdGVyQgPgQQIapQEKCVJhaUZpbHRlchJDCgtmaWx0", - "ZXJfdHlwZRgBIAEoDjIpLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlJh", - "aUZpbHRlclR5cGVCA+BBAhJTChBjb25maWRlbmNlX2xldmVsGAIgASgOMjQu", - "Z29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRGV0ZWN0aW9uQ29uZmlkZW5j", - "ZUxldmVsQgPgQQEiwAEKEVNkcEZpbHRlclNldHRpbmdzEkcKDGJhc2ljX2Nv", - "bmZpZxgBIAEoCzIqLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNkcEJh", - "c2ljQ29uZmlnQgPgQQFIABJNCg9hZHZhbmNlZF9jb25maWcYAiABKAsyLS5n", - "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5TZHBBZHZhbmNlZENvbmZpZ0ID", - "4EEBSABCEwoRc2RwX2NvbmZpZ3VyYXRpb24i3QEKDlNkcEJhc2ljQ29uZmln", - "EmUKEmZpbHRlcl9lbmZvcmNlbWVudBgDIAEoDjJELmdvb2dsZS5jbG91ZC5t", - "b2RlbGFybW9yLnYxLlNkcEJhc2ljQ29uZmlnLlNkcEJhc2ljQ29uZmlnRW5m", - "b3JjZW1lbnRCA+BBASJkChlTZHBCYXNpY0NvbmZpZ0VuZm9yY2VtZW50EiwK", - "KFNEUF9CQVNJQ19DT05GSUdfRU5GT1JDRU1FTlRfVU5TUEVDSUZJRUQQABIL", - "CgdFTkFCTEVEEAESDAoIRElTQUJMRUQQAiJUChFTZHBBZHZhbmNlZENvbmZp", - "ZxIdChBpbnNwZWN0X3RlbXBsYXRlGAEgASgJQgPgQQESIAoTZGVpZGVudGlm", - "eV90ZW1wbGF0ZRgCIAEoCUID4EEBIoYCChlTYW5pdGl6ZVVzZXJQcm9tcHRS", - "ZXF1ZXN0EjgKBG5hbWUYASABKAlCKuBBAvpBJAoibW9kZWxhcm1vci5nb29n", - "bGVhcGlzLmNvbS9UZW1wbGF0ZRJDChB1c2VyX3Byb21wdF9kYXRhGAIgASgL", - "MiQuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRGF0YUl0ZW1CA+BBAhJq", - "CiFtdWx0aV9sYW5ndWFnZV9kZXRlY3Rpb25fbWV0YWRhdGEYBiABKAsyOi5n", - "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5NdWx0aUxhbmd1YWdlRGV0ZWN0", - "aW9uTWV0YWRhdGFCA+BBASKmAgocU2FuaXRpemVNb2RlbFJlc3BvbnNlUmVx", - "dWVzdBI4CgRuYW1lGAEgASgJQirgQQL6QSQKIm1vZGVsYXJtb3IuZ29vZ2xl", - "YXBpcy5jb20vVGVtcGxhdGUSRgoTbW9kZWxfcmVzcG9uc2VfZGF0YRgCIAEo", - "CzIkLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkRhdGFJdGVtQgPgQQIS", - "GAoLdXNlcl9wcm9tcHQYBCABKAlCA+BBARJqCiFtdWx0aV9sYW5ndWFnZV9k", - "ZXRlY3Rpb25fbWV0YWRhdGEYByABKAsyOi5nb29nbGUuY2xvdWQubW9kZWxh", - "cm1vci52MS5NdWx0aUxhbmd1YWdlRGV0ZWN0aW9uTWV0YWRhdGFCA+BBASJu", - "ChpTYW5pdGl6ZVVzZXJQcm9tcHRSZXNwb25zZRJQChNzYW5pdGl6YXRpb25f", - "cmVzdWx0GAEgASgLMi4uZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuU2Fu", - "aXRpemF0aW9uUmVzdWx0QgPgQQMicQodU2FuaXRpemVNb2RlbFJlc3BvbnNl", - "UmVzcG9uc2USUAoTc2FuaXRpemF0aW9uX3Jlc3VsdBgBIAEoCzIuLmdvb2ds", - "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNhbml0aXphdGlvblJlc3VsdEID4EED", - "IskEChJTYW5pdGl6YXRpb25SZXN1bHQSTQoSZmlsdGVyX21hdGNoX3N0YXRl", - "GAEgASgOMiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyTWF0", - "Y2hTdGF0ZUID4EEDEl4KDmZpbHRlcl9yZXN1bHRzGAIgAygLMkEuZ29vZ2xl", - "LmNsb3VkLm1vZGVsYXJtb3IudjEuU2FuaXRpemF0aW9uUmVzdWx0LkZpbHRl", - "clJlc3VsdHNFbnRyeUID4EEDEkwKEWludm9jYXRpb25fcmVzdWx0GAQgASgO", - "MiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuSW52b2NhdGlvblJlc3Vs", - "dEID4EEDEmcKFXNhbml0aXphdGlvbl9tZXRhZGF0YRgDIAEoCzJDLmdvb2ds", - "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNhbml0aXphdGlvblJlc3VsdC5TYW5p", - "dGl6YXRpb25NZXRhZGF0YUID4EEDGm0KFFNhbml0aXphdGlvbk1ldGFkYXRh", - "EhIKCmVycm9yX2NvZGUYASABKAMSFQoNZXJyb3JfbWVzc2FnZRgCIAEoCRIq", - "CiJpZ25vcmVfcGFydGlhbF9pbnZvY2F0aW9uX2ZhaWx1cmVzGAMgASgIGl4K", - "EkZpbHRlclJlc3VsdHNFbnRyeRILCgNrZXkYASABKAkSNwoFdmFsdWUYAiAB", - "KAsyKC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJSZXN1bHQ6", - "AjgBImwKHk11bHRpTGFuZ3VhZ2VEZXRlY3Rpb25NZXRhZGF0YRIcCg9zb3Vy", - "Y2VfbGFuZ3VhZ2UYASABKAlCA+BBARIsCh9lbmFibGVfbXVsdGlfbGFuZ3Vh", - "Z2VfZGV0ZWN0aW9uGAIgASgIQgPgQQEinAQKDEZpbHRlclJlc3VsdBJIChFy", - "YWlfZmlsdGVyX3Jlc3VsdBgBIAEoCzIrLmdvb2dsZS5jbG91ZC5tb2RlbGFy", - "bW9yLnYxLlJhaUZpbHRlclJlc3VsdEgAEkgKEXNkcF9maWx0ZXJfcmVzdWx0", - "GAIgASgLMisuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuU2RwRmlsdGVy", - "UmVzdWx0SAASYAoecGlfYW5kX2phaWxicmVha19maWx0ZXJfcmVzdWx0GAMg", - "ASgLMjYuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuUGlBbmRKYWlsYnJl", - "YWtGaWx0ZXJSZXN1bHRIABJbChttYWxpY2lvdXNfdXJpX2ZpbHRlcl9yZXN1", - "bHQYBCABKAsyNC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5NYWxpY2lv", - "dXNVcmlGaWx0ZXJSZXN1bHRIABJRChljc2FtX2ZpbHRlcl9maWx0ZXJfcmVz", - "dWx0GAUgASgLMiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuQ3NhbUZp", - "bHRlclJlc3VsdEgAElUKGHZpcnVzX3NjYW5fZmlsdGVyX3Jlc3VsdBgGIAEo", - "CzIxLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlZpcnVzU2NhbkZpbHRl", - "clJlc3VsdEgAQg8KDWZpbHRlcl9yZXN1bHQivwUKD1JhaUZpbHRlclJlc3Vs", - "dBJOCg9leGVjdXRpb25fc3RhdGUYASABKA4yMC5nb29nbGUuY2xvdWQubW9k", - "ZWxhcm1vci52MS5GaWx0ZXJFeGVjdXRpb25TdGF0ZUID4EEDEj4KDW1lc3Nh", - "Z2VfaXRlbXMYAiADKAsyJy5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5N", - "ZXNzYWdlSXRlbRJGCgttYXRjaF9zdGF0ZRgDIAEoDjIsLmdvb2dsZS5jbG91", - "ZC5tb2RlbGFybW9yLnYxLkZpbHRlck1hdGNoU3RhdGVCA+BBAxJmChdyYWlf", - "ZmlsdGVyX3R5cGVfcmVzdWx0cxgEIAMoCzJFLmdvb2dsZS5jbG91ZC5tb2Rl", - "bGFybW9yLnYxLlJhaUZpbHRlclJlc3VsdC5SYWlGaWx0ZXJUeXBlUmVzdWx0", - "c0VudHJ5Gu0BChNSYWlGaWx0ZXJUeXBlUmVzdWx0Ej4KC2ZpbHRlcl90eXBl", - "GAEgASgOMikuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuUmFpRmlsdGVy", - "VHlwZRJOChBjb25maWRlbmNlX2xldmVsGAIgASgOMjQuZ29vZ2xlLmNsb3Vk", - "Lm1vZGVsYXJtb3IudjEuRGV0ZWN0aW9uQ29uZmlkZW5jZUxldmVsEkYKC21h", - "dGNoX3N0YXRlGAMgASgOMiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEu", - "RmlsdGVyTWF0Y2hTdGF0ZUID4EEDGnwKGVJhaUZpbHRlclR5cGVSZXN1bHRz", - "RW50cnkSCwoDa2V5GAEgASgJEk4KBXZhbHVlGAIgASgLMj8uZ29vZ2xlLmNs", - "b3VkLm1vZGVsYXJtb3IudjEuUmFpRmlsdGVyUmVzdWx0LlJhaUZpbHRlclR5", - "cGVSZXN1bHQ6AjgBIrEBCg9TZHBGaWx0ZXJSZXN1bHQSRgoOaW5zcGVjdF9y", - "ZXN1bHQYASABKAsyLC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5TZHBJ", - "bnNwZWN0UmVzdWx0SAASTAoRZGVpZGVudGlmeV9yZXN1bHQYAiABKAsyLy5n", - "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5TZHBEZWlkZW50aWZ5UmVzdWx0", - "SABCCAoGcmVzdWx0IsACChBTZHBJbnNwZWN0UmVzdWx0Ek4KD2V4ZWN1dGlv", - "bl9zdGF0ZRgBIAEoDjIwLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZp", - "bHRlckV4ZWN1dGlvblN0YXRlQgPgQQMSPgoNbWVzc2FnZV9pdGVtcxgCIAMo", - "CzInLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLk1lc3NhZ2VJdGVtEkYK", - "C21hdGNoX3N0YXRlGAMgASgOMiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3Iu", - "djEuRmlsdGVyTWF0Y2hTdGF0ZUID4EEDEjgKCGZpbmRpbmdzGAQgAygLMiYu", - "Z29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuU2RwRmluZGluZxIaChJmaW5k", - "aW5nc190cnVuY2F0ZWQYBSABKAgiZgoIRGF0YUl0ZW0SDgoEdGV4dBgBIAEo", - "CUgAEj0KCWJ5dGVfaXRlbRgCIAEoCzIoLmdvb2dsZS5jbG91ZC5tb2RlbGFy", - "bW9yLnYxLkJ5dGVEYXRhSXRlbUgAQgsKCWRhdGFfaXRlbSKaAgoMQnl0ZURh", - "dGFJdGVtElIKDmJ5dGVfZGF0YV90eXBlGAEgASgOMjUuZ29vZ2xlLmNsb3Vk", - "Lm1vZGVsYXJtb3IudjEuQnl0ZURhdGFJdGVtLkJ5dGVJdGVtVHlwZUID4EEC", - "EhYKCWJ5dGVfZGF0YRgCIAEoDEID4EECIp0BCgxCeXRlSXRlbVR5cGUSHgoa", - "QllURV9JVEVNX1RZUEVfVU5TUEVDSUZJRUQQABISCg5QTEFJTlRFWFRfVVRG", - "OBABEgcKA1BERhACEhEKDVdPUkRfRE9DVU1FTlQQAxISCg5FWENFTF9ET0NV", - "TUVOVBAEEhcKE1BPV0VSUE9JTlRfRE9DVU1FTlQQBRIHCgNUWFQQBhIHCgND", - "U1YQByLQAgoTU2RwRGVpZGVudGlmeVJlc3VsdBJOCg9leGVjdXRpb25fc3Rh", - "dGUYASABKA4yMC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJF", - "eGVjdXRpb25TdGF0ZUID4EEDEj4KDW1lc3NhZ2VfaXRlbXMYAiADKAsyJy5n", - "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5NZXNzYWdlSXRlbRJGCgttYXRj", - "aF9zdGF0ZRgDIAEoDjIsLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZp", - "bHRlck1hdGNoU3RhdGVCA+BBAxIyCgRkYXRhGAQgASgLMiQuZ29vZ2xlLmNs", - "b3VkLm1vZGVsYXJtb3IudjEuRGF0YUl0ZW0SGQoRdHJhbnNmb3JtZWRfYnl0", - "ZXMYBSABKAMSEgoKaW5mb190eXBlcxgGIAMoCSLEAgoKU2RwRmluZGluZxIR", - "CglpbmZvX3R5cGUYASABKAkSRAoKbGlrZWxpaG9vZBgCIAEoDjIwLmdvb2ds", - "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNkcEZpbmRpbmdMaWtlbGlob29kEksK", - "CGxvY2F0aW9uGAMgASgLMjkuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEu", - "U2RwRmluZGluZy5TZHBGaW5kaW5nTG9jYXRpb24ajwEKElNkcEZpbmRpbmdM", - "b2NhdGlvbhI5CgpieXRlX3JhbmdlGAEgASgLMiUuZ29vZ2xlLmNsb3VkLm1v", - "ZGVsYXJtb3IudjEuUmFuZ2VJbmZvEj4KD2NvZGVwb2ludF9yYW5nZRgCIAEo", - "CzIlLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlJhbmdlSW5mbyLEAgoa", - "UGlBbmRKYWlsYnJlYWtGaWx0ZXJSZXN1bHQSTgoPZXhlY3V0aW9uX3N0YXRl", - "GAEgASgOMjAuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyRXhl", - "Y3V0aW9uU3RhdGVCA+BBAxI+Cg1tZXNzYWdlX2l0ZW1zGAIgAygLMicuZ29v", - "Z2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuTWVzc2FnZUl0ZW0SRgoLbWF0Y2hf", - "c3RhdGUYAyABKA4yLC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5GaWx0", - "ZXJNYXRjaFN0YXRlQgPgQQMSTgoQY29uZmlkZW5jZV9sZXZlbBgFIAEoDjI0", - "Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkRldGVjdGlvbkNvbmZpZGVu", - "Y2VMZXZlbCLHAwoYTWFsaWNpb3VzVXJpRmlsdGVyUmVzdWx0Ek4KD2V4ZWN1", + "ay5wcm90bxofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90bxoWZ29v", + "Z2xlL3R5cGUvZGF0ZS5wcm90byL1CQoIVGVtcGxhdGUSEQoEbmFtZRgBIAEo", + "CUID4EEIEjQKC2NyZWF0ZV90aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVm", + "LlRpbWVzdGFtcEID4EEDEjQKC3VwZGF0ZV90aW1lGAMgASgLMhouZ29vZ2xl", + "LnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEkUKBmxhYmVscxgEIAMoCzIwLmdv", + "b2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlRlbXBsYXRlLkxhYmVsc0VudHJ5", + "QgPgQQESRAoNZmlsdGVyX2NvbmZpZxgFIAEoCzIoLmdvb2dsZS5jbG91ZC5t", + "b2RlbGFybW9yLnYxLkZpbHRlckNvbmZpZ0ID4EECElUKEXRlbXBsYXRlX21l", + "dGFkYXRhGAYgASgLMjUuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVGVt", + "cGxhdGUuVGVtcGxhdGVNZXRhZGF0YUID4EEBGtoFChBUZW1wbGF0ZU1ldGFk", + "YXRhEi8KImlnbm9yZV9wYXJ0aWFsX2ludm9jYXRpb25fZmFpbHVyZXMYASAB", + "KAhCA+BBARIsCh9jdXN0b21fcHJvbXB0X3NhZmV0eV9lcnJvcl9jb2RlGAIg", + "ASgFQgPgQQESLwoiY3VzdG9tX3Byb21wdF9zYWZldHlfZXJyb3JfbWVzc2Fn", + "ZRgDIAEoCUID4EEBEjIKJWN1c3RvbV9sbG1fcmVzcG9uc2Vfc2FmZXR5X2Vy", + "cm9yX2NvZGUYBCABKAVCA+BBARI1CihjdXN0b21fbGxtX3Jlc3BvbnNlX3Nh", + "ZmV0eV9lcnJvcl9tZXNzYWdlGAUgASgJQgPgQQESJAoXbG9nX3RlbXBsYXRl", + "X29wZXJhdGlvbnMYBiABKAhCA+BBARIkChdsb2dfc2FuaXRpemVfb3BlcmF0", + "aW9ucxgHIAEoCEID4EEBEmQKEGVuZm9yY2VtZW50X3R5cGUYCCABKA4yRS5n", + "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5UZW1wbGF0ZS5UZW1wbGF0ZU1l", + "dGFkYXRhLkVuZm9yY2VtZW50VHlwZUID4EEBEnMKGG11bHRpX2xhbmd1YWdl", + "X2RldGVjdGlvbhgJIAEoCzJMLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYx", + "LlRlbXBsYXRlLlRlbXBsYXRlTWV0YWRhdGEuTXVsdGlMYW5ndWFnZURldGVj", + "dGlvbkID4EEBGkYKFk11bHRpTGFuZ3VhZ2VEZXRlY3Rpb24SLAofZW5hYmxl", + "X211bHRpX2xhbmd1YWdlX2RldGVjdGlvbhgBIAEoCEID4EECIlwKD0VuZm9y", + "Y2VtZW50VHlwZRIgChxFTkZPUkNFTUVOVF9UWVBFX1VOU1BFQ0lGSUVEEAAS", + "EAoMSU5TUEVDVF9PTkxZEAESFQoRSU5TUEVDVF9BTkRfQkxPQ0sQAhotCgtM", + "YWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBOnrq", + "QXcKIm1vZGVsYXJtb3IuZ29vZ2xlYXBpcy5jb20vVGVtcGxhdGUSPHByb2pl", + "Y3RzL3twcm9qZWN0fS9sb2NhdGlvbnMve2xvY2F0aW9ufS90ZW1wbGF0ZXMv", + "e3RlbXBsYXRlfSoJdGVtcGxhdGVzMgh0ZW1wbGF0ZSKLCQoMRmxvb3JTZXR0", + "aW5nEhEKBG5hbWUYASABKAlCA+BBCBI0CgtjcmVhdGVfdGltZRgCIAEoCzIa", + "Lmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxI0Cgt1cGRhdGVfdGlt", + "ZRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxJECg1m", + "aWx0ZXJfY29uZmlnGAQgASgLMiguZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3Iu", + "djEuRmlsdGVyQ29uZmlnQgPgQQISMgogZW5hYmxlX2Zsb29yX3NldHRpbmdf", + "ZW5mb3JjZW1lbnQYBSABKAhCA+BBAUgAiAEBElwKE2ludGVncmF0ZWRfc2Vy", + "dmljZXMYBiADKA4yOi5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5GbG9v", + "clNldHRpbmcuSW50ZWdyYXRlZFNlcnZpY2VCA+BBARJfChlhaV9wbGF0Zm9y", + "bV9mbG9vcl9zZXR0aW5nGAcgASgLMjIuZ29vZ2xlLmNsb3VkLm1vZGVsYXJt", + "b3IudjEuQWlQbGF0Zm9ybUZsb29yU2V0dGluZ0ID4EEBSAGIAQESYgoWZmxv", + "b3Jfc2V0dGluZ19tZXRhZGF0YRgIIAEoCzI9Lmdvb2dsZS5jbG91ZC5tb2Rl", + "bGFybW9yLnYxLkZsb29yU2V0dGluZy5GbG9vclNldHRpbmdNZXRhZGF0YUID", + "4EEBGtsBChRGbG9vclNldHRpbmdNZXRhZGF0YRJ7ChhtdWx0aV9sYW5ndWFn", + "ZV9kZXRlY3Rpb24YASABKAsyVC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52", + "MS5GbG9vclNldHRpbmcuRmxvb3JTZXR0aW5nTWV0YWRhdGEuTXVsdGlMYW5n", + "dWFnZURldGVjdGlvbkID4EEBGkYKFk11bHRpTGFuZ3VhZ2VEZXRlY3Rpb24S", + "LAofZW5hYmxlX211bHRpX2xhbmd1YWdlX2RldGVjdGlvbhgBIAEoCEID4EEC", + "IkgKEUludGVncmF0ZWRTZXJ2aWNlEiIKHklOVEVHUkFURURfU0VSVklDRV9V", + "TlNQRUNJRklFRBAAEg8KC0FJX1BMQVRGT1JNEAE68wHqQe8BCiZtb2RlbGFy", + "bW9yLmdvb2dsZWFwaXMuY29tL0Zsb29yU2V0dGluZxI0cHJvamVjdHMve3By", + "b2plY3R9L2xvY2F0aW9ucy97bG9jYXRpb259L2Zsb29yU2V0dGluZxIyZm9s", + "ZGVycy97Zm9sZGVyfS9sb2NhdGlvbnMve2xvY2F0aW9ufS9mbG9vclNldHRp", + "bmcSPm9yZ2FuaXphdGlvbnMve29yZ2FuaXphdGlvbn0vbG9jYXRpb25zL3ts", + "b2NhdGlvbn0vZmxvb3JTZXR0aW5nKg1mbG9vclNldHRpbmdzMgxmbG9vclNl", + "dHRpbmdCIwohX2VuYWJsZV9mbG9vcl9zZXR0aW5nX2VuZm9yY2VtZW50QhwK", + "Gl9haV9wbGF0Zm9ybV9mbG9vcl9zZXR0aW5nIo4BChZBaVBsYXRmb3JtRmxv", + "b3JTZXR0aW5nEhsKDGluc3BlY3Rfb25seRgBIAEoCEID4EEBSAASIAoRaW5z", + "cGVjdF9hbmRfYmxvY2sYAiABKAhCA+BBAUgAEiEKFGVuYWJsZV9jbG91ZF9s", + "b2dnaW5nGAMgASgIQgPgQQFCEgoQZW5mb3JjZW1lbnRfdHlwZSKvAQoUTGlz", + "dFRlbXBsYXRlc1JlcXVlc3QSOgoGcGFyZW50GAEgASgJQirgQQL6QSQSIm1v", + "ZGVsYXJtb3IuZ29vZ2xlYXBpcy5jb20vVGVtcGxhdGUSFgoJcGFnZV9zaXpl", + "GAIgASgFQgPgQQESFwoKcGFnZV90b2tlbhgDIAEoCUID4EEBEhMKBmZpbHRl", + "chgEIAEoCUID4EEBEhUKCG9yZGVyX2J5GAUgASgJQgPgQQEifgoVTGlzdFRl", + "bXBsYXRlc1Jlc3BvbnNlEjcKCXRlbXBsYXRlcxgBIAMoCzIkLmdvb2dsZS5j", + "bG91ZC5tb2RlbGFybW9yLnYxLlRlbXBsYXRlEhcKD25leHRfcGFnZV90b2tl", + "bhgCIAEoCRITCgt1bnJlYWNoYWJsZRgDIAMoCSJOChJHZXRUZW1wbGF0ZVJl", + "cXVlc3QSOAoEbmFtZRgBIAEoCUIq4EEC+kEkCiJtb2RlbGFybW9yLmdvb2ds", + "ZWFwaXMuY29tL1RlbXBsYXRlIssBChVDcmVhdGVUZW1wbGF0ZVJlcXVlc3QS", + "OgoGcGFyZW50GAEgASgJQirgQQL6QSQSIm1vZGVsYXJtb3IuZ29vZ2xlYXBp", + "cy5jb20vVGVtcGxhdGUSGAoLdGVtcGxhdGVfaWQYAiABKAlCA+BBAhI7Cgh0", + "ZW1wbGF0ZRgDIAEoCzIkLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlRl", + "bXBsYXRlQgPgQQISHwoKcmVxdWVzdF9pZBgEIAEoCUIL4EEB4ozP1wgCCAEi", + "qwEKFVVwZGF0ZVRlbXBsYXRlUmVxdWVzdBI0Cgt1cGRhdGVfbWFzaxgBIAEo", + "CzIaLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE1hc2tCA+BBAhI7Cgh0ZW1wbGF0", + "ZRgCIAEoCzIkLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlRlbXBsYXRl", + "QgPgQQISHwoKcmVxdWVzdF9pZBgDIAEoCUIL4EEB4ozP1wgCCAEicgoVRGVs", + "ZXRlVGVtcGxhdGVSZXF1ZXN0EjgKBG5hbWUYASABKAlCKuBBAvpBJAoibW9k", + "ZWxhcm1vci5nb29nbGVhcGlzLmNvbS9UZW1wbGF0ZRIfCgpyZXF1ZXN0X2lk", + "GAIgASgJQgvgQQHijM/XCAIIASJWChZHZXRGbG9vclNldHRpbmdSZXF1ZXN0", + "EjwKBG5hbWUYASABKAlCLuBBAvpBKAombW9kZWxhcm1vci5nb29nbGVhcGlz", + "LmNvbS9GbG9vclNldHRpbmcilwEKGVVwZGF0ZUZsb29yU2V0dGluZ1JlcXVl", + "c3QSRAoNZmxvb3Jfc2V0dGluZxgBIAEoCzIoLmdvb2dsZS5jbG91ZC5tb2Rl", + "bGFybW9yLnYxLkZsb29yU2V0dGluZ0ID4EECEjQKC3VwZGF0ZV9tYXNrGAIg", + "ASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFza0ID4EEBIu8CCgxGaWx0", + "ZXJDb25maWcSSAoMcmFpX3NldHRpbmdzGAEgASgLMi0uZ29vZ2xlLmNsb3Vk", + "Lm1vZGVsYXJtb3IudjEuUmFpRmlsdGVyU2V0dGluZ3NCA+BBARJICgxzZHBf", + "c2V0dGluZ3MYAiABKAsyLS5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5T", + "ZHBGaWx0ZXJTZXR0aW5nc0ID4EEBEmcKIHBpX2FuZF9qYWlsYnJlYWtfZmls", + "dGVyX3NldHRpbmdzGAMgASgLMjguZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3Iu", + "djEuUGlBbmRKYWlsYnJlYWtGaWx0ZXJTZXR0aW5nc0ID4EEBEmIKHW1hbGlj", + "aW91c191cmlfZmlsdGVyX3NldHRpbmdzGAQgASgLMjYuZ29vZ2xlLmNsb3Vk", + "Lm1vZGVsYXJtb3IudjEuTWFsaWNpb3VzVXJpRmlsdGVyU2V0dGluZ3NCA+BB", + "ASLhAgocUGlBbmRKYWlsYnJlYWtGaWx0ZXJTZXR0aW5ncxJ5ChJmaWx0ZXJf", + "ZW5mb3JjZW1lbnQYASABKA4yWC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52", + "MS5QaUFuZEphaWxicmVha0ZpbHRlclNldHRpbmdzLlBpQW5kSmFpbGJyZWFr", + "RmlsdGVyRW5mb3JjZW1lbnRCA+BBARJTChBjb25maWRlbmNlX2xldmVsGAMg", + "ASgOMjQuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRGV0ZWN0aW9uQ29u", + "ZmlkZW5jZUxldmVsQgPgQQEicQofUGlBbmRKYWlsYnJlYWtGaWx0ZXJFbmZv", + "cmNlbWVudBIzCi9QSV9BTkRfSkFJTEJSRUFLX0ZJTFRFUl9FTkZPUkNFTUVO", + "VF9VTlNQRUNJRklFRBAAEgsKB0VOQUJMRUQQARIMCghESVNBQkxFRBACIoEC", + "ChpNYWxpY2lvdXNVcmlGaWx0ZXJTZXR0aW5ncxJ1ChJmaWx0ZXJfZW5mb3Jj", + "ZW1lbnQYASABKA4yVC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5NYWxp", + "Y2lvdXNVcmlGaWx0ZXJTZXR0aW5ncy5NYWxpY2lvdXNVcmlGaWx0ZXJFbmZv", + "cmNlbWVudEID4EEBImwKHU1hbGljaW91c1VyaUZpbHRlckVuZm9yY2VtZW50", + "EjAKLE1BTElDSU9VU19VUklfRklMVEVSX0VORk9SQ0VNRU5UX1VOU1BFQ0lG", + "SUVEEAASCwoHRU5BQkxFRBABEgwKCERJU0FCTEVEEAIijgIKEVJhaUZpbHRl", + "clNldHRpbmdzElEKC3JhaV9maWx0ZXJzGAEgAygLMjcuZ29vZ2xlLmNsb3Vk", + "Lm1vZGVsYXJtb3IudjEuUmFpRmlsdGVyU2V0dGluZ3MuUmFpRmlsdGVyQgPg", + "QQIapQEKCVJhaUZpbHRlchJDCgtmaWx0ZXJfdHlwZRgBIAEoDjIpLmdvb2ds", + "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLlJhaUZpbHRlclR5cGVCA+BBAhJTChBj", + "b25maWRlbmNlX2xldmVsGAIgASgOMjQuZ29vZ2xlLmNsb3VkLm1vZGVsYXJt", + "b3IudjEuRGV0ZWN0aW9uQ29uZmlkZW5jZUxldmVsQgPgQQEiwAEKEVNkcEZp", + "bHRlclNldHRpbmdzEkcKDGJhc2ljX2NvbmZpZxgBIAEoCzIqLmdvb2dsZS5j", + "bG91ZC5tb2RlbGFybW9yLnYxLlNkcEJhc2ljQ29uZmlnQgPgQQFIABJNCg9h", + "ZHZhbmNlZF9jb25maWcYAiABKAsyLS5nb29nbGUuY2xvdWQubW9kZWxhcm1v", + "ci52MS5TZHBBZHZhbmNlZENvbmZpZ0ID4EEBSABCEwoRc2RwX2NvbmZpZ3Vy", + "YXRpb24i3QEKDlNkcEJhc2ljQ29uZmlnEmUKEmZpbHRlcl9lbmZvcmNlbWVu", + "dBgDIAEoDjJELmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNkcEJhc2lj", + "Q29uZmlnLlNkcEJhc2ljQ29uZmlnRW5mb3JjZW1lbnRCA+BBASJkChlTZHBC", + "YXNpY0NvbmZpZ0VuZm9yY2VtZW50EiwKKFNEUF9CQVNJQ19DT05GSUdfRU5G", + "T1JDRU1FTlRfVU5TUEVDSUZJRUQQABILCgdFTkFCTEVEEAESDAoIRElTQUJM", + "RUQQAiJUChFTZHBBZHZhbmNlZENvbmZpZxIdChBpbnNwZWN0X3RlbXBsYXRl", + "GAEgASgJQgPgQQESIAoTZGVpZGVudGlmeV90ZW1wbGF0ZRgCIAEoCUID4EEB", + "IuYCChlTYW5pdGl6ZVVzZXJQcm9tcHRSZXF1ZXN0EjgKBG5hbWUYASABKAlC", + "KuBBAvpBJAoibW9kZWxhcm1vci5nb29nbGVhcGlzLmNvbS9UZW1wbGF0ZRJD", + "ChB1c2VyX3Byb21wdF9kYXRhGAIgASgLMiQuZ29vZ2xlLmNsb3VkLm1vZGVs", + "YXJtb3IudjEuRGF0YUl0ZW1CA+BBAhJqCiFtdWx0aV9sYW5ndWFnZV9kZXRl", + "Y3Rpb25fbWV0YWRhdGEYBiABKAsyOi5nb29nbGUuY2xvdWQubW9kZWxhcm1v", + "ci52MS5NdWx0aUxhbmd1YWdlRGV0ZWN0aW9uTWV0YWRhdGFCA+BBARJLCg5z", + "dHJlYW1pbmdfbW9kZRgHIAEoDjIpLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9y", + "LnYxLlN0cmVhbWluZ01vZGVCA+BBAUgAiAEBQhEKD19zdHJlYW1pbmdfbW9k", + "ZSKGAwocU2FuaXRpemVNb2RlbFJlc3BvbnNlUmVxdWVzdBI4CgRuYW1lGAEg", + "ASgJQirgQQL6QSQKIm1vZGVsYXJtb3IuZ29vZ2xlYXBpcy5jb20vVGVtcGxh", + "dGUSRgoTbW9kZWxfcmVzcG9uc2VfZGF0YRgCIAEoCzIkLmdvb2dsZS5jbG91", + "ZC5tb2RlbGFybW9yLnYxLkRhdGFJdGVtQgPgQQISGAoLdXNlcl9wcm9tcHQY", + "BCABKAlCA+BBARJqCiFtdWx0aV9sYW5ndWFnZV9kZXRlY3Rpb25fbWV0YWRh", + "dGEYByABKAsyOi5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5NdWx0aUxh", + "bmd1YWdlRGV0ZWN0aW9uTWV0YWRhdGFCA+BBARJLCg5zdHJlYW1pbmdfbW9k", + "ZRgIIAEoDjIpLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlN0cmVhbWlu", + "Z01vZGVCA+BBAUgAiAEBQhEKD19zdHJlYW1pbmdfbW9kZSJuChpTYW5pdGl6", + "ZVVzZXJQcm9tcHRSZXNwb25zZRJQChNzYW5pdGl6YXRpb25fcmVzdWx0GAEg", + "ASgLMi4uZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuU2FuaXRpemF0aW9u", + "UmVzdWx0QgPgQQMicQodU2FuaXRpemVNb2RlbFJlc3BvbnNlUmVzcG9uc2US", + "UAoTc2FuaXRpemF0aW9uX3Jlc3VsdBgBIAEoCzIuLmdvb2dsZS5jbG91ZC5t", + "b2RlbGFybW9yLnYxLlNhbml0aXphdGlvblJlc3VsdEID4EEDIpUFChJTYW5p", + "dGl6YXRpb25SZXN1bHQSTQoSZmlsdGVyX21hdGNoX3N0YXRlGAEgASgOMiwu", + "Z29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyTWF0Y2hTdGF0ZUID", + "4EEDEl4KDmZpbHRlcl9yZXN1bHRzGAIgAygLMkEuZ29vZ2xlLmNsb3VkLm1v", + "ZGVsYXJtb3IudjEuU2FuaXRpemF0aW9uUmVzdWx0LkZpbHRlclJlc3VsdHNF", + "bnRyeUID4EEDEkwKEWludm9jYXRpb25fcmVzdWx0GAQgASgOMiwuZ29vZ2xl", + "LmNsb3VkLm1vZGVsYXJtb3IudjEuSW52b2NhdGlvblJlc3VsdEID4EEDEmcK", + "FXNhbml0aXphdGlvbl9tZXRhZGF0YRgDIAEoCzJDLmdvb2dsZS5jbG91ZC5t", + "b2RlbGFybW9yLnYxLlNhbml0aXphdGlvblJlc3VsdC5TYW5pdGl6YXRpb25N", + "ZXRhZGF0YUID4EEDGrgBChRTYW5pdGl6YXRpb25NZXRhZGF0YRISCgplcnJv", + "cl9jb2RlGAEgASgDEhUKDWVycm9yX21lc3NhZ2UYAiABKAkSKgoiaWdub3Jl", + "X3BhcnRpYWxfaW52b2NhdGlvbl9mYWlsdXJlcxgDIAEoCBJJChZzdHJlYW1f", + "Y2h1bmtfcHJvY2Vzc2VkGAQgASgLMiQuZ29vZ2xlLmNsb3VkLm1vZGVsYXJt", + "b3IudjEuRGF0YUl0ZW1CA+BBAxpeChJGaWx0ZXJSZXN1bHRzRW50cnkSCwoD", + "a2V5GAEgASgJEjcKBXZhbHVlGAIgASgLMiguZ29vZ2xlLmNsb3VkLm1vZGVs", + "YXJtb3IudjEuRmlsdGVyUmVzdWx0OgI4ASJsCh5NdWx0aUxhbmd1YWdlRGV0", + "ZWN0aW9uTWV0YWRhdGESHAoPc291cmNlX2xhbmd1YWdlGAEgASgJQgPgQQES", + "LAofZW5hYmxlX211bHRpX2xhbmd1YWdlX2RldGVjdGlvbhgCIAEoCEID4EEB", + "IpwECgxGaWx0ZXJSZXN1bHQSSAoRcmFpX2ZpbHRlcl9yZXN1bHQYASABKAsy", + "Ky5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5SYWlGaWx0ZXJSZXN1bHRI", + "ABJIChFzZHBfZmlsdGVyX3Jlc3VsdBgCIAEoCzIrLmdvb2dsZS5jbG91ZC5t", + "b2RlbGFybW9yLnYxLlNkcEZpbHRlclJlc3VsdEgAEmAKHnBpX2FuZF9qYWls", + "YnJlYWtfZmlsdGVyX3Jlc3VsdBgDIAEoCzI2Lmdvb2dsZS5jbG91ZC5tb2Rl", + "bGFybW9yLnYxLlBpQW5kSmFpbGJyZWFrRmlsdGVyUmVzdWx0SAASWwobbWFs", + "aWNpb3VzX3VyaV9maWx0ZXJfcmVzdWx0GAQgASgLMjQuZ29vZ2xlLmNsb3Vk", + "Lm1vZGVsYXJtb3IudjEuTWFsaWNpb3VzVXJpRmlsdGVyUmVzdWx0SAASUQoZ", + "Y3NhbV9maWx0ZXJfZmlsdGVyX3Jlc3VsdBgFIAEoCzIsLmdvb2dsZS5jbG91", + "ZC5tb2RlbGFybW9yLnYxLkNzYW1GaWx0ZXJSZXN1bHRIABJVChh2aXJ1c19z", + "Y2FuX2ZpbHRlcl9yZXN1bHQYBiABKAsyMS5nb29nbGUuY2xvdWQubW9kZWxh", + "cm1vci52MS5WaXJ1c1NjYW5GaWx0ZXJSZXN1bHRIAEIPCg1maWx0ZXJfcmVz", + "dWx0Ir8FCg9SYWlGaWx0ZXJSZXN1bHQSTgoPZXhlY3V0aW9uX3N0YXRlGAEg", + "ASgOMjAuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyRXhlY3V0", + "aW9uU3RhdGVCA+BBAxI+Cg1tZXNzYWdlX2l0ZW1zGAIgAygLMicuZ29vZ2xl", + "LmNsb3VkLm1vZGVsYXJtb3IudjEuTWVzc2FnZUl0ZW0SRgoLbWF0Y2hfc3Rh", + "dGUYAyABKA4yLC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJN", + "YXRjaFN0YXRlQgPgQQMSZgoXcmFpX2ZpbHRlcl90eXBlX3Jlc3VsdHMYBCAD", + "KAsyRS5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5SYWlGaWx0ZXJSZXN1", + "bHQuUmFpRmlsdGVyVHlwZVJlc3VsdHNFbnRyeRrtAQoTUmFpRmlsdGVyVHlw", + "ZVJlc3VsdBI+CgtmaWx0ZXJfdHlwZRgBIAEoDjIpLmdvb2dsZS5jbG91ZC5t", + "b2RlbGFybW9yLnYxLlJhaUZpbHRlclR5cGUSTgoQY29uZmlkZW5jZV9sZXZl", + "bBgCIAEoDjI0Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkRldGVjdGlv", + "bkNvbmZpZGVuY2VMZXZlbBJGCgttYXRjaF9zdGF0ZRgDIAEoDjIsLmdvb2ds", + "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZpbHRlck1hdGNoU3RhdGVCA+BBAxp8", + "ChlSYWlGaWx0ZXJUeXBlUmVzdWx0c0VudHJ5EgsKA2tleRgBIAEoCRJOCgV2", + "YWx1ZRgCIAEoCzI/Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlJhaUZp", + "bHRlclJlc3VsdC5SYWlGaWx0ZXJUeXBlUmVzdWx0OgI4ASKxAQoPU2RwRmls", + "dGVyUmVzdWx0EkYKDmluc3BlY3RfcmVzdWx0GAEgASgLMiwuZ29vZ2xlLmNs", + "b3VkLm1vZGVsYXJtb3IudjEuU2RwSW5zcGVjdFJlc3VsdEgAEkwKEWRlaWRl", + "bnRpZnlfcmVzdWx0GAIgASgLMi8uZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3Iu", + "djEuU2RwRGVpZGVudGlmeVJlc3VsdEgAQggKBnJlc3VsdCLAAgoQU2RwSW5z", + "cGVjdFJlc3VsdBJOCg9leGVjdXRpb25fc3RhdGUYASABKA4yMC5nb29nbGUu", + "Y2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJFeGVjdXRpb25TdGF0ZUID4EED", + "Ej4KDW1lc3NhZ2VfaXRlbXMYAiADKAsyJy5nb29nbGUuY2xvdWQubW9kZWxh", + "cm1vci52MS5NZXNzYWdlSXRlbRJGCgttYXRjaF9zdGF0ZRgDIAEoDjIsLmdv", + "b2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZpbHRlck1hdGNoU3RhdGVCA+BB", + "AxI4CghmaW5kaW5ncxgEIAMoCzImLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9y", + "LnYxLlNkcEZpbmRpbmcSGgoSZmluZGluZ3NfdHJ1bmNhdGVkGAUgASgIImYK", + "CERhdGFJdGVtEg4KBHRleHQYASABKAlIABI9CglieXRlX2l0ZW0YAiABKAsy", + "KC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5CeXRlRGF0YUl0ZW1IAEIL", + "CglkYXRhX2l0ZW0imgIKDEJ5dGVEYXRhSXRlbRJSCg5ieXRlX2RhdGFfdHlw", + "ZRgBIAEoDjI1Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkJ5dGVEYXRh", + "SXRlbS5CeXRlSXRlbVR5cGVCA+BBAhIWCglieXRlX2RhdGEYAiABKAxCA+BB", + "AiKdAQoMQnl0ZUl0ZW1UeXBlEh4KGkJZVEVfSVRFTV9UWVBFX1VOU1BFQ0lG", + "SUVEEAASEgoOUExBSU5URVhUX1VURjgQARIHCgNQREYQAhIRCg1XT1JEX0RP", + "Q1VNRU5UEAMSEgoORVhDRUxfRE9DVU1FTlQQBBIXChNQT1dFUlBPSU5UX0RP", + "Q1VNRU5UEAUSBwoDVFhUEAYSBwoDQ1NWEAci0AIKE1NkcERlaWRlbnRpZnlS", + "ZXN1bHQSTgoPZXhlY3V0aW9uX3N0YXRlGAEgASgOMjAuZ29vZ2xlLmNsb3Vk", + "Lm1vZGVsYXJtb3IudjEuRmlsdGVyRXhlY3V0aW9uU3RhdGVCA+BBAxI+Cg1t", + "ZXNzYWdlX2l0ZW1zGAIgAygLMicuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3Iu", + "djEuTWVzc2FnZUl0ZW0SRgoLbWF0Y2hfc3RhdGUYAyABKA4yLC5nb29nbGUu", + "Y2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJNYXRjaFN0YXRlQgPgQQMSMgoE", + "ZGF0YRgEIAEoCzIkLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkRhdGFJ", + "dGVtEhkKEXRyYW5zZm9ybWVkX2J5dGVzGAUgASgDEhIKCmluZm9fdHlwZXMY", + "BiADKAkixAIKClNkcEZpbmRpbmcSEQoJaW5mb190eXBlGAEgASgJEkQKCmxp", + "a2VsaWhvb2QYAiABKA4yMC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5T", + "ZHBGaW5kaW5nTGlrZWxpaG9vZBJLCghsb2NhdGlvbhgDIAEoCzI5Lmdvb2ds", + "ZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNkcEZpbmRpbmcuU2RwRmluZGluZ0xv", + "Y2F0aW9uGo8BChJTZHBGaW5kaW5nTG9jYXRpb24SOQoKYnl0ZV9yYW5nZRgB", + "IAEoCzIlLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlJhbmdlSW5mbxI+", + "Cg9jb2RlcG9pbnRfcmFuZ2UYAiABKAsyJS5nb29nbGUuY2xvdWQubW9kZWxh", + "cm1vci52MS5SYW5nZUluZm8ixAIKGlBpQW5kSmFpbGJyZWFrRmlsdGVyUmVz", + "dWx0Ek4KD2V4ZWN1dGlvbl9zdGF0ZRgBIAEoDjIwLmdvb2dsZS5jbG91ZC5t", + "b2RlbGFybW9yLnYxLkZpbHRlckV4ZWN1dGlvblN0YXRlQgPgQQMSPgoNbWVz", + "c2FnZV9pdGVtcxgCIAMoCzInLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYx", + "Lk1lc3NhZ2VJdGVtEkYKC21hdGNoX3N0YXRlGAMgASgOMiwuZ29vZ2xlLmNs", + "b3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyTWF0Y2hTdGF0ZUID4EEDEk4KEGNv", + "bmZpZGVuY2VfbGV2ZWwYBSABKA4yNC5nb29nbGUuY2xvdWQubW9kZWxhcm1v", + "ci52MS5EZXRlY3Rpb25Db25maWRlbmNlTGV2ZWwixwMKGE1hbGljaW91c1Vy", + "aUZpbHRlclJlc3VsdBJOCg9leGVjdXRpb25fc3RhdGUYASABKA4yMC5nb29n", + "bGUuY2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJFeGVjdXRpb25TdGF0ZUID", + "4EEDEj4KDW1lc3NhZ2VfaXRlbXMYAiADKAsyJy5nb29nbGUuY2xvdWQubW9k", + "ZWxhcm1vci52MS5NZXNzYWdlSXRlbRJGCgttYXRjaF9zdGF0ZRgDIAEoDjIs", + "Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZpbHRlck1hdGNoU3RhdGVC", + "A+BBAxJxChttYWxpY2lvdXNfdXJpX21hdGNoZWRfaXRlbXMYBCADKAsyTC5n", + "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5NYWxpY2lvdXNVcmlGaWx0ZXJS", + "ZXN1bHQuTWFsaWNpb3VzVXJpTWF0Y2hlZEl0ZW0aYAoXTWFsaWNpb3VzVXJp", + "TWF0Y2hlZEl0ZW0SCwoDdXJpGAEgASgJEjgKCWxvY2F0aW9ucxgCIAMoCzIl", + "Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlJhbmdlSW5mbyKgBAoVVmly", + "dXNTY2FuRmlsdGVyUmVzdWx0Ek4KD2V4ZWN1dGlvbl9zdGF0ZRgBIAEoDjIw", + "Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkZpbHRlckV4ZWN1dGlvblN0", + "YXRlQgPgQQMSPgoNbWVzc2FnZV9pdGVtcxgCIAMoCzInLmdvb2dsZS5jbG91", + "ZC5tb2RlbGFybW9yLnYxLk1lc3NhZ2VJdGVtEkYKC21hdGNoX3N0YXRlGAMg", + "ASgOMiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyTWF0Y2hT", + "dGF0ZUID4EEDEmIKFHNjYW5uZWRfY29udGVudF90eXBlGAQgASgOMkQuZ29v", + "Z2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVmlydXNTY2FuRmlsdGVyUmVzdWx0", + "LlNjYW5uZWRDb250ZW50VHlwZRIZCgxzY2FubmVkX3NpemUYBSABKANIAIgB", + "ARI+Cg12aXJ1c19kZXRhaWxzGAYgAygLMicuZ29vZ2xlLmNsb3VkLm1vZGVs", + "YXJtb3IudjEuVmlydXNEZXRhaWwiXwoSU2Nhbm5lZENvbnRlbnRUeXBlEiQK", + "IFNDQU5ORURfQ09OVEVOVF9UWVBFX1VOU1BFQ0lGSUVEEAASCwoHVU5LTk9X", + "ThABEg0KCVBMQUlOVEVYVBACEgcKA1BERhADQg8KDV9zY2FubmVkX3NpemUi", + "mwIKC1ZpcnVzRGV0YWlsEg4KBnZlbmRvchgBIAEoCRINCgVuYW1lcxgCIAMo", + "CRJHCgt0aHJlYXRfdHlwZRgDIAEoDjIyLmdvb2dsZS5jbG91ZC5tb2RlbGFy", + "bW9yLnYxLlZpcnVzRGV0YWlsLlRocmVhdFR5cGUiowEKClRocmVhdFR5cGUS", + "GwoXVEhSRUFUX1RZUEVfVU5TUEVDSUZJRUQQABILCgdVTktOT1dOEAESEQoN", + "VklSVVNfT1JfV09STRACEhUKEU1BTElDSU9VU19QUk9HUkFNEAMSHwobUE9U", + "RU5USUFMTFlfSEFSTUZVTF9DT05URU5UEAQSIAocUE9URU5USUFMTFlfVU5X", + "QU5URURfQ09OVEVOVBAFIuoBChBDc2FtRmlsdGVyUmVzdWx0Ek4KD2V4ZWN1", "dGlvbl9zdGF0ZRgBIAEoDjIwLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYx", "LkZpbHRlckV4ZWN1dGlvblN0YXRlQgPgQQMSPgoNbWVzc2FnZV9pdGVtcxgC", "IAMoCzInLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLk1lc3NhZ2VJdGVt", "EkYKC21hdGNoX3N0YXRlGAMgASgOMiwuZ29vZ2xlLmNsb3VkLm1vZGVsYXJt", - "b3IudjEuRmlsdGVyTWF0Y2hTdGF0ZUID4EEDEnEKG21hbGljaW91c191cmlf", - "bWF0Y2hlZF9pdGVtcxgEIAMoCzJMLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9y", - "LnYxLk1hbGljaW91c1VyaUZpbHRlclJlc3VsdC5NYWxpY2lvdXNVcmlNYXRj", - "aGVkSXRlbRpgChdNYWxpY2lvdXNVcmlNYXRjaGVkSXRlbRILCgN1cmkYASAB", - "KAkSOAoJbG9jYXRpb25zGAIgAygLMiUuZ29vZ2xlLmNsb3VkLm1vZGVsYXJt", - "b3IudjEuUmFuZ2VJbmZvIqAEChVWaXJ1c1NjYW5GaWx0ZXJSZXN1bHQSTgoP", - "ZXhlY3V0aW9uX3N0YXRlGAEgASgOMjAuZ29vZ2xlLmNsb3VkLm1vZGVsYXJt", - "b3IudjEuRmlsdGVyRXhlY3V0aW9uU3RhdGVCA+BBAxI+Cg1tZXNzYWdlX2l0", - "ZW1zGAIgAygLMicuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuTWVzc2Fn", - "ZUl0ZW0SRgoLbWF0Y2hfc3RhdGUYAyABKA4yLC5nb29nbGUuY2xvdWQubW9k", - "ZWxhcm1vci52MS5GaWx0ZXJNYXRjaFN0YXRlQgPgQQMSYgoUc2Nhbm5lZF9j", - "b250ZW50X3R5cGUYBCABKA4yRC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52", - "MS5WaXJ1c1NjYW5GaWx0ZXJSZXN1bHQuU2Nhbm5lZENvbnRlbnRUeXBlEhkK", - "DHNjYW5uZWRfc2l6ZRgFIAEoA0gAiAEBEj4KDXZpcnVzX2RldGFpbHMYBiAD", - "KAsyJy5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5WaXJ1c0RldGFpbCJf", - "ChJTY2FubmVkQ29udGVudFR5cGUSJAogU0NBTk5FRF9DT05URU5UX1RZUEVf", - "VU5TUEVDSUZJRUQQABILCgdVTktOT1dOEAESDQoJUExBSU5URVhUEAISBwoD", - "UERGEANCDwoNX3NjYW5uZWRfc2l6ZSKbAgoLVmlydXNEZXRhaWwSDgoGdmVu", - "ZG9yGAEgASgJEg0KBW5hbWVzGAIgAygJEkcKC3RocmVhdF90eXBlGAMgASgO", - "MjIuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVmlydXNEZXRhaWwuVGhy", - "ZWF0VHlwZSKjAQoKVGhyZWF0VHlwZRIbChdUSFJFQVRfVFlQRV9VTlNQRUNJ", - "RklFRBAAEgsKB1VOS05PV04QARIRCg1WSVJVU19PUl9XT1JNEAISFQoRTUFM", - "SUNJT1VTX1BST0dSQU0QAxIfChtQT1RFTlRJQUxMWV9IQVJNRlVMX0NPTlRF", - "TlQQBBIgChxQT1RFTlRJQUxMWV9VTldBTlRFRF9DT05URU5UEAUi6gEKEENz", - "YW1GaWx0ZXJSZXN1bHQSTgoPZXhlY3V0aW9uX3N0YXRlGAEgASgOMjAuZ29v", - "Z2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmlsdGVyRXhlY3V0aW9uU3RhdGVC", - "A+BBAxI+Cg1tZXNzYWdlX2l0ZW1zGAIgAygLMicuZ29vZ2xlLmNsb3VkLm1v", - "ZGVsYXJtb3IudjEuTWVzc2FnZUl0ZW0SRgoLbWF0Y2hfc3RhdGUYAyABKA4y", - "LC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5GaWx0ZXJNYXRjaFN0YXRl", - "QgPgQQMiuAEKC01lc3NhZ2VJdGVtEkkKDG1lc3NhZ2VfdHlwZRgBIAEoDjIz", - "Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLk1lc3NhZ2VJdGVtLk1lc3Nh", - "Z2VUeXBlEg8KB21lc3NhZ2UYAiABKAkiTQoLTWVzc2FnZVR5cGUSHAoYTUVT", - "U0FHRV9UWVBFX1VOU1BFQ0lGSUVEEAASCAoESU5GTxABEgsKB1dBUk5JTkcQ", - "AhIJCgVFUlJPUhADIkMKCVJhbmdlSW5mbxISCgVzdGFydBgBIAEoA0gAiAEB", - "EhAKA2VuZBgCIAEoA0gBiAEBQggKBl9zdGFydEIGCgRfZW5kKlsKEEZpbHRl", - "ck1hdGNoU3RhdGUSIgoeRklMVEVSX01BVENIX1NUQVRFX1VOU1BFQ0lGSUVE", - "EAASEgoOTk9fTUFUQ0hfRk9VTkQQARIPCgtNQVRDSF9GT1VORBACKmwKFEZp", - "bHRlckV4ZWN1dGlvblN0YXRlEiYKIkZJTFRFUl9FWEVDVVRJT05fU1RBVEVf", - "VU5TUEVDSUZJRUQQABIVChFFWEVDVVRJT05fU1VDQ0VTUxABEhUKEUVYRUNV", - "VElPTl9TS0lQUEVEEAIqdwoNUmFpRmlsdGVyVHlwZRIfChtSQUlfRklMVEVS", - "X1RZUEVfVU5TUEVDSUZJRUQQABIVChFTRVhVQUxMWV9FWFBMSUNJVBACEg8K", - "C0hBVEVfU1BFRUNIEAMSDgoKSEFSQVNTTUVOVBAGEg0KCURBTkdFUk9VUxAR", - "KnkKGERldGVjdGlvbkNvbmZpZGVuY2VMZXZlbBIqCiZERVRFQ1RJT05fQ09O", - "RklERU5DRV9MRVZFTF9VTlNQRUNJRklFRBAAEhEKDUxPV19BTkRfQUJPVkUQ", - "ARIUChBNRURJVU1fQU5EX0FCT1ZFEAISCAoESElHSBADKooBChRTZHBGaW5k", - "aW5nTGlrZWxpaG9vZBImCiJTRFBfRklORElOR19MSUtFTElIT09EX1VOU1BF", - "Q0lGSUVEEAASEQoNVkVSWV9VTkxJS0VMWRABEgwKCFVOTElLRUxZEAISDAoI", - "UE9TU0lCTEUQAxIKCgZMSUtFTFkQBBIPCgtWRVJZX0xJS0VMWRAFKlwKEElu", - "dm9jYXRpb25SZXN1bHQSIQodSU5WT0NBVElPTl9SRVNVTFRfVU5TUEVDSUZJ", - "RUQQABILCgdTVUNDRVNTEAESCwoHUEFSVElBTBACEgsKB0ZBSUxVUkUQAzLE", - "EAoKTW9kZWxBcm1vchK0AQoNTGlzdFRlbXBsYXRlcxIwLmdvb2dsZS5jbG91", - "ZC5tb2RlbGFybW9yLnYxLkxpc3RUZW1wbGF0ZXNSZXF1ZXN0GjEuZ29vZ2xl", - "LmNsb3VkLm1vZGVsYXJtb3IudjEuTGlzdFRlbXBsYXRlc1Jlc3BvbnNlIj7a", - "QQZwYXJlbnSC0+STAi8SLS92MS97cGFyZW50PXByb2plY3RzLyovbG9jYXRp", - "b25zLyp9L3RlbXBsYXRlcxKhAQoLR2V0VGVtcGxhdGUSLi5nb29nbGUuY2xv", - "dWQubW9kZWxhcm1vci52MS5HZXRUZW1wbGF0ZVJlcXVlc3QaJC5nb29nbGUu", - "Y2xvdWQubW9kZWxhcm1vci52MS5UZW1wbGF0ZSI82kEEbmFtZYLT5JMCLxIt", - "L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zLyovdGVtcGxhdGVzLyp9", - "EsgBCg5DcmVhdGVUZW1wbGF0ZRIxLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9y", - "LnYxLkNyZWF0ZVRlbXBsYXRlUmVxdWVzdBokLmdvb2dsZS5jbG91ZC5tb2Rl", - "bGFybW9yLnYxLlRlbXBsYXRlIl3aQRtwYXJlbnQsdGVtcGxhdGUsdGVtcGxh", - "dGVfaWSC0+STAjkiLS92MS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25z", - "Lyp9L3RlbXBsYXRlczoIdGVtcGxhdGUSygEKDlVwZGF0ZVRlbXBsYXRlEjEu", - "Z29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVXBkYXRlVGVtcGxhdGVSZXF1", - "ZXN0GiQuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVGVtcGxhdGUiX9pB", - "FHRlbXBsYXRlLHVwZGF0ZV9tYXNrgtPkkwJCMjYvdjEve3RlbXBsYXRlLm5h", - "bWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi90ZW1wbGF0ZXMvKn06CHRlbXBs", - "YXRlEpkBCg5EZWxldGVUZW1wbGF0ZRIxLmdvb2dsZS5jbG91ZC5tb2RlbGFy", - "bW9yLnYxLkRlbGV0ZVRlbXBsYXRlUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1", - "Zi5FbXB0eSI82kEEbmFtZYLT5JMCLyotL3YxL3tuYW1lPXByb2plY3RzLyov", - "bG9jYXRpb25zLyovdGVtcGxhdGVzLyp9EpgCCg9HZXRGbG9vclNldHRpbmcS", - "Mi5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5HZXRGbG9vclNldHRpbmdS", - "ZXF1ZXN0GiguZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmxvb3JTZXR0", - "aW5nIqYB2kEEbmFtZYLT5JMCmAESLi92MS97bmFtZT1wcm9qZWN0cy8qL2xv", - "Y2F0aW9ucy8qL2Zsb29yU2V0dGluZ31aLxItL3YxL3tuYW1lPWZvbGRlcnMv", - "Ki9sb2NhdGlvbnMvKi9mbG9vclNldHRpbmd9WjUSMy92MS97bmFtZT1vcmdh", - "bml6YXRpb25zLyovbG9jYXRpb25zLyovZmxvb3JTZXR0aW5nfRKKAwoSVXBk", - "YXRlRmxvb3JTZXR0aW5nEjUuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEu", - "VXBkYXRlRmxvb3JTZXR0aW5nUmVxdWVzdBooLmdvb2dsZS5jbG91ZC5tb2Rl", - "bGFybW9yLnYxLkZsb29yU2V0dGluZyKSAtpBGWZsb29yX3NldHRpbmcsdXBk", - "YXRlX21hc2uC0+STAu8BMjwvdjEve2Zsb29yX3NldHRpbmcubmFtZT1wcm9q", - "ZWN0cy8qL2xvY2F0aW9ucy8qL2Zsb29yU2V0dGluZ306DWZsb29yX3NldHRp", - "bmdaTDI7L3YxL3tmbG9vcl9zZXR0aW5nLm5hbWU9Zm9sZGVycy8qL2xvY2F0", - "aW9ucy8qL2Zsb29yU2V0dGluZ306DWZsb29yX3NldHRpbmdaUjJBL3YxL3tm", - "bG9vcl9zZXR0aW5nLm5hbWU9b3JnYW5pemF0aW9ucy8qL2xvY2F0aW9ucy8q", - "L2Zsb29yU2V0dGluZ306DWZsb29yX3NldHRpbmcS0AEKElNhbml0aXplVXNl", - "clByb21wdBI1Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNhbml0aXpl", - "VXNlclByb21wdFJlcXVlc3QaNi5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52", - "MS5TYW5pdGl6ZVVzZXJQcm9tcHRSZXNwb25zZSJLgtPkkwJFIkAvdjEve25h", - "bWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi90ZW1wbGF0ZXMvKn06c2FuaXRp", - "emVVc2VyUHJvbXB0OgEqEtwBChVTYW5pdGl6ZU1vZGVsUmVzcG9uc2USOC5n", - "b29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5TYW5pdGl6ZU1vZGVsUmVzcG9u", - "c2VSZXF1ZXN0GjkuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuU2FuaXRp", - "emVNb2RlbFJlc3BvbnNlUmVzcG9uc2UiToLT5JMCSCJDL3YxL3tuYW1lPXBy", - "b2plY3RzLyovbG9jYXRpb25zLyovdGVtcGxhdGVzLyp9OnNhbml0aXplTW9k", - "ZWxSZXNwb25zZToBKhpNykEZbW9kZWxhcm1vci5nb29nbGVhcGlzLmNvbdJB", - "Lmh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvY2xvdWQtcGxhdGZv", - "cm1CqQEKHmNvbS5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MUILVjFtYWlu", - "UHJvdG9QAVo+Y2xvdWQuZ29vZ2xlLmNvbS9nby9tb2RlbGFybW9yL2FwaXYx", - "L21vZGVsYXJtb3JwYjttb2RlbGFybW9ycGKqAhpHb29nbGUuQ2xvdWQuTW9k", - "ZWxBcm1vci5WMcoCGkdvb2dsZVxDbG91ZFxNb2RlbEFybW9yXFYxYgZwcm90", - "bzM=")); + "b3IudjEuRmlsdGVyTWF0Y2hTdGF0ZUID4EEDIrgBCgtNZXNzYWdlSXRlbRJJ", + "CgxtZXNzYWdlX3R5cGUYASABKA4yMy5nb29nbGUuY2xvdWQubW9kZWxhcm1v", + "ci52MS5NZXNzYWdlSXRlbS5NZXNzYWdlVHlwZRIPCgdtZXNzYWdlGAIgASgJ", + "Ik0KC01lc3NhZ2VUeXBlEhwKGE1FU1NBR0VfVFlQRV9VTlNQRUNJRklFRBAA", + "EggKBElORk8QARILCgdXQVJOSU5HEAISCQoFRVJST1IQAyJDCglSYW5nZUlu", + "Zm8SEgoFc3RhcnQYASABKANIAIgBARIQCgNlbmQYAiABKANIAYgBAUIICgZf", + "c3RhcnRCBgoEX2VuZCpbChBGaWx0ZXJNYXRjaFN0YXRlEiIKHkZJTFRFUl9N", + "QVRDSF9TVEFURV9VTlNQRUNJRklFRBAAEhIKDk5PX01BVENIX0ZPVU5EEAES", + "DwoLTUFUQ0hfRk9VTkQQAipsChRGaWx0ZXJFeGVjdXRpb25TdGF0ZRImCiJG", + "SUxURVJfRVhFQ1VUSU9OX1NUQVRFX1VOU1BFQ0lGSUVEEAASFQoRRVhFQ1VU", + "SU9OX1NVQ0NFU1MQARIVChFFWEVDVVRJT05fU0tJUFBFRBACKncKDVJhaUZp", + "bHRlclR5cGUSHwobUkFJX0ZJTFRFUl9UWVBFX1VOU1BFQ0lGSUVEEAASFQoR", + "U0VYVUFMTFlfRVhQTElDSVQQAhIPCgtIQVRFX1NQRUVDSBADEg4KCkhBUkFT", + "U01FTlQQBhINCglEQU5HRVJPVVMQESp5ChhEZXRlY3Rpb25Db25maWRlbmNl", + "TGV2ZWwSKgomREVURUNUSU9OX0NPTkZJREVOQ0VfTEVWRUxfVU5TUEVDSUZJ", + "RUQQABIRCg1MT1dfQU5EX0FCT1ZFEAESFAoQTUVESVVNX0FORF9BQk9WRRAC", + "EggKBEhJR0gQAyqKAQoUU2RwRmluZGluZ0xpa2VsaWhvb2QSJgoiU0RQX0ZJ", + "TkRJTkdfTElLRUxJSE9PRF9VTlNQRUNJRklFRBAAEhEKDVZFUllfVU5MSUtF", + "TFkQARIMCghVTkxJS0VMWRACEgwKCFBPU1NJQkxFEAMSCgoGTElLRUxZEAQS", + "DwoLVkVSWV9MSUtFTFkQBSpcChBJbnZvY2F0aW9uUmVzdWx0EiEKHUlOVk9D", + "QVRJT05fUkVTVUxUX1VOU1BFQ0lGSUVEEAASCwoHU1VDQ0VTUxABEgsKB1BB", + "UlRJQUwQAhILCgdGQUlMVVJFEAMqaQoNU3RyZWFtaW5nTW9kZRIeChpTVFJF", + "QU1JTkdfTU9ERV9VTlNQRUNJRklFRBAAEhsKF1NUUkVBTUlOR19NT0RFX0JV", + "RkZFUkVEEAESGwoXU1RSRUFNSU5HX01PREVfUkVBTFRJTUUQAjLxEgoKTW9k", + "ZWxBcm1vchK0AQoNTGlzdFRlbXBsYXRlcxIwLmdvb2dsZS5jbG91ZC5tb2Rl", + "bGFybW9yLnYxLkxpc3RUZW1wbGF0ZXNSZXF1ZXN0GjEuZ29vZ2xlLmNsb3Vk", + "Lm1vZGVsYXJtb3IudjEuTGlzdFRlbXBsYXRlc1Jlc3BvbnNlIj7aQQZwYXJl", + "bnSC0+STAi8SLS92MS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zLyp9", + "L3RlbXBsYXRlcxKhAQoLR2V0VGVtcGxhdGUSLi5nb29nbGUuY2xvdWQubW9k", + "ZWxhcm1vci52MS5HZXRUZW1wbGF0ZVJlcXVlc3QaJC5nb29nbGUuY2xvdWQu", + "bW9kZWxhcm1vci52MS5UZW1wbGF0ZSI82kEEbmFtZYLT5JMCLxItL3YxL3tu", + "YW1lPXByb2plY3RzLyovbG9jYXRpb25zLyovdGVtcGxhdGVzLyp9EsgBCg5D", + "cmVhdGVUZW1wbGF0ZRIxLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLkNy", + "ZWF0ZVRlbXBsYXRlUmVxdWVzdBokLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9y", + "LnYxLlRlbXBsYXRlIl3aQRtwYXJlbnQsdGVtcGxhdGUsdGVtcGxhdGVfaWSC", + "0+STAjkiLS92MS97cGFyZW50PXByb2plY3RzLyovbG9jYXRpb25zLyp9L3Rl", + "bXBsYXRlczoIdGVtcGxhdGUSygEKDlVwZGF0ZVRlbXBsYXRlEjEuZ29vZ2xl", + "LmNsb3VkLm1vZGVsYXJtb3IudjEuVXBkYXRlVGVtcGxhdGVSZXF1ZXN0GiQu", + "Z29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVGVtcGxhdGUiX9pBFHRlbXBs", + "YXRlLHVwZGF0ZV9tYXNrgtPkkwJCMjYvdjEve3RlbXBsYXRlLm5hbWU9cHJv", + "amVjdHMvKi9sb2NhdGlvbnMvKi90ZW1wbGF0ZXMvKn06CHRlbXBsYXRlEpkB", + "Cg5EZWxldGVUZW1wbGF0ZRIxLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYx", + "LkRlbGV0ZVRlbXBsYXRlUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0", + "eSI82kEEbmFtZYLT5JMCLyotL3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRp", + "b25zLyovdGVtcGxhdGVzLyp9EpgCCg9HZXRGbG9vclNldHRpbmcSMi5nb29n", + "bGUuY2xvdWQubW9kZWxhcm1vci52MS5HZXRGbG9vclNldHRpbmdSZXF1ZXN0", + "GiguZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuRmxvb3JTZXR0aW5nIqYB", + "2kEEbmFtZYLT5JMCmAESLi92MS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9u", + "cy8qL2Zsb29yU2V0dGluZ31aLxItL3YxL3tuYW1lPWZvbGRlcnMvKi9sb2Nh", + "dGlvbnMvKi9mbG9vclNldHRpbmd9WjUSMy92MS97bmFtZT1vcmdhbml6YXRp", + "b25zLyovbG9jYXRpb25zLyovZmxvb3JTZXR0aW5nfRKKAwoSVXBkYXRlRmxv", + "b3JTZXR0aW5nEjUuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuVXBkYXRl", + "Rmxvb3JTZXR0aW5nUmVxdWVzdBooLmdvb2dsZS5jbG91ZC5tb2RlbGFybW9y", + "LnYxLkZsb29yU2V0dGluZyKSAtpBGWZsb29yX3NldHRpbmcsdXBkYXRlX21h", + "c2uC0+STAu8BMjwvdjEve2Zsb29yX3NldHRpbmcubmFtZT1wcm9qZWN0cy8q", + "L2xvY2F0aW9ucy8qL2Zsb29yU2V0dGluZ306DWZsb29yX3NldHRpbmdaTDI7", + "L3YxL3tmbG9vcl9zZXR0aW5nLm5hbWU9Zm9sZGVycy8qL2xvY2F0aW9ucy8q", + "L2Zsb29yU2V0dGluZ306DWZsb29yX3NldHRpbmdaUjJBL3YxL3tmbG9vcl9z", + "ZXR0aW5nLm5hbWU9b3JnYW5pemF0aW9ucy8qL2xvY2F0aW9ucy8qL2Zsb29y", + "U2V0dGluZ306DWZsb29yX3NldHRpbmcS0AEKElNhbml0aXplVXNlclByb21w", + "dBI1Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNhbml0aXplVXNlclBy", + "b21wdFJlcXVlc3QaNi5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5TYW5p", + "dGl6ZVVzZXJQcm9tcHRSZXNwb25zZSJLgtPkkwJFIkAvdjEve25hbWU9cHJv", + "amVjdHMvKi9sb2NhdGlvbnMvKi90ZW1wbGF0ZXMvKn06c2FuaXRpemVVc2Vy", + "UHJvbXB0OgEqEtwBChVTYW5pdGl6ZU1vZGVsUmVzcG9uc2USOC5nb29nbGUu", + "Y2xvdWQubW9kZWxhcm1vci52MS5TYW5pdGl6ZU1vZGVsUmVzcG9uc2VSZXF1", + "ZXN0GjkuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3IudjEuU2FuaXRpemVNb2Rl", + "bFJlc3BvbnNlUmVzcG9uc2UiToLT5JMCSCJDL3YxL3tuYW1lPXByb2plY3Rz", + "LyovbG9jYXRpb25zLyovdGVtcGxhdGVzLyp9OnNhbml0aXplTW9kZWxSZXNw", + "b25zZToBKhKPAQoYU3RyZWFtU2FuaXRpemVVc2VyUHJvbXB0EjUuZ29vZ2xl", + "LmNsb3VkLm1vZGVsYXJtb3IudjEuU2FuaXRpemVVc2VyUHJvbXB0UmVxdWVz", + "dBo2Lmdvb2dsZS5jbG91ZC5tb2RlbGFybW9yLnYxLlNhbml0aXplVXNlclBy", + "b21wdFJlc3BvbnNlIgAoATABEpgBChtTdHJlYW1TYW5pdGl6ZU1vZGVsUmVz", + "cG9uc2USOC5nb29nbGUuY2xvdWQubW9kZWxhcm1vci52MS5TYW5pdGl6ZU1v", + "ZGVsUmVzcG9uc2VSZXF1ZXN0GjkuZ29vZ2xlLmNsb3VkLm1vZGVsYXJtb3Iu", + "djEuU2FuaXRpemVNb2RlbFJlc3BvbnNlUmVzcG9uc2UiACgBMAEaTcpBGW1v", + "ZGVsYXJtb3IuZ29vZ2xlYXBpcy5jb23SQS5odHRwczovL3d3dy5nb29nbGVh", + "cGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQqkBCh5jb20uZ29vZ2xlLmNs", + "b3VkLm1vZGVsYXJtb3IudjFCC1YxbWFpblByb3RvUAFaPmNsb3VkLmdvb2ds", + "ZS5jb20vZ28vbW9kZWxhcm1vci9hcGl2MS9tb2RlbGFybW9ycGI7bW9kZWxh", + "cm1vcnBiqgIaR29vZ2xlLkNsb3VkLk1vZGVsQXJtb3IuVjHKAhpHb29nbGVc", + "Q2xvdWRcTW9kZWxBcm1vclxWMWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.FieldInfoReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, - new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.ModelArmor.V1.FilterMatchState), typeof(global::Google.Cloud.ModelArmor.V1.FilterExecutionState), typeof(global::Google.Cloud.ModelArmor.V1.RaiFilterType), typeof(global::Google.Cloud.ModelArmor.V1.DetectionConfidenceLevel), typeof(global::Google.Cloud.ModelArmor.V1.SdpFindingLikelihood), typeof(global::Google.Cloud.ModelArmor.V1.InvocationResult), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.FieldInfoReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.FieldMaskReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Type.DateReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.ModelArmor.V1.FilterMatchState), typeof(global::Google.Cloud.ModelArmor.V1.FilterExecutionState), typeof(global::Google.Cloud.ModelArmor.V1.RaiFilterType), typeof(global::Google.Cloud.ModelArmor.V1.DetectionConfidenceLevel), typeof(global::Google.Cloud.ModelArmor.V1.SdpFindingLikelihood), typeof(global::Google.Cloud.ModelArmor.V1.InvocationResult), typeof(global::Google.Cloud.ModelArmor.V1.StreamingMode), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.Template), global::Google.Cloud.ModelArmor.V1.Template.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "Labels", "FilterConfig", "TemplateMetadata" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.Template.Types.TemplateMetadata), global::Google.Cloud.ModelArmor.V1.Template.Types.TemplateMetadata.Parser, new[]{ "IgnorePartialInvocationFailures", "CustomPromptSafetyErrorCode", "CustomPromptSafetyErrorMessage", "CustomLlmResponseSafetyErrorCode", "CustomLlmResponseSafetyErrorMessage", "LogTemplateOperations", "LogSanitizeOperations", "EnforcementType", "MultiLanguageDetection" }, null, new[]{ typeof(global::Google.Cloud.ModelArmor.V1.Template.Types.TemplateMetadata.Types.EnforcementType) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.Template.Types.TemplateMetadata.Types.MultiLanguageDetection), global::Google.Cloud.ModelArmor.V1.Template.Types.TemplateMetadata.Types.MultiLanguageDetection.Parser, new[]{ "EnableMultiLanguageDetection" }, null, null, null, null)}), null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.FloorSetting), global::Google.Cloud.ModelArmor.V1.FloorSetting.Parser, new[]{ "Name", "CreateTime", "UpdateTime", "FilterConfig", "EnableFloorSettingEnforcement", "IntegratedServices", "AiPlatformFloorSetting", "FloorSettingMetadata" }, new[]{ "EnableFloorSettingEnforcement", "AiPlatformFloorSetting" }, new[]{ typeof(global::Google.Cloud.ModelArmor.V1.FloorSetting.Types.IntegratedService) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.FloorSetting.Types.FloorSettingMetadata), global::Google.Cloud.ModelArmor.V1.FloorSetting.Types.FloorSettingMetadata.Parser, new[]{ "MultiLanguageDetection" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.FloorSetting.Types.FloorSettingMetadata.Types.MultiLanguageDetection), global::Google.Cloud.ModelArmor.V1.FloorSetting.Types.FloorSettingMetadata.Types.MultiLanguageDetection.Parser, new[]{ "EnableMultiLanguageDetection" }, null, null, null, null)})}), @@ -384,11 +399,11 @@ static ServiceReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SdpFilterSettings), global::Google.Cloud.ModelArmor.V1.SdpFilterSettings.Parser, new[]{ "BasicConfig", "AdvancedConfig" }, new[]{ "SdpConfiguration" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SdpBasicConfig), global::Google.Cloud.ModelArmor.V1.SdpBasicConfig.Parser, new[]{ "FilterEnforcement" }, null, new[]{ typeof(global::Google.Cloud.ModelArmor.V1.SdpBasicConfig.Types.SdpBasicConfigEnforcement) }, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SdpAdvancedConfig), global::Google.Cloud.ModelArmor.V1.SdpAdvancedConfig.Parser, new[]{ "InspectTemplate", "DeidentifyTemplate" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizeUserPromptRequest), global::Google.Cloud.ModelArmor.V1.SanitizeUserPromptRequest.Parser, new[]{ "Name", "UserPromptData", "MultiLanguageDetectionMetadata" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizeModelResponseRequest), global::Google.Cloud.ModelArmor.V1.SanitizeModelResponseRequest.Parser, new[]{ "Name", "ModelResponseData", "UserPrompt", "MultiLanguageDetectionMetadata" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizeUserPromptRequest), global::Google.Cloud.ModelArmor.V1.SanitizeUserPromptRequest.Parser, new[]{ "Name", "UserPromptData", "MultiLanguageDetectionMetadata", "StreamingMode" }, new[]{ "StreamingMode" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizeModelResponseRequest), global::Google.Cloud.ModelArmor.V1.SanitizeModelResponseRequest.Parser, new[]{ "Name", "ModelResponseData", "UserPrompt", "MultiLanguageDetectionMetadata", "StreamingMode" }, new[]{ "StreamingMode" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizeUserPromptResponse), global::Google.Cloud.ModelArmor.V1.SanitizeUserPromptResponse.Parser, new[]{ "SanitizationResult" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizeModelResponseResponse), global::Google.Cloud.ModelArmor.V1.SanitizeModelResponseResponse.Parser, new[]{ "SanitizationResult" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizationResult), global::Google.Cloud.ModelArmor.V1.SanitizationResult.Parser, new[]{ "FilterMatchState", "FilterResults", "InvocationResult", "SanitizationMetadata" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizationResult.Types.SanitizationMetadata), global::Google.Cloud.ModelArmor.V1.SanitizationResult.Types.SanitizationMetadata.Parser, new[]{ "ErrorCode", "ErrorMessage", "IgnorePartialInvocationFailures" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizationResult), global::Google.Cloud.ModelArmor.V1.SanitizationResult.Parser, new[]{ "FilterMatchState", "FilterResults", "InvocationResult", "SanitizationMetadata" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.SanitizationResult.Types.SanitizationMetadata), global::Google.Cloud.ModelArmor.V1.SanitizationResult.Types.SanitizationMetadata.Parser, new[]{ "ErrorCode", "ErrorMessage", "IgnorePartialInvocationFailures", "StreamChunkProcessed" }, null, null, null, null), null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.MultiLanguageDetectionMetadata), global::Google.Cloud.ModelArmor.V1.MultiLanguageDetectionMetadata.Parser, new[]{ "SourceLanguage", "EnableMultiLanguageDetection" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.ModelArmor.V1.FilterResult), global::Google.Cloud.ModelArmor.V1.FilterResult.Parser, new[]{ "RaiFilterResult", "SdpFilterResult", "PiAndJailbreakFilterResult", "MaliciousUriFilterResult", "CsamFilterFilterResult", "VirusScanFilterResult" }, new[]{ "FilterResult" }, null, null, null), @@ -554,6 +569,24 @@ public enum InvocationResult { [pbr::OriginalName("FAILURE")] Failure = 3, } + /// + /// Streaming Mode for Sanitize* API. + /// + public enum StreamingMode { + /// + /// Default value. + /// + [pbr::OriginalName("STREAMING_MODE_UNSPECIFIED")] Unspecified = 0, + /// + /// Buffered Streaming mode. + /// + [pbr::OriginalName("STREAMING_MODE_BUFFERED")] Buffered = 1, + /// + /// Real Time Streaming mode. + /// + [pbr::OriginalName("STREAMING_MODE_REALTIME")] Realtime = 2, + } + #endregion #region Messages @@ -7448,6 +7481,7 @@ public sealed partial class SanitizeUserPromptRequest : pb::IMessage _parser = new pb::MessageParser(() => new SanitizeUserPromptRequest()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pb::MessageParser Parser { get { return _parser; } } @@ -7475,9 +7509,11 @@ public SanitizeUserPromptRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public SanitizeUserPromptRequest(SanitizeUserPromptRequest other) : this() { + _hasBits0 = other._hasBits0; name_ = other.name_; userPromptData_ = other.userPromptData_ != null ? other.userPromptData_.Clone() : null; multiLanguageDetectionMetadata_ = other.multiLanguageDetectionMetadata_ != null ? other.multiLanguageDetectionMetadata_.Clone() : null; + streamingMode_ = other.streamingMode_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -7533,6 +7569,36 @@ public string Name { } } + /// Field number for the "streaming_mode" field. + public const int StreamingModeFieldNumber = 7; + private readonly static global::Google.Cloud.ModelArmor.V1.StreamingMode StreamingModeDefaultValue = global::Google.Cloud.ModelArmor.V1.StreamingMode.Unspecified; + + private global::Google.Cloud.ModelArmor.V1.StreamingMode streamingMode_; + /// + /// Optional. Streaming Mode for StreamSanitize* API. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.ModelArmor.V1.StreamingMode StreamingMode { + get { if ((_hasBits0 & 1) != 0) { return streamingMode_; } else { return StreamingModeDefaultValue; } } + set { + _hasBits0 |= 1; + streamingMode_ = value; + } + } + /// Gets whether the "streaming_mode" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamingMode { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "streaming_mode" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamingMode() { + _hasBits0 &= ~1; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -7551,6 +7617,7 @@ public bool Equals(SanitizeUserPromptRequest other) { if (Name != other.Name) return false; if (!object.Equals(UserPromptData, other.UserPromptData)) return false; if (!object.Equals(MultiLanguageDetectionMetadata, other.MultiLanguageDetectionMetadata)) return false; + if (StreamingMode != other.StreamingMode) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7561,6 +7628,7 @@ public override int GetHashCode() { if (Name.Length != 0) hash ^= Name.GetHashCode(); if (userPromptData_ != null) hash ^= UserPromptData.GetHashCode(); if (multiLanguageDetectionMetadata_ != null) hash ^= MultiLanguageDetectionMetadata.GetHashCode(); + if (HasStreamingMode) hash ^= StreamingMode.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7591,6 +7659,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(50); output.WriteMessage(MultiLanguageDetectionMetadata); } + if (HasStreamingMode) { + output.WriteRawTag(56); + output.WriteEnum((int) StreamingMode); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -7613,6 +7685,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(50); output.WriteMessage(MultiLanguageDetectionMetadata); } + if (HasStreamingMode) { + output.WriteRawTag(56); + output.WriteEnum((int) StreamingMode); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -7632,6 +7708,9 @@ public int CalculateSize() { if (multiLanguageDetectionMetadata_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(MultiLanguageDetectionMetadata); } + if (HasStreamingMode) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) StreamingMode); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -7659,6 +7738,9 @@ public void MergeFrom(SanitizeUserPromptRequest other) { } MultiLanguageDetectionMetadata.MergeFrom(other.MultiLanguageDetectionMetadata); } + if (other.HasStreamingMode) { + StreamingMode = other.StreamingMode; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7696,6 +7778,10 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(MultiLanguageDetectionMetadata); break; } + case 56: { + StreamingMode = (global::Google.Cloud.ModelArmor.V1.StreamingMode) input.ReadEnum(); + break; + } } } #endif @@ -7733,6 +7819,10 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(MultiLanguageDetectionMetadata); break; } + case 56: { + StreamingMode = (global::Google.Cloud.ModelArmor.V1.StreamingMode) input.ReadEnum(); + break; + } } } } @@ -7751,6 +7841,7 @@ public sealed partial class SanitizeModelResponseRequest : pb::IMessage _parser = new pb::MessageParser(() => new SanitizeModelResponseRequest()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pb::MessageParser Parser { get { return _parser; } } @@ -7778,10 +7869,12 @@ public SanitizeModelResponseRequest() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public SanitizeModelResponseRequest(SanitizeModelResponseRequest other) : this() { + _hasBits0 = other._hasBits0; name_ = other.name_; modelResponseData_ = other.modelResponseData_ != null ? other.modelResponseData_.Clone() : null; userPrompt_ = other.userPrompt_; multiLanguageDetectionMetadata_ = other.multiLanguageDetectionMetadata_ != null ? other.multiLanguageDetectionMetadata_.Clone() : null; + streamingMode_ = other.streamingMode_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -7852,6 +7945,36 @@ public string UserPrompt { } } + /// Field number for the "streaming_mode" field. + public const int StreamingModeFieldNumber = 8; + private readonly static global::Google.Cloud.ModelArmor.V1.StreamingMode StreamingModeDefaultValue = global::Google.Cloud.ModelArmor.V1.StreamingMode.Unspecified; + + private global::Google.Cloud.ModelArmor.V1.StreamingMode streamingMode_; + /// + /// Optional. Streaming Mode for StreamSanitize* API. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.ModelArmor.V1.StreamingMode StreamingMode { + get { if ((_hasBits0 & 1) != 0) { return streamingMode_; } else { return StreamingModeDefaultValue; } } + set { + _hasBits0 |= 1; + streamingMode_ = value; + } + } + /// Gets whether the "streaming_mode" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamingMode { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "streaming_mode" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamingMode() { + _hasBits0 &= ~1; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -7871,6 +7994,7 @@ public bool Equals(SanitizeModelResponseRequest other) { if (!object.Equals(ModelResponseData, other.ModelResponseData)) return false; if (UserPrompt != other.UserPrompt) return false; if (!object.Equals(MultiLanguageDetectionMetadata, other.MultiLanguageDetectionMetadata)) return false; + if (StreamingMode != other.StreamingMode) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7882,6 +8006,7 @@ public override int GetHashCode() { if (modelResponseData_ != null) hash ^= ModelResponseData.GetHashCode(); if (UserPrompt.Length != 0) hash ^= UserPrompt.GetHashCode(); if (multiLanguageDetectionMetadata_ != null) hash ^= MultiLanguageDetectionMetadata.GetHashCode(); + if (HasStreamingMode) hash ^= StreamingMode.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7916,6 +8041,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(58); output.WriteMessage(MultiLanguageDetectionMetadata); } + if (HasStreamingMode) { + output.WriteRawTag(64); + output.WriteEnum((int) StreamingMode); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -7942,6 +8071,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(58); output.WriteMessage(MultiLanguageDetectionMetadata); } + if (HasStreamingMode) { + output.WriteRawTag(64); + output.WriteEnum((int) StreamingMode); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -7964,6 +8097,9 @@ public int CalculateSize() { if (multiLanguageDetectionMetadata_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(MultiLanguageDetectionMetadata); } + if (HasStreamingMode) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) StreamingMode); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -7994,6 +8130,9 @@ public void MergeFrom(SanitizeModelResponseRequest other) { } MultiLanguageDetectionMetadata.MergeFrom(other.MultiLanguageDetectionMetadata); } + if (other.HasStreamingMode) { + StreamingMode = other.StreamingMode; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8035,6 +8174,10 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(MultiLanguageDetectionMetadata); break; } + case 64: { + StreamingMode = (global::Google.Cloud.ModelArmor.V1.StreamingMode) input.ReadEnum(); + break; + } } } #endif @@ -8076,6 +8219,10 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(MultiLanguageDetectionMetadata); break; } + case 64: { + StreamingMode = (global::Google.Cloud.ModelArmor.V1.StreamingMode) input.ReadEnum(); + break; + } } } } @@ -8886,6 +9033,7 @@ public SanitizationMetadata(SanitizationMetadata other) : this() { errorCode_ = other.errorCode_; errorMessage_ = other.errorMessage_; ignorePartialInvocationFailures_ = other.ignorePartialInvocationFailures_; + streamChunkProcessed_ = other.streamChunkProcessed_ != null ? other.streamChunkProcessed_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -8941,6 +9089,21 @@ public bool IgnorePartialInvocationFailures { } } + /// Field number for the "stream_chunk_processed" field. + public const int StreamChunkProcessedFieldNumber = 4; + private global::Google.Cloud.ModelArmor.V1.DataItem streamChunkProcessed_; + /// + /// Output only. The stream chunk processed by the Sanitization service. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.ModelArmor.V1.DataItem StreamChunkProcessed { + get { return streamChunkProcessed_; } + set { + streamChunkProcessed_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -8959,6 +9122,7 @@ public bool Equals(SanitizationMetadata other) { if (ErrorCode != other.ErrorCode) return false; if (ErrorMessage != other.ErrorMessage) return false; if (IgnorePartialInvocationFailures != other.IgnorePartialInvocationFailures) return false; + if (!object.Equals(StreamChunkProcessed, other.StreamChunkProcessed)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8969,6 +9133,7 @@ public override int GetHashCode() { if (ErrorCode != 0L) hash ^= ErrorCode.GetHashCode(); if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); if (IgnorePartialInvocationFailures != false) hash ^= IgnorePartialInvocationFailures.GetHashCode(); + if (streamChunkProcessed_ != null) hash ^= StreamChunkProcessed.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8999,6 +9164,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(24); output.WriteBool(IgnorePartialInvocationFailures); } + if (streamChunkProcessed_ != null) { + output.WriteRawTag(34); + output.WriteMessage(StreamChunkProcessed); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -9021,6 +9190,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(24); output.WriteBool(IgnorePartialInvocationFailures); } + if (streamChunkProcessed_ != null) { + output.WriteRawTag(34); + output.WriteMessage(StreamChunkProcessed); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -9040,6 +9213,9 @@ public int CalculateSize() { if (IgnorePartialInvocationFailures != false) { size += 1 + 1; } + if (streamChunkProcessed_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StreamChunkProcessed); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -9061,6 +9237,12 @@ public void MergeFrom(SanitizationMetadata other) { if (other.IgnorePartialInvocationFailures != false) { IgnorePartialInvocationFailures = other.IgnorePartialInvocationFailures; } + if (other.streamChunkProcessed_ != null) { + if (streamChunkProcessed_ == null) { + StreamChunkProcessed = new global::Google.Cloud.ModelArmor.V1.DataItem(); + } + StreamChunkProcessed.MergeFrom(other.StreamChunkProcessed); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9092,6 +9274,13 @@ public void MergeFrom(pb::CodedInputStream input) { IgnorePartialInvocationFailures = input.ReadBool(); break; } + case 34: { + if (streamChunkProcessed_ == null) { + StreamChunkProcessed = new global::Google.Cloud.ModelArmor.V1.DataItem(); + } + input.ReadMessage(StreamChunkProcessed); + break; + } } } #endif @@ -9123,6 +9312,13 @@ public void MergeFrom(pb::CodedInputStream input) { IgnorePartialInvocationFailures = input.ReadBool(); break; } + case 34: { + if (streamChunkProcessed_ == null) { + StreamChunkProcessed = new global::Google.Cloud.ModelArmor.V1.DataItem(); + } + input.ReadMessage(StreamChunkProcessed); + break; + } } } } diff --git a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ServiceGrpc.g.cs b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ServiceGrpc.g.cs index 825c4ce6f41c..d5f998046159 100644 --- a/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ServiceGrpc.g.cs +++ b/apis/Google.Cloud.ModelArmor.V1/Google.Cloud.ModelArmor.V1/ServiceGrpc.g.cs @@ -3,7 +3,7 @@ // source: google/cloud/modelarmor/v1/service.proto // // Original file comments: -// Copyright 2025 Google LLC +// Copyright 2026 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -166,6 +166,22 @@ static T __Helper_DeserializeMessage(grpc::DeserializationContext context, gl __Marshaller_google_cloud_modelarmor_v1_SanitizeModelResponseRequest, __Marshaller_google_cloud_modelarmor_v1_SanitizeModelResponseResponse); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_StreamSanitizeUserPrompt = new grpc::Method( + grpc::MethodType.DuplexStreaming, + __ServiceName, + "StreamSanitizeUserPrompt", + __Marshaller_google_cloud_modelarmor_v1_SanitizeUserPromptRequest, + __Marshaller_google_cloud_modelarmor_v1_SanitizeUserPromptResponse); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_StreamSanitizeModelResponse = new grpc::Method( + grpc::MethodType.DuplexStreaming, + __ServiceName, + "StreamSanitizeModelResponse", + __Marshaller_google_cloud_modelarmor_v1_SanitizeModelResponseRequest, + __Marshaller_google_cloud_modelarmor_v1_SanitizeModelResponseResponse); + /// Service descriptor public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor { @@ -284,6 +300,32 @@ public abstract partial class ModelArmorBase throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Streaming version of Sanitize User Prompt. + /// + /// Used for reading requests from the client. + /// Used for sending responses back to the client. + /// The context of the server-side call handler being invoked. + /// A task indicating completion of the handler. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task StreamSanitizeUserPrompt(grpc::IAsyncStreamReader requestStream, grpc::IServerStreamWriter responseStream, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Streaming version of Sanitizes Model Response. + /// + /// Used for reading requests from the client. + /// Used for sending responses back to the client. + /// The context of the server-side call handler being invoked. + /// A task indicating completion of the handler. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task StreamSanitizeModelResponse(grpc::IAsyncStreamReader requestStream, grpc::IServerStreamWriter responseStream, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + } /// Client for ModelArmor @@ -745,6 +787,50 @@ protected ModelArmorClient(ClientBaseConfiguration configuration) : base(configu { return CallInvoker.AsyncUnaryCall(__Method_SanitizeModelResponse, null, options, request); } + /// + /// Streaming version of Sanitize User Prompt. + /// + /// 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::AsyncDuplexStreamingCall StreamSanitizeUserPrompt(grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return StreamSanitizeUserPrompt(new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Streaming version of Sanitize User Prompt. + /// + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncDuplexStreamingCall StreamSanitizeUserPrompt(grpc::CallOptions options) + { + return CallInvoker.AsyncDuplexStreamingCall(__Method_StreamSanitizeUserPrompt, null, options); + } + /// + /// Streaming version of Sanitizes Model Response. + /// + /// 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::AsyncDuplexStreamingCall StreamSanitizeModelResponse(grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return StreamSanitizeModelResponse(new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Streaming version of Sanitizes Model Response. + /// + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncDuplexStreamingCall StreamSanitizeModelResponse(grpc::CallOptions options) + { + return CallInvoker.AsyncDuplexStreamingCall(__Method_StreamSanitizeModelResponse, null, options); + } /// Creates a new instance of client from given ClientBaseConfiguration. [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] protected override ModelArmorClient NewInstance(ClientBaseConfiguration configuration) @@ -767,7 +853,9 @@ protected override ModelArmorClient NewInstance(ClientBaseConfiguration configur .AddMethod(__Method_GetFloorSetting, serviceImpl.GetFloorSetting) .AddMethod(__Method_UpdateFloorSetting, serviceImpl.UpdateFloorSetting) .AddMethod(__Method_SanitizeUserPrompt, serviceImpl.SanitizeUserPrompt) - .AddMethod(__Method_SanitizeModelResponse, serviceImpl.SanitizeModelResponse).Build(); + .AddMethod(__Method_SanitizeModelResponse, serviceImpl.SanitizeModelResponse) + .AddMethod(__Method_StreamSanitizeUserPrompt, serviceImpl.StreamSanitizeUserPrompt) + .AddMethod(__Method_StreamSanitizeModelResponse, serviceImpl.StreamSanitizeModelResponse).Build(); } /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. @@ -786,6 +874,8 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, ModelArmor serviceBinder.AddMethod(__Method_UpdateFloorSetting, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.UpdateFloorSetting)); serviceBinder.AddMethod(__Method_SanitizeUserPrompt, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.SanitizeUserPrompt)); serviceBinder.AddMethod(__Method_SanitizeModelResponse, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.SanitizeModelResponse)); + serviceBinder.AddMethod(__Method_StreamSanitizeUserPrompt, serviceImpl == null ? null : new grpc::DuplexStreamingServerMethod(serviceImpl.StreamSanitizeUserPrompt)); + serviceBinder.AddMethod(__Method_StreamSanitizeModelResponse, serviceImpl == null ? null : new grpc::DuplexStreamingServerMethod(serviceImpl.StreamSanitizeModelResponse)); } } diff --git a/apis/Google.Cloud.ModelArmor.V1/gapic_metadata.json b/apis/Google.Cloud.ModelArmor.V1/gapic_metadata.json index 11c3c3734aa3..892343af9800 100644 --- a/apis/Google.Cloud.ModelArmor.V1/gapic_metadata.json +++ b/apis/Google.Cloud.ModelArmor.V1/gapic_metadata.json @@ -52,6 +52,18 @@ "SanitizeUserPromptAsync" ] }, + "StreamSanitizeModelResponse": { + "methods": [ + "StreamSanitizeModelResponse", + "StreamSanitizeModelResponseAsync" + ] + }, + "StreamSanitizeUserPrompt": { + "methods": [ + "StreamSanitizeUserPrompt", + "StreamSanitizeUserPromptAsync" + ] + }, "UpdateFloorSetting": { "methods": [ "UpdateFloorSetting", diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json index e0a780edec41..a3848188356a 100644 --- a/generator-input/pipeline-state.json +++ b/generator-input/pipeline-state.json @@ -217,7 +217,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-03-05T07:42:15.441334858Z", - "lastGeneratedCommit": "d90d23fa13599f525245fe446086f83cf8863ca4", + "lastGeneratedCommit": "08f4bdd37d79f29c7b6a7082c1c73ef78de4b898", "lastReleasedCommit": "938377b80d3444b91cd329164b0c10507f07f9e8", "apiPaths": [ "google/cloud/alloydb/v1" @@ -232,7 +232,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-03-05T07:43:25.884957452Z", - "lastGeneratedCommit": "d90d23fa13599f525245fe446086f83cf8863ca4", + "lastGeneratedCommit": "08f4bdd37d79f29c7b6a7082c1c73ef78de4b898", "lastReleasedCommit": "938377b80d3444b91cd329164b0c10507f07f9e8", "apiPaths": [ "google/cloud/alloydb/v1alpha" @@ -247,7 +247,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-03-05T07:45:44.483594420Z", - "lastGeneratedCommit": "d90d23fa13599f525245fe446086f83cf8863ca4", + "lastGeneratedCommit": "08f4bdd37d79f29c7b6a7082c1c73ef78de4b898", "lastReleasedCommit": "938377b80d3444b91cd329164b0c10507f07f9e8", "apiPaths": [ "google/cloud/alloydb/v1beta" @@ -1092,7 +1092,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-02-09T14:09:35.006899259Z", - "lastGeneratedCommit": "4e434c1c1fc79b51fd68d576b337fa0ed387f54c", + "lastGeneratedCommit": "00bb3db8a8cc88f0755e872856462b902d6dd8c4", "lastReleasedCommit": "4e434c1c1fc79b51fd68d576b337fa0ed387f54c", "apiPaths": [ "google/cloud/confidentialcomputing/v1" @@ -4118,7 +4118,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2026-03-05T08:28:56.905811928Z", - "lastGeneratedCommit": "359422ce8d726f52e0ad35b48024896c714fa033", + "lastGeneratedCommit": "465f309dd31630c8de4ed10891e494d612fa1864", "lastReleasedCommit": "1ccd68a09ccd14f82d260a8edb96878027295675", "apiPaths": [ "google/firestore/v1" @@ -4284,7 +4284,7 @@ "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC", "releaseTimestamp": "2025-11-05T22:17:29.452870924Z", - "lastGeneratedCommit": "16b4737e7b870914e0c384b87f0e50ed388aa225", + "lastGeneratedCommit": "591ae025072c1608bd7b38039feeb296f640605a", "lastReleasedCommit": "36533b09a6b383f3c30d13c3c26092154ecf5388", "apiPaths": [ "google/cloud/modelarmor/v1"