From 2ce84bea9074fbbd67ddf2d72b0fb65d6af7e55b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 11 Dec 2024 17:26:14 +0000 Subject: [PATCH] feat: updates to protobuf definitions for flipt v1.53.1 (#52) Co-authored-by: flipt-bot --- src/Flipt.Grpc/Analytics.cs | 25 +- src/Flipt.Grpc/Auth.cs | 206 +-- src/Flipt.Grpc/Evaluation.cs | 592 ++++++-- src/Flipt.Grpc/EvaluationGrpc.cs | 3 - src/Flipt.Grpc/Event.cs | 1045 ++++++++++++++ src/Flipt.Grpc/Flipt.cs | 969 +++++++++---- src/Flipt.Grpc/Ofrep.cs | 2264 ++++++++++++++++++++++++++++++ src/Flipt.Grpc/OfrepGrpc.cs | 272 ++++ 8 files changed, 4840 insertions(+), 536 deletions(-) create mode 100644 src/Flipt.Grpc/Event.cs create mode 100644 src/Flipt.Grpc/Ofrep.cs create mode 100644 src/Flipt.Grpc/OfrepGrpc.cs diff --git a/src/Flipt.Grpc/Analytics.cs b/src/Flipt.Grpc/Analytics.cs index 20b5f4b..5b8c209 100644 --- a/src/Flipt.Grpc/Analytics.cs +++ b/src/Flipt.Grpc/Analytics.cs @@ -24,19 +24,20 @@ public static partial class AnalyticsReflection { static AnalyticsReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( - "ChlhbmFseXRpY3MvYW5hbHl0aWNzLnByb3RvEg9mbGlwdC5hbmFseXRpY3Mi", - "hAEKHkdldEZsYWdFdmFsdWF0aW9uc0NvdW50UmVxdWVzdBIjCg1uYW1lc3Bh", - "Y2Vfa2V5GAEgASgJUgxuYW1lc3BhY2VLZXkSGQoIZmxhZ19rZXkYAiABKAlS", - "B2ZsYWdLZXkSEgoEZnJvbRgDIAEoCVIEZnJvbRIOCgJ0bxgEIAEoCVICdG8i", - "WQofR2V0RmxhZ0V2YWx1YXRpb25zQ291bnRSZXNwb25zZRIeCgp0aW1lc3Rh", - "bXBzGAEgAygJUgp0aW1lc3RhbXBzEhYKBnZhbHVlcxgCIAMoAlIGdmFsdWVz", - "MpIBChBBbmFseXRpY3NTZXJ2aWNlEn4KF0dldEZsYWdFdmFsdWF0aW9uc0Nv", - "dW50Ei8uZmxpcHQuYW5hbHl0aWNzLkdldEZsYWdFdmFsdWF0aW9uc0NvdW50", - "UmVxdWVzdBowLmZsaXB0LmFuYWx5dGljcy5HZXRGbGFnRXZhbHVhdGlvbnND", - "b3VudFJlc3BvbnNlIgBCJ1olZ28uZmxpcHQuaW8vZmxpcHQvcnBjL2ZsaXB0", - "L2FuYWx5dGljc2IGcHJvdG8z")); + "ChlhbmFseXRpY3MvYW5hbHl0aWNzLnByb3RvEg9mbGlwdC5hbmFseXRpY3Ma", + "G2dvb2dsZS9hcGkvdmlzaWJpbGl0eS5wcm90byKEAQoeR2V0RmxhZ0V2YWx1", + "YXRpb25zQ291bnRSZXF1ZXN0EiMKDW5hbWVzcGFjZV9rZXkYASABKAlSDG5h", + "bWVzcGFjZUtleRIZCghmbGFnX2tleRgCIAEoCVIHZmxhZ0tleRISCgRmcm9t", + "GAMgASgJUgRmcm9tEg4KAnRvGAQgASgJUgJ0byJZCh9HZXRGbGFnRXZhbHVh", + "dGlvbnNDb3VudFJlc3BvbnNlEh4KCnRpbWVzdGFtcHMYASADKAlSCnRpbWVz", + "dGFtcHMSFgoGdmFsdWVzGAIgAygCUgZ2YWx1ZXMyrAEKEEFuYWx5dGljc1Nl", + "cnZpY2USfgoXR2V0RmxhZ0V2YWx1YXRpb25zQ291bnQSLy5mbGlwdC5hbmFs", + "eXRpY3MuR2V0RmxhZ0V2YWx1YXRpb25zQ291bnRSZXF1ZXN0GjAuZmxpcHQu", + "YW5hbHl0aWNzLkdldEZsYWdFdmFsdWF0aW9uc0NvdW50UmVzcG9uc2UiABoY", + "+tLkkwISEhBmbGlwdDpzZGs6aWdub3JlQidaJWdvLmZsaXB0LmlvL2ZsaXB0", + "L3JwYy9mbGlwdC9hbmFseXRpY3NiBnByb3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { }, + new pbr::FileDescriptor[] { global::Google.Api.VisibilityReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Analytics.GetFlagEvaluationsCountRequest), global::Flipt.Analytics.GetFlagEvaluationsCountRequest.Parser, new[]{ "NamespaceKey", "FlagKey", "From", "To" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Analytics.GetFlagEvaluationsCountResponse), global::Flipt.Analytics.GetFlagEvaluationsCountResponse.Parser, new[]{ "Timestamps", "Values" }, null, null, null, null) diff --git a/src/Flipt.Grpc/Auth.cs b/src/Flipt.Grpc/Auth.cs index 55d790d..ebc995f 100644 --- a/src/Flipt.Grpc/Auth.cs +++ b/src/Flipt.Grpc/Auth.cs @@ -26,86 +26,104 @@ static AuthReflection() { string.Concat( "Cg9hdXRoL2F1dGgucHJvdG8SCmZsaXB0LmF1dGgaG2dvb2dsZS9wcm90b2J1", "Zi9lbXB0eS5wcm90bxocZ29vZ2xlL3Byb3RvYnVmL3N0cnVjdC5wcm90bxof", - "Z29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byK2AQoKTWV0aG9kSW5m", - "bxIqCgZtZXRob2QYASABKA4yEi5mbGlwdC5hdXRoLk1ldGhvZFIGbWV0aG9k", - "EhgKB2VuYWJsZWQYAiABKAhSB2VuYWJsZWQSLQoSc2Vzc2lvbl9jb21wYXRp", - "YmxlGAMgASgIUhFzZXNzaW9uQ29tcGF0aWJsZRIzCghtZXRhZGF0YRgEIAEo", - "CzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RSCG1ldGFkYXRhIlUKIUxpc3RB", - "dXRoZW50aWNhdGlvbk1ldGhvZHNSZXNwb25zZRIwCgdtZXRob2RzGAEgAygL", - "MhYuZmxpcHQuYXV0aC5NZXRob2RJbmZvUgdtZXRob2RzIoADCg5BdXRoZW50", - "aWNhdGlvbhIOCgJpZBgBIAEoCVICaWQSKgoGbWV0aG9kGAIgASgOMhIuZmxp", - "cHQuYXV0aC5NZXRob2RSBm1ldGhvZBI5CgpleHBpcmVzX2F0GAMgASgLMhou", - "Z29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJZXhwaXJlc0F0EjkKCmNyZWF0", - "ZWRfYXQYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgljcmVh", - "dGVkQXQSOQoKdXBkYXRlZF9hdBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5U", - "aW1lc3RhbXBSCXVwZGF0ZWRBdBJECghtZXRhZGF0YRgGIAMoCzIoLmZsaXB0", - "LmF1dGguQXV0aGVudGljYXRpb24uTWV0YWRhdGFFbnRyeVIIbWV0YWRhdGEa", - "OwoNTWV0YWRhdGFFbnRyeRIQCgNrZXkYASABKAlSA2tleRIUCgV2YWx1ZRgC", - "IAEoCVIFdmFsdWU6AjgBIioKGEdldEF1dGhlbnRpY2F0aW9uUmVxdWVzdBIO", - "CgJpZBgBIAEoCVICaWQifQoaTGlzdEF1dGhlbnRpY2F0aW9uc1JlcXVlc3QS", - "KgoGbWV0aG9kGAEgASgOMhIuZmxpcHQuYXV0aC5NZXRob2RSBm1ldGhvZBIU", - "CgVsaW1pdBgCIAEoBVIFbGltaXQSHQoKcGFnZV90b2tlbhgDIAEoCVIJcGFn", - "ZVRva2VuIosBChtMaXN0QXV0aGVudGljYXRpb25zUmVzcG9uc2USRAoPYXV0", - "aGVudGljYXRpb25zGAEgAygLMhouZmxpcHQuYXV0aC5BdXRoZW50aWNhdGlv", - "blIPYXV0aGVudGljYXRpb25zEiYKD25leHRfcGFnZV90b2tlbhgCIAEoCVIN", - "bmV4dFBhZ2VUb2tlbiItChtEZWxldGVBdXRoZW50aWNhdGlvblJlcXVlc3QS", - "DgoCaWQYASABKAlSAmlkInAKH0V4cGlyZUF1dGhlbnRpY2F0aW9uU2VsZlJl", - "cXVlc3QSPgoKZXhwaXJlc19hdBgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5U", - "aW1lc3RhbXBIAFIJZXhwaXJlc0F0iAEBQg0KC19leHBpcmVzX2F0IqoBChJD", - "cmVhdGVUb2tlblJlcXVlc3QSEgoEbmFtZRgBIAEoCVIEbmFtZRIgCgtkZXNj", - "cmlwdGlvbhgCIAEoCVILZGVzY3JpcHRpb24SOQoKZXhwaXJlc19hdBgDIAEo", - "CzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCWV4cGlyZXNBdBIjCg1u", - "YW1lc3BhY2Vfa2V5GAQgASgJUgxuYW1lc3BhY2VLZXkifAoTQ3JlYXRlVG9r", - "ZW5SZXNwb25zZRIhCgxjbGllbnRfdG9rZW4YASABKAlSC2NsaWVudFRva2Vu", - "EkIKDmF1dGhlbnRpY2F0aW9uGAIgASgLMhouZmxpcHQuYXV0aC5BdXRoZW50", - "aWNhdGlvblIOYXV0aGVudGljYXRpb24iRwoTQXV0aG9yaXplVVJMUmVxdWVz", - "dBIaCghwcm92aWRlchgBIAEoCVIIcHJvdmlkZXISFAoFc3RhdGUYAiABKAlS", - "BXN0YXRlIjsKFEF1dGhvcml6ZVVSTFJlc3BvbnNlEiMKDWF1dGhvcml6ZV91", - "cmwYASABKAlSDGF1dGhvcml6ZVVybCJXCg9DYWxsYmFja1JlcXVlc3QSGgoI", - "cHJvdmlkZXIYASABKAlSCHByb3ZpZGVyEhIKBGNvZGUYAiABKAlSBGNvZGUS", - "FAoFc3RhdGUYAyABKAlSBXN0YXRlInkKEENhbGxiYWNrUmVzcG9uc2USIQoM", - "Y2xpZW50X3Rva2VuGAEgASgJUgtjbGllbnRUb2tlbhJCCg5hdXRoZW50aWNh", - "dGlvbhgCIAEoCzIaLmZsaXB0LmF1dGguQXV0aGVudGljYXRpb25SDmF1dGhl", - "bnRpY2F0aW9uIlEKG1ZlcmlmeVNlcnZpY2VBY2NvdW50UmVxdWVzdBIyChVz", - "ZXJ2aWNlX2FjY291bnRfdG9rZW4YASABKAlSE3NlcnZpY2VBY2NvdW50VG9r", - "ZW4ihQEKHFZlcmlmeVNlcnZpY2VBY2NvdW50UmVzcG9uc2USIQoMY2xpZW50", - "X3Rva2VuGAEgASgJUgtjbGllbnRUb2tlbhJCCg5hdXRoZW50aWNhdGlvbhgC", - "IAEoCzIaLmZsaXB0LmF1dGguQXV0aGVudGljYXRpb25SDmF1dGhlbnRpY2F0", - "aW9uKnYKBk1ldGhvZBIPCgtNRVRIT0RfTk9ORRAAEhAKDE1FVEhPRF9UT0tF", - "ThABEg8KC01FVEhPRF9PSURDEAISFQoRTUVUSE9EX0tVQkVSTkVURVMQAxIR", - "Cg1NRVRIT0RfR0lUSFVCEAQSDgoKTUVUSE9EX0pXVBAFMoMBChtQdWJsaWNB", - "dXRoZW50aWNhdGlvblNlcnZpY2USZAoZTGlzdEF1dGhlbnRpY2F0aW9uTWV0", - "aG9kcxIWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eRotLmZsaXB0LmF1dGguTGlz", - "dEF1dGhlbnRpY2F0aW9uTWV0aG9kc1Jlc3BvbnNlIgAy5wMKFUF1dGhlbnRp", - "Y2F0aW9uU2VydmljZRJNChVHZXRBdXRoZW50aWNhdGlvblNlbGYSFi5nb29n", - "bGUucHJvdG9idWYuRW1wdHkaGi5mbGlwdC5hdXRoLkF1dGhlbnRpY2F0aW9u", - "IgASVwoRR2V0QXV0aGVudGljYXRpb24SJC5mbGlwdC5hdXRoLkdldEF1dGhl", - "bnRpY2F0aW9uUmVxdWVzdBoaLmZsaXB0LmF1dGguQXV0aGVudGljYXRpb24i", - "ABJoChNMaXN0QXV0aGVudGljYXRpb25zEiYuZmxpcHQuYXV0aC5MaXN0QXV0", - "aGVudGljYXRpb25zUmVxdWVzdBonLmZsaXB0LmF1dGguTGlzdEF1dGhlbnRp", - "Y2F0aW9uc1Jlc3BvbnNlIgASWQoURGVsZXRlQXV0aGVudGljYXRpb24SJy5m", - "bGlwdC5hdXRoLkRlbGV0ZUF1dGhlbnRpY2F0aW9uUmVxdWVzdBoWLmdvb2ds", - "ZS5wcm90b2J1Zi5FbXB0eSIAEmEKGEV4cGlyZUF1dGhlbnRpY2F0aW9uU2Vs", - "ZhIrLmZsaXB0LmF1dGguRXhwaXJlQXV0aGVudGljYXRpb25TZWxmUmVxdWVz", - "dBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSIAMnQKIEF1dGhlbnRpY2F0aW9u", - "TWV0aG9kVG9rZW5TZXJ2aWNlElAKC0NyZWF0ZVRva2VuEh4uZmxpcHQuYXV0", - "aC5DcmVhdGVUb2tlblJlcXVlc3QaHy5mbGlwdC5hdXRoLkNyZWF0ZVRva2Vu", - "UmVzcG9uc2UiADK/AQofQXV0aGVudGljYXRpb25NZXRob2RPSURDU2Vydmlj", - "ZRJTCgxBdXRob3JpemVVUkwSHy5mbGlwdC5hdXRoLkF1dGhvcml6ZVVSTFJl", - "cXVlc3QaIC5mbGlwdC5hdXRoLkF1dGhvcml6ZVVSTFJlc3BvbnNlIgASRwoI", - "Q2FsbGJhY2sSGy5mbGlwdC5hdXRoLkNhbGxiYWNrUmVxdWVzdBocLmZsaXB0", - "LmF1dGguQ2FsbGJhY2tSZXNwb25zZSIAMpQBCiVBdXRoZW50aWNhdGlvbk1l", - "dGhvZEt1YmVybmV0ZXNTZXJ2aWNlEmsKFFZlcmlmeVNlcnZpY2VBY2NvdW50", - "EicuZmxpcHQuYXV0aC5WZXJpZnlTZXJ2aWNlQWNjb3VudFJlcXVlc3QaKC5m", - "bGlwdC5hdXRoLlZlcmlmeVNlcnZpY2VBY2NvdW50UmVzcG9uc2UiADLBAQoh", - "QXV0aGVudGljYXRpb25NZXRob2RHaXRodWJTZXJ2aWNlElMKDEF1dGhvcml6", - "ZVVSTBIfLmZsaXB0LmF1dGguQXV0aG9yaXplVVJMUmVxdWVzdBogLmZsaXB0", - "LmF1dGguQXV0aG9yaXplVVJMUmVzcG9uc2UiABJHCghDYWxsYmFjaxIbLmZs", - "aXB0LmF1dGguQ2FsbGJhY2tSZXF1ZXN0GhwuZmxpcHQuYXV0aC5DYWxsYmFj", - "a1Jlc3BvbnNlIgBCIlogZ28uZmxpcHQuaW8vZmxpcHQvcnBjL2ZsaXB0L2F1", - "dGhiBnByb3RvMw==")); + "Z29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90bxocZ29vZ2xlL2FwaS9h", + "bm5vdGF0aW9ucy5wcm90bxokZ25vc3RpYy9vcGVuYXBpL3YzL2Fubm90YXRp", + "b25zLnByb3RvIrYBCgpNZXRob2RJbmZvEioKBm1ldGhvZBgBIAEoDjISLmZs", + "aXB0LmF1dGguTWV0aG9kUgZtZXRob2QSGAoHZW5hYmxlZBgCIAEoCFIHZW5h", + "YmxlZBItChJzZXNzaW9uX2NvbXBhdGlibGUYAyABKAhSEXNlc3Npb25Db21w", + "YXRpYmxlEjMKCG1ldGFkYXRhGAQgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0", + "cnVjdFIIbWV0YWRhdGEiVQohTGlzdEF1dGhlbnRpY2F0aW9uTWV0aG9kc1Jl", + "c3BvbnNlEjAKB21ldGhvZHMYASADKAsyFi5mbGlwdC5hdXRoLk1ldGhvZElu", + "Zm9SB21ldGhvZHMigAMKDkF1dGhlbnRpY2F0aW9uEg4KAmlkGAEgASgJUgJp", + "ZBIqCgZtZXRob2QYAiABKA4yEi5mbGlwdC5hdXRoLk1ldGhvZFIGbWV0aG9k", + "EjkKCmV4cGlyZXNfYXQYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", + "YW1wUglleHBpcmVzQXQSOQoKY3JlYXRlZF9hdBgEIAEoCzIaLmdvb2dsZS5w", + "cm90b2J1Zi5UaW1lc3RhbXBSCWNyZWF0ZWRBdBI5Cgp1cGRhdGVkX2F0GAUg", + "ASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJdXBkYXRlZEF0EkQK", + "CG1ldGFkYXRhGAYgAygLMiguZmxpcHQuYXV0aC5BdXRoZW50aWNhdGlvbi5N", + "ZXRhZGF0YUVudHJ5UghtZXRhZGF0YRo7Cg1NZXRhZGF0YUVudHJ5EhAKA2tl", + "eRgBIAEoCVIDa2V5EhQKBXZhbHVlGAIgASgJUgV2YWx1ZToCOAEiKgoYR2V0", + "QXV0aGVudGljYXRpb25SZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZCJ9ChpMaXN0", + "QXV0aGVudGljYXRpb25zUmVxdWVzdBIqCgZtZXRob2QYASABKA4yEi5mbGlw", + "dC5hdXRoLk1ldGhvZFIGbWV0aG9kEhQKBWxpbWl0GAIgASgFUgVsaW1pdBId", + "CgpwYWdlX3Rva2VuGAMgASgJUglwYWdlVG9rZW4iiwEKG0xpc3RBdXRoZW50", + "aWNhdGlvbnNSZXNwb25zZRJECg9hdXRoZW50aWNhdGlvbnMYASADKAsyGi5m", + "bGlwdC5hdXRoLkF1dGhlbnRpY2F0aW9uUg9hdXRoZW50aWNhdGlvbnMSJgoP", + "bmV4dF9wYWdlX3Rva2VuGAIgASgJUg1uZXh0UGFnZVRva2VuIi0KG0RlbGV0", + "ZUF1dGhlbnRpY2F0aW9uUmVxdWVzdBIOCgJpZBgBIAEoCVICaWQicAofRXhw", + "aXJlQXV0aGVudGljYXRpb25TZWxmUmVxdWVzdBI+CgpleHBpcmVzX2F0GAEg", + "ASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEgAUglleHBpcmVzQXSI", + "AQFCDQoLX2V4cGlyZXNfYXQisQIKEkNyZWF0ZVRva2VuUmVxdWVzdBISCgRu", + "YW1lGAEgASgJUgRuYW1lEiAKC2Rlc2NyaXB0aW9uGAIgASgJUgtkZXNjcmlw", + "dGlvbhI5CgpleHBpcmVzX2F0GAMgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcFIJZXhwaXJlc0F0EiMKDW5hbWVzcGFjZV9rZXkYBCABKAlSDG5h", + "bWVzcGFjZUtleRJICghtZXRhZGF0YRgHIAMoCzIsLmZsaXB0LmF1dGguQ3Jl", + "YXRlVG9rZW5SZXF1ZXN0Lk1ldGFkYXRhRW50cnlSCG1ldGFkYXRhGjsKDU1l", + "dGFkYXRhRW50cnkSEAoDa2V5GAEgASgJUgNrZXkSFAoFdmFsdWUYAiABKAlS", + "BXZhbHVlOgI4ASJ8ChNDcmVhdGVUb2tlblJlc3BvbnNlEiEKDGNsaWVudF90", + "b2tlbhgBIAEoCVILY2xpZW50VG9rZW4SQgoOYXV0aGVudGljYXRpb24YAiAB", + "KAsyGi5mbGlwdC5hdXRoLkF1dGhlbnRpY2F0aW9uUg5hdXRoZW50aWNhdGlv", + "biJHChNBdXRob3JpemVVUkxSZXF1ZXN0EhoKCHByb3ZpZGVyGAEgASgJUghw", + "cm92aWRlchIUCgVzdGF0ZRgCIAEoCVIFc3RhdGUiOwoUQXV0aG9yaXplVVJM", + "UmVzcG9uc2USIwoNYXV0aG9yaXplX3VybBgBIAEoCVIMYXV0aG9yaXplVXJs", + "IlcKD0NhbGxiYWNrUmVxdWVzdBIaCghwcm92aWRlchgBIAEoCVIIcHJvdmlk", + "ZXISEgoEY29kZRgCIAEoCVIEY29kZRIUCgVzdGF0ZRgDIAEoCVIFc3RhdGUi", + "eQoQQ2FsbGJhY2tSZXNwb25zZRIhCgxjbGllbnRfdG9rZW4YASABKAlSC2Ns", + "aWVudFRva2VuEkIKDmF1dGhlbnRpY2F0aW9uGAIgASgLMhouZmxpcHQuYXV0", + "aC5BdXRoZW50aWNhdGlvblIOYXV0aGVudGljYXRpb24iUQobVmVyaWZ5U2Vy", + "dmljZUFjY291bnRSZXF1ZXN0EjIKFXNlcnZpY2VfYWNjb3VudF90b2tlbhgB", + "IAEoCVITc2VydmljZUFjY291bnRUb2tlbiKFAQocVmVyaWZ5U2VydmljZUFj", + "Y291bnRSZXNwb25zZRIhCgxjbGllbnRfdG9rZW4YASABKAlSC2NsaWVudFRv", + "a2VuEkIKDmF1dGhlbnRpY2F0aW9uGAIgASgLMhouZmxpcHQuYXV0aC5BdXRo", + "ZW50aWNhdGlvblIOYXV0aGVudGljYXRpb24qjAEKBk1ldGhvZBIPCgtNRVRI", + "T0RfTk9ORRAAEhAKDE1FVEhPRF9UT0tFThABEg8KC01FVEhPRF9PSURDEAIS", + "FQoRTUVUSE9EX0tVQkVSTkVURVMQAxIRCg1NRVRIT0RfR0lUSFVCEAQSDgoK", + "TUVUSE9EX0pXVBAFEhQKDE1FVEhPRF9DTE9VRBAGGgIIATKDAQobUHVibGlj", + "QXV0aGVudGljYXRpb25TZXJ2aWNlEmQKGUxpc3RBdXRoZW50aWNhdGlvbk1l", + "dGhvZHMSFi5nb29nbGUucHJvdG9idWYuRW1wdHkaLS5mbGlwdC5hdXRoLkxp", + "c3RBdXRoZW50aWNhdGlvbk1ldGhvZHNSZXNwb25zZSIAMsYFChVBdXRoZW50", + "aWNhdGlvblNlcnZpY2UScgoVR2V0QXV0aGVudGljYXRpb25TZWxmEhYuZ29v", + "Z2xlLnByb3RvYnVmLkVtcHR5GhouZmxpcHQuYXV0aC5BdXRoZW50aWNhdGlv", + "biIlukcNKgtnZXRBdXRoU2VsZoLT5JMCDxINL2F1dGgvdjEvc2VsZhKEAQoR", + "R2V0QXV0aGVudGljYXRpb24SJC5mbGlwdC5hdXRoLkdldEF1dGhlbnRpY2F0", + "aW9uUmVxdWVzdBoaLmZsaXB0LmF1dGguQXV0aGVudGljYXRpb24iLbpHDioM", + "Z2V0QXV0aFRva2VugtPkkwIWEhQvYXV0aC92MS90b2tlbnMve2lkfRKSAQoT", + "TGlzdEF1dGhlbnRpY2F0aW9ucxImLmZsaXB0LmF1dGguTGlzdEF1dGhlbnRp", + "Y2F0aW9uc1JlcXVlc3QaJy5mbGlwdC5hdXRoLkxpc3RBdXRoZW50aWNhdGlv", + "bnNSZXNwb25zZSIqukcQKg5saXN0QXV0aFRva2Vuc4LT5JMCERIPL2F1dGgv", + "djEvdG9rZW5zEokBChREZWxldGVBdXRoZW50aWNhdGlvbhInLmZsaXB0LmF1", + "dGguRGVsZXRlQXV0aGVudGljYXRpb25SZXF1ZXN0GhYuZ29vZ2xlLnByb3Rv", + "YnVmLkVtcHR5IjC6RxEqD2RlbGV0ZUF1dGhUb2tlboLT5JMCFioUL2F1dGgv", + "djEvdG9rZW5zL3tpZH0SkAEKGEV4cGlyZUF1dGhlbnRpY2F0aW9uU2VsZhIr", + "LmZsaXB0LmF1dGguRXhwaXJlQXV0aGVudGljYXRpb25TZWxmUmVxdWVzdBoW", + "Lmdvb2dsZS5wcm90b2J1Zi5FbXB0eSIvukcQKg5leHBpcmVBdXRoU2VsZoLT", + "5JMCFhoUL2F1dGgvdjEvc2VsZi9leHBpcmUyqwEKIEF1dGhlbnRpY2F0aW9u", + "TWV0aG9kVG9rZW5TZXJ2aWNlEoYBCgtDcmVhdGVUb2tlbhIeLmZsaXB0LmF1", + "dGguQ3JlYXRlVG9rZW5SZXF1ZXN0Gh8uZmxpcHQuYXV0aC5DcmVhdGVUb2tl", + "blJlc3BvbnNlIja6RxMqEWNyZWF0ZU1ldGhvZFRva2VugtPkkwIaOgEqIhUv", + "YXV0aC92MS9tZXRob2QvdG9rZW4yyAIKH0F1dGhlbnRpY2F0aW9uTWV0aG9k", + "T0lEQ1NlcnZpY2USmQEKDEF1dGhvcml6ZVVSTBIfLmZsaXB0LmF1dGguQXV0", + "aG9yaXplVVJMUmVxdWVzdBogLmZsaXB0LmF1dGguQXV0aG9yaXplVVJMUmVz", + "cG9uc2UiRrpHEioQb2lkY0F1dGhvcml6ZVVSTILT5JMCKxIpL2F1dGgvdjEv", + "bWV0aG9kL29pZGMve3Byb3ZpZGVyfS9hdXRob3JpemUSiAEKCENhbGxiYWNr", + "EhsuZmxpcHQuYXV0aC5DYWxsYmFja1JlcXVlc3QaHC5mbGlwdC5hdXRoLkNh", + "bGxiYWNrUmVzcG9uc2UiQbpHDioMb2lkY0NhbGxiYWNrgtPkkwIqEigvYXV0", + "aC92MS9tZXRob2Qvb2lkYy97cHJvdmlkZXJ9L2NhbGxiYWNrMuwBCiVBdXRo", + "ZW50aWNhdGlvbk1ldGhvZEt1YmVybmV0ZXNTZXJ2aWNlEsIBChRWZXJpZnlT", + "ZXJ2aWNlQWNjb3VudBInLmZsaXB0LmF1dGguVmVyaWZ5U2VydmljZUFjY291", + "bnRSZXF1ZXN0GiguZmxpcHQuYXV0aC5WZXJpZnlTZXJ2aWNlQWNjb3VudFJl", + "c3BvbnNlIle6RyAqHmt1YmVybmV0ZXNWZXJpZnlTZXJ2aWNlQWNjb3VudILT", + "5JMCLjoBKiIpL2F1dGgvdjEvbWV0aG9kL2t1YmVybmV0ZXMvc2VydmljZWFj", + "Y291bnQywQEKIUF1dGhlbnRpY2F0aW9uTWV0aG9kR2l0aHViU2VydmljZRJT", + "CgxBdXRob3JpemVVUkwSHy5mbGlwdC5hdXRoLkF1dGhvcml6ZVVSTFJlcXVl", + "c3QaIC5mbGlwdC5hdXRoLkF1dGhvcml6ZVVSTFJlc3BvbnNlIgASRwoIQ2Fs", + "bGJhY2sSGy5mbGlwdC5hdXRoLkNhbGxiYWNrUmVxdWVzdBocLmZsaXB0LmF1", + "dGguQ2FsbGJhY2tSZXNwb25zZSIAQo4BWiBnby5mbGlwdC5pby9mbGlwdC9y", + "cGMvZmxpcHQvYXV0aLpHaRoXChVodHRwOi8vbG9jYWxob3N0OjgwODAqPDo6", + "Ch4KCmJlYXJlckF1dGgSEAoOCgRodHRwKgZiZWFyZXIKGAoHand0QXV0aBIN", + "CgsKBGh0dHAqA0pXVDIQCg4KCmJlYXJlckF1dGgSAGIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Gnostic.Openapi.V3.AnnotationsReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Flipt.Auth.Method), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.MethodInfo), global::Flipt.Auth.MethodInfo.Parser, new[]{ "Method", "Enabled", "SessionCompatible", "Metadata" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.ListAuthenticationMethodsResponse), global::Flipt.Auth.ListAuthenticationMethodsResponse.Parser, new[]{ "Methods" }, null, null, null, null), @@ -115,7 +133,7 @@ static AuthReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.ListAuthenticationsResponse), global::Flipt.Auth.ListAuthenticationsResponse.Parser, new[]{ "Authentications", "NextPageToken" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.DeleteAuthenticationRequest), global::Flipt.Auth.DeleteAuthenticationRequest.Parser, new[]{ "Id" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.ExpireAuthenticationSelfRequest), global::Flipt.Auth.ExpireAuthenticationSelfRequest.Parser, new[]{ "ExpiresAt" }, new[]{ "ExpiresAt" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.CreateTokenRequest), global::Flipt.Auth.CreateTokenRequest.Parser, new[]{ "Name", "Description", "ExpiresAt", "NamespaceKey" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.CreateTokenRequest), global::Flipt.Auth.CreateTokenRequest.Parser, new[]{ "Name", "Description", "ExpiresAt", "NamespaceKey", "Metadata" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.CreateTokenResponse), global::Flipt.Auth.CreateTokenResponse.Parser, new[]{ "ClientToken", "Authentication" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.AuthorizeURLRequest), global::Flipt.Auth.AuthorizeURLRequest.Parser, new[]{ "Provider", "State" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Auth.AuthorizeURLResponse), global::Flipt.Auth.AuthorizeURLResponse.Parser, new[]{ "AuthorizeUrl" }, null, null, null, null), @@ -136,6 +154,8 @@ public enum Method { [pbr::OriginalName("METHOD_KUBERNETES")] Kubernetes = 3, [pbr::OriginalName("METHOD_GITHUB")] Github = 4, [pbr::OriginalName("METHOD_JWT")] Jwt = 5, + [global::System.ObsoleteAttribute] + [pbr::OriginalName("METHOD_CLOUD")] Cloud = 6, } #endregion @@ -2110,6 +2130,7 @@ public CreateTokenRequest(CreateTokenRequest other) : this() { description_ = other.description_; expiresAt_ = other.expiresAt_ != null ? other.expiresAt_.Clone() : null; namespaceKey_ = other.namespaceKey_; + metadata_ = other.metadata_.Clone(); _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -2167,6 +2188,17 @@ public string NamespaceKey { } } + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 7; + private static readonly pbc::MapField.Codec _map_metadata_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 58); + private readonly pbc::MapField metadata_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Metadata { + get { return metadata_; } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -2186,6 +2218,7 @@ public bool Equals(CreateTokenRequest other) { if (Description != other.Description) return false; if (!object.Equals(ExpiresAt, other.ExpiresAt)) return false; if (NamespaceKey != other.NamespaceKey) return false; + if (!Metadata.Equals(other.Metadata)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -2197,6 +2230,7 @@ public override int GetHashCode() { if (Description.Length != 0) hash ^= Description.GetHashCode(); if (expiresAt_ != null) hash ^= ExpiresAt.GetHashCode(); if (NamespaceKey.Length != 0) hash ^= NamespaceKey.GetHashCode(); + hash ^= Metadata.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -2231,6 +2265,7 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(34); output.WriteString(NamespaceKey); } + metadata_.WriteTo(output, _map_metadata_codec); if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -2257,6 +2292,7 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(34); output.WriteString(NamespaceKey); } + metadata_.WriteTo(ref output, _map_metadata_codec); if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -2279,6 +2315,7 @@ public int CalculateSize() { if (NamespaceKey.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(NamespaceKey); } + size += metadata_.CalculateSize(_map_metadata_codec); if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -2306,6 +2343,7 @@ public void MergeFrom(CreateTokenRequest other) { if (other.NamespaceKey.Length != 0) { NamespaceKey = other.NamespaceKey; } + metadata_.MergeFrom(other.metadata_); _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -2340,6 +2378,10 @@ public void MergeFrom(pb::CodedInputStream input) { NamespaceKey = input.ReadString(); break; } + case 58: { + metadata_.AddEntriesFrom(input, _map_metadata_codec); + break; + } } } #endif @@ -2374,6 +2416,10 @@ public void MergeFrom(pb::CodedInputStream input) { NamespaceKey = input.ReadString(); break; } + case 58: { + metadata_.AddEntriesFrom(ref input, _map_metadata_codec); + break; + } } } } diff --git a/src/Flipt.Grpc/Evaluation.cs b/src/Flipt.Grpc/Evaluation.cs index 95464fb..4f2008a 100644 --- a/src/Flipt.Grpc/Evaluation.cs +++ b/src/Flipt.Grpc/Evaluation.cs @@ -25,134 +25,147 @@ static EvaluationReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "ChtldmFsdWF0aW9uL2V2YWx1YXRpb24ucHJvdG8SEGZsaXB0LmV2YWx1YXRp", - "b24aH2dvb2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8itQIKEUV2YWx1", - "YXRpb25SZXF1ZXN0Eh0KCnJlcXVlc3RfaWQYASABKAlSCXJlcXVlc3RJZBIj", - "Cg1uYW1lc3BhY2Vfa2V5GAIgASgJUgxuYW1lc3BhY2VLZXkSGQoIZmxhZ19r", - "ZXkYAyABKAlSB2ZsYWdLZXkSGwoJZW50aXR5X2lkGAQgASgJUghlbnRpdHlJ", - "ZBJKCgdjb250ZXh0GAUgAygLMjAuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0", - "aW9uUmVxdWVzdC5Db250ZXh0RW50cnlSB2NvbnRleHQSHAoJcmVmZXJlbmNl", - "GAYgASgJUglyZWZlcmVuY2UaOgoMQ29udGV4dEVudHJ5EhAKA2tleRgBIAEo", - "CVIDa2V5EhQKBXZhbHVlGAIgASgJUgV2YWx1ZToCOAEilgEKFkJhdGNoRXZh", - "bHVhdGlvblJlcXVlc3QSHQoKcmVxdWVzdF9pZBgBIAEoCVIJcmVxdWVzdElk", - "Ej8KCHJlcXVlc3RzGAMgAygLMiMuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0", - "aW9uUmVxdWVzdFIIcmVxdWVzdHMSHAoJcmVmZXJlbmNlGAQgASgJUglyZWZl", - "cmVuY2UitAEKF0JhdGNoRXZhbHVhdGlvblJlc3BvbnNlEh0KCnJlcXVlc3Rf", - "aWQYASABKAlSCXJlcXVlc3RJZBJCCglyZXNwb25zZXMYAiADKAsyJC5mbGlw", - "dC5ldmFsdWF0aW9uLkV2YWx1YXRpb25SZXNwb25zZVIJcmVzcG9uc2VzEjYK", - "F3JlcXVlc3RfZHVyYXRpb25fbWlsbGlzGAMgASgBUhVyZXF1ZXN0RHVyYXRp", - "b25NaWxsaXMi5gIKEkV2YWx1YXRpb25SZXNwb25zZRI8CgR0eXBlGAEgASgO", - "MiguZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uUmVzcG9uc2VUeXBlUgR0", - "eXBlElgKEGJvb2xlYW5fcmVzcG9uc2UYAiABKAsyKy5mbGlwdC5ldmFsdWF0", - "aW9uLkJvb2xlYW5FdmFsdWF0aW9uUmVzcG9uc2VIAFIPYm9vbGVhblJlc3Bv", - "bnNlElgKEHZhcmlhbnRfcmVzcG9uc2UYAyABKAsyKy5mbGlwdC5ldmFsdWF0", - "aW9uLlZhcmlhbnRFdmFsdWF0aW9uUmVzcG9uc2VIAFIPdmFyaWFudFJlc3Bv", - "bnNlElIKDmVycm9yX3Jlc3BvbnNlGAQgASgLMikuZmxpcHQuZXZhbHVhdGlv", - "bi5FcnJvckV2YWx1YXRpb25SZXNwb25zZUgAUg1lcnJvclJlc3BvbnNlQgoK", - "CHJlc3BvbnNlIp0CChlCb29sZWFuRXZhbHVhdGlvblJlc3BvbnNlEhgKB2Vu", - "YWJsZWQYASABKAhSB2VuYWJsZWQSOgoGcmVhc29uGAIgASgOMiIuZmxpcHQu", - "ZXZhbHVhdGlvbi5FdmFsdWF0aW9uUmVhc29uUgZyZWFzb24SHQoKcmVxdWVz", - "dF9pZBgDIAEoCVIJcmVxdWVzdElkEjYKF3JlcXVlc3RfZHVyYXRpb25fbWls", - "bGlzGAQgASgBUhVyZXF1ZXN0RHVyYXRpb25NaWxsaXMSOAoJdGltZXN0YW1w", - "GAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJdGltZXN0YW1w", - "EhkKCGZsYWdfa2V5GAYgASgJUgdmbGFnS2V5IowDChlWYXJpYW50RXZhbHVh", - "dGlvblJlc3BvbnNlEhQKBW1hdGNoGAEgASgIUgVtYXRjaBIhCgxzZWdtZW50", - "X2tleXMYAiADKAlSC3NlZ21lbnRLZXlzEjoKBnJlYXNvbhgDIAEoDjIiLmZs", - "aXB0LmV2YWx1YXRpb24uRXZhbHVhdGlvblJlYXNvblIGcmVhc29uEh8KC3Zh", - "cmlhbnRfa2V5GAQgASgJUgp2YXJpYW50S2V5Ei0KEnZhcmlhbnRfYXR0YWNo", - "bWVudBgFIAEoCVIRdmFyaWFudEF0dGFjaG1lbnQSHQoKcmVxdWVzdF9pZBgG", - "IAEoCVIJcmVxdWVzdElkEjYKF3JlcXVlc3RfZHVyYXRpb25fbWlsbGlzGAcg", - "ASgBUhVyZXF1ZXN0RHVyYXRpb25NaWxsaXMSOAoJdGltZXN0YW1wGAggASgL", - "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJdGltZXN0YW1wEhkKCGZs", - "YWdfa2V5GAkgASgJUgdmbGFnS2V5IpoBChdFcnJvckV2YWx1YXRpb25SZXNw", - "b25zZRIZCghmbGFnX2tleRgBIAEoCVIHZmxhZ0tleRIjCg1uYW1lc3BhY2Vf", - "a2V5GAIgASgJUgxuYW1lc3BhY2VLZXkSPwoGcmVhc29uGAMgASgOMicuZmxp", - "cHQuZXZhbHVhdGlvbi5FcnJvckV2YWx1YXRpb25SZWFzb25SBnJlYXNvbiLK", - "AQoWRXZhbHVhdGlvbkRpc3RyaWJ1dGlvbhIOCgJpZBgBIAEoCVICaWQSFwoH", - "cnVsZV9pZBgCIAEoCVIGcnVsZUlkEh0KCnZhcmlhbnRfaWQYAyABKAlSCXZh", - "cmlhbnRJZBIfCgt2YXJpYW50X2tleRgEIAEoCVIKdmFyaWFudEtleRItChJ2", - "YXJpYW50X2F0dGFjaG1lbnQYBSABKAlSEXZhcmlhbnRBdHRhY2htZW50EhgK", - "B3JvbGxvdXQYBiABKAJSB3JvbGxvdXQiggIKEUV2YWx1YXRpb25Sb2xsb3V0", - "EjsKBHR5cGUYASABKA4yJy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25S", - "b2xsb3V0VHlwZVIEdHlwZRISCgRyYW5rGAIgASgFUgRyYW5rEkYKB3NlZ21l", - "bnQYAyABKAsyKi5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25Sb2xsb3V0", - "U2VnbWVudEgAUgdzZWdtZW50EkwKCXRocmVzaG9sZBgEIAEoCzIsLmZsaXB0", - "LmV2YWx1YXRpb24uRXZhbHVhdGlvblJvbGxvdXRUaHJlc2hvbGRIAFIJdGhy", - "ZXNob2xkQgYKBHJ1bGUiUgoaRXZhbHVhdGlvblJvbGxvdXRUaHJlc2hvbGQS", - "HgoKcGVyY2VudGFnZRgBIAEoAlIKcGVyY2VudGFnZRIUCgV2YWx1ZRgCIAEo", - "CFIFdmFsdWUiyQEKGEV2YWx1YXRpb25Sb2xsb3V0U2VnbWVudBIUCgV2YWx1", - "ZRgBIAEoCFIFdmFsdWUSVgoQc2VnbWVudF9vcGVyYXRvchgCIAEoDjIrLmZs", - "aXB0LmV2YWx1YXRpb24uRXZhbHVhdGlvblNlZ21lbnRPcGVyYXRvclIPc2Vn", - "bWVudE9wZXJhdG9yEj8KCHNlZ21lbnRzGAMgAygLMiMuZmxpcHQuZXZhbHVh", - "dGlvbi5FdmFsdWF0aW9uU2VnbWVudFIIc2VnbWVudHMi6AIKEUV2YWx1YXRp", - "b25TZWdtZW50EhAKA2tleRgBIAEoCVIDa2V5EhIKBG5hbWUYAiABKAlSBG5h", - "bWUSIAoLZGVzY3JpcHRpb24YAyABKAlSC2Rlc2NyaXB0aW9uEksKCm1hdGNo", - "X3R5cGUYBCABKA4yLC5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25TZWdt", - "ZW50TWF0Y2hUeXBlUgltYXRjaFR5cGUSOQoKY3JlYXRlZF9hdBgFIAEoCzIa", - "Lmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCWNyZWF0ZWRBdBI5Cgp1cGRh", - "dGVkX2F0GAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJdXBk", - "YXRlZEF0EkgKC2NvbnN0cmFpbnRzGAcgAygLMiYuZmxpcHQuZXZhbHVhdGlv", - "bi5FdmFsdWF0aW9uQ29uc3RyYWludFILY29uc3RyYWludHMimwMKDkV2YWx1", - "YXRpb25GbGFnEhAKA2tleRgBIAEoCVIDa2V5EhIKBG5hbWUYAiABKAlSBG5h", - "bWUSIAoLZGVzY3JpcHRpb24YAyABKAlSC2Rlc2NyaXB0aW9uEhgKB2VuYWJs", - "ZWQYBCABKAhSB2VuYWJsZWQSOAoEdHlwZRgFIAEoDjIkLmZsaXB0LmV2YWx1", - "YXRpb24uRXZhbHVhdGlvbkZsYWdUeXBlUgR0eXBlEjkKCmNyZWF0ZWRfYXQY", - "BiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgljcmVhdGVkQXQS", - "OQoKdXBkYXRlZF9hdBgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3Rh", - "bXBSCXVwZGF0ZWRBdBI2CgVydWxlcxgIIAMoCzIgLmZsaXB0LmV2YWx1YXRp", - "b24uRXZhbHVhdGlvblJ1bGVSBXJ1bGVzEj8KCHJvbGxvdXRzGAkgAygLMiMu", - "ZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uUm9sbG91dFIIcm9sbG91dHMi", - "vgEKFEV2YWx1YXRpb25Db25zdHJhaW50Eg4KAmlkGAEgASgJUgJpZBJICgR0", - "eXBlGAIgASgOMjQuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uQ29uc3Ry", - "YWludENvbXBhcmlzb25UeXBlUgR0eXBlEhoKCHByb3BlcnR5GAMgASgJUghw", - "cm9wZXJ0eRIaCghvcGVyYXRvchgEIAEoCVIIb3BlcmF0b3ISFAoFdmFsdWUY", - "BSABKAlSBXZhbHVlIp0CCg5FdmFsdWF0aW9uUnVsZRIOCgJpZBgBIAEoCVIC", - "aWQSPwoIc2VnbWVudHMYAiADKAsyIy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1", - "YXRpb25TZWdtZW50UghzZWdtZW50cxISCgRyYW5rGAMgASgFUgRyYW5rElYK", - "EHNlZ21lbnRfb3BlcmF0b3IYBCABKA4yKy5mbGlwdC5ldmFsdWF0aW9uLkV2", - "YWx1YXRpb25TZWdtZW50T3BlcmF0b3JSD3NlZ21lbnRPcGVyYXRvchJOCg1k", - "aXN0cmlidXRpb25zGAUgAygLMiguZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0", - "aW9uRGlzdHJpYnV0aW9uUg1kaXN0cmlidXRpb25zIicKE0V2YWx1YXRpb25O", - "YW1lc3BhY2USEAoDa2V5GAEgASgJUgNrZXkimgEKG0V2YWx1YXRpb25OYW1l", - "c3BhY2VTbmFwc2hvdBJDCgluYW1lc3BhY2UYASABKAsyJS5mbGlwdC5ldmFs", - "dWF0aW9uLkV2YWx1YXRpb25OYW1lc3BhY2VSCW5hbWVzcGFjZRI2CgVmbGFn", - "cxgCIAMoCzIgLmZsaXB0LmV2YWx1YXRpb24uRXZhbHVhdGlvbkZsYWdSBWZs", - "YWdzIlQKIkV2YWx1YXRpb25OYW1lc3BhY2VTbmFwc2hvdFJlcXVlc3QSEAoD", - "a2V5GAEgASgJUgNrZXkSHAoJcmVmZXJlbmNlGAIgASgJUglyZWZlcmVuY2Uq", - "kgEKEEV2YWx1YXRpb25SZWFzb24SHQoZVU5LTk9XTl9FVkFMVUFUSU9OX1JF", - "QVNPThAAEiMKH0ZMQUdfRElTQUJMRURfRVZBTFVBVElPTl9SRUFTT04QARIb", - "ChdNQVRDSF9FVkFMVUFUSU9OX1JFQVNPThACEh0KGURFRkFVTFRfRVZBTFVB", - "VElPTl9SRUFTT04QAypjChVFcnJvckV2YWx1YXRpb25SZWFzb24SIwofVU5L", - "Tk9XTl9FUlJPUl9FVkFMVUFUSU9OX1JFQVNPThAAEiUKIU5PVF9GT1VORF9F", - "UlJPUl9FVkFMVUFUSU9OX1JFQVNPThABKogBChZFdmFsdWF0aW9uUmVzcG9u", - "c2VUeXBlEiQKIFZBUklBTlRfRVZBTFVBVElPTl9SRVNQT05TRV9UWVBFEAAS", - "JAogQk9PTEVBTl9FVkFMVUFUSU9OX1JFU1BPTlNFX1RZUEUQARIiCh5FUlJP", - "Ul9FVkFMVUFUSU9OX1JFU1BPTlNFX1RZUEUQAipnChVFdmFsdWF0aW9uUm9s", - "bG91dFR5cGUSGAoUVU5LTk9XTl9ST0xMT1VUX1RZUEUQABIYChRTRUdNRU5U", - "X1JPTExPVVRfVFlQRRABEhoKFlRIUkVTSE9MRF9ST0xMT1VUX1RZUEUQAipO", - "ChlFdmFsdWF0aW9uU2VnbWVudE9wZXJhdG9yEhcKE09SX1NFR01FTlRfT1BF", - "UkFUT1IQABIYChRBTkRfU0VHTUVOVF9PUEVSQVRPUhABKlQKGkV2YWx1YXRp", - "b25TZWdtZW50TWF0Y2hUeXBlEhoKFkFMTF9TRUdNRU5UX01BVENIX1RZUEUQ", - "ABIaChZBTllfU0VHTUVOVF9NQVRDSF9UWVBFEAEqQgoSRXZhbHVhdGlvbkZs", - "YWdUeXBlEhUKEVZBUklBTlRfRkxBR19UWVBFEAASFQoRQk9PTEVBTl9GTEFH", - "X1RZUEUQASrrAQoiRXZhbHVhdGlvbkNvbnN0cmFpbnRDb21wYXJpc29uVHlw", - "ZRImCiJVTktOT1dOX0NPTlNUUkFJTlRfQ09NUEFSSVNPTl9UWVBFEAASJQoh", - "U1RSSU5HX0NPTlNUUkFJTlRfQ09NUEFSSVNPTl9UWVBFEAESJQohTlVNQkVS", - "X0NPTlNUUkFJTlRfQ09NUEFSSVNPTl9UWVBFEAISJgoiQk9PTEVBTl9DT05T", - "VFJBSU5UX0NPTVBBUklTT05fVFlQRRADEicKI0RBVEVUSU1FX0NPTlNUUkFJ", - "TlRfQ09NUEFSSVNPTl9UWVBFEAQysQIKEUV2YWx1YXRpb25TZXJ2aWNlEl0K", - "B0Jvb2xlYW4SIy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25SZXF1ZXN0", - "GisuZmxpcHQuZXZhbHVhdGlvbi5Cb29sZWFuRXZhbHVhdGlvblJlc3BvbnNl", - "IgASXQoHVmFyaWFudBIjLmZsaXB0LmV2YWx1YXRpb24uRXZhbHVhdGlvblJl", - "cXVlc3QaKy5mbGlwdC5ldmFsdWF0aW9uLlZhcmlhbnRFdmFsdWF0aW9uUmVz", - "cG9uc2UiABJeCgVCYXRjaBIoLmZsaXB0LmV2YWx1YXRpb24uQmF0Y2hFdmFs", - "dWF0aW9uUmVxdWVzdBopLmZsaXB0LmV2YWx1YXRpb24uQmF0Y2hFdmFsdWF0", - "aW9uUmVzcG9uc2UiADKSAQoLRGF0YVNlcnZpY2USggEKG0V2YWx1YXRpb25T", - "bmFwc2hvdE5hbWVzcGFjZRI0LmZsaXB0LmV2YWx1YXRpb24uRXZhbHVhdGlv", - "bk5hbWVzcGFjZVNuYXBzaG90UmVxdWVzdBotLmZsaXB0LmV2YWx1YXRpb24u", - "RXZhbHVhdGlvbk5hbWVzcGFjZVNuYXBzaG90QihaJmdvLmZsaXB0LmlvL2Zs", - "aXB0L3JwYy9mbGlwdC9ldmFsdWF0aW9uYgZwcm90bzM=")); + "b24aH2dvb2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8aHGdvb2dsZS9h", + "cGkvYW5ub3RhdGlvbnMucHJvdG8aG2dvb2dsZS9hcGkvdmlzaWJpbGl0eS5w", + "cm90bxofZ29vZ2xlL2FwaS9maWVsZF9iZWhhdmlvci5wcm90bxokZ25vc3Rp", + "Yy9vcGVuYXBpL3YzL2Fubm90YXRpb25zLnByb3RvIskCChFFdmFsdWF0aW9u", + "UmVxdWVzdBIdCgpyZXF1ZXN0X2lkGAEgASgJUglyZXF1ZXN0SWQSKAoNbmFt", + "ZXNwYWNlX2tleRgCIAEoCUID4EECUgxuYW1lc3BhY2VLZXkSHgoIZmxhZ19r", + "ZXkYAyABKAlCA+BBAlIHZmxhZ0tleRIgCgllbnRpdHlfaWQYBCABKAlCA+BB", + "AlIIZW50aXR5SWQSTwoHY29udGV4dBgFIAMoCzIwLmZsaXB0LmV2YWx1YXRp", + "b24uRXZhbHVhdGlvblJlcXVlc3QuQ29udGV4dEVudHJ5QgPgQQJSB2NvbnRl", + "eHQSHAoJcmVmZXJlbmNlGAYgASgJUglyZWZlcmVuY2UaOgoMQ29udGV4dEVu", + "dHJ5EhAKA2tleRgBIAEoCVIDa2V5EhQKBXZhbHVlGAIgASgJUgV2YWx1ZToC", + "OAEimwEKFkJhdGNoRXZhbHVhdGlvblJlcXVlc3QSHQoKcmVxdWVzdF9pZBgB", + "IAEoCVIJcmVxdWVzdElkEkQKCHJlcXVlc3RzGAMgAygLMiMuZmxpcHQuZXZh", + "bHVhdGlvbi5FdmFsdWF0aW9uUmVxdWVzdEID4EECUghyZXF1ZXN0cxIcCgly", + "ZWZlcmVuY2UYBCABKAlSCXJlZmVyZW5jZSK0AQoXQmF0Y2hFdmFsdWF0aW9u", + "UmVzcG9uc2USHQoKcmVxdWVzdF9pZBgBIAEoCVIJcmVxdWVzdElkEkIKCXJl", + "c3BvbnNlcxgCIAMoCzIkLmZsaXB0LmV2YWx1YXRpb24uRXZhbHVhdGlvblJl", + "c3BvbnNlUglyZXNwb25zZXMSNgoXcmVxdWVzdF9kdXJhdGlvbl9taWxsaXMY", + "AyABKAFSFXJlcXVlc3REdXJhdGlvbk1pbGxpcyLmAgoSRXZhbHVhdGlvblJl", + "c3BvbnNlEjwKBHR5cGUYASABKA4yKC5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1", + "YXRpb25SZXNwb25zZVR5cGVSBHR5cGUSWAoQYm9vbGVhbl9yZXNwb25zZRgC", + "IAEoCzIrLmZsaXB0LmV2YWx1YXRpb24uQm9vbGVhbkV2YWx1YXRpb25SZXNw", + "b25zZUgAUg9ib29sZWFuUmVzcG9uc2USWAoQdmFyaWFudF9yZXNwb25zZRgD", + "IAEoCzIrLmZsaXB0LmV2YWx1YXRpb24uVmFyaWFudEV2YWx1YXRpb25SZXNw", + "b25zZUgAUg92YXJpYW50UmVzcG9uc2USUgoOZXJyb3JfcmVzcG9uc2UYBCAB", + "KAsyKS5mbGlwdC5ldmFsdWF0aW9uLkVycm9yRXZhbHVhdGlvblJlc3BvbnNl", + "SABSDWVycm9yUmVzcG9uc2VCCgoIcmVzcG9uc2UinQIKGUJvb2xlYW5FdmFs", + "dWF0aW9uUmVzcG9uc2USGAoHZW5hYmxlZBgBIAEoCFIHZW5hYmxlZBI6CgZy", + "ZWFzb24YAiABKA4yIi5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25SZWFz", + "b25SBnJlYXNvbhIdCgpyZXF1ZXN0X2lkGAMgASgJUglyZXF1ZXN0SWQSNgoX", + "cmVxdWVzdF9kdXJhdGlvbl9taWxsaXMYBCABKAFSFXJlcXVlc3REdXJhdGlv", + "bk1pbGxpcxI4Cgl0aW1lc3RhbXAYBSABKAsyGi5nb29nbGUucHJvdG9idWYu", + "VGltZXN0YW1wUgl0aW1lc3RhbXASGQoIZmxhZ19rZXkYBiABKAlSB2ZsYWdL", + "ZXkijAMKGVZhcmlhbnRFdmFsdWF0aW9uUmVzcG9uc2USFAoFbWF0Y2gYASAB", + "KAhSBW1hdGNoEiEKDHNlZ21lbnRfa2V5cxgCIAMoCVILc2VnbWVudEtleXMS", + "OgoGcmVhc29uGAMgASgOMiIuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9u", + "UmVhc29uUgZyZWFzb24SHwoLdmFyaWFudF9rZXkYBCABKAlSCnZhcmlhbnRL", + "ZXkSLQoSdmFyaWFudF9hdHRhY2htZW50GAUgASgJUhF2YXJpYW50QXR0YWNo", + "bWVudBIdCgpyZXF1ZXN0X2lkGAYgASgJUglyZXF1ZXN0SWQSNgoXcmVxdWVz", + "dF9kdXJhdGlvbl9taWxsaXMYByABKAFSFXJlcXVlc3REdXJhdGlvbk1pbGxp", + "cxI4Cgl0aW1lc3RhbXAYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", + "YW1wUgl0aW1lc3RhbXASGQoIZmxhZ19rZXkYCSABKAlSB2ZsYWdLZXkimgEK", + "F0Vycm9yRXZhbHVhdGlvblJlc3BvbnNlEhkKCGZsYWdfa2V5GAEgASgJUgdm", + "bGFnS2V5EiMKDW5hbWVzcGFjZV9rZXkYAiABKAlSDG5hbWVzcGFjZUtleRI/", + "CgZyZWFzb24YAyABKA4yJy5mbGlwdC5ldmFsdWF0aW9uLkVycm9yRXZhbHVh", + "dGlvblJlYXNvblIGcmVhc29uIsoBChZFdmFsdWF0aW9uRGlzdHJpYnV0aW9u", + "Eg4KAmlkGAEgASgJUgJpZBIXCgdydWxlX2lkGAIgASgJUgZydWxlSWQSHQoK", + "dmFyaWFudF9pZBgDIAEoCVIJdmFyaWFudElkEh8KC3ZhcmlhbnRfa2V5GAQg", + "ASgJUgp2YXJpYW50S2V5Ei0KEnZhcmlhbnRfYXR0YWNobWVudBgFIAEoCVIR", + "dmFyaWFudEF0dGFjaG1lbnQSGAoHcm9sbG91dBgGIAEoAlIHcm9sbG91dCKC", + "AgoRRXZhbHVhdGlvblJvbGxvdXQSOwoEdHlwZRgBIAEoDjInLmZsaXB0LmV2", + "YWx1YXRpb24uRXZhbHVhdGlvblJvbGxvdXRUeXBlUgR0eXBlEhIKBHJhbmsY", + "AiABKAVSBHJhbmsSRgoHc2VnbWVudBgDIAEoCzIqLmZsaXB0LmV2YWx1YXRp", + "b24uRXZhbHVhdGlvblJvbGxvdXRTZWdtZW50SABSB3NlZ21lbnQSTAoJdGhy", + "ZXNob2xkGAQgASgLMiwuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uUm9s", + "bG91dFRocmVzaG9sZEgAUgl0aHJlc2hvbGRCBgoEcnVsZSJSChpFdmFsdWF0", + "aW9uUm9sbG91dFRocmVzaG9sZBIeCgpwZXJjZW50YWdlGAEgASgCUgpwZXJj", + "ZW50YWdlEhQKBXZhbHVlGAIgASgIUgV2YWx1ZSLJAQoYRXZhbHVhdGlvblJv", + "bGxvdXRTZWdtZW50EhQKBXZhbHVlGAEgASgIUgV2YWx1ZRJWChBzZWdtZW50", + "X29wZXJhdG9yGAIgASgOMisuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9u", + "U2VnbWVudE9wZXJhdG9yUg9zZWdtZW50T3BlcmF0b3ISPwoIc2VnbWVudHMY", + "AyADKAsyIy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25TZWdtZW50Ughz", + "ZWdtZW50cyLoAgoRRXZhbHVhdGlvblNlZ21lbnQSEAoDa2V5GAEgASgJUgNr", + "ZXkSEgoEbmFtZRgCIAEoCVIEbmFtZRIgCgtkZXNjcmlwdGlvbhgDIAEoCVIL", + "ZGVzY3JpcHRpb24SSwoKbWF0Y2hfdHlwZRgEIAEoDjIsLmZsaXB0LmV2YWx1", + "YXRpb24uRXZhbHVhdGlvblNlZ21lbnRNYXRjaFR5cGVSCW1hdGNoVHlwZRI5", + "CgpjcmVhdGVkX2F0GAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFt", + "cFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRfYXQYBiABKAsyGi5nb29nbGUucHJv", + "dG9idWYuVGltZXN0YW1wUgl1cGRhdGVkQXQSSAoLY29uc3RyYWludHMYByAD", + "KAsyJi5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25Db25zdHJhaW50Ugtj", + "b25zdHJhaW50cyJVChFFdmFsdWF0aW9uVmFyaWFudBIOCgJpZBgBIAEoCVIC", + "aWQSEAoDa2V5GAIgASgJUgNrZXkSHgoKYXR0YWNobWVudBgDIAEoCVIKYXR0", + "YWNobWVudCKCBAoORXZhbHVhdGlvbkZsYWcSEAoDa2V5GAEgASgJUgNrZXkS", + "EgoEbmFtZRgCIAEoCVIEbmFtZRIgCgtkZXNjcmlwdGlvbhgDIAEoCVILZGVz", + "Y3JpcHRpb24SGAoHZW5hYmxlZBgEIAEoCFIHZW5hYmxlZBI4CgR0eXBlGAUg", + "ASgOMiQuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uRmxhZ1R5cGVSBHR5", + "cGUSOQoKY3JlYXRlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1l", + "c3RhbXBSCWNyZWF0ZWRBdBI5Cgp1cGRhdGVkX2F0GAcgASgLMhouZ29vZ2xl", + "LnByb3RvYnVmLlRpbWVzdGFtcFIJdXBkYXRlZEF0EjYKBXJ1bGVzGAggAygL", + "MiAuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uUnVsZVIFcnVsZXMSPwoI", + "cm9sbG91dHMYCSADKAsyIy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25S", + "b2xsb3V0Ughyb2xsb3V0cxJRCg9kZWZhdWx0X3ZhcmlhbnQYCiABKAsyIy5m", + "bGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25WYXJpYW50SABSDmRlZmF1bHRW", + "YXJpYW50iAEBQhIKEF9kZWZhdWx0X3ZhcmlhbnQivgEKFEV2YWx1YXRpb25D", + "b25zdHJhaW50Eg4KAmlkGAEgASgJUgJpZBJICgR0eXBlGAIgASgOMjQuZmxp", + "cHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uQ29uc3RyYWludENvbXBhcmlzb25U", + "eXBlUgR0eXBlEhoKCHByb3BlcnR5GAMgASgJUghwcm9wZXJ0eRIaCghvcGVy", + "YXRvchgEIAEoCVIIb3BlcmF0b3ISFAoFdmFsdWUYBSABKAlSBXZhbHVlIp0C", + "Cg5FdmFsdWF0aW9uUnVsZRIOCgJpZBgBIAEoCVICaWQSPwoIc2VnbWVudHMY", + "AiADKAsyIy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25TZWdtZW50Ughz", + "ZWdtZW50cxISCgRyYW5rGAMgASgFUgRyYW5rElYKEHNlZ21lbnRfb3BlcmF0", + "b3IYBCABKA4yKy5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRpb25TZWdtZW50", + "T3BlcmF0b3JSD3NlZ21lbnRPcGVyYXRvchJOCg1kaXN0cmlidXRpb25zGAUg", + "AygLMiguZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uRGlzdHJpYnV0aW9u", + "Ug1kaXN0cmlidXRpb25zIicKE0V2YWx1YXRpb25OYW1lc3BhY2USEAoDa2V5", + "GAEgASgJUgNrZXkimgEKG0V2YWx1YXRpb25OYW1lc3BhY2VTbmFwc2hvdBJD", + "CgluYW1lc3BhY2UYASABKAsyJS5mbGlwdC5ldmFsdWF0aW9uLkV2YWx1YXRp", + "b25OYW1lc3BhY2VSCW5hbWVzcGFjZRI2CgVmbGFncxgCIAMoCzIgLmZsaXB0", + "LmV2YWx1YXRpb24uRXZhbHVhdGlvbkZsYWdSBWZsYWdzIlQKIkV2YWx1YXRp", + "b25OYW1lc3BhY2VTbmFwc2hvdFJlcXVlc3QSEAoDa2V5GAEgASgJUgNrZXkS", + "HAoJcmVmZXJlbmNlGAIgASgJUglyZWZlcmVuY2UqkgEKEEV2YWx1YXRpb25S", + "ZWFzb24SHQoZVU5LTk9XTl9FVkFMVUFUSU9OX1JFQVNPThAAEiMKH0ZMQUdf", + "RElTQUJMRURfRVZBTFVBVElPTl9SRUFTT04QARIbChdNQVRDSF9FVkFMVUFU", + "SU9OX1JFQVNPThACEh0KGURFRkFVTFRfRVZBTFVBVElPTl9SRUFTT04QAypj", + "ChVFcnJvckV2YWx1YXRpb25SZWFzb24SIwofVU5LTk9XTl9FUlJPUl9FVkFM", + "VUFUSU9OX1JFQVNPThAAEiUKIU5PVF9GT1VORF9FUlJPUl9FVkFMVUFUSU9O", + "X1JFQVNPThABKogBChZFdmFsdWF0aW9uUmVzcG9uc2VUeXBlEiQKIFZBUklB", + "TlRfRVZBTFVBVElPTl9SRVNQT05TRV9UWVBFEAASJAogQk9PTEVBTl9FVkFM", + "VUFUSU9OX1JFU1BPTlNFX1RZUEUQARIiCh5FUlJPUl9FVkFMVUFUSU9OX1JF", + "U1BPTlNFX1RZUEUQAipnChVFdmFsdWF0aW9uUm9sbG91dFR5cGUSGAoUVU5L", + "Tk9XTl9ST0xMT1VUX1RZUEUQABIYChRTRUdNRU5UX1JPTExPVVRfVFlQRRAB", + "EhoKFlRIUkVTSE9MRF9ST0xMT1VUX1RZUEUQAipOChlFdmFsdWF0aW9uU2Vn", + "bWVudE9wZXJhdG9yEhcKE09SX1NFR01FTlRfT1BFUkFUT1IQABIYChRBTkRf", + "U0VHTUVOVF9PUEVSQVRPUhABKlQKGkV2YWx1YXRpb25TZWdtZW50TWF0Y2hU", + "eXBlEhoKFkFMTF9TRUdNRU5UX01BVENIX1RZUEUQABIaChZBTllfU0VHTUVO", + "VF9NQVRDSF9UWVBFEAEqQgoSRXZhbHVhdGlvbkZsYWdUeXBlEhUKEVZBUklB", + "TlRfRkxBR19UWVBFEAASFQoRQk9PTEVBTl9GTEFHX1RZUEUQASqVAgoiRXZh", + "bHVhdGlvbkNvbnN0cmFpbnRDb21wYXJpc29uVHlwZRImCiJVTktOT1dOX0NP", + "TlNUUkFJTlRfQ09NUEFSSVNPTl9UWVBFEAASJQohU1RSSU5HX0NPTlNUUkFJ", + "TlRfQ09NUEFSSVNPTl9UWVBFEAESJQohTlVNQkVSX0NPTlNUUkFJTlRfQ09N", + "UEFSSVNPTl9UWVBFEAISJgoiQk9PTEVBTl9DT05TVFJBSU5UX0NPTVBBUklT", + "T05fVFlQRRADEicKI0RBVEVUSU1FX0NPTlNUUkFJTlRfQ09NUEFSSVNPTl9U", + "WVBFEAQSKAokRU5USVRZX0lEX0NPTlNUUkFJTlRfQ09NUEFSSVNPTl9UWVBF", + "EAUyyQMKEUV2YWx1YXRpb25TZXJ2aWNlEpABCgdCb29sZWFuEiMuZmxpcHQu", + "ZXZhbHVhdGlvbi5FdmFsdWF0aW9uUmVxdWVzdBorLmZsaXB0LmV2YWx1YXRp", + "b24uQm9vbGVhbkV2YWx1YXRpb25SZXNwb25zZSIzukcRKg9ldmFsdWF0ZUJv", + "b2xlYW6C0+STAhk6ASoiFC9ldmFsdWF0ZS92MS9ib29sZWFuEpABCgdWYXJp", + "YW50EiMuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9uUmVxdWVzdBorLmZs", + "aXB0LmV2YWx1YXRpb24uVmFyaWFudEV2YWx1YXRpb25SZXNwb25zZSIzukcR", + "Kg9ldmFsdWF0ZVZhcmlhbnSC0+STAhk6ASoiFC9ldmFsdWF0ZS92MS92YXJp", + "YW50Eo0BCgVCYXRjaBIoLmZsaXB0LmV2YWx1YXRpb24uQmF0Y2hFdmFsdWF0", + "aW9uUmVxdWVzdBopLmZsaXB0LmV2YWx1YXRpb24uQmF0Y2hFdmFsdWF0aW9u", + "UmVzcG9uc2UiL7pHDyoNZXZhbHVhdGVCYXRjaILT5JMCFzoBKiISL2V2YWx1", + "YXRlL3YxL2JhdGNoMqwBCgtEYXRhU2VydmljZRKCAQobRXZhbHVhdGlvblNu", + "YXBzaG90TmFtZXNwYWNlEjQuZmxpcHQuZXZhbHVhdGlvbi5FdmFsdWF0aW9u", + "TmFtZXNwYWNlU25hcHNob3RSZXF1ZXN0Gi0uZmxpcHQuZXZhbHVhdGlvbi5F", + "dmFsdWF0aW9uTmFtZXNwYWNlU25hcHNob3QaGPrS5JMCEhIQZmxpcHQ6c2Rr", + "Omlnbm9yZUIoWiZnby5mbGlwdC5pby9mbGlwdC9ycGMvZmxpcHQvZXZhbHVh", + "dGlvbmIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.VisibilityReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Gnostic.Openapi.V3.AnnotationsReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Flipt.Evaluation.EvaluationReason), typeof(global::Flipt.Evaluation.ErrorEvaluationReason), typeof(global::Flipt.Evaluation.EvaluationResponseType), typeof(global::Flipt.Evaluation.EvaluationRolloutType), typeof(global::Flipt.Evaluation.EvaluationSegmentOperator), typeof(global::Flipt.Evaluation.EvaluationSegmentMatchType), typeof(global::Flipt.Evaluation.EvaluationFlagType), typeof(global::Flipt.Evaluation.EvaluationConstraintComparisonType), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationRequest), global::Flipt.Evaluation.EvaluationRequest.Parser, new[]{ "RequestId", "NamespaceKey", "FlagKey", "EntityId", "Context", "Reference" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.BatchEvaluationRequest), global::Flipt.Evaluation.BatchEvaluationRequest.Parser, new[]{ "RequestId", "Requests", "Reference" }, null, null, null, null), @@ -166,7 +179,8 @@ static EvaluationReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationRolloutThreshold), global::Flipt.Evaluation.EvaluationRolloutThreshold.Parser, new[]{ "Percentage", "Value" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationRolloutSegment), global::Flipt.Evaluation.EvaluationRolloutSegment.Parser, new[]{ "Value", "SegmentOperator", "Segments" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationSegment), global::Flipt.Evaluation.EvaluationSegment.Parser, new[]{ "Key", "Name", "Description", "MatchType", "CreatedAt", "UpdatedAt", "Constraints" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationFlag), global::Flipt.Evaluation.EvaluationFlag.Parser, new[]{ "Key", "Name", "Description", "Enabled", "Type", "CreatedAt", "UpdatedAt", "Rules", "Rollouts" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationVariant), global::Flipt.Evaluation.EvaluationVariant.Parser, new[]{ "Id", "Key", "Attachment" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationFlag), global::Flipt.Evaluation.EvaluationFlag.Parser, new[]{ "Key", "Name", "Description", "Enabled", "Type", "CreatedAt", "UpdatedAt", "Rules", "Rollouts", "DefaultVariant" }, new[]{ "DefaultVariant" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationConstraint), global::Flipt.Evaluation.EvaluationConstraint.Parser, new[]{ "Id", "Type", "Property", "Operator", "Value" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationRule), global::Flipt.Evaluation.EvaluationRule.Parser, new[]{ "Id", "Segments", "Rank", "SegmentOperator", "Distributions" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Evaluation.EvaluationNamespace), global::Flipt.Evaluation.EvaluationNamespace.Parser, new[]{ "Key" }, null, null, null, null), @@ -223,6 +237,7 @@ public enum EvaluationConstraintComparisonType { [pbr::OriginalName("NUMBER_CONSTRAINT_COMPARISON_TYPE")] NumberConstraintComparisonType = 2, [pbr::OriginalName("BOOLEAN_CONSTRAINT_COMPARISON_TYPE")] BooleanConstraintComparisonType = 3, [pbr::OriginalName("DATETIME_CONSTRAINT_COMPARISON_TYPE")] DatetimeConstraintComparisonType = 4, + [pbr::OriginalName("ENTITY_ID_CONSTRAINT_COMPARISON_TYPE")] EntityIdConstraintComparisonType = 5, } #endregion @@ -4228,6 +4243,269 @@ public void MergeFrom(pb::CodedInputStream input) { } + public sealed partial class EvaluationVariant : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EvaluationVariant()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Evaluation.EvaluationReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluationVariant() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluationVariant(EvaluationVariant other) : this() { + id_ = other.id_; + key_ = other.key_; + attachment_ = other.attachment_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluationVariant Clone() { + return new EvaluationVariant(this); + } + + /// Field number for the "id" field. + public const int IdFieldNumber = 1; + private string id_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Id { + get { return id_; } + set { + id_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "key" field. + public const int KeyFieldNumber = 2; + private string key_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Key { + get { return key_; } + set { + key_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attachment" field. + public const int AttachmentFieldNumber = 3; + private string attachment_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Attachment { + get { return attachment_; } + set { + attachment_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EvaluationVariant); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EvaluationVariant other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Id != other.Id) return false; + if (Key != other.Key) return false; + if (Attachment != other.Attachment) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Id.Length != 0) hash ^= Id.GetHashCode(); + if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (Attachment.Length != 0) hash ^= Attachment.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Id.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Id); + } + if (Key.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Key); + } + if (Attachment.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Attachment); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Id.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Id); + } + if (Key.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Key); + } + if (Attachment.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Attachment); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Id.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Id); + } + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + if (Attachment.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Attachment); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EvaluationVariant other) { + if (other == null) { + return; + } + if (other.Id.Length != 0) { + Id = other.Id; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + if (other.Attachment.Length != 0) { + Attachment = other.Attachment; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Id = input.ReadString(); + break; + } + case 18: { + Key = input.ReadString(); + break; + } + case 26: { + Attachment = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Id = input.ReadString(); + break; + } + case 18: { + Key = input.ReadString(); + break; + } + case 26: { + Attachment = input.ReadString(); + break; + } + } + } + } + #endif + + } + public sealed partial class EvaluationFlag : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage @@ -4242,7 +4520,7 @@ public sealed partial class EvaluationFlag : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Flipt.Evaluation.EvaluationReflection.Descriptor.MessageTypes[12]; } + get { return global::Flipt.Evaluation.EvaluationReflection.Descriptor.MessageTypes[13]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -4271,6 +4549,7 @@ public EvaluationFlag(EvaluationFlag other) : this() { updatedAt_ = other.updatedAt_ != null ? other.updatedAt_.Clone() : null; rules_ = other.rules_.Clone(); rollouts_ = other.rollouts_.Clone(); + defaultVariant_ = other.defaultVariant_ != null ? other.defaultVariant_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -4386,6 +4665,18 @@ public bool Enabled { get { return rollouts_; } } + /// Field number for the "default_variant" field. + public const int DefaultVariantFieldNumber = 10; + private global::Flipt.Evaluation.EvaluationVariant defaultVariant_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Evaluation.EvaluationVariant DefaultVariant { + get { return defaultVariant_; } + set { + defaultVariant_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -4410,6 +4701,7 @@ public bool Equals(EvaluationFlag other) { if (!object.Equals(UpdatedAt, other.UpdatedAt)) return false; if(!rules_.Equals(other.rules_)) return false; if(!rollouts_.Equals(other.rollouts_)) return false; + if (!object.Equals(DefaultVariant, other.DefaultVariant)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -4426,6 +4718,7 @@ public override int GetHashCode() { if (updatedAt_ != null) hash ^= UpdatedAt.GetHashCode(); hash ^= rules_.GetHashCode(); hash ^= rollouts_.GetHashCode(); + if (defaultVariant_ != null) hash ^= DefaultVariant.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4474,6 +4767,10 @@ public void WriteTo(pb::CodedOutputStream output) { } rules_.WriteTo(output, _repeated_rules_codec); rollouts_.WriteTo(output, _repeated_rollouts_codec); + if (defaultVariant_ != null) { + output.WriteRawTag(82); + output.WriteMessage(DefaultVariant); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -4514,6 +4811,10 @@ public void WriteTo(pb::CodedOutputStream output) { } rules_.WriteTo(ref output, _repeated_rules_codec); rollouts_.WriteTo(ref output, _repeated_rollouts_codec); + if (defaultVariant_ != null) { + output.WriteRawTag(82); + output.WriteMessage(DefaultVariant); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -4547,6 +4848,9 @@ public int CalculateSize() { } size += rules_.CalculateSize(_repeated_rules_codec); size += rollouts_.CalculateSize(_repeated_rollouts_codec); + if (defaultVariant_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DefaultVariant); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -4588,6 +4892,12 @@ public void MergeFrom(EvaluationFlag other) { } rules_.Add(other.rules_); rollouts_.Add(other.rollouts_); + if (other.defaultVariant_ != null) { + if (defaultVariant_ == null) { + DefaultVariant = new global::Flipt.Evaluation.EvaluationVariant(); + } + DefaultVariant.MergeFrom(other.DefaultVariant); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -4645,6 +4955,13 @@ public void MergeFrom(pb::CodedInputStream input) { rollouts_.AddEntriesFrom(input, _repeated_rollouts_codec); break; } + case 82: { + if (defaultVariant_ == null) { + DefaultVariant = new global::Flipt.Evaluation.EvaluationVariant(); + } + input.ReadMessage(DefaultVariant); + break; + } } } #endif @@ -4702,6 +5019,13 @@ public void MergeFrom(pb::CodedInputStream input) { rollouts_.AddEntriesFrom(ref input, _repeated_rollouts_codec); break; } + case 82: { + if (defaultVariant_ == null) { + DefaultVariant = new global::Flipt.Evaluation.EvaluationVariant(); + } + input.ReadMessage(DefaultVariant); + break; + } } } } @@ -4723,7 +5047,7 @@ public sealed partial class EvaluationConstraint : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::Flipt.Evaluation.EvaluationReflection.Descriptor.MessageTypes[14]; } + get { return global::Flipt.Evaluation.EvaluationReflection.Descriptor.MessageTypes[15]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5375,7 +5699,7 @@ public sealed partial class EvaluationNamespace : pb::IMessage - /// flipt:sdk:ignore - /// public static partial class DataService { static readonly string __ServiceName = "flipt.evaluation.DataService"; diff --git a/src/Flipt.Grpc/Event.cs b/src/Flipt.Grpc/Event.cs new file mode 100644 index 0000000..e8a8cf1 --- /dev/null +++ b/src/Flipt.Grpc/Event.cs @@ -0,0 +1,1045 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: audit/event.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace Flipt.Audit { + + /// Holder for reflection information generated from audit/event.proto + public static partial class EventReflection { + + #region Descriptor + /// File descriptor for audit/event.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static EventReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChFhdWRpdC9ldmVudC5wcm90bxILZmxpcHQuYXVkaXQaHGdvb2dsZS9wcm90", + "b2J1Zi9zdHJ1Y3QucHJvdG8aH2dvb2dsZS9wcm90b2J1Zi90aW1lc3RhbXAu", + "cHJvdG8igwEKBUFjdG9yEiYKDmF1dGhlbnRpY2F0aW9uGAEgASgJUg5hdXRo", + "ZW50aWNhdGlvbhIOCgJpcBgCIAEoCVICaXASFAoFZW1haWwYAyABKAlSBWVt", + "YWlsEhIKBG5hbWUYBCABKAlSBG5hbWUSGAoHcGljdHVyZRgFIAEoCVIHcGlj", + "dHVyZSJDCghNZXRhZGF0YRItCgVhY3RvchgBIAEoCzISLmZsaXB0LmF1ZGl0", + "LkFjdG9ySABSBWFjdG9yiAEBQggKBl9hY3RvciKmAgoFRXZlbnQSGAoHdmVy", + "c2lvbhgBIAEoCVIHdmVyc2lvbhISCgR0eXBlGAIgASgJUgR0eXBlEhYKBmFj", + "dGlvbhgDIAEoCVIGYWN0aW9uEjEKCG1ldGFkYXRhGAQgASgLMhUuZmxpcHQu", + "YXVkaXQuTWV0YWRhdGFSCG1ldGFkYXRhEjYKB3BheWxvYWQYBSABKAsyFy5n", + "b29nbGUucHJvdG9idWYuU3RydWN0SABSB3BheWxvYWSIAQESOAoJdGltZXN0", + "YW1wGAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJdGltZXN0", + "YW1wEhsKBnN0YXR1cxgHIAEoCUgBUgZzdGF0dXOIAQFCCgoIX3BheWxvYWRC", + "CQoHX3N0YXR1c0IjWiFnby5mbGlwdC5pby9mbGlwdC9ycGMvZmxpcHQvYXVk", + "aXRiBnByb3RvMw==")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Audit.Actor), global::Flipt.Audit.Actor.Parser, new[]{ "Authentication", "Ip", "Email", "Name", "Picture" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Audit.Metadata), global::Flipt.Audit.Metadata.Parser, new[]{ "Actor" }, new[]{ "Actor" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Audit.Event), global::Flipt.Audit.Event.Parser, new[]{ "Version", "Type", "Action", "Metadata", "Payload", "Timestamp", "Status" }, new[]{ "Payload", "Status" }, null, null, null) + })); + } + #endregion + + } + #region Messages + public sealed partial class Actor : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Actor()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Audit.EventReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Actor() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Actor(Actor other) : this() { + authentication_ = other.authentication_; + ip_ = other.ip_; + email_ = other.email_; + name_ = other.name_; + picture_ = other.picture_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Actor Clone() { + return new Actor(this); + } + + /// Field number for the "authentication" field. + public const int AuthenticationFieldNumber = 1; + private string authentication_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Authentication { + get { return authentication_; } + set { + authentication_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "ip" field. + public const int IpFieldNumber = 2; + private string ip_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Ip { + get { return ip_; } + set { + ip_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "email" field. + public const int EmailFieldNumber = 3; + private string email_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Email { + get { return email_; } + set { + email_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 4; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "picture" field. + public const int PictureFieldNumber = 5; + private string picture_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Picture { + get { return picture_; } + set { + picture_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Actor); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Actor other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Authentication != other.Authentication) return false; + if (Ip != other.Ip) return false; + if (Email != other.Email) return false; + if (Name != other.Name) return false; + if (Picture != other.Picture) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Authentication.Length != 0) hash ^= Authentication.GetHashCode(); + if (Ip.Length != 0) hash ^= Ip.GetHashCode(); + if (Email.Length != 0) hash ^= Email.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Picture.Length != 0) hash ^= Picture.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Authentication.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Authentication); + } + if (Ip.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Ip); + } + if (Email.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Email); + } + if (Name.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Name); + } + if (Picture.Length != 0) { + output.WriteRawTag(42); + output.WriteString(Picture); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Authentication.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Authentication); + } + if (Ip.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Ip); + } + if (Email.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Email); + } + if (Name.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Name); + } + if (Picture.Length != 0) { + output.WriteRawTag(42); + output.WriteString(Picture); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Authentication.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Authentication); + } + if (Ip.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Ip); + } + if (Email.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Email); + } + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Picture.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Picture); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Actor other) { + if (other == null) { + return; + } + if (other.Authentication.Length != 0) { + Authentication = other.Authentication; + } + if (other.Ip.Length != 0) { + Ip = other.Ip; + } + if (other.Email.Length != 0) { + Email = other.Email; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Picture.Length != 0) { + Picture = other.Picture; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Authentication = input.ReadString(); + break; + } + case 18: { + Ip = input.ReadString(); + break; + } + case 26: { + Email = input.ReadString(); + break; + } + case 34: { + Name = input.ReadString(); + break; + } + case 42: { + Picture = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Authentication = input.ReadString(); + break; + } + case 18: { + Ip = input.ReadString(); + break; + } + case 26: { + Email = input.ReadString(); + break; + } + case 34: { + Name = input.ReadString(); + break; + } + case 42: { + Picture = input.ReadString(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Metadata : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Metadata()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Audit.EventReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Metadata() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Metadata(Metadata other) : this() { + actor_ = other.actor_ != null ? other.actor_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Metadata Clone() { + return new Metadata(this); + } + + /// Field number for the "actor" field. + public const int ActorFieldNumber = 1; + private global::Flipt.Audit.Actor actor_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Audit.Actor Actor { + get { return actor_; } + set { + actor_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Metadata); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Metadata other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Actor, other.Actor)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (actor_ != null) hash ^= Actor.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (actor_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Actor); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (actor_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Actor); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (actor_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Actor); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Metadata other) { + if (other == null) { + return; + } + if (other.actor_ != null) { + if (actor_ == null) { + Actor = new global::Flipt.Audit.Actor(); + } + Actor.MergeFrom(other.Actor); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (actor_ == null) { + Actor = new global::Flipt.Audit.Actor(); + } + input.ReadMessage(Actor); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (actor_ == null) { + Actor = new global::Flipt.Audit.Actor(); + } + input.ReadMessage(Actor); + break; + } + } + } + } + #endif + + } + + public sealed partial class Event : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Event()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Audit.EventReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Event() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Event(Event other) : this() { + version_ = other.version_; + type_ = other.type_; + action_ = other.action_; + metadata_ = other.metadata_ != null ? other.metadata_.Clone() : null; + payload_ = other.payload_ != null ? other.payload_.Clone() : null; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + status_ = other.status_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Event Clone() { + return new Event(this); + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 1; + private string version_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Version { + get { return version_; } + set { + version_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 2; + private string type_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Type { + get { return type_; } + set { + type_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "action" field. + public const int ActionFieldNumber = 3; + private string action_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Action { + get { return action_; } + set { + action_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 4; + private global::Flipt.Audit.Metadata metadata_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Audit.Metadata Metadata { + get { return metadata_; } + set { + metadata_ = value; + } + } + + /// Field number for the "payload" field. + public const int PayloadFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Struct payload_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Struct Payload { + get { return payload_; } + set { + payload_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 7; + private readonly static string StatusDefaultValue = ""; + + private string status_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Status { + get { return status_ ?? StatusDefaultValue; } + set { + status_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "status" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStatus { + get { return status_ != null; } + } + /// Clears the value of the "status" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStatus() { + status_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Event); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Event other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Version != other.Version) return false; + if (Type != other.Type) return false; + if (Action != other.Action) return false; + if (!object.Equals(Metadata, other.Metadata)) return false; + if (!object.Equals(Payload, other.Payload)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (Status != other.Status) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Version.Length != 0) hash ^= Version.GetHashCode(); + if (Type.Length != 0) hash ^= Type.GetHashCode(); + if (Action.Length != 0) hash ^= Action.GetHashCode(); + if (metadata_ != null) hash ^= Metadata.GetHashCode(); + if (payload_ != null) hash ^= Payload.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (HasStatus) hash ^= Status.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Version.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Version); + } + if (Type.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Type); + } + if (Action.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Action); + } + if (metadata_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Metadata); + } + if (payload_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Payload); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (HasStatus) { + output.WriteRawTag(58); + output.WriteString(Status); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Version.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Version); + } + if (Type.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Type); + } + if (Action.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Action); + } + if (metadata_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Metadata); + } + if (payload_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Payload); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (HasStatus) { + output.WriteRawTag(58); + output.WriteString(Status); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Version.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Version); + } + if (Type.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Type); + } + if (Action.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Action); + } + if (metadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Metadata); + } + if (payload_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Payload); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (HasStatus) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Status); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Event other) { + if (other == null) { + return; + } + if (other.Version.Length != 0) { + Version = other.Version; + } + if (other.Type.Length != 0) { + Type = other.Type; + } + if (other.Action.Length != 0) { + Action = other.Action; + } + if (other.metadata_ != null) { + if (metadata_ == null) { + Metadata = new global::Flipt.Audit.Metadata(); + } + Metadata.MergeFrom(other.Metadata); + } + if (other.payload_ != null) { + if (payload_ == null) { + Payload = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + Payload.MergeFrom(other.Payload); + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.HasStatus) { + Status = other.Status; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Version = input.ReadString(); + break; + } + case 18: { + Type = input.ReadString(); + break; + } + case 26: { + Action = input.ReadString(); + break; + } + case 34: { + if (metadata_ == null) { + Metadata = new global::Flipt.Audit.Metadata(); + } + input.ReadMessage(Metadata); + break; + } + case 42: { + if (payload_ == null) { + Payload = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Payload); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 58: { + Status = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Version = input.ReadString(); + break; + } + case 18: { + Type = input.ReadString(); + break; + } + case 26: { + Action = input.ReadString(); + break; + } + case 34: { + if (metadata_ == null) { + Metadata = new global::Flipt.Audit.Metadata(); + } + input.ReadMessage(Metadata); + break; + } + case 42: { + if (payload_ == null) { + Payload = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Payload); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 58: { + Status = input.ReadString(); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Flipt.Grpc/Flipt.cs b/src/Flipt.Grpc/Flipt.cs index 132d80e..d5225e7 100644 --- a/src/Flipt.Grpc/Flipt.cs +++ b/src/Flipt.Grpc/Flipt.cs @@ -25,312 +25,407 @@ static FliptReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "CgtmbGlwdC5wcm90bxIFZmxpcHQaG2dvb2dsZS9wcm90b2J1Zi9lbXB0eS5w", - "cm90bxofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90byKMAgoRRXZh", - "bHVhdGlvblJlcXVlc3QSHQoKcmVxdWVzdF9pZBgBIAEoCVIJcmVxdWVzdElk", - "EhkKCGZsYWdfa2V5GAIgASgJUgdmbGFnS2V5EhsKCWVudGl0eV9pZBgDIAEo", - "CVIIZW50aXR5SWQSPwoHY29udGV4dBgEIAMoCzIlLmZsaXB0LkV2YWx1YXRp", - "b25SZXF1ZXN0LkNvbnRleHRFbnRyeVIHY29udGV4dBIjCg1uYW1lc3BhY2Vf", - "a2V5GAUgASgJUgxuYW1lc3BhY2VLZXkaOgoMQ29udGV4dEVudHJ5EhAKA2tl", - "eRgBIAEoCVIDa2V5EhQKBXZhbHVlGAIgASgJUgV2YWx1ZToCOAEivgEKFkJh", - "dGNoRXZhbHVhdGlvblJlcXVlc3QSHQoKcmVxdWVzdF9pZBgBIAEoCVIJcmVx", - "dWVzdElkEjQKCHJlcXVlc3RzGAIgAygLMhguZmxpcHQuRXZhbHVhdGlvblJl", - "cXVlc3RSCHJlcXVlc3RzEioKEWV4Y2x1ZGVfbm90X2ZvdW5kGAMgASgIUg9l", - "eGNsdWRlTm90Rm91bmQSIwoNbmFtZXNwYWNlX2tleRgEIAEoCVIMbmFtZXNw", - "YWNlS2V5IqkBChdCYXRjaEV2YWx1YXRpb25SZXNwb25zZRIdCgpyZXF1ZXN0", - "X2lkGAEgASgJUglyZXF1ZXN0SWQSNwoJcmVzcG9uc2VzGAIgAygLMhkuZmxp", - "cHQuRXZhbHVhdGlvblJlc3BvbnNlUglyZXNwb25zZXMSNgoXcmVxdWVzdF9k", - "dXJhdGlvbl9taWxsaXMYAyABKAFSFXJlcXVlc3REdXJhdGlvbk1pbGxpcyLi", - "BAoSRXZhbHVhdGlvblJlc3BvbnNlEh0KCnJlcXVlc3RfaWQYASABKAlSCXJl", - "cXVlc3RJZBIbCgllbnRpdHlfaWQYAiABKAlSCGVudGl0eUlkElYKD3JlcXVl", - "c3RfY29udGV4dBgDIAMoCzItLmZsaXB0LkV2YWx1YXRpb25SZXNwb25zZS5S", - "ZXF1ZXN0Q29udGV4dEVudHJ5Ug5yZXF1ZXN0Q29udGV4dBIUCgVtYXRjaBgE", - "IAEoCFIFbWF0Y2gSGQoIZmxhZ19rZXkYBSABKAlSB2ZsYWdLZXkSIwoLc2Vn", - "bWVudF9rZXkYBiABKAlCAhgBUgpzZWdtZW50S2V5EjgKCXRpbWVzdGFtcBgH", - "IAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCXRpbWVzdGFtcBIU", - "CgV2YWx1ZRgIIAEoCVIFdmFsdWUSNgoXcmVxdWVzdF9kdXJhdGlvbl9taWxs", - "aXMYCSABKAFSFXJlcXVlc3REdXJhdGlvbk1pbGxpcxIeCgphdHRhY2htZW50", - "GAogASgJUgphdHRhY2htZW50Ei8KBnJlYXNvbhgLIAEoDjIXLmZsaXB0LkV2", - "YWx1YXRpb25SZWFzb25SBnJlYXNvbhIjCg1uYW1lc3BhY2Vfa2V5GAwgASgJ", - "UgxuYW1lc3BhY2VLZXkSIQoMc2VnbWVudF9rZXlzGA0gAygJUgtzZWdtZW50", - "S2V5cxpBChNSZXF1ZXN0Q29udGV4dEVudHJ5EhAKA2tleRgBIAEoCVIDa2V5", - "EhQKBXZhbHVlGAIgASgJUgV2YWx1ZToCOAEi5wEKCU5hbWVzcGFjZRIQCgNr", - "ZXkYASABKAlSA2tleRISCgRuYW1lGAIgASgJUgRuYW1lEiAKC2Rlc2NyaXB0", - "aW9uGAMgASgJUgtkZXNjcmlwdGlvbhIcCglwcm90ZWN0ZWQYBCABKAhSCXBy", - "b3RlY3RlZBI5CgpjcmVhdGVkX2F0GAUgASgLMhouZ29vZ2xlLnByb3RvYnVm", - "LlRpbWVzdGFtcFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRfYXQYBiABKAsyGi5n", - "b29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl1cGRhdGVkQXQiigEKDU5hbWVz", - "cGFjZUxpc3QSMAoKbmFtZXNwYWNlcxgBIAMoCzIQLmZsaXB0Lk5hbWVzcGFj", - "ZVIKbmFtZXNwYWNlcxImCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAlSDW5leHRQ", - "YWdlVG9rZW4SHwoLdG90YWxfY291bnQYAyABKAVSCnRvdGFsQ291bnQiRQoT", - "R2V0TmFtZXNwYWNlUmVxdWVzdBIQCgNrZXkYASABKAlSA2tleRIcCglyZWZl", - "cmVuY2UYAiABKAlSCXJlZmVyZW5jZSKFAQoUTGlzdE5hbWVzcGFjZVJlcXVl", - "c3QSFAoFbGltaXQYASABKAVSBWxpbWl0EhoKBm9mZnNldBgCIAEoBUICGAFS", - "Bm9mZnNldBIdCgpwYWdlX3Rva2VuGAMgASgJUglwYWdlVG9rZW4SHAoJcmVm", - "ZXJlbmNlGAQgASgJUglyZWZlcmVuY2UiYAoWQ3JlYXRlTmFtZXNwYWNlUmVx", - "dWVzdBIQCgNrZXkYASABKAlSA2tleRISCgRuYW1lGAIgASgJUgRuYW1lEiAK", - "C2Rlc2NyaXB0aW9uGAMgASgJUgtkZXNjcmlwdGlvbiJgChZVcGRhdGVOYW1l", - "c3BhY2VSZXF1ZXN0EhAKA2tleRgBIAEoCVIDa2V5EhIKBG5hbWUYAiABKAlS", - "BG5hbWUSIAoLZGVzY3JpcHRpb24YAyABKAlSC2Rlc2NyaXB0aW9uIioKFkRl", - "bGV0ZU5hbWVzcGFjZVJlcXVlc3QSEAoDa2V5GAEgASgJUgNrZXki1AIKBEZs", - "YWcSEAoDa2V5GAEgASgJUgNrZXkSEgoEbmFtZRgCIAEoCVIEbmFtZRIgCgtk", - "ZXNjcmlwdGlvbhgDIAEoCVILZGVzY3JpcHRpb24SGAoHZW5hYmxlZBgEIAEo", - "CFIHZW5hYmxlZBI5CgpjcmVhdGVkX2F0GAUgASgLMhouZ29vZ2xlLnByb3Rv", - "YnVmLlRpbWVzdGFtcFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRfYXQYBiABKAsy", - "Gi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl1cGRhdGVkQXQSKgoIdmFy", - "aWFudHMYByADKAsyDi5mbGlwdC5WYXJpYW50Ugh2YXJpYW50cxIjCg1uYW1l", - "c3BhY2Vfa2V5GAggASgJUgxuYW1lc3BhY2VLZXkSIwoEdHlwZRgJIAEoDjIP", - "LmZsaXB0LkZsYWdUeXBlUgR0eXBlInYKCEZsYWdMaXN0EiEKBWZsYWdzGAEg", - "AygLMgsuZmxpcHQuRmxhZ1IFZmxhZ3MSJgoPbmV4dF9wYWdlX3Rva2VuGAIg", - "ASgJUg1uZXh0UGFnZVRva2VuEh8KC3RvdGFsX2NvdW50GAMgASgFUgp0b3Rh", - "bENvdW50ImUKDkdldEZsYWdSZXF1ZXN0EhAKA2tleRgBIAEoCVIDa2V5EiMK", - "DW5hbWVzcGFjZV9rZXkYAiABKAlSDG5hbWVzcGFjZUtleRIcCglyZWZlcmVu", - "Y2UYAyABKAlSCXJlZmVyZW5jZSKlAQoPTGlzdEZsYWdSZXF1ZXN0EhQKBWxp", - "bWl0GAEgASgFUgVsaW1pdBIaCgZvZmZzZXQYAiABKAVCAhgBUgZvZmZzZXQS", - "HQoKcGFnZV90b2tlbhgDIAEoCVIJcGFnZVRva2VuEiMKDW5hbWVzcGFjZV9r", - "ZXkYBCABKAlSDG5hbWVzcGFjZUtleRIcCglyZWZlcmVuY2UYBSABKAlSCXJl", - "ZmVyZW5jZSK/AQoRQ3JlYXRlRmxhZ1JlcXVlc3QSEAoDa2V5GAEgASgJUgNr", - "ZXkSEgoEbmFtZRgCIAEoCVIEbmFtZRIgCgtkZXNjcmlwdGlvbhgDIAEoCVIL", - "ZGVzY3JpcHRpb24SGAoHZW5hYmxlZBgEIAEoCFIHZW5hYmxlZBIjCg1uYW1l", - "c3BhY2Vfa2V5GAUgASgJUgxuYW1lc3BhY2VLZXkSIwoEdHlwZRgGIAEoDjIP", - "LmZsaXB0LkZsYWdUeXBlUgR0eXBlIpoBChFVcGRhdGVGbGFnUmVxdWVzdBIQ", - "CgNrZXkYASABKAlSA2tleRISCgRuYW1lGAIgASgJUgRuYW1lEiAKC2Rlc2Ny", - "aXB0aW9uGAMgASgJUgtkZXNjcmlwdGlvbhIYCgdlbmFibGVkGAQgASgIUgdl", - "bmFibGVkEiMKDW5hbWVzcGFjZV9rZXkYBSABKAlSDG5hbWVzcGFjZUtleSJK", - "ChFEZWxldGVGbGFnUmVxdWVzdBIQCgNrZXkYASABKAlSA2tleRIjCg1uYW1l", - "c3BhY2Vfa2V5GAIgASgJUgxuYW1lc3BhY2VLZXkitwIKB1ZhcmlhbnQSDgoC", - "aWQYASABKAlSAmlkEhkKCGZsYWdfa2V5GAIgASgJUgdmbGFnS2V5EhAKA2tl", - "eRgDIAEoCVIDa2V5EhIKBG5hbWUYBCABKAlSBG5hbWUSIAoLZGVzY3JpcHRp", - "b24YBSABKAlSC2Rlc2NyaXB0aW9uEjkKCmNyZWF0ZWRfYXQYBiABKAsyGi5n", - "b29nbGUucHJvdG9idWYuVGltZXN0YW1wUgljcmVhdGVkQXQSOQoKdXBkYXRl", - "ZF9hdBgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCXVwZGF0", - "ZWRBdBIeCgphdHRhY2htZW50GAggASgJUgphdHRhY2htZW50EiMKDW5hbWVz", - "cGFjZV9rZXkYCSABKAlSDG5hbWVzcGFjZUtleSK+AQoUQ3JlYXRlVmFyaWFu", - "dFJlcXVlc3QSGQoIZmxhZ19rZXkYASABKAlSB2ZsYWdLZXkSEAoDa2V5GAIg", - "ASgJUgNrZXkSEgoEbmFtZRgDIAEoCVIEbmFtZRIgCgtkZXNjcmlwdGlvbhgE", - "IAEoCVILZGVzY3JpcHRpb24SHgoKYXR0YWNobWVudBgFIAEoCVIKYXR0YWNo", - "bWVudBIjCg1uYW1lc3BhY2Vfa2V5GAYgASgJUgxuYW1lc3BhY2VLZXkizgEK", - "FFVwZGF0ZVZhcmlhbnRSZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghmbGFn", - "X2tleRgCIAEoCVIHZmxhZ0tleRIQCgNrZXkYAyABKAlSA2tleRISCgRuYW1l", - "GAQgASgJUgRuYW1lEiAKC2Rlc2NyaXB0aW9uGAUgASgJUgtkZXNjcmlwdGlv", - "bhIeCgphdHRhY2htZW50GAYgASgJUgphdHRhY2htZW50EiMKDW5hbWVzcGFj", - "ZV9rZXkYByABKAlSDG5hbWVzcGFjZUtleSJmChREZWxldGVWYXJpYW50UmVx", - "dWVzdBIOCgJpZBgBIAEoCVICaWQSGQoIZmxhZ19rZXkYAiABKAlSB2ZsYWdL", - "ZXkSIwoNbmFtZXNwYWNlX2tleRgDIAEoCVIMbmFtZXNwYWNlS2V5ItICCgdT", - "ZWdtZW50EhAKA2tleRgBIAEoCVIDa2V5EhIKBG5hbWUYAiABKAlSBG5hbWUS", - "IAoLZGVzY3JpcHRpb24YAyABKAlSC2Rlc2NyaXB0aW9uEjkKCmNyZWF0ZWRf", - "YXQYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgljcmVhdGVk", - "QXQSOQoKdXBkYXRlZF9hdBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1l", - "c3RhbXBSCXVwZGF0ZWRBdBIzCgtjb25zdHJhaW50cxgGIAMoCzIRLmZsaXB0", - "LkNvbnN0cmFpbnRSC2NvbnN0cmFpbnRzEi8KCm1hdGNoX3R5cGUYByABKA4y", - "EC5mbGlwdC5NYXRjaFR5cGVSCW1hdGNoVHlwZRIjCg1uYW1lc3BhY2Vfa2V5", - "GAggASgJUgxuYW1lc3BhY2VLZXkiggEKC1NlZ21lbnRMaXN0EioKCHNlZ21l", - "bnRzGAEgAygLMg4uZmxpcHQuU2VnbWVudFIIc2VnbWVudHMSJgoPbmV4dF9w", - "YWdlX3Rva2VuGAIgASgJUg1uZXh0UGFnZVRva2VuEh8KC3RvdGFsX2NvdW50", - "GAMgASgFUgp0b3RhbENvdW50ImgKEUdldFNlZ21lbnRSZXF1ZXN0EhAKA2tl", - "eRgBIAEoCVIDa2V5EiMKDW5hbWVzcGFjZV9rZXkYAiABKAlSDG5hbWVzcGFj", - "ZUtleRIcCglyZWZlcmVuY2UYAyABKAlSCXJlZmVyZW5jZSKoAQoSTGlzdFNl", - "Z21lbnRSZXF1ZXN0EhQKBWxpbWl0GAEgASgFUgVsaW1pdBIaCgZvZmZzZXQY", - "AiABKAVCAhgBUgZvZmZzZXQSHQoKcGFnZV90b2tlbhgDIAEoCVIJcGFnZVRv", - "a2VuEiMKDW5hbWVzcGFjZV9rZXkYBCABKAlSDG5hbWVzcGFjZUtleRIcCgly", - "ZWZlcmVuY2UYBSABKAlSCXJlZmVyZW5jZSK0AQoUQ3JlYXRlU2VnbWVudFJl", - "cXVlc3QSEAoDa2V5GAEgASgJUgNrZXkSEgoEbmFtZRgCIAEoCVIEbmFtZRIg", - "CgtkZXNjcmlwdGlvbhgDIAEoCVILZGVzY3JpcHRpb24SLwoKbWF0Y2hfdHlw", - "ZRgEIAEoDjIQLmZsaXB0Lk1hdGNoVHlwZVIJbWF0Y2hUeXBlEiMKDW5hbWVz", - "cGFjZV9rZXkYBSABKAlSDG5hbWVzcGFjZUtleSK0AQoUVXBkYXRlU2VnbWVu", - "dFJlcXVlc3QSEAoDa2V5GAEgASgJUgNrZXkSEgoEbmFtZRgCIAEoCVIEbmFt", - "ZRIgCgtkZXNjcmlwdGlvbhgDIAEoCVILZGVzY3JpcHRpb24SLwoKbWF0Y2hf", - "dHlwZRgEIAEoDjIQLmZsaXB0Lk1hdGNoVHlwZVIJbWF0Y2hUeXBlEiMKDW5h", - "bWVzcGFjZV9rZXkYBSABKAlSDG5hbWVzcGFjZUtleSJNChREZWxldGVTZWdt", - "ZW50UmVxdWVzdBIQCgNrZXkYASABKAlSA2tleRIjCg1uYW1lc3BhY2Vfa2V5", - "GAIgASgJUgxuYW1lc3BhY2VLZXki8wIKCkNvbnN0cmFpbnQSDgoCaWQYASAB", - "KAlSAmlkEh8KC3NlZ21lbnRfa2V5GAIgASgJUgpzZWdtZW50S2V5EikKBHR5", - "cGUYAyABKA4yFS5mbGlwdC5Db21wYXJpc29uVHlwZVIEdHlwZRIaCghwcm9w", - "ZXJ0eRgEIAEoCVIIcHJvcGVydHkSGgoIb3BlcmF0b3IYBSABKAlSCG9wZXJh", - "dG9yEhQKBXZhbHVlGAYgASgJUgV2YWx1ZRI5CgpjcmVhdGVkX2F0GAcgASgL", - "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJY3JlYXRlZEF0EjkKCnVw", - "ZGF0ZWRfYXQYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl1", - "cGRhdGVkQXQSIwoNbmFtZXNwYWNlX2tleRgJIAEoCVIMbmFtZXNwYWNlS2V5", - "EiAKC2Rlc2NyaXB0aW9uGAogASgJUgtkZXNjcmlwdGlvbiL6AQoXQ3JlYXRl", - "Q29uc3RyYWludFJlcXVlc3QSHwoLc2VnbWVudF9rZXkYASABKAlSCnNlZ21l", - "bnRLZXkSKQoEdHlwZRgCIAEoDjIVLmZsaXB0LkNvbXBhcmlzb25UeXBlUgR0", - "eXBlEhoKCHByb3BlcnR5GAMgASgJUghwcm9wZXJ0eRIaCghvcGVyYXRvchgE", - "IAEoCVIIb3BlcmF0b3ISFAoFdmFsdWUYBSABKAlSBXZhbHVlEiMKDW5hbWVz", - "cGFjZV9rZXkYBiABKAlSDG5hbWVzcGFjZUtleRIgCgtkZXNjcmlwdGlvbhgH", - "IAEoCVILZGVzY3JpcHRpb24iigIKF1VwZGF0ZUNvbnN0cmFpbnRSZXF1ZXN0", - "Eg4KAmlkGAEgASgJUgJpZBIfCgtzZWdtZW50X2tleRgCIAEoCVIKc2VnbWVu", - "dEtleRIpCgR0eXBlGAMgASgOMhUuZmxpcHQuQ29tcGFyaXNvblR5cGVSBHR5", - "cGUSGgoIcHJvcGVydHkYBCABKAlSCHByb3BlcnR5EhoKCG9wZXJhdG9yGAUg", - "ASgJUghvcGVyYXRvchIUCgV2YWx1ZRgGIAEoCVIFdmFsdWUSIwoNbmFtZXNw", - "YWNlX2tleRgHIAEoCVIMbmFtZXNwYWNlS2V5EiAKC2Rlc2NyaXB0aW9uGAgg", - "ASgJUgtkZXNjcmlwdGlvbiJvChdEZWxldGVDb25zdHJhaW50UmVxdWVzdBIO", - "CgJpZBgBIAEoCVICaWQSHwoLc2VnbWVudF9rZXkYAiABKAlSCnNlZ21lbnRL", - "ZXkSIwoNbmFtZXNwYWNlX2tleRgDIAEoCVIMbmFtZXNwYWNlS2V5IqEDCgdS", - "b2xsb3V0Eg4KAmlkGAEgASgJUgJpZBIjCg1uYW1lc3BhY2Vfa2V5GAIgASgJ", - "UgxuYW1lc3BhY2VLZXkSGQoIZmxhZ19rZXkYAyABKAlSB2ZsYWdLZXkSJgoE", - "dHlwZRgEIAEoDjISLmZsaXB0LlJvbGxvdXRUeXBlUgR0eXBlEhIKBHJhbmsY", - "BSABKAVSBHJhbmsSIAoLZGVzY3JpcHRpb24YBiABKAlSC2Rlc2NyaXB0aW9u", - "EjkKCmNyZWF0ZWRfYXQYByABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0", - "YW1wUgljcmVhdGVkQXQSOQoKdXBkYXRlZF9hdBgIIAEoCzIaLmdvb2dsZS5w", - "cm90b2J1Zi5UaW1lc3RhbXBSCXVwZGF0ZWRBdBIxCgdzZWdtZW50GBQgASgL", - "MhUuZmxpcHQuUm9sbG91dFNlZ21lbnRIAFIHc2VnbWVudBI3Cgl0aHJlc2hv", - "bGQYFSABKAsyFy5mbGlwdC5Sb2xsb3V0VGhyZXNob2xkSABSCXRocmVzaG9s", - "ZEIGCgRydWxlIrEBCg5Sb2xsb3V0U2VnbWVudBIjCgtzZWdtZW50X2tleRgB", - "IAEoCUICGAFSCnNlZ21lbnRLZXkSFAoFdmFsdWUYAiABKAhSBXZhbHVlEiEK", - "DHNlZ21lbnRfa2V5cxgDIAMoCVILc2VnbWVudEtleXMSQQoQc2VnbWVudF9v", - "cGVyYXRvchgEIAEoDjIWLmZsaXB0LlNlZ21lbnRPcGVyYXRvclIPc2VnbWVu", - "dE9wZXJhdG9yIkgKEFJvbGxvdXRUaHJlc2hvbGQSHgoKcGVyY2VudGFnZRgB", - "IAEoAlIKcGVyY2VudGFnZRIUCgV2YWx1ZRgCIAEoCFIFdmFsdWUifAoLUm9s", - "bG91dExpc3QSJAoFcnVsZXMYASADKAsyDi5mbGlwdC5Sb2xsb3V0UgVydWxl", - "cxImCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAlSDW5leHRQYWdlVG9rZW4SHwoL", - "dG90YWxfY291bnQYAyABKAVSCnRvdGFsQ291bnQipwEKEkxpc3RSb2xsb3V0", - "UmVxdWVzdBIjCg1uYW1lc3BhY2Vfa2V5GAEgASgJUgxuYW1lc3BhY2VLZXkS", - "GQoIZmxhZ19rZXkYAiABKAlSB2ZsYWdLZXkSFAoFbGltaXQYAyABKAVSBWxp", - "bWl0Eh0KCnBhZ2VfdG9rZW4YBCABKAlSCXBhZ2VUb2tlbhIcCglyZWZlcmVu", - "Y2UYBSABKAlSCXJlZmVyZW5jZSKBAQoRR2V0Um9sbG91dFJlcXVlc3QSDgoC", - "aWQYASABKAlSAmlkEiMKDW5hbWVzcGFjZV9rZXkYAiABKAlSDG5hbWVzcGFj", - "ZUtleRIZCghmbGFnX2tleRgDIAEoCVIHZmxhZ0tleRIcCglyZWZlcmVuY2UY", - "BCABKAlSCXJlZmVyZW5jZSKAAgoUQ3JlYXRlUm9sbG91dFJlcXVlc3QSIwoN", - "bmFtZXNwYWNlX2tleRgBIAEoCVIMbmFtZXNwYWNlS2V5EhkKCGZsYWdfa2V5", - "GAIgASgJUgdmbGFnS2V5EhIKBHJhbmsYAyABKAVSBHJhbmsSIAoLZGVzY3Jp", - "cHRpb24YBCABKAlSC2Rlc2NyaXB0aW9uEjEKB3NlZ21lbnQYFCABKAsyFS5m", - "bGlwdC5Sb2xsb3V0U2VnbWVudEgAUgdzZWdtZW50EjcKCXRocmVzaG9sZBgV", - "IAEoCzIXLmZsaXB0LlJvbGxvdXRUaHJlc2hvbGRIAFIJdGhyZXNob2xkQgYK", - "BHJ1bGUi/AEKFFVwZGF0ZVJvbGxvdXRSZXF1ZXN0Eg4KAmlkGAEgASgJUgJp", - "ZBIjCg1uYW1lc3BhY2Vfa2V5GAIgASgJUgxuYW1lc3BhY2VLZXkSGQoIZmxh", - "Z19rZXkYAyABKAlSB2ZsYWdLZXkSIAoLZGVzY3JpcHRpb24YBCABKAlSC2Rl", - "c2NyaXB0aW9uEjEKB3NlZ21lbnQYFCABKAsyFS5mbGlwdC5Sb2xsb3V0U2Vn", - "bWVudEgAUgdzZWdtZW50EjcKCXRocmVzaG9sZBgVIAEoCzIXLmZsaXB0LlJv", - "bGxvdXRUaHJlc2hvbGRIAFIJdGhyZXNob2xkQgYKBHJ1bGUiZgoURGVsZXRl", - "Um9sbG91dFJlcXVlc3QSDgoCaWQYASABKAlSAmlkEiMKDW5hbWVzcGFjZV9r", - "ZXkYAiABKAlSDG5hbWVzcGFjZUtleRIZCghmbGFnX2tleRgDIAEoCVIHZmxh", - "Z0tleSJ3ChRPcmRlclJvbGxvdXRzUmVxdWVzdBIZCghmbGFnX2tleRgBIAEo", - "CVIHZmxhZ0tleRIjCg1uYW1lc3BhY2Vfa2V5GAIgASgJUgxuYW1lc3BhY2VL", - "ZXkSHwoLcm9sbG91dF9pZHMYAyADKAlSCnJvbGxvdXRJZHMiogMKBFJ1bGUS", - "DgoCaWQYASABKAlSAmlkEhkKCGZsYWdfa2V5GAIgASgJUgdmbGFnS2V5Eh8K", - "C3NlZ21lbnRfa2V5GAMgASgJUgpzZWdtZW50S2V5EjkKDWRpc3RyaWJ1dGlv", - "bnMYBCADKAsyEy5mbGlwdC5EaXN0cmlidXRpb25SDWRpc3RyaWJ1dGlvbnMS", - "EgoEcmFuaxgFIAEoBVIEcmFuaxI5CgpjcmVhdGVkX2F0GAYgASgLMhouZ29v", - "Z2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRf", - "YXQYByABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl1cGRhdGVk", - "QXQSIwoNbmFtZXNwYWNlX2tleRgIIAEoCVIMbmFtZXNwYWNlS2V5EiEKDHNl", - "Z21lbnRfa2V5cxgJIAMoCVILc2VnbWVudEtleXMSQQoQc2VnbWVudF9vcGVy", - "YXRvchgKIAEoDjIWLmZsaXB0LlNlZ21lbnRPcGVyYXRvclIPc2VnbWVudE9w", - "ZXJhdG9yInYKCFJ1bGVMaXN0EiEKBXJ1bGVzGAEgAygLMgsuZmxpcHQuUnVs", - "ZVIFcnVsZXMSJgoPbmV4dF9wYWdlX3Rva2VuGAIgASgJUg1uZXh0UGFnZVRv", - "a2VuEh8KC3RvdGFsX2NvdW50GAMgASgFUgp0b3RhbENvdW50IsABCg9MaXN0", - "UnVsZVJlcXVlc3QSFAoFbGltaXQYASABKAVSBWxpbWl0EhoKBm9mZnNldBgC", - "IAEoBUICGAFSBm9mZnNldBIZCghmbGFnX2tleRgDIAEoCVIHZmxhZ0tleRId", - "CgpwYWdlX3Rva2VuGAQgASgJUglwYWdlVG9rZW4SIwoNbmFtZXNwYWNlX2tl", - "eRgFIAEoCVIMbmFtZXNwYWNlS2V5EhwKCXJlZmVyZW5jZRgGIAEoCVIJcmVm", - "ZXJlbmNlIn4KDkdldFJ1bGVSZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghm", - "bGFnX2tleRgCIAEoCVIHZmxhZ0tleRIjCg1uYW1lc3BhY2Vfa2V5GAMgASgJ", - "UgxuYW1lc3BhY2VLZXkSHAoJcmVmZXJlbmNlGAQgASgJUglyZWZlcmVuY2Ui", - "8gEKEUNyZWF0ZVJ1bGVSZXF1ZXN0EhkKCGZsYWdfa2V5GAEgASgJUgdmbGFn", - "S2V5EiMKC3NlZ21lbnRfa2V5GAIgASgJQgIYAVIKc2VnbWVudEtleRISCgRy", - "YW5rGAMgASgFUgRyYW5rEiMKDW5hbWVzcGFjZV9rZXkYBCABKAlSDG5hbWVz", - "cGFjZUtleRIhCgxzZWdtZW50X2tleXMYBSADKAlSC3NlZ21lbnRLZXlzEkEK", - "EHNlZ21lbnRfb3BlcmF0b3IYBiABKA4yFi5mbGlwdC5TZWdtZW50T3BlcmF0", - "b3JSD3NlZ21lbnRPcGVyYXRvciLuAQoRVXBkYXRlUnVsZVJlcXVlc3QSDgoC", - "aWQYASABKAlSAmlkEhkKCGZsYWdfa2V5GAIgASgJUgdmbGFnS2V5EiMKC3Nl", - "Z21lbnRfa2V5GAMgASgJQgIYAVIKc2VnbWVudEtleRIjCg1uYW1lc3BhY2Vf", - "a2V5GAQgASgJUgxuYW1lc3BhY2VLZXkSIQoMc2VnbWVudF9rZXlzGAUgAygJ", - "UgtzZWdtZW50S2V5cxJBChBzZWdtZW50X29wZXJhdG9yGAYgASgOMhYuZmxp", - "cHQuU2VnbWVudE9wZXJhdG9yUg9zZWdtZW50T3BlcmF0b3IiYwoRRGVsZXRl", - "UnVsZVJlcXVlc3QSDgoCaWQYASABKAlSAmlkEhkKCGZsYWdfa2V5GAIgASgJ", - "UgdmbGFnS2V5EiMKDW5hbWVzcGFjZV9rZXkYAyABKAlSDG5hbWVzcGFjZUtl", - "eSJuChFPcmRlclJ1bGVzUmVxdWVzdBIZCghmbGFnX2tleRgBIAEoCVIHZmxh", - "Z0tleRIZCghydWxlX2lkcxgCIAMoCVIHcnVsZUlkcxIjCg1uYW1lc3BhY2Vf", - "a2V5GAMgASgJUgxuYW1lc3BhY2VLZXki5gEKDERpc3RyaWJ1dGlvbhIOCgJp", - "ZBgBIAEoCVICaWQSFwoHcnVsZV9pZBgCIAEoCVIGcnVsZUlkEh0KCnZhcmlh", - "bnRfaWQYAyABKAlSCXZhcmlhbnRJZBIYCgdyb2xsb3V0GAQgASgCUgdyb2xs", - "b3V0EjkKCmNyZWF0ZWRfYXQYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGlt", + "cm90bxocZ29vZ2xlL3Byb3RvYnVmL3N0cnVjdC5wcm90bxofZ29vZ2xlL3By", + "b3RvYnVmL3RpbWVzdGFtcC5wcm90bxocZ29vZ2xlL2FwaS9hbm5vdGF0aW9u", + "cy5wcm90bxofZ29vZ2xlL2FwaS9maWVsZF9iZWhhdmlvci5wcm90bxokZ25v", + "c3RpYy9vcGVuYXBpL3YzL2Fubm90YXRpb25zLnByb3RvIowCChFFdmFsdWF0", + "aW9uUmVxdWVzdBIdCgpyZXF1ZXN0X2lkGAEgASgJUglyZXF1ZXN0SWQSGQoI", + "ZmxhZ19rZXkYAiABKAlSB2ZsYWdLZXkSGwoJZW50aXR5X2lkGAMgASgJUghl", + "bnRpdHlJZBI/Cgdjb250ZXh0GAQgAygLMiUuZmxpcHQuRXZhbHVhdGlvblJl", + "cXVlc3QuQ29udGV4dEVudHJ5Ugdjb250ZXh0EiMKDW5hbWVzcGFjZV9rZXkY", + "BSABKAlSDG5hbWVzcGFjZUtleRo6CgxDb250ZXh0RW50cnkSEAoDa2V5GAEg", + "ASgJUgNrZXkSFAoFdmFsdWUYAiABKAlSBXZhbHVlOgI4ASK+AQoWQmF0Y2hF", + "dmFsdWF0aW9uUmVxdWVzdBIdCgpyZXF1ZXN0X2lkGAEgASgJUglyZXF1ZXN0", + "SWQSNAoIcmVxdWVzdHMYAiADKAsyGC5mbGlwdC5FdmFsdWF0aW9uUmVxdWVz", + "dFIIcmVxdWVzdHMSKgoRZXhjbHVkZV9ub3RfZm91bmQYAyABKAhSD2V4Y2x1", + "ZGVOb3RGb3VuZBIjCg1uYW1lc3BhY2Vfa2V5GAQgASgJUgxuYW1lc3BhY2VL", + "ZXkiqQEKF0JhdGNoRXZhbHVhdGlvblJlc3BvbnNlEh0KCnJlcXVlc3RfaWQY", + "ASABKAlSCXJlcXVlc3RJZBI3CglyZXNwb25zZXMYAiADKAsyGS5mbGlwdC5F", + "dmFsdWF0aW9uUmVzcG9uc2VSCXJlc3BvbnNlcxI2ChdyZXF1ZXN0X2R1cmF0", + "aW9uX21pbGxpcxgDIAEoAVIVcmVxdWVzdER1cmF0aW9uTWlsbGlzIuIEChJF", + "dmFsdWF0aW9uUmVzcG9uc2USHQoKcmVxdWVzdF9pZBgBIAEoCVIJcmVxdWVz", + "dElkEhsKCWVudGl0eV9pZBgCIAEoCVIIZW50aXR5SWQSVgoPcmVxdWVzdF9j", + "b250ZXh0GAMgAygLMi0uZmxpcHQuRXZhbHVhdGlvblJlc3BvbnNlLlJlcXVl", + "c3RDb250ZXh0RW50cnlSDnJlcXVlc3RDb250ZXh0EhQKBW1hdGNoGAQgASgI", + "UgVtYXRjaBIZCghmbGFnX2tleRgFIAEoCVIHZmxhZ0tleRIjCgtzZWdtZW50", + "X2tleRgGIAEoCUICGAFSCnNlZ21lbnRLZXkSOAoJdGltZXN0YW1wGAcgASgL", + "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcFIJdGltZXN0YW1wEhQKBXZh", + "bHVlGAggASgJUgV2YWx1ZRI2ChdyZXF1ZXN0X2R1cmF0aW9uX21pbGxpcxgJ", + "IAEoAVIVcmVxdWVzdER1cmF0aW9uTWlsbGlzEh4KCmF0dGFjaG1lbnQYCiAB", + "KAlSCmF0dGFjaG1lbnQSLwoGcmVhc29uGAsgASgOMhcuZmxpcHQuRXZhbHVh", + "dGlvblJlYXNvblIGcmVhc29uEiMKDW5hbWVzcGFjZV9rZXkYDCABKAlSDG5h", + "bWVzcGFjZUtleRIhCgxzZWdtZW50X2tleXMYDSADKAlSC3NlZ21lbnRLZXlz", + "GkEKE1JlcXVlc3RDb250ZXh0RW50cnkSEAoDa2V5GAEgASgJUgNrZXkSFAoF", + "dmFsdWUYAiABKAlSBXZhbHVlOgI4ASLnAQoJTmFtZXNwYWNlEhAKA2tleRgB", + "IAEoCVIDa2V5EhIKBG5hbWUYAiABKAlSBG5hbWUSIAoLZGVzY3JpcHRpb24Y", + "AyABKAlSC2Rlc2NyaXB0aW9uEhwKCXByb3RlY3RlZBgEIAEoCFIJcHJvdGVj", + "dGVkEjkKCmNyZWF0ZWRfYXQYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGlt", "ZXN0YW1wUgljcmVhdGVkQXQSOQoKdXBkYXRlZF9hdBgGIAEoCzIaLmdvb2ds", - "ZS5wcm90b2J1Zi5UaW1lc3RhbXBSCXVwZGF0ZWRBdCKtAQoZQ3JlYXRlRGlz", - "dHJpYnV0aW9uUmVxdWVzdBIZCghmbGFnX2tleRgBIAEoCVIHZmxhZ0tleRIX", - "CgdydWxlX2lkGAIgASgJUgZydWxlSWQSHQoKdmFyaWFudF9pZBgDIAEoCVIJ", - "dmFyaWFudElkEhgKB3JvbGxvdXQYBCABKAJSB3JvbGxvdXQSIwoNbmFtZXNw", - "YWNlX2tleRgFIAEoCVIMbmFtZXNwYWNlS2V5Ir0BChlVcGRhdGVEaXN0cmli", - "dXRpb25SZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghmbGFnX2tleRgCIAEo", - "CVIHZmxhZ0tleRIXCgdydWxlX2lkGAMgASgJUgZydWxlSWQSHQoKdmFyaWFu", - "dF9pZBgEIAEoCVIJdmFyaWFudElkEhgKB3JvbGxvdXQYBSABKAJSB3JvbGxv", - "dXQSIwoNbmFtZXNwYWNlX2tleRgGIAEoCVIMbmFtZXNwYWNlS2V5IqMBChlE", - "ZWxldGVEaXN0cmlidXRpb25SZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghm", - "bGFnX2tleRgCIAEoCVIHZmxhZ0tleRIXCgdydWxlX2lkGAMgASgJUgZydWxl", - "SWQSHQoKdmFyaWFudF9pZBgEIAEoCVIJdmFyaWFudElkEiMKDW5hbWVzcGFj", - "ZV9rZXkYBSABKAlSDG5hbWVzcGFjZUtleSq2AQoQRXZhbHVhdGlvblJlYXNv", - "bhIdChlVTktOT1dOX0VWQUxVQVRJT05fUkVBU09OEAASIwofRkxBR19ESVNB", - "QkxFRF9FVkFMVUFUSU9OX1JFQVNPThABEiQKIEZMQUdfTk9UX0ZPVU5EX0VW", - "QUxVQVRJT05fUkVBU09OEAISGwoXTUFUQ0hfRVZBTFVBVElPTl9SRUFTT04Q", - "AxIbChdFUlJPUl9FVkFMVUFUSU9OX1JFQVNPThAEKjgKCEZsYWdUeXBlEhUK", - "EVZBUklBTlRfRkxBR19UWVBFEAASFQoRQk9PTEVBTl9GTEFHX1RZUEUQASoz", - "CglNYXRjaFR5cGUSEgoOQUxMX01BVENIX1RZUEUQABISCg5BTllfTUFUQ0hf", - "VFlQRRABKqABCg5Db21wYXJpc29uVHlwZRIbChdVTktOT1dOX0NPTVBBUklT", - "T05fVFlQRRAAEhoKFlNUUklOR19DT01QQVJJU09OX1RZUEUQARIaChZOVU1C", - "RVJfQ09NUEFSSVNPTl9UWVBFEAISGwoXQk9PTEVBTl9DT01QQVJJU09OX1RZ", - "UEUQAxIcChhEQVRFVElNRV9DT01QQVJJU09OX1RZUEUQBCpdCgtSb2xsb3V0", - "VHlwZRIYChRVTktOT1dOX1JPTExPVVRfVFlQRRAAEhgKFFNFR01FTlRfUk9M", - "TE9VVF9UWVBFEAESGgoWVEhSRVNIT0xEX1JPTExPVVRfVFlQRRACKkQKD1Nl", - "Z21lbnRPcGVyYXRvchIXChNPUl9TRUdNRU5UX09QRVJBVE9SEAASGAoUQU5E", - "X1NFR01FTlRfT1BFUkFUT1IQATLbEwoFRmxpcHQSRAoIRXZhbHVhdGUSGC5m", - "bGlwdC5FdmFsdWF0aW9uUmVxdWVzdBoZLmZsaXB0LkV2YWx1YXRpb25SZXNw", - "b25zZSIDiAIBElMKDUJhdGNoRXZhbHVhdGUSHS5mbGlwdC5CYXRjaEV2YWx1", - "YXRpb25SZXF1ZXN0Gh4uZmxpcHQuQmF0Y2hFdmFsdWF0aW9uUmVzcG9uc2Ui", - "A4gCARI+CgxHZXROYW1lc3BhY2USGi5mbGlwdC5HZXROYW1lc3BhY2VSZXF1", - "ZXN0GhAuZmxpcHQuTmFtZXNwYWNlIgASRQoOTGlzdE5hbWVzcGFjZXMSGy5m", - "bGlwdC5MaXN0TmFtZXNwYWNlUmVxdWVzdBoULmZsaXB0Lk5hbWVzcGFjZUxp", - "c3QiABJECg9DcmVhdGVOYW1lc3BhY2USHS5mbGlwdC5DcmVhdGVOYW1lc3Bh", - "Y2VSZXF1ZXN0GhAuZmxpcHQuTmFtZXNwYWNlIgASRAoPVXBkYXRlTmFtZXNw", + "ZS5wcm90b2J1Zi5UaW1lc3RhbXBSCXVwZGF0ZWRBdCKKAQoNTmFtZXNwYWNl", + "TGlzdBIwCgpuYW1lc3BhY2VzGAEgAygLMhAuZmxpcHQuTmFtZXNwYWNlUgpu", + "YW1lc3BhY2VzEiYKD25leHRfcGFnZV90b2tlbhgCIAEoCVINbmV4dFBhZ2VU", + "b2tlbhIfCgt0b3RhbF9jb3VudBgDIAEoBVIKdG90YWxDb3VudCJFChNHZXRO", + "YW1lc3BhY2VSZXF1ZXN0EhAKA2tleRgBIAEoCVIDa2V5EhwKCXJlZmVyZW5j", + "ZRgCIAEoCVIJcmVmZXJlbmNlIoUBChRMaXN0TmFtZXNwYWNlUmVxdWVzdBIU", + "CgVsaW1pdBgBIAEoBVIFbGltaXQSGgoGb2Zmc2V0GAIgASgFQgIYAVIGb2Zm", + "c2V0Eh0KCnBhZ2VfdG9rZW4YAyABKAlSCXBhZ2VUb2tlbhIcCglyZWZlcmVu", + "Y2UYBCABKAlSCXJlZmVyZW5jZSJqChZDcmVhdGVOYW1lc3BhY2VSZXF1ZXN0", + "EhUKA2tleRgBIAEoCUID4EECUgNrZXkSFwoEbmFtZRgCIAEoCUID4EECUgRu", + "YW1lEiAKC2Rlc2NyaXB0aW9uGAMgASgJUgtkZXNjcmlwdGlvbiJlChZVcGRh", + "dGVOYW1lc3BhY2VSZXF1ZXN0EhAKA2tleRgBIAEoCVIDa2V5EhcKBG5hbWUY", + "AiABKAlCA+BBAlIEbmFtZRIgCgtkZXNjcmlwdGlvbhgDIAEoCVILZGVzY3Jp", + "cHRpb24iQAoWRGVsZXRlTmFtZXNwYWNlUmVxdWVzdBIQCgNrZXkYASABKAlS", + "A2tleRIUCgVmb3JjZRgCIAEoCFIFZm9yY2Ui7QMKBEZsYWcSEAoDa2V5GAEg", + "ASgJUgNrZXkSEgoEbmFtZRgCIAEoCVIEbmFtZRIgCgtkZXNjcmlwdGlvbhgD", + "IAEoCVILZGVzY3JpcHRpb24SGAoHZW5hYmxlZBgEIAEoCFIHZW5hYmxlZBI5", + "CgpjcmVhdGVkX2F0GAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFt", + "cFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRfYXQYBiABKAsyGi5nb29nbGUucHJv", + "dG9idWYuVGltZXN0YW1wUgl1cGRhdGVkQXQSKgoIdmFyaWFudHMYByADKAsy", + "Di5mbGlwdC5WYXJpYW50Ugh2YXJpYW50cxIjCg1uYW1lc3BhY2Vfa2V5GAgg", + "ASgJUgxuYW1lc3BhY2VLZXkSIwoEdHlwZRgJIAEoDjIPLmZsaXB0LkZsYWdU", + "eXBlUgR0eXBlEjwKD2RlZmF1bHRfdmFyaWFudBgKIAEoCzIOLmZsaXB0LlZh", + "cmlhbnRIAFIOZGVmYXVsdFZhcmlhbnSIAQESOAoIbWV0YWRhdGEYCyABKAsy", + "Fy5nb29nbGUucHJvdG9idWYuU3RydWN0SAFSCG1ldGFkYXRhiAEBQhIKEF9k", + "ZWZhdWx0X3ZhcmlhbnRCCwoJX21ldGFkYXRhInYKCEZsYWdMaXN0EiEKBWZs", + "YWdzGAEgAygLMgsuZmxpcHQuRmxhZ1IFZmxhZ3MSJgoPbmV4dF9wYWdlX3Rv", + "a2VuGAIgASgJUg1uZXh0UGFnZVRva2VuEh8KC3RvdGFsX2NvdW50GAMgASgF", + "Ugp0b3RhbENvdW50ImUKDkdldEZsYWdSZXF1ZXN0EhAKA2tleRgBIAEoCVID", + "a2V5EiMKDW5hbWVzcGFjZV9rZXkYAiABKAlSDG5hbWVzcGFjZUtleRIcCgly", + "ZWZlcmVuY2UYAyABKAlSCXJlZmVyZW5jZSKlAQoPTGlzdEZsYWdSZXF1ZXN0", + "EhQKBWxpbWl0GAEgASgFUgVsaW1pdBIaCgZvZmZzZXQYAiABKAVCAhgBUgZv", + "ZmZzZXQSHQoKcGFnZV90b2tlbhgDIAEoCVIJcGFnZVRva2VuEiMKDW5hbWVz", + "cGFjZV9rZXkYBCABKAlSDG5hbWVzcGFjZUtleRIcCglyZWZlcmVuY2UYBSAB", + "KAlSCXJlZmVyZW5jZSKVAgoRQ3JlYXRlRmxhZ1JlcXVlc3QSFQoDa2V5GAEg", + "ASgJQgPgQQJSA2tleRIXCgRuYW1lGAIgASgJQgPgQQJSBG5hbWUSIAoLZGVz", + "Y3JpcHRpb24YAyABKAlSC2Rlc2NyaXB0aW9uEhgKB2VuYWJsZWQYBCABKAhS", + "B2VuYWJsZWQSIwoNbmFtZXNwYWNlX2tleRgFIAEoCVIMbmFtZXNwYWNlS2V5", + "EigKBHR5cGUYBiABKA4yDy5mbGlwdC5GbGFnVHlwZUID4EECUgR0eXBlEjgK", + "CG1ldGFkYXRhGAcgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVjdEgAUght", + "ZXRhZGF0YYgBAUILCglfbWV0YWRhdGEilAIKEVVwZGF0ZUZsYWdSZXF1ZXN0", + "EhAKA2tleRgBIAEoCVIDa2V5EhcKBG5hbWUYAiABKAlCA+BBAlIEbmFtZRIg", + "CgtkZXNjcmlwdGlvbhgDIAEoCVILZGVzY3JpcHRpb24SGAoHZW5hYmxlZBgE", + "IAEoCFIHZW5hYmxlZBIjCg1uYW1lc3BhY2Vfa2V5GAUgASgJUgxuYW1lc3Bh", + "Y2VLZXkSLAoSZGVmYXVsdF92YXJpYW50X2lkGAYgASgJUhBkZWZhdWx0VmFy", + "aWFudElkEjgKCG1ldGFkYXRhGAcgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0", + "cnVjdEgAUghtZXRhZGF0YYgBAUILCglfbWV0YWRhdGEiSgoRRGVsZXRlRmxh", + "Z1JlcXVlc3QSEAoDa2V5GAEgASgJUgNrZXkSIwoNbmFtZXNwYWNlX2tleRgC", + "IAEoCVIMbmFtZXNwYWNlS2V5IrcCCgdWYXJpYW50Eg4KAmlkGAEgASgJUgJp", + "ZBIZCghmbGFnX2tleRgCIAEoCVIHZmxhZ0tleRIQCgNrZXkYAyABKAlSA2tl", + "eRISCgRuYW1lGAQgASgJUgRuYW1lEiAKC2Rlc2NyaXB0aW9uGAUgASgJUgtk", + "ZXNjcmlwdGlvbhI5CgpjcmVhdGVkX2F0GAYgASgLMhouZ29vZ2xlLnByb3Rv", + "YnVmLlRpbWVzdGFtcFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRfYXQYByABKAsy", + "Gi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wUgl1cGRhdGVkQXQSHgoKYXR0", + "YWNobWVudBgIIAEoCVIKYXR0YWNobWVudBIjCg1uYW1lc3BhY2Vfa2V5GAkg", + "ASgJUgxuYW1lc3BhY2VLZXkiwwEKFENyZWF0ZVZhcmlhbnRSZXF1ZXN0EhkK", + "CGZsYWdfa2V5GAEgASgJUgdmbGFnS2V5EhUKA2tleRgCIAEoCUID4EECUgNr", + "ZXkSEgoEbmFtZRgDIAEoCVIEbmFtZRIgCgtkZXNjcmlwdGlvbhgEIAEoCVIL", + "ZGVzY3JpcHRpb24SHgoKYXR0YWNobWVudBgFIAEoCVIKYXR0YWNobWVudBIj", + "Cg1uYW1lc3BhY2Vfa2V5GAYgASgJUgxuYW1lc3BhY2VLZXki0wEKFFVwZGF0", + "ZVZhcmlhbnRSZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghmbGFnX2tleRgC", + "IAEoCVIHZmxhZ0tleRIVCgNrZXkYAyABKAlCA+BBAlIDa2V5EhIKBG5hbWUY", + "BCABKAlSBG5hbWUSIAoLZGVzY3JpcHRpb24YBSABKAlSC2Rlc2NyaXB0aW9u", + "Eh4KCmF0dGFjaG1lbnQYBiABKAlSCmF0dGFjaG1lbnQSIwoNbmFtZXNwYWNl", + "X2tleRgHIAEoCVIMbmFtZXNwYWNlS2V5ImYKFERlbGV0ZVZhcmlhbnRSZXF1", + "ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghmbGFnX2tleRgCIAEoCVIHZmxhZ0tl", + "eRIjCg1uYW1lc3BhY2Vfa2V5GAMgASgJUgxuYW1lc3BhY2VLZXki0gIKB1Nl", + "Z21lbnQSEAoDa2V5GAEgASgJUgNrZXkSEgoEbmFtZRgCIAEoCVIEbmFtZRIg", + "CgtkZXNjcmlwdGlvbhgDIAEoCVILZGVzY3JpcHRpb24SOQoKY3JlYXRlZF9h", + "dBgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCWNyZWF0ZWRB", + "dBI5Cgp1cGRhdGVkX2F0GAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVz", + "dGFtcFIJdXBkYXRlZEF0EjMKC2NvbnN0cmFpbnRzGAYgAygLMhEuZmxpcHQu", + "Q29uc3RyYWludFILY29uc3RyYWludHMSLwoKbWF0Y2hfdHlwZRgHIAEoDjIQ", + "LmZsaXB0Lk1hdGNoVHlwZVIJbWF0Y2hUeXBlEiMKDW5hbWVzcGFjZV9rZXkY", + "CCABKAlSDG5hbWVzcGFjZUtleSKCAQoLU2VnbWVudExpc3QSKgoIc2VnbWVu", + "dHMYASADKAsyDi5mbGlwdC5TZWdtZW50UghzZWdtZW50cxImCg9uZXh0X3Bh", + "Z2VfdG9rZW4YAiABKAlSDW5leHRQYWdlVG9rZW4SHwoLdG90YWxfY291bnQY", + "AyABKAVSCnRvdGFsQ291bnQiaAoRR2V0U2VnbWVudFJlcXVlc3QSEAoDa2V5", + "GAEgASgJUgNrZXkSIwoNbmFtZXNwYWNlX2tleRgCIAEoCVIMbmFtZXNwYWNl", + "S2V5EhwKCXJlZmVyZW5jZRgDIAEoCVIJcmVmZXJlbmNlIqgBChJMaXN0U2Vn", + "bWVudFJlcXVlc3QSFAoFbGltaXQYASABKAVSBWxpbWl0EhoKBm9mZnNldBgC", + "IAEoBUICGAFSBm9mZnNldBIdCgpwYWdlX3Rva2VuGAMgASgJUglwYWdlVG9r", + "ZW4SIwoNbmFtZXNwYWNlX2tleRgEIAEoCVIMbmFtZXNwYWNlS2V5EhwKCXJl", + "ZmVyZW5jZRgFIAEoCVIJcmVmZXJlbmNlIsMBChRDcmVhdGVTZWdtZW50UmVx", + "dWVzdBIVCgNrZXkYASABKAlCA+BBAlIDa2V5EhcKBG5hbWUYAiABKAlCA+BB", + "AlIEbmFtZRIgCgtkZXNjcmlwdGlvbhgDIAEoCVILZGVzY3JpcHRpb24SNAoK", + "bWF0Y2hfdHlwZRgEIAEoDjIQLmZsaXB0Lk1hdGNoVHlwZUID4EECUgltYXRj", + "aFR5cGUSIwoNbmFtZXNwYWNlX2tleRgFIAEoCVIMbmFtZXNwYWNlS2V5Ir4B", + "ChRVcGRhdGVTZWdtZW50UmVxdWVzdBIQCgNrZXkYASABKAlSA2tleRIXCgRu", + "YW1lGAIgASgJQgPgQQJSBG5hbWUSIAoLZGVzY3JpcHRpb24YAyABKAlSC2Rl", + "c2NyaXB0aW9uEjQKCm1hdGNoX3R5cGUYBCABKA4yEC5mbGlwdC5NYXRjaFR5", + "cGVCA+BBAlIJbWF0Y2hUeXBlEiMKDW5hbWVzcGFjZV9rZXkYBSABKAlSDG5h", + "bWVzcGFjZUtleSJNChREZWxldGVTZWdtZW50UmVxdWVzdBIQCgNrZXkYASAB", + "KAlSA2tleRIjCg1uYW1lc3BhY2Vfa2V5GAIgASgJUgxuYW1lc3BhY2VLZXki", + "8wIKCkNvbnN0cmFpbnQSDgoCaWQYASABKAlSAmlkEh8KC3NlZ21lbnRfa2V5", + "GAIgASgJUgpzZWdtZW50S2V5EikKBHR5cGUYAyABKA4yFS5mbGlwdC5Db21w", + "YXJpc29uVHlwZVIEdHlwZRIaCghwcm9wZXJ0eRgEIAEoCVIIcHJvcGVydHkS", + "GgoIb3BlcmF0b3IYBSABKAlSCG9wZXJhdG9yEhQKBXZhbHVlGAYgASgJUgV2", + "YWx1ZRI5CgpjcmVhdGVkX2F0GAcgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcFIJY3JlYXRlZEF0EjkKCnVwZGF0ZWRfYXQYCCABKAsyGi5nb29n", + "bGUucHJvdG9idWYuVGltZXN0YW1wUgl1cGRhdGVkQXQSIwoNbmFtZXNwYWNl", + "X2tleRgJIAEoCVIMbmFtZXNwYWNlS2V5EiAKC2Rlc2NyaXB0aW9uGAogASgJ", + "UgtkZXNjcmlwdGlvbiKJAgoXQ3JlYXRlQ29uc3RyYWludFJlcXVlc3QSHwoL", + "c2VnbWVudF9rZXkYASABKAlSCnNlZ21lbnRLZXkSLgoEdHlwZRgCIAEoDjIV", + "LmZsaXB0LkNvbXBhcmlzb25UeXBlQgPgQQJSBHR5cGUSHwoIcHJvcGVydHkY", + "AyABKAlCA+BBAlIIcHJvcGVydHkSHwoIb3BlcmF0b3IYBCABKAlCA+BBAlII", + "b3BlcmF0b3ISFAoFdmFsdWUYBSABKAlSBXZhbHVlEiMKDW5hbWVzcGFjZV9r", + "ZXkYBiABKAlSDG5hbWVzcGFjZUtleRIgCgtkZXNjcmlwdGlvbhgHIAEoCVIL", + "ZGVzY3JpcHRpb24imQIKF1VwZGF0ZUNvbnN0cmFpbnRSZXF1ZXN0Eg4KAmlk", + "GAEgASgJUgJpZBIfCgtzZWdtZW50X2tleRgCIAEoCVIKc2VnbWVudEtleRIu", + "CgR0eXBlGAMgASgOMhUuZmxpcHQuQ29tcGFyaXNvblR5cGVCA+BBAlIEdHlw", + "ZRIfCghwcm9wZXJ0eRgEIAEoCUID4EECUghwcm9wZXJ0eRIfCghvcGVyYXRv", + "chgFIAEoCUID4EECUghvcGVyYXRvchIUCgV2YWx1ZRgGIAEoCVIFdmFsdWUS", + "IwoNbmFtZXNwYWNlX2tleRgHIAEoCVIMbmFtZXNwYWNlS2V5EiAKC2Rlc2Ny", + "aXB0aW9uGAggASgJUgtkZXNjcmlwdGlvbiJvChdEZWxldGVDb25zdHJhaW50", + "UmVxdWVzdBIOCgJpZBgBIAEoCVICaWQSHwoLc2VnbWVudF9rZXkYAiABKAlS", + "CnNlZ21lbnRLZXkSIwoNbmFtZXNwYWNlX2tleRgDIAEoCVIMbmFtZXNwYWNl", + "S2V5IqEDCgdSb2xsb3V0Eg4KAmlkGAEgASgJUgJpZBIjCg1uYW1lc3BhY2Vf", + "a2V5GAIgASgJUgxuYW1lc3BhY2VLZXkSGQoIZmxhZ19rZXkYAyABKAlSB2Zs", + "YWdLZXkSJgoEdHlwZRgEIAEoDjISLmZsaXB0LlJvbGxvdXRUeXBlUgR0eXBl", + "EhIKBHJhbmsYBSABKAVSBHJhbmsSIAoLZGVzY3JpcHRpb24YBiABKAlSC2Rl", + "c2NyaXB0aW9uEjkKCmNyZWF0ZWRfYXQYByABKAsyGi5nb29nbGUucHJvdG9i", + "dWYuVGltZXN0YW1wUgljcmVhdGVkQXQSOQoKdXBkYXRlZF9hdBgIIAEoCzIa", + "Lmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCXVwZGF0ZWRBdBIxCgdzZWdt", + "ZW50GBQgASgLMhUuZmxpcHQuUm9sbG91dFNlZ21lbnRIAFIHc2VnbWVudBI3", + "Cgl0aHJlc2hvbGQYFSABKAsyFy5mbGlwdC5Sb2xsb3V0VGhyZXNob2xkSABS", + "CXRocmVzaG9sZEIGCgRydWxlIrEBCg5Sb2xsb3V0U2VnbWVudBIjCgtzZWdt", + "ZW50X2tleRgBIAEoCUICGAFSCnNlZ21lbnRLZXkSFAoFdmFsdWUYAiABKAhS", + "BXZhbHVlEiEKDHNlZ21lbnRfa2V5cxgDIAMoCVILc2VnbWVudEtleXMSQQoQ", + "c2VnbWVudF9vcGVyYXRvchgEIAEoDjIWLmZsaXB0LlNlZ21lbnRPcGVyYXRv", + "clIPc2VnbWVudE9wZXJhdG9yIkgKEFJvbGxvdXRUaHJlc2hvbGQSHgoKcGVy", + "Y2VudGFnZRgBIAEoAlIKcGVyY2VudGFnZRIUCgV2YWx1ZRgCIAEoCFIFdmFs", + "dWUifAoLUm9sbG91dExpc3QSJAoFcnVsZXMYASADKAsyDi5mbGlwdC5Sb2xs", + "b3V0UgVydWxlcxImCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAlSDW5leHRQYWdl", + "VG9rZW4SHwoLdG90YWxfY291bnQYAyABKAVSCnRvdGFsQ291bnQipwEKEkxp", + "c3RSb2xsb3V0UmVxdWVzdBIjCg1uYW1lc3BhY2Vfa2V5GAEgASgJUgxuYW1l", + "c3BhY2VLZXkSGQoIZmxhZ19rZXkYAiABKAlSB2ZsYWdLZXkSFAoFbGltaXQY", + "AyABKAVSBWxpbWl0Eh0KCnBhZ2VfdG9rZW4YBCABKAlSCXBhZ2VUb2tlbhIc", + "CglyZWZlcmVuY2UYBSABKAlSCXJlZmVyZW5jZSKBAQoRR2V0Um9sbG91dFJl", + "cXVlc3QSDgoCaWQYASABKAlSAmlkEiMKDW5hbWVzcGFjZV9rZXkYAiABKAlS", + "DG5hbWVzcGFjZUtleRIZCghmbGFnX2tleRgDIAEoCVIHZmxhZ0tleRIcCgly", + "ZWZlcmVuY2UYBCABKAlSCXJlZmVyZW5jZSKFAgoUQ3JlYXRlUm9sbG91dFJl", + "cXVlc3QSIwoNbmFtZXNwYWNlX2tleRgBIAEoCVIMbmFtZXNwYWNlS2V5EhkK", + "CGZsYWdfa2V5GAIgASgJUgdmbGFnS2V5EhcKBHJhbmsYAyABKAVCA+BBAlIE", + "cmFuaxIgCgtkZXNjcmlwdGlvbhgEIAEoCVILZGVzY3JpcHRpb24SMQoHc2Vn", + "bWVudBgUIAEoCzIVLmZsaXB0LlJvbGxvdXRTZWdtZW50SABSB3NlZ21lbnQS", + "NwoJdGhyZXNob2xkGBUgASgLMhcuZmxpcHQuUm9sbG91dFRocmVzaG9sZEgA", + "Ugl0aHJlc2hvbGRCBgoEcnVsZSL8AQoUVXBkYXRlUm9sbG91dFJlcXVlc3QS", + "DgoCaWQYASABKAlSAmlkEiMKDW5hbWVzcGFjZV9rZXkYAiABKAlSDG5hbWVz", + "cGFjZUtleRIZCghmbGFnX2tleRgDIAEoCVIHZmxhZ0tleRIgCgtkZXNjcmlw", + "dGlvbhgEIAEoCVILZGVzY3JpcHRpb24SMQoHc2VnbWVudBgUIAEoCzIVLmZs", + "aXB0LlJvbGxvdXRTZWdtZW50SABSB3NlZ21lbnQSNwoJdGhyZXNob2xkGBUg", + "ASgLMhcuZmxpcHQuUm9sbG91dFRocmVzaG9sZEgAUgl0aHJlc2hvbGRCBgoE", + "cnVsZSJmChREZWxldGVSb2xsb3V0UmVxdWVzdBIOCgJpZBgBIAEoCVICaWQS", + "IwoNbmFtZXNwYWNlX2tleRgCIAEoCVIMbmFtZXNwYWNlS2V5EhkKCGZsYWdf", + "a2V5GAMgASgJUgdmbGFnS2V5InwKFE9yZGVyUm9sbG91dHNSZXF1ZXN0EhkK", + "CGZsYWdfa2V5GAEgASgJUgdmbGFnS2V5EiMKDW5hbWVzcGFjZV9rZXkYAiAB", + "KAlSDG5hbWVzcGFjZUtleRIkCgtyb2xsb3V0X2lkcxgDIAMoCUID4EECUgpy", + "b2xsb3V0SWRzIqIDCgRSdWxlEg4KAmlkGAEgASgJUgJpZBIZCghmbGFnX2tl", + "eRgCIAEoCVIHZmxhZ0tleRIfCgtzZWdtZW50X2tleRgDIAEoCVIKc2VnbWVu", + "dEtleRI5Cg1kaXN0cmlidXRpb25zGAQgAygLMhMuZmxpcHQuRGlzdHJpYnV0", + "aW9uUg1kaXN0cmlidXRpb25zEhIKBHJhbmsYBSABKAVSBHJhbmsSOQoKY3Jl", + "YXRlZF9hdBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCWNy", + "ZWF0ZWRBdBI5Cgp1cGRhdGVkX2F0GAcgASgLMhouZ29vZ2xlLnByb3RvYnVm", + "LlRpbWVzdGFtcFIJdXBkYXRlZEF0EiMKDW5hbWVzcGFjZV9rZXkYCCABKAlS", + "DG5hbWVzcGFjZUtleRIhCgxzZWdtZW50X2tleXMYCSADKAlSC3NlZ21lbnRL", + "ZXlzEkEKEHNlZ21lbnRfb3BlcmF0b3IYCiABKA4yFi5mbGlwdC5TZWdtZW50", + "T3BlcmF0b3JSD3NlZ21lbnRPcGVyYXRvciJ2CghSdWxlTGlzdBIhCgVydWxl", + "cxgBIAMoCzILLmZsaXB0LlJ1bGVSBXJ1bGVzEiYKD25leHRfcGFnZV90b2tl", + "bhgCIAEoCVINbmV4dFBhZ2VUb2tlbhIfCgt0b3RhbF9jb3VudBgDIAEoBVIK", + "dG90YWxDb3VudCLAAQoPTGlzdFJ1bGVSZXF1ZXN0EhQKBWxpbWl0GAEgASgF", + "UgVsaW1pdBIaCgZvZmZzZXQYAiABKAVCAhgBUgZvZmZzZXQSGQoIZmxhZ19r", + "ZXkYAyABKAlSB2ZsYWdLZXkSHQoKcGFnZV90b2tlbhgEIAEoCVIJcGFnZVRv", + "a2VuEiMKDW5hbWVzcGFjZV9rZXkYBSABKAlSDG5hbWVzcGFjZUtleRIcCgly", + "ZWZlcmVuY2UYBiABKAlSCXJlZmVyZW5jZSJ+Cg5HZXRSdWxlUmVxdWVzdBIO", + "CgJpZBgBIAEoCVICaWQSGQoIZmxhZ19rZXkYAiABKAlSB2ZsYWdLZXkSIwoN", + "bmFtZXNwYWNlX2tleRgDIAEoCVIMbmFtZXNwYWNlS2V5EhwKCXJlZmVyZW5j", + "ZRgEIAEoCVIJcmVmZXJlbmNlIvcBChFDcmVhdGVSdWxlUmVxdWVzdBIZCghm", + "bGFnX2tleRgBIAEoCVIHZmxhZ0tleRIjCgtzZWdtZW50X2tleRgCIAEoCUIC", + "GAFSCnNlZ21lbnRLZXkSFwoEcmFuaxgDIAEoBUID4EECUgRyYW5rEiMKDW5h", + "bWVzcGFjZV9rZXkYBCABKAlSDG5hbWVzcGFjZUtleRIhCgxzZWdtZW50X2tl", + "eXMYBSADKAlSC3NlZ21lbnRLZXlzEkEKEHNlZ21lbnRfb3BlcmF0b3IYBiAB", + "KA4yFi5mbGlwdC5TZWdtZW50T3BlcmF0b3JSD3NlZ21lbnRPcGVyYXRvciLu", + "AQoRVXBkYXRlUnVsZVJlcXVlc3QSDgoCaWQYASABKAlSAmlkEhkKCGZsYWdf", + "a2V5GAIgASgJUgdmbGFnS2V5EiMKC3NlZ21lbnRfa2V5GAMgASgJQgIYAVIK", + "c2VnbWVudEtleRIjCg1uYW1lc3BhY2Vfa2V5GAQgASgJUgxuYW1lc3BhY2VL", + "ZXkSIQoMc2VnbWVudF9rZXlzGAUgAygJUgtzZWdtZW50S2V5cxJBChBzZWdt", + "ZW50X29wZXJhdG9yGAYgASgOMhYuZmxpcHQuU2VnbWVudE9wZXJhdG9yUg9z", + "ZWdtZW50T3BlcmF0b3IiYwoRRGVsZXRlUnVsZVJlcXVlc3QSDgoCaWQYASAB", + "KAlSAmlkEhkKCGZsYWdfa2V5GAIgASgJUgdmbGFnS2V5EiMKDW5hbWVzcGFj", + "ZV9rZXkYAyABKAlSDG5hbWVzcGFjZUtleSJzChFPcmRlclJ1bGVzUmVxdWVz", + "dBIZCghmbGFnX2tleRgBIAEoCVIHZmxhZ0tleRIeCghydWxlX2lkcxgCIAMo", + "CUID4EECUgdydWxlSWRzEiMKDW5hbWVzcGFjZV9rZXkYAyABKAlSDG5hbWVz", + "cGFjZUtleSLmAQoMRGlzdHJpYnV0aW9uEg4KAmlkGAEgASgJUgJpZBIXCgdy", + "dWxlX2lkGAIgASgJUgZydWxlSWQSHQoKdmFyaWFudF9pZBgDIAEoCVIJdmFy", + "aWFudElkEhgKB3JvbGxvdXQYBCABKAJSB3JvbGxvdXQSOQoKY3JlYXRlZF9h", + "dBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBSCWNyZWF0ZWRB", + "dBI5Cgp1cGRhdGVkX2F0GAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVz", + "dGFtcFIJdXBkYXRlZEF0IrcBChlDcmVhdGVEaXN0cmlidXRpb25SZXF1ZXN0", + "EhkKCGZsYWdfa2V5GAEgASgJUgdmbGFnS2V5EhcKB3J1bGVfaWQYAiABKAlS", + "BnJ1bGVJZBIiCgp2YXJpYW50X2lkGAMgASgJQgPgQQJSCXZhcmlhbnRJZBId", + "Cgdyb2xsb3V0GAQgASgCQgPgQQJSB3JvbGxvdXQSIwoNbmFtZXNwYWNlX2tl", + "eRgFIAEoCVIMbmFtZXNwYWNlS2V5IscBChlVcGRhdGVEaXN0cmlidXRpb25S", + "ZXF1ZXN0Eg4KAmlkGAEgASgJUgJpZBIZCghmbGFnX2tleRgCIAEoCVIHZmxh", + "Z0tleRIXCgdydWxlX2lkGAMgASgJUgZydWxlSWQSIgoKdmFyaWFudF9pZBgE", + "IAEoCUID4EECUgl2YXJpYW50SWQSHQoHcm9sbG91dBgFIAEoAkID4EECUgdy", + "b2xsb3V0EiMKDW5hbWVzcGFjZV9rZXkYBiABKAlSDG5hbWVzcGFjZUtleSKj", + "AQoZRGVsZXRlRGlzdHJpYnV0aW9uUmVxdWVzdBIOCgJpZBgBIAEoCVICaWQS", + "GQoIZmxhZ19rZXkYAiABKAlSB2ZsYWdLZXkSFwoHcnVsZV9pZBgDIAEoCVIG", + "cnVsZUlkEh0KCnZhcmlhbnRfaWQYBCABKAlSCXZhcmlhbnRJZBIjCg1uYW1l", + "c3BhY2Vfa2V5GAUgASgJUgxuYW1lc3BhY2VLZXkq1QEKEEV2YWx1YXRpb25S", + "ZWFzb24SHQoZVU5LTk9XTl9FVkFMVUFUSU9OX1JFQVNPThAAEiMKH0ZMQUdf", + "RElTQUJMRURfRVZBTFVBVElPTl9SRUFTT04QARIkCiBGTEFHX05PVF9GT1VO", + "RF9FVkFMVUFUSU9OX1JFQVNPThACEhsKF01BVENIX0VWQUxVQVRJT05fUkVB", + "U09OEAMSGwoXRVJST1JfRVZBTFVBVElPTl9SRUFTT04QBBIdChlERUZBVUxU", + "X0VWQUxVQVRJT05fUkVBU09OEAUqOAoIRmxhZ1R5cGUSFQoRVkFSSUFOVF9G", + "TEFHX1RZUEUQABIVChFCT09MRUFOX0ZMQUdfVFlQRRABKjMKCU1hdGNoVHlw", + "ZRISCg5BTExfTUFUQ0hfVFlQRRAAEhIKDkFOWV9NQVRDSF9UWVBFEAEqvwEK", + "DkNvbXBhcmlzb25UeXBlEhsKF1VOS05PV05fQ09NUEFSSVNPTl9UWVBFEAAS", + "GgoWU1RSSU5HX0NPTVBBUklTT05fVFlQRRABEhoKFk5VTUJFUl9DT01QQVJJ", + "U09OX1RZUEUQAhIbChdCT09MRUFOX0NPTVBBUklTT05fVFlQRRADEhwKGERB", + "VEVUSU1FX0NPTVBBUklTT05fVFlQRRAEEh0KGUVOVElUWV9JRF9DT01QQVJJ", + "U09OX1RZUEUQBSpdCgtSb2xsb3V0VHlwZRIYChRVTktOT1dOX1JPTExPVVRf", + "VFlQRRAAEhgKFFNFR01FTlRfUk9MTE9VVF9UWVBFEAESGgoWVEhSRVNIT0xE", + "X1JPTExPVVRfVFlQRRACKkQKD1NlZ21lbnRPcGVyYXRvchIXChNPUl9TRUdN", + "RU5UX09QRVJBVE9SEAASGAoUQU5EX1NFR01FTlRfT1BFUkFUT1IQATLcLwoF", + "RmxpcHQSRAoIRXZhbHVhdGUSGC5mbGlwdC5FdmFsdWF0aW9uUmVxdWVzdBoZ", + "LmZsaXB0LkV2YWx1YXRpb25SZXNwb25zZSIDiAIBElMKDUJhdGNoRXZhbHVh", + "dGUSHS5mbGlwdC5CYXRjaEV2YWx1YXRpb25SZXF1ZXN0Gh4uZmxpcHQuQmF0", + "Y2hFdmFsdWF0aW9uUmVzcG9uc2UiA4gCARKCAQoMR2V0TmFtZXNwYWNlEhou", + "ZmxpcHQuR2V0TmFtZXNwYWNlUmVxdWVzdBoQLmZsaXB0Lk5hbWVzcGFjZSJE", + "ukchChFOYW1lc3BhY2VzU2VydmljZSoMZ2V0TmFtZXNwYWNlgtPkkwIaEhgv", + "YXBpL3YxL25hbWVzcGFjZXMve2tleX0ShQEKDkxpc3ROYW1lc3BhY2VzEhsu", + "ZmxpcHQuTGlzdE5hbWVzcGFjZVJlcXVlc3QaFC5mbGlwdC5OYW1lc3BhY2VM", + "aXN0IkC6RyMKEU5hbWVzcGFjZXNTZXJ2aWNlKg5saXN0TmFtZXNwYWNlc4LT", + "5JMCFBISL2FwaS92MS9uYW1lc3BhY2VzEogBCg9DcmVhdGVOYW1lc3BhY2US", + "HS5mbGlwdC5DcmVhdGVOYW1lc3BhY2VSZXF1ZXN0GhAuZmxpcHQuTmFtZXNw", + "YWNlIkS6RyQKEU5hbWVzcGFjZXNTZXJ2aWNlKg9jcmVhdGVOYW1lc3BhY2WC", + "0+STAhc6ASoiEi9hcGkvdjEvbmFtZXNwYWNlcxKOAQoPVXBkYXRlTmFtZXNw", "YWNlEh0uZmxpcHQuVXBkYXRlTmFtZXNwYWNlUmVxdWVzdBoQLmZsaXB0Lk5h", - "bWVzcGFjZSIAEkoKD0RlbGV0ZU5hbWVzcGFjZRIdLmZsaXB0LkRlbGV0ZU5h", - "bWVzcGFjZVJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiABIvCgdH", - "ZXRGbGFnEhUuZmxpcHQuR2V0RmxhZ1JlcXVlc3QaCy5mbGlwdC5GbGFnIgAS", - "NgoJTGlzdEZsYWdzEhYuZmxpcHQuTGlzdEZsYWdSZXF1ZXN0Gg8uZmxpcHQu", - "RmxhZ0xpc3QiABI1CgpDcmVhdGVGbGFnEhguZmxpcHQuQ3JlYXRlRmxhZ1Jl", - "cXVlc3QaCy5mbGlwdC5GbGFnIgASNQoKVXBkYXRlRmxhZxIYLmZsaXB0LlVw", - "ZGF0ZUZsYWdSZXF1ZXN0GgsuZmxpcHQuRmxhZyIAEkAKCkRlbGV0ZUZsYWcS", - "GC5mbGlwdC5EZWxldGVGbGFnUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5F", - "bXB0eSIAEj4KDUNyZWF0ZVZhcmlhbnQSGy5mbGlwdC5DcmVhdGVWYXJpYW50", - "UmVxdWVzdBoOLmZsaXB0LlZhcmlhbnQiABI+Cg1VcGRhdGVWYXJpYW50Ehsu", - "ZmxpcHQuVXBkYXRlVmFyaWFudFJlcXVlc3QaDi5mbGlwdC5WYXJpYW50IgAS", - "RgoNRGVsZXRlVmFyaWFudBIbLmZsaXB0LkRlbGV0ZVZhcmlhbnRSZXF1ZXN0", - "GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5IgASLwoHR2V0UnVsZRIVLmZsaXB0", - "LkdldFJ1bGVSZXF1ZXN0GgsuZmxpcHQuUnVsZSIAEjYKCUxpc3RSdWxlcxIW", - "LmZsaXB0Lkxpc3RSdWxlUmVxdWVzdBoPLmZsaXB0LlJ1bGVMaXN0IgASNQoK", - "Q3JlYXRlUnVsZRIYLmZsaXB0LkNyZWF0ZVJ1bGVSZXF1ZXN0GgsuZmxpcHQu", - "UnVsZSIAEjUKClVwZGF0ZVJ1bGUSGC5mbGlwdC5VcGRhdGVSdWxlUmVxdWVz", - "dBoLLmZsaXB0LlJ1bGUiABJACgpPcmRlclJ1bGVzEhguZmxpcHQuT3JkZXJS", - "dWxlc1JlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiABJACgpEZWxl", - "dGVSdWxlEhguZmxpcHQuRGVsZXRlUnVsZVJlcXVlc3QaFi5nb29nbGUucHJv", - "dG9idWYuRW1wdHkiABI4CgpHZXRSb2xsb3V0EhguZmxpcHQuR2V0Um9sbG91", - "dFJlcXVlc3QaDi5mbGlwdC5Sb2xsb3V0IgASPwoMTGlzdFJvbGxvdXRzEhku", - "ZmxpcHQuTGlzdFJvbGxvdXRSZXF1ZXN0GhIuZmxpcHQuUm9sbG91dExpc3Qi", - "ABI+Cg1DcmVhdGVSb2xsb3V0EhsuZmxpcHQuQ3JlYXRlUm9sbG91dFJlcXVl", - "c3QaDi5mbGlwdC5Sb2xsb3V0IgASPgoNVXBkYXRlUm9sbG91dBIbLmZsaXB0", - "LlVwZGF0ZVJvbGxvdXRSZXF1ZXN0Gg4uZmxpcHQuUm9sbG91dCIAEkYKDURl", - "bGV0ZVJvbGxvdXQSGy5mbGlwdC5EZWxldGVSb2xsb3V0UmVxdWVzdBoWLmdv", - "b2dsZS5wcm90b2J1Zi5FbXB0eSIAEkYKDU9yZGVyUm9sbG91dHMSGy5mbGlw", - "dC5PcmRlclJvbGxvdXRzUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0", - "eSIAEk0KEkNyZWF0ZURpc3RyaWJ1dGlvbhIgLmZsaXB0LkNyZWF0ZURpc3Ry", - "aWJ1dGlvblJlcXVlc3QaEy5mbGlwdC5EaXN0cmlidXRpb24iABJNChJVcGRh", - "dGVEaXN0cmlidXRpb24SIC5mbGlwdC5VcGRhdGVEaXN0cmlidXRpb25SZXF1", - "ZXN0GhMuZmxpcHQuRGlzdHJpYnV0aW9uIgASUAoSRGVsZXRlRGlzdHJpYnV0", - "aW9uEiAuZmxpcHQuRGVsZXRlRGlzdHJpYnV0aW9uUmVxdWVzdBoWLmdvb2ds", - "ZS5wcm90b2J1Zi5FbXB0eSIAEjgKCkdldFNlZ21lbnQSGC5mbGlwdC5HZXRT", - "ZWdtZW50UmVxdWVzdBoOLmZsaXB0LlNlZ21lbnQiABI/CgxMaXN0U2VnbWVu", - "dHMSGS5mbGlwdC5MaXN0U2VnbWVudFJlcXVlc3QaEi5mbGlwdC5TZWdtZW50", - "TGlzdCIAEj4KDUNyZWF0ZVNlZ21lbnQSGy5mbGlwdC5DcmVhdGVTZWdtZW50", - "UmVxdWVzdBoOLmZsaXB0LlNlZ21lbnQiABI+Cg1VcGRhdGVTZWdtZW50Ehsu", - "ZmxpcHQuVXBkYXRlU2VnbWVudFJlcXVlc3QaDi5mbGlwdC5TZWdtZW50IgAS", - "RgoNRGVsZXRlU2VnbWVudBIbLmZsaXB0LkRlbGV0ZVNlZ21lbnRSZXF1ZXN0", - "GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5IgASRwoQQ3JlYXRlQ29uc3RyYWlu", - "dBIeLmZsaXB0LkNyZWF0ZUNvbnN0cmFpbnRSZXF1ZXN0GhEuZmxpcHQuQ29u", - "c3RyYWludCIAEkcKEFVwZGF0ZUNvbnN0cmFpbnQSHi5mbGlwdC5VcGRhdGVD", - "b25zdHJhaW50UmVxdWVzdBoRLmZsaXB0LkNvbnN0cmFpbnQiABJMChBEZWxl", - "dGVDb25zdHJhaW50Eh4uZmxpcHQuRGVsZXRlQ29uc3RyYWludFJlcXVlc3Qa", - "Fi5nb29nbGUucHJvdG9idWYuRW1wdHkiAEIdWhtnby5mbGlwdC5pby9mbGlw", - "dC9ycGMvZmxpcHRiBnByb3RvMw==")); + "bWVzcGFjZSJKukckChFOYW1lc3BhY2VzU2VydmljZSoPdXBkYXRlTmFtZXNw", + "YWNlgtPkkwIdOgEqGhgvYXBpL3YxL25hbWVzcGFjZXMve2tleX0SkQEKD0Rl", + "bGV0ZU5hbWVzcGFjZRIdLmZsaXB0LkRlbGV0ZU5hbWVzcGFjZVJlcXVlc3Qa", + "Fi5nb29nbGUucHJvdG9idWYuRW1wdHkiR7pHJAoRTmFtZXNwYWNlc1NlcnZp", + "Y2UqD2RlbGV0ZU5hbWVzcGFjZYLT5JMCGioYL2FwaS92MS9uYW1lc3BhY2Vz", + "L3trZXl9En8KB0dldEZsYWcSFS5mbGlwdC5HZXRGbGFnUmVxdWVzdBoLLmZs", + "aXB0LkZsYWciULpHFwoMRmxhZ3NTZXJ2aWNlKgdnZXRGbGFngtPkkwIwEi4v", + "YXBpL3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9rZXl9L2ZsYWdzL3trZXl9", + "EoIBCglMaXN0RmxhZ3MSFi5mbGlwdC5MaXN0RmxhZ1JlcXVlc3QaDy5mbGlw", + "dC5GbGFnTGlzdCJMukcZCgxGbGFnc1NlcnZpY2UqCWxpc3RGbGFnc4LT5JMC", + "KhIoL2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncxKF", + "AQoKQ3JlYXRlRmxhZxIYLmZsaXB0LkNyZWF0ZUZsYWdSZXF1ZXN0GgsuZmxp", + "cHQuRmxhZyJQukcaCgxGbGFnc1NlcnZpY2UqCmNyZWF0ZUZsYWeC0+STAi06", + "ASoiKC9hcGkvdjEvbmFtZXNwYWNlcy97bmFtZXNwYWNlX2tleX0vZmxhZ3MS", + "iwEKClVwZGF0ZUZsYWcSGC5mbGlwdC5VcGRhdGVGbGFnUmVxdWVzdBoLLmZs", + "aXB0LkZsYWciVrpHGgoMRmxhZ3NTZXJ2aWNlKgp1cGRhdGVGbGFngtPkkwIz", + "OgEqGi4vYXBpL3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9rZXl9L2ZsYWdz", + "L3trZXl9EpMBCgpEZWxldGVGbGFnEhguZmxpcHQuRGVsZXRlRmxhZ1JlcXVl", + "c3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiU7pHGgoMRmxhZ3NTZXJ2aWNl", + "KgpkZWxldGVGbGFngtPkkwIwKi4vYXBpL3YxL25hbWVzcGFjZXMve25hbWVz", + "cGFjZV9rZXl9L2ZsYWdzL3trZXl9EqgBCg1DcmVhdGVWYXJpYW50EhsuZmxp", + "cHQuQ3JlYXRlVmFyaWFudFJlcXVlc3QaDi5mbGlwdC5WYXJpYW50Imq6RyAK", + "D1ZhcmlhbnRzU2VydmljZSoNY3JlYXRlVmFyaWFudILT5JMCQToBKiI8L2Fw", + "aS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncy97ZmxhZ19r", + "ZXl9L3ZhcmlhbnRzEq0BCg1VcGRhdGVWYXJpYW50EhsuZmxpcHQuVXBkYXRl", + "VmFyaWFudFJlcXVlc3QaDi5mbGlwdC5WYXJpYW50Im+6RyAKD1ZhcmlhbnRz", + "U2VydmljZSoNdXBkYXRlVmFyaWFudILT5JMCRjoBKhpBL2FwaS92MS9uYW1l", + "c3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncy97ZmxhZ19rZXl9L3Zhcmlh", + "bnRzL3tpZH0SsgEKDURlbGV0ZVZhcmlhbnQSGy5mbGlwdC5EZWxldGVWYXJp", + "YW50UmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJsukcgCg9WYXJp", + "YW50c1NlcnZpY2UqDWRlbGV0ZVZhcmlhbnSC0+STAkMqQS9hcGkvdjEvbmFt", + "ZXNwYWNlcy97bmFtZXNwYWNlX2tleX0vZmxhZ3Mve2ZsYWdfa2V5fS92YXJp", + "YW50cy97aWR9Eo8BCgdHZXRSdWxlEhUuZmxpcHQuR2V0UnVsZVJlcXVlc3Qa", + "Cy5mbGlwdC5SdWxlImC6RxcKDFJ1bGVzU2VydmljZSoHZ2V0UnVsZYLT5JMC", + "QBI+L2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncy97", + "ZmxhZ19rZXl9L3J1bGVzL3tpZH0SkwEKCUxpc3RSdWxlcxIWLmZsaXB0Lkxp", + "c3RSdWxlUmVxdWVzdBoPLmZsaXB0LlJ1bGVMaXN0Il26RxkKDFJ1bGVzU2Vy", + "dmljZSoJbGlzdFJ1bGVzgtPkkwI7EjkvYXBpL3YxL25hbWVzcGFjZXMve25h", + "bWVzcGFjZV9rZXl9L2ZsYWdzL3tmbGFnX2tleX0vcnVsZXMSlgEKCkNyZWF0", + "ZVJ1bGUSGC5mbGlwdC5DcmVhdGVSdWxlUmVxdWVzdBoLLmZsaXB0LlJ1bGUi", + "YbpHGgoMUnVsZXNTZXJ2aWNlKgpjcmVhdGVSdWxlgtPkkwI+OgEqIjkvYXBp", + "L3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9rZXl9L2ZsYWdzL3tmbGFnX2tl", + "eX0vcnVsZXMSmwEKClVwZGF0ZVJ1bGUSGC5mbGlwdC5VcGRhdGVSdWxlUmVx", + "dWVzdBoLLmZsaXB0LlJ1bGUiZrpHGgoMUnVsZXNTZXJ2aWNlKgp1cGRhdGVS", + "dWxlgtPkkwJDOgEqGj4vYXBpL3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9r", + "ZXl9L2ZsYWdzL3tmbGFnX2tleX0vcnVsZXMve2lkfRKnAQoKT3JkZXJSdWxl", + "cxIYLmZsaXB0Lk9yZGVyUnVsZXNSZXF1ZXN0GhYuZ29vZ2xlLnByb3RvYnVm", + "LkVtcHR5Ime6RxoKDFJ1bGVzU2VydmljZSoKb3JkZXJSdWxlc4LT5JMCRDoB", + "Kho/L2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncy97", + "ZmxhZ19rZXl9L3J1bGVzL29yZGVyEqMBCgpEZWxldGVSdWxlEhguZmxpcHQu", + "RGVsZXRlUnVsZVJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiY7pH", + "GgoMUnVsZXNTZXJ2aWNlKgpkZWxldGVSdWxlgtPkkwJAKj4vYXBpL3YxL25h", + "bWVzcGFjZXMve25hbWVzcGFjZV9rZXl9L2ZsYWdzL3tmbGFnX2tleX0vcnVs", + "ZXMve2lkfRKhAQoKR2V0Um9sbG91dBIYLmZsaXB0LkdldFJvbGxvdXRSZXF1", + "ZXN0Gg4uZmxpcHQuUm9sbG91dCJpukcdCg9Sb2xsb3V0c1NlcnZpY2UqCmdl", + "dFJvbGxvdXSC0+STAkMSQS9hcGkvdjEvbmFtZXNwYWNlcy97bmFtZXNwYWNl", + "X2tleX0vZmxhZ3Mve2ZsYWdfa2V5fS9yb2xsb3V0cy97aWR9EqUBCgxMaXN0", + "Um9sbG91dHMSGS5mbGlwdC5MaXN0Um9sbG91dFJlcXVlc3QaEi5mbGlwdC5S", + "b2xsb3V0TGlzdCJmukcfCg9Sb2xsb3V0c1NlcnZpY2UqDGxpc3RSb2xsb3V0", + "c4LT5JMCPhI8L2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9m", + "bGFncy97ZmxhZ19rZXl9L3JvbGxvdXRzEqgBCg1DcmVhdGVSb2xsb3V0Ehsu", + "ZmxpcHQuQ3JlYXRlUm9sbG91dFJlcXVlc3QaDi5mbGlwdC5Sb2xsb3V0Imq6", + "RyAKD1JvbGxvdXRzU2VydmljZSoNY3JlYXRlUm9sbG91dILT5JMCQToBKiI8", + "L2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncy97Zmxh", + "Z19rZXl9L3JvbGxvdXRzEq0BCg1VcGRhdGVSb2xsb3V0EhsuZmxpcHQuVXBk", + "YXRlUm9sbG91dFJlcXVlc3QaDi5mbGlwdC5Sb2xsb3V0Im+6RyAKD1JvbGxv", + "dXRzU2VydmljZSoNdXBkYXRlUm9sbG91dILT5JMCRjoBKhpBL2FwaS92MS9u", + "YW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5fS9mbGFncy97ZmxhZ19rZXl9L3Jv", + "bGxvdXRzL3tpZH0SsgEKDURlbGV0ZVJvbGxvdXQSGy5mbGlwdC5EZWxldGVS", + "b2xsb3V0UmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJsukcgCg9S", + "b2xsb3V0c1NlcnZpY2UqDWRlbGV0ZVJvbGxvdXSC0+STAkMqQS9hcGkvdjEv", + "bmFtZXNwYWNlcy97bmFtZXNwYWNlX2tleX0vZmxhZ3Mve2ZsYWdfa2V5fS9y", + "b2xsb3V0cy97aWR9ErYBCg1PcmRlclJvbGxvdXRzEhsuZmxpcHQuT3JkZXJS", + "b2xsb3V0c1JlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkicLpHIAoP", + "Um9sbG91dHNTZXJ2aWNlKg1vcmRlclJvbGxvdXRzgtPkkwJHOgEqGkIvYXBp", + "L3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9rZXl9L2ZsYWdzL3tmbGFnX2tl", + "eX0vcm9sbG91dHMvb3JkZXIS1wEKEkNyZWF0ZURpc3RyaWJ1dGlvbhIgLmZs", + "aXB0LkNyZWF0ZURpc3RyaWJ1dGlvblJlcXVlc3QaEy5mbGlwdC5EaXN0cmli", + "dXRpb24iiQG6RyoKFERpc3RyaWJ1dGlvbnNTZXJ2aWNlKhJjcmVhdGVEaXN0", + "cmlidXRpb26C0+STAlY6ASoiUS9hcGkvdjEvbmFtZXNwYWNlcy97bmFtZXNw", + "YWNlX2tleX0vZmxhZ3Mve2ZsYWdfa2V5fS9ydWxlcy97cnVsZV9pZH0vZGlz", + "dHJpYnV0aW9ucxLcAQoSVXBkYXRlRGlzdHJpYnV0aW9uEiAuZmxpcHQuVXBk", + "YXRlRGlzdHJpYnV0aW9uUmVxdWVzdBoTLmZsaXB0LkRpc3RyaWJ1dGlvbiKO", + "AbpHKgoURGlzdHJpYnV0aW9uc1NlcnZpY2UqEnVwZGF0ZURpc3RyaWJ1dGlv", + "boLT5JMCWzoBKhpWL2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vfa2V5", + "fS9mbGFncy97ZmxhZ19rZXl9L3J1bGVzL3tydWxlX2lkfS9kaXN0cmlidXRp", + "b25zL3tpZH0S3AEKEkRlbGV0ZURpc3RyaWJ1dGlvbhIgLmZsaXB0LkRlbGV0", + "ZURpc3RyaWJ1dGlvblJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHki", + "iwG6RyoKFERpc3RyaWJ1dGlvbnNTZXJ2aWNlKhJkZWxldGVEaXN0cmlidXRp", + "b26C0+STAlgqVi9hcGkvdjEvbmFtZXNwYWNlcy97bmFtZXNwYWNlX2tleX0v", + "ZmxhZ3Mve2ZsYWdfa2V5fS9ydWxlcy97cnVsZV9pZH0vZGlzdHJpYnV0aW9u", + "cy97aWR9EpEBCgpHZXRTZWdtZW50EhguZmxpcHQuR2V0U2VnbWVudFJlcXVl", + "c3QaDi5mbGlwdC5TZWdtZW50Ilm6Rx0KD1NlZ21lbnRzU2VydmljZSoKZ2V0", + "U2VnbWVudILT5JMCMxIxL2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vf", + "a2V5fS9zZWdtZW50cy97a2V5fRKUAQoMTGlzdFNlZ21lbnRzEhkuZmxpcHQu", + "TGlzdFNlZ21lbnRSZXF1ZXN0GhIuZmxpcHQuU2VnbWVudExpc3QiVbpHHwoP", + "U2VnbWVudHNTZXJ2aWNlKgxsaXN0U2VnbWVudHOC0+STAi0SKy9hcGkvdjEv", + "bmFtZXNwYWNlcy97bmFtZXNwYWNlX2tleX0vc2VnbWVudHMSlwEKDUNyZWF0", + "ZVNlZ21lbnQSGy5mbGlwdC5DcmVhdGVTZWdtZW50UmVxdWVzdBoOLmZsaXB0", + "LlNlZ21lbnQiWbpHIAoPU2VnbWVudHNTZXJ2aWNlKg1jcmVhdGVTZWdtZW50", + "gtPkkwIwOgEqIisvYXBpL3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9rZXl9", + "L3NlZ21lbnRzEp0BCg1VcGRhdGVTZWdtZW50EhsuZmxpcHQuVXBkYXRlU2Vn", + "bWVudFJlcXVlc3QaDi5mbGlwdC5TZWdtZW50Il+6RyAKD1NlZ21lbnRzU2Vy", + "dmljZSoNdXBkYXRlU2VnbWVudILT5JMCNjoBKhoxL2FwaS92MS9uYW1lc3Bh", + "Y2VzL3tuYW1lc3BhY2Vfa2V5fS9zZWdtZW50cy97a2V5fRKiAQoNRGVsZXRl", + "U2VnbWVudBIbLmZsaXB0LkRlbGV0ZVNlZ21lbnRSZXF1ZXN0GhYuZ29vZ2xl", + "LnByb3RvYnVmLkVtcHR5Ily6RyAKD1NlZ21lbnRzU2VydmljZSoNZGVsZXRl", + "U2VnbWVudILT5JMCMyoxL2FwaS92MS9uYW1lc3BhY2VzL3tuYW1lc3BhY2Vf", + "a2V5fS9zZWdtZW50cy97a2V5fRLAAQoQQ3JlYXRlQ29uc3RyYWludBIeLmZs", + "aXB0LkNyZWF0ZUNvbnN0cmFpbnRSZXF1ZXN0GhEuZmxpcHQuQ29uc3RyYWlu", + "dCJ5ukcmChJDb25zdHJhaW50c1NlcnZpY2UqEGNyZWF0ZUNvbnN0cmFpbnSC", + "0+STAko6ASoiRS9hcGkvdjEvbmFtZXNwYWNlcy97bmFtZXNwYWNlX2tleX0v", + "c2VnbWVudHMve3NlZ21lbnRfa2V5fS9jb25zdHJhaW50cxLFAQoQVXBkYXRl", + "Q29uc3RyYWludBIeLmZsaXB0LlVwZGF0ZUNvbnN0cmFpbnRSZXF1ZXN0GhEu", + "ZmxpcHQuQ29uc3RyYWludCJ+ukcmChJDb25zdHJhaW50c1NlcnZpY2UqEHVw", + "ZGF0ZUNvbnN0cmFpbnSC0+STAk86ASoaSi9hcGkvdjEvbmFtZXNwYWNlcy97", + "bmFtZXNwYWNlX2tleX0vc2VnbWVudHMve3NlZ21lbnRfa2V5fS9jb25zdHJh", + "aW50cy97aWR9EscBChBEZWxldGVDb25zdHJhaW50Eh4uZmxpcHQuRGVsZXRl", + "Q29uc3RyYWludFJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkie7pH", + "JgoSQ29uc3RyYWludHNTZXJ2aWNlKhBkZWxldGVDb25zdHJhaW50gtPkkwJM", + "KkovYXBpL3YxL25hbWVzcGFjZXMve25hbWVzcGFjZV9rZXl9L3NlZ21lbnRz", + "L3tzZWdtZW50X2tleX0vY29uc3RyYWludHMve2lkfUIdWhtnby5mbGlwdC5p", + "by9mbGlwdC9ycGMvZmxpcHRiBnByb3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.EmptyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Gnostic.Openapi.V3.AnnotationsReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Flipt.EvaluationReason), typeof(global::Flipt.FlagType), typeof(global::Flipt.MatchType), typeof(global::Flipt.ComparisonType), typeof(global::Flipt.RolloutType), typeof(global::Flipt.SegmentOperator), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.EvaluationRequest), global::Flipt.EvaluationRequest.Parser, new[]{ "RequestId", "FlagKey", "EntityId", "Context", "NamespaceKey" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.BatchEvaluationRequest), global::Flipt.BatchEvaluationRequest.Parser, new[]{ "RequestId", "Requests", "ExcludeNotFound", "NamespaceKey" }, null, null, null, null), @@ -342,13 +437,13 @@ static FliptReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.ListNamespaceRequest), global::Flipt.ListNamespaceRequest.Parser, new[]{ "Limit", "Offset", "PageToken", "Reference" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.CreateNamespaceRequest), global::Flipt.CreateNamespaceRequest.Parser, new[]{ "Key", "Name", "Description" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.UpdateNamespaceRequest), global::Flipt.UpdateNamespaceRequest.Parser, new[]{ "Key", "Name", "Description" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.DeleteNamespaceRequest), global::Flipt.DeleteNamespaceRequest.Parser, new[]{ "Key" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Flag), global::Flipt.Flag.Parser, new[]{ "Key", "Name", "Description", "Enabled", "CreatedAt", "UpdatedAt", "Variants", "NamespaceKey", "Type" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.DeleteNamespaceRequest), global::Flipt.DeleteNamespaceRequest.Parser, new[]{ "Key", "Force" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Flag), global::Flipt.Flag.Parser, new[]{ "Key", "Name", "Description", "Enabled", "CreatedAt", "UpdatedAt", "Variants", "NamespaceKey", "Type", "DefaultVariant", "Metadata" }, new[]{ "DefaultVariant", "Metadata" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.FlagList), global::Flipt.FlagList.Parser, new[]{ "Flags", "NextPageToken", "TotalCount" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.GetFlagRequest), global::Flipt.GetFlagRequest.Parser, new[]{ "Key", "NamespaceKey", "Reference" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.ListFlagRequest), global::Flipt.ListFlagRequest.Parser, new[]{ "Limit", "Offset", "PageToken", "NamespaceKey", "Reference" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.CreateFlagRequest), global::Flipt.CreateFlagRequest.Parser, new[]{ "Key", "Name", "Description", "Enabled", "NamespaceKey", "Type" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.UpdateFlagRequest), global::Flipt.UpdateFlagRequest.Parser, new[]{ "Key", "Name", "Description", "Enabled", "NamespaceKey" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.CreateFlagRequest), global::Flipt.CreateFlagRequest.Parser, new[]{ "Key", "Name", "Description", "Enabled", "NamespaceKey", "Type", "Metadata" }, new[]{ "Metadata" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.UpdateFlagRequest), global::Flipt.UpdateFlagRequest.Parser, new[]{ "Key", "Name", "Description", "Enabled", "NamespaceKey", "DefaultVariantId", "Metadata" }, new[]{ "Metadata" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.DeleteFlagRequest), global::Flipt.DeleteFlagRequest.Parser, new[]{ "Key", "NamespaceKey" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Variant), global::Flipt.Variant.Parser, new[]{ "Id", "FlagKey", "Key", "Name", "Description", "CreatedAt", "UpdatedAt", "Attachment", "NamespaceKey" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.CreateVariantRequest), global::Flipt.CreateVariantRequest.Parser, new[]{ "FlagKey", "Key", "Name", "Description", "Attachment", "NamespaceKey" }, null, null, null, null), @@ -399,6 +494,7 @@ public enum EvaluationReason { [pbr::OriginalName("FLAG_NOT_FOUND_EVALUATION_REASON")] FlagNotFoundEvaluationReason = 2, [pbr::OriginalName("MATCH_EVALUATION_REASON")] MatchEvaluationReason = 3, [pbr::OriginalName("ERROR_EVALUATION_REASON")] ErrorEvaluationReason = 4, + [pbr::OriginalName("DEFAULT_EVALUATION_REASON")] DefaultEvaluationReason = 5, } public enum FlagType { @@ -417,6 +513,7 @@ public enum ComparisonType { [pbr::OriginalName("NUMBER_COMPARISON_TYPE")] NumberComparisonType = 2, [pbr::OriginalName("BOOLEAN_COMPARISON_TYPE")] BooleanComparisonType = 3, [pbr::OriginalName("DATETIME_COMPARISON_TYPE")] DatetimeComparisonType = 4, + [pbr::OriginalName("ENTITY_ID_COMPARISON_TYPE")] EntityIdComparisonType = 5, } public enum RolloutType { @@ -3653,6 +3750,7 @@ public DeleteNamespaceRequest() { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public DeleteNamespaceRequest(DeleteNamespaceRequest other) : this() { key_ = other.key_; + force_ = other.force_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -3674,6 +3772,18 @@ public string Key { } } + /// Field number for the "force" field. + public const int ForceFieldNumber = 2; + private bool force_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Force { + get { return force_; } + set { + force_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -3690,6 +3800,7 @@ public bool Equals(DeleteNamespaceRequest other) { return true; } if (Key != other.Key) return false; + if (Force != other.Force) return false; return Equals(_unknownFields, other._unknownFields); } @@ -3698,6 +3809,7 @@ public bool Equals(DeleteNamespaceRequest other) { public override int GetHashCode() { int hash = 1; if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (Force != false) hash ^= Force.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -3720,6 +3832,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(Key); } + if (Force != false) { + output.WriteRawTag(16); + output.WriteBool(Force); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -3734,6 +3850,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(Key); } + if (Force != false) { + output.WriteRawTag(16); + output.WriteBool(Force); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -3747,6 +3867,9 @@ public int CalculateSize() { if (Key.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); } + if (Force != false) { + size += 1 + 1; + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -3762,6 +3885,9 @@ public void MergeFrom(DeleteNamespaceRequest other) { if (other.Key.Length != 0) { Key = other.Key; } + if (other.Force != false) { + Force = other.Force; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -3781,6 +3907,10 @@ public void MergeFrom(pb::CodedInputStream input) { Key = input.ReadString(); break; } + case 16: { + Force = input.ReadBool(); + break; + } } } #endif @@ -3800,6 +3930,10 @@ public void MergeFrom(pb::CodedInputStream input) { Key = input.ReadString(); break; } + case 16: { + Force = input.ReadBool(); + break; + } } } } @@ -3850,6 +3984,8 @@ public Flag(Flag other) : this() { variants_ = other.variants_.Clone(); namespaceKey_ = other.namespaceKey_; type_ = other.type_; + defaultVariant_ = other.defaultVariant_ != null ? other.defaultVariant_.Clone() : null; + metadata_ = other.metadata_ != null ? other.metadata_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -3966,6 +4102,30 @@ public string NamespaceKey { } } + /// Field number for the "default_variant" field. + public const int DefaultVariantFieldNumber = 10; + private global::Flipt.Variant defaultVariant_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Variant DefaultVariant { + get { return defaultVariant_; } + set { + defaultVariant_ = value; + } + } + + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 11; + private global::Google.Protobuf.WellKnownTypes.Struct metadata_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Struct Metadata { + get { return metadata_; } + set { + metadata_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -3990,6 +4150,8 @@ public bool Equals(Flag other) { if(!variants_.Equals(other.variants_)) return false; if (NamespaceKey != other.NamespaceKey) return false; if (Type != other.Type) return false; + if (!object.Equals(DefaultVariant, other.DefaultVariant)) return false; + if (!object.Equals(Metadata, other.Metadata)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -4006,6 +4168,8 @@ public override int GetHashCode() { hash ^= variants_.GetHashCode(); if (NamespaceKey.Length != 0) hash ^= NamespaceKey.GetHashCode(); if (Type != global::Flipt.FlagType.VariantFlagType) hash ^= Type.GetHashCode(); + if (defaultVariant_ != null) hash ^= DefaultVariant.GetHashCode(); + if (metadata_ != null) hash ^= Metadata.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4057,6 +4221,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(72); output.WriteEnum((int) Type); } + if (defaultVariant_ != null) { + output.WriteRawTag(82); + output.WriteMessage(DefaultVariant); + } + if (metadata_ != null) { + output.WriteRawTag(90); + output.WriteMessage(Metadata); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -4100,6 +4272,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(72); output.WriteEnum((int) Type); } + if (defaultVariant_ != null) { + output.WriteRawTag(82); + output.WriteMessage(DefaultVariant); + } + if (metadata_ != null) { + output.WriteRawTag(90); + output.WriteMessage(Metadata); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -4135,6 +4315,12 @@ public int CalculateSize() { if (Type != global::Flipt.FlagType.VariantFlagType) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); } + if (defaultVariant_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DefaultVariant); + } + if (metadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Metadata); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -4178,6 +4364,18 @@ public void MergeFrom(Flag other) { if (other.Type != global::Flipt.FlagType.VariantFlagType) { Type = other.Type; } + if (other.defaultVariant_ != null) { + if (defaultVariant_ == null) { + DefaultVariant = new global::Flipt.Variant(); + } + DefaultVariant.MergeFrom(other.DefaultVariant); + } + if (other.metadata_ != null) { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + Metadata.MergeFrom(other.Metadata); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -4235,6 +4433,20 @@ public void MergeFrom(pb::CodedInputStream input) { Type = (global::Flipt.FlagType) input.ReadEnum(); break; } + case 82: { + if (defaultVariant_ == null) { + DefaultVariant = new global::Flipt.Variant(); + } + input.ReadMessage(DefaultVariant); + break; + } + case 90: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } } } #endif @@ -4292,6 +4504,20 @@ public void MergeFrom(pb::CodedInputStream input) { Type = (global::Flipt.FlagType) input.ReadEnum(); break; } + case 82: { + if (defaultVariant_ == null) { + DefaultVariant = new global::Flipt.Variant(); + } + input.ReadMessage(DefaultVariant); + break; + } + case 90: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } } } } @@ -5192,6 +5418,7 @@ public CreateFlagRequest(CreateFlagRequest other) : this() { enabled_ = other.enabled_; namespaceKey_ = other.namespaceKey_; type_ = other.type_; + metadata_ = other.metadata_ != null ? other.metadata_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -5273,6 +5500,18 @@ public string NamespaceKey { } } + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 7; + private global::Google.Protobuf.WellKnownTypes.Struct metadata_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Struct Metadata { + get { return metadata_; } + set { + metadata_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -5294,6 +5533,7 @@ public bool Equals(CreateFlagRequest other) { if (Enabled != other.Enabled) return false; if (NamespaceKey != other.NamespaceKey) return false; if (Type != other.Type) return false; + if (!object.Equals(Metadata, other.Metadata)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5307,6 +5547,7 @@ public override int GetHashCode() { if (Enabled != false) hash ^= Enabled.GetHashCode(); if (NamespaceKey.Length != 0) hash ^= NamespaceKey.GetHashCode(); if (Type != global::Flipt.FlagType.VariantFlagType) hash ^= Type.GetHashCode(); + if (metadata_ != null) hash ^= Metadata.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -5349,6 +5590,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(48); output.WriteEnum((int) Type); } + if (metadata_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Metadata); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -5383,6 +5628,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(48); output.WriteEnum((int) Type); } + if (metadata_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Metadata); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -5411,6 +5660,9 @@ public int CalculateSize() { if (Type != global::Flipt.FlagType.VariantFlagType) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); } + if (metadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Metadata); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -5441,6 +5693,12 @@ public void MergeFrom(CreateFlagRequest other) { if (other.Type != global::Flipt.FlagType.VariantFlagType) { Type = other.Type; } + if (other.metadata_ != null) { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + Metadata.MergeFrom(other.Metadata); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -5480,6 +5738,13 @@ public void MergeFrom(pb::CodedInputStream input) { Type = (global::Flipt.FlagType) input.ReadEnum(); break; } + case 58: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } } } #endif @@ -5519,6 +5784,13 @@ public void MergeFrom(pb::CodedInputStream input) { Type = (global::Flipt.FlagType) input.ReadEnum(); break; } + case 58: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } } } } @@ -5565,6 +5837,8 @@ public UpdateFlagRequest(UpdateFlagRequest other) : this() { description_ = other.description_; enabled_ = other.enabled_; namespaceKey_ = other.namespaceKey_; + defaultVariantId_ = other.defaultVariantId_; + metadata_ = other.metadata_ != null ? other.metadata_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -5634,6 +5908,30 @@ public string NamespaceKey { } } + /// Field number for the "default_variant_id" field. + public const int DefaultVariantIdFieldNumber = 6; + private string defaultVariantId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DefaultVariantId { + get { return defaultVariantId_; } + set { + defaultVariantId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 7; + private global::Google.Protobuf.WellKnownTypes.Struct metadata_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Struct Metadata { + get { return metadata_; } + set { + metadata_ = value; + } + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -5654,6 +5952,8 @@ public bool Equals(UpdateFlagRequest other) { if (Description != other.Description) return false; if (Enabled != other.Enabled) return false; if (NamespaceKey != other.NamespaceKey) return false; + if (DefaultVariantId != other.DefaultVariantId) return false; + if (!object.Equals(Metadata, other.Metadata)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5666,6 +5966,8 @@ public override int GetHashCode() { if (Description.Length != 0) hash ^= Description.GetHashCode(); if (Enabled != false) hash ^= Enabled.GetHashCode(); if (NamespaceKey.Length != 0) hash ^= NamespaceKey.GetHashCode(); + if (DefaultVariantId.Length != 0) hash ^= DefaultVariantId.GetHashCode(); + if (metadata_ != null) hash ^= Metadata.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -5704,6 +6006,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(42); output.WriteString(NamespaceKey); } + if (DefaultVariantId.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DefaultVariantId); + } + if (metadata_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Metadata); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -5734,6 +6044,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(42); output.WriteString(NamespaceKey); } + if (DefaultVariantId.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DefaultVariantId); + } + if (metadata_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Metadata); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -5759,6 +6077,12 @@ public int CalculateSize() { if (NamespaceKey.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(NamespaceKey); } + if (DefaultVariantId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DefaultVariantId); + } + if (metadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Metadata); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -5786,6 +6110,15 @@ public void MergeFrom(UpdateFlagRequest other) { if (other.NamespaceKey.Length != 0) { NamespaceKey = other.NamespaceKey; } + if (other.DefaultVariantId.Length != 0) { + DefaultVariantId = other.DefaultVariantId; + } + if (other.metadata_ != null) { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + Metadata.MergeFrom(other.Metadata); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -5821,6 +6154,17 @@ public void MergeFrom(pb::CodedInputStream input) { NamespaceKey = input.ReadString(); break; } + case 50: { + DefaultVariantId = input.ReadString(); + break; + } + case 58: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } } } #endif @@ -5856,6 +6200,17 @@ public void MergeFrom(pb::CodedInputStream input) { NamespaceKey = input.ReadString(); break; } + case 50: { + DefaultVariantId = input.ReadString(); + break; + } + case 58: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } } } } diff --git a/src/Flipt.Grpc/Ofrep.cs b/src/Flipt.Grpc/Ofrep.cs new file mode 100644 index 0000000..1807802 --- /dev/null +++ b/src/Flipt.Grpc/Ofrep.cs @@ -0,0 +1,2264 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: ofrep/ofrep.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace Flipt.Ofrep { + + /// Holder for reflection information generated from ofrep/ofrep.proto + public static partial class OfrepReflection { + + #region Descriptor + /// File descriptor for ofrep/ofrep.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static OfrepReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChFvZnJlcC9vZnJlcC5wcm90bxILZmxpcHQub2ZyZXAaHGdvb2dsZS9wcm90", + "b2J1Zi9zdHJ1Y3QucHJvdG8aHGdvb2dsZS9hcGkvYW5ub3RhdGlvbnMucHJv", + "dG8aG2dvb2dsZS9hcGkvdmlzaWJpbGl0eS5wcm90bxofZ29vZ2xlL2FwaS9m", + "aWVsZF9iZWhhdmlvci5wcm90bxokZ25vc3RpYy9vcGVuYXBpL3YzL2Fubm90", + "YXRpb25zLnByb3RvIiEKH0dldFByb3ZpZGVyQ29uZmlndXJhdGlvblJlcXVl", + "c3QidQogR2V0UHJvdmlkZXJDb25maWd1cmF0aW9uUmVzcG9uc2USEgoEbmFt", + "ZRgBIAEoCVIEbmFtZRI9CgxjYXBhYmlsaXRpZXMYAiABKAsyGS5mbGlwdC5v", + "ZnJlcC5DYXBhYmlsaXRpZXNSDGNhcGFiaWxpdGllcyKjAQoMQ2FwYWJpbGl0", + "aWVzEk0KEmNhY2hlX2ludmFsaWRhdGlvbhgBIAEoCzIeLmZsaXB0Lm9mcmVw", + "LkNhY2hlSW52YWxpZGF0aW9uUhFjYWNoZUludmFsaWRhdGlvbhJECg9mbGFn", + "X2V2YWx1YXRpb24YAiABKAsyGy5mbGlwdC5vZnJlcC5GbGFnRXZhbHVhdGlv", + "blIOZmxhZ0V2YWx1YXRpb24iQwoRQ2FjaGVJbnZhbGlkYXRpb24SLgoHcG9s", + "bGluZxgBIAEoCzIULmZsaXB0Lm9mcmVwLlBvbGxpbmdSB3BvbGxpbmciWgoH", + "UG9sbGluZxIYCgdlbmFibGVkGAEgASgIUgdlbmFibGVkEjUKF21pbl9wb2xs", + "aW5nX2ludGVydmFsX21zGAIgASgNUhRtaW5Qb2xsaW5nSW50ZXJ2YWxNcyI5", + "Cg5GbGFnRXZhbHVhdGlvbhInCg9zdXBwb3J0ZWRfdHlwZXMYASADKAlSDnN1", + "cHBvcnRlZFR5cGVzIqwBChNFdmFsdWF0ZUZsYWdSZXF1ZXN0EhAKA2tleRgB", + "IAEoCVIDa2V5EkcKB2NvbnRleHQYAiADKAsyLS5mbGlwdC5vZnJlcC5FdmFs", + "dWF0ZUZsYWdSZXF1ZXN0LkNvbnRleHRFbnRyeVIHY29udGV4dBo6CgxDb250", + "ZXh0RW50cnkSEAoDa2V5GAEgASgJUgNrZXkSFAoFdmFsdWUYAiABKAlSBXZh", + "bHVlOgI4ASLTAQoNRXZhbHVhdGVkRmxhZxIQCgNrZXkYASABKAlSA2tleRIz", + "CgZyZWFzb24YAiABKA4yGy5mbGlwdC5vZnJlcC5FdmFsdWF0ZVJlYXNvblIG", + "cmVhc29uEhgKB3ZhcmlhbnQYAyABKAlSB3ZhcmlhbnQSMwoIbWV0YWRhdGEY", + "BCABKAsyFy5nb29nbGUucHJvdG9idWYuU3RydWN0UghtZXRhZGF0YRIsCgV2", + "YWx1ZRgFIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZVIFdmFsdWUimgEK", + "E0V2YWx1YXRlQnVsa1JlcXVlc3QSRwoHY29udGV4dBgCIAMoCzItLmZsaXB0", + "Lm9mcmVwLkV2YWx1YXRlQnVsa1JlcXVlc3QuQ29udGV4dEVudHJ5Ugdjb250", + "ZXh0GjoKDENvbnRleHRFbnRyeRIQCgNrZXkYASABKAlSA2tleRIUCgV2YWx1", + "ZRgCIAEoCVIFdmFsdWU6AjgBIk8KFkJ1bGtFdmFsdWF0aW9uUmVzcG9uc2US", + "NQoFZmxhZ3MYASADKAsyGi5mbGlwdC5vZnJlcC5FdmFsdWF0ZWRGbGFnQgPg", + "QQJSBWZsYWdzKk0KDkV2YWx1YXRlUmVhc29uEgsKB1VOS05PV04QABIMCghE", + "SVNBQkxFRBABEhMKD1RBUkdFVElOR19NQVRDSBACEgsKB0RFRkFVTFQQAzKA", + "BAoMT0ZSRVBTZXJ2aWNlErABChhHZXRQcm92aWRlckNvbmZpZ3VyYXRpb24S", + "LC5mbGlwdC5vZnJlcC5HZXRQcm92aWRlckNvbmZpZ3VyYXRpb25SZXF1ZXN0", + "Gi0uZmxpcHQub2ZyZXAuR2V0UHJvdmlkZXJDb25maWd1cmF0aW9uUmVzcG9u", + "c2UiN7pHFSoTb2ZyZXAuY29uZmlndXJhdGlvboLT5JMCGRIXL29mcmVwL3Yx", + "L2NvbmZpZ3VyYXRpb24SjgEKDEV2YWx1YXRlRmxhZxIgLmZsaXB0Lm9mcmVw", + "LkV2YWx1YXRlRmxhZ1JlcXVlc3QaGi5mbGlwdC5vZnJlcC5FdmFsdWF0ZWRG", + "bGFnIkC6RxQqEm9mcmVwLmV2YWx1YXRlRmxhZ4LT5JMCIzoBKiIeL29mcmVw", + "L3YxL2V2YWx1YXRlL2ZsYWdzL3trZXl9EpEBCgxFdmFsdWF0ZUJ1bGsSIC5m", + "bGlwdC5vZnJlcC5FdmFsdWF0ZUJ1bGtSZXF1ZXN0GiMuZmxpcHQub2ZyZXAu", + "QnVsa0V2YWx1YXRpb25SZXNwb25zZSI6ukcUKhJvZnJlcC5ldmFsdWF0ZUJ1", + "bGuC0+STAh06ASoiGC9vZnJlcC92MS9ldmFsdWF0ZS9mbGFncxoY+tLkkwIS", + "EhBmbGlwdDpzZGs6aWdub3JlQiNaIWdvLmZsaXB0LmlvL2ZsaXB0L3JwYy9m", + "bGlwdC9vZnJlcGIGcHJvdG8z")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.VisibilityReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Gnostic.Openapi.V3.AnnotationsReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Flipt.Ofrep.EvaluateReason), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.GetProviderConfigurationRequest), global::Flipt.Ofrep.GetProviderConfigurationRequest.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.GetProviderConfigurationResponse), global::Flipt.Ofrep.GetProviderConfigurationResponse.Parser, new[]{ "Name", "Capabilities" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.Capabilities), global::Flipt.Ofrep.Capabilities.Parser, new[]{ "CacheInvalidation", "FlagEvaluation" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.CacheInvalidation), global::Flipt.Ofrep.CacheInvalidation.Parser, new[]{ "Polling" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.Polling), global::Flipt.Ofrep.Polling.Parser, new[]{ "Enabled", "MinPollingIntervalMs" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.FlagEvaluation), global::Flipt.Ofrep.FlagEvaluation.Parser, new[]{ "SupportedTypes" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.EvaluateFlagRequest), global::Flipt.Ofrep.EvaluateFlagRequest.Parser, new[]{ "Key", "Context" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.EvaluatedFlag), global::Flipt.Ofrep.EvaluatedFlag.Parser, new[]{ "Key", "Reason", "Variant", "Metadata", "Value" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.EvaluateBulkRequest), global::Flipt.Ofrep.EvaluateBulkRequest.Parser, new[]{ "Context" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Flipt.Ofrep.BulkEvaluationResponse), global::Flipt.Ofrep.BulkEvaluationResponse.Parser, new[]{ "Flags" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + public enum EvaluateReason { + [pbr::OriginalName("UNKNOWN")] Unknown = 0, + [pbr::OriginalName("DISABLED")] Disabled = 1, + [pbr::OriginalName("TARGETING_MATCH")] TargetingMatch = 2, + [pbr::OriginalName("DEFAULT")] Default = 3, + } + + #endregion + + #region Messages + public sealed partial class GetProviderConfigurationRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetProviderConfigurationRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetProviderConfigurationRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetProviderConfigurationRequest(GetProviderConfigurationRequest other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetProviderConfigurationRequest Clone() { + return new GetProviderConfigurationRequest(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as GetProviderConfigurationRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(GetProviderConfigurationRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(GetProviderConfigurationRequest other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + public sealed partial class GetProviderConfigurationResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetProviderConfigurationResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetProviderConfigurationResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetProviderConfigurationResponse(GetProviderConfigurationResponse other) : this() { + name_ = other.name_; + capabilities_ = other.capabilities_ != null ? other.capabilities_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public GetProviderConfigurationResponse Clone() { + return new GetProviderConfigurationResponse(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "capabilities" field. + public const int CapabilitiesFieldNumber = 2; + private global::Flipt.Ofrep.Capabilities capabilities_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Ofrep.Capabilities Capabilities { + get { return capabilities_; } + set { + capabilities_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as GetProviderConfigurationResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(GetProviderConfigurationResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (!object.Equals(Capabilities, other.Capabilities)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (capabilities_ != null) hash ^= Capabilities.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (capabilities_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Capabilities); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (capabilities_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Capabilities); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (capabilities_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Capabilities); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(GetProviderConfigurationResponse other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.capabilities_ != null) { + if (capabilities_ == null) { + Capabilities = new global::Flipt.Ofrep.Capabilities(); + } + Capabilities.MergeFrom(other.Capabilities); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + if (capabilities_ == null) { + Capabilities = new global::Flipt.Ofrep.Capabilities(); + } + input.ReadMessage(Capabilities); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + if (capabilities_ == null) { + Capabilities = new global::Flipt.Ofrep.Capabilities(); + } + input.ReadMessage(Capabilities); + break; + } + } + } + } + #endif + + } + + public sealed partial class Capabilities : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Capabilities()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Capabilities() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Capabilities(Capabilities other) : this() { + cacheInvalidation_ = other.cacheInvalidation_ != null ? other.cacheInvalidation_.Clone() : null; + flagEvaluation_ = other.flagEvaluation_ != null ? other.flagEvaluation_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Capabilities Clone() { + return new Capabilities(this); + } + + /// Field number for the "cache_invalidation" field. + public const int CacheInvalidationFieldNumber = 1; + private global::Flipt.Ofrep.CacheInvalidation cacheInvalidation_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Ofrep.CacheInvalidation CacheInvalidation { + get { return cacheInvalidation_; } + set { + cacheInvalidation_ = value; + } + } + + /// Field number for the "flag_evaluation" field. + public const int FlagEvaluationFieldNumber = 2; + private global::Flipt.Ofrep.FlagEvaluation flagEvaluation_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Ofrep.FlagEvaluation FlagEvaluation { + get { return flagEvaluation_; } + set { + flagEvaluation_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Capabilities); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Capabilities other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(CacheInvalidation, other.CacheInvalidation)) return false; + if (!object.Equals(FlagEvaluation, other.FlagEvaluation)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (cacheInvalidation_ != null) hash ^= CacheInvalidation.GetHashCode(); + if (flagEvaluation_ != null) hash ^= FlagEvaluation.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (cacheInvalidation_ != null) { + output.WriteRawTag(10); + output.WriteMessage(CacheInvalidation); + } + if (flagEvaluation_ != null) { + output.WriteRawTag(18); + output.WriteMessage(FlagEvaluation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (cacheInvalidation_ != null) { + output.WriteRawTag(10); + output.WriteMessage(CacheInvalidation); + } + if (flagEvaluation_ != null) { + output.WriteRawTag(18); + output.WriteMessage(FlagEvaluation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (cacheInvalidation_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(CacheInvalidation); + } + if (flagEvaluation_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(FlagEvaluation); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Capabilities other) { + if (other == null) { + return; + } + if (other.cacheInvalidation_ != null) { + if (cacheInvalidation_ == null) { + CacheInvalidation = new global::Flipt.Ofrep.CacheInvalidation(); + } + CacheInvalidation.MergeFrom(other.CacheInvalidation); + } + if (other.flagEvaluation_ != null) { + if (flagEvaluation_ == null) { + FlagEvaluation = new global::Flipt.Ofrep.FlagEvaluation(); + } + FlagEvaluation.MergeFrom(other.FlagEvaluation); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (cacheInvalidation_ == null) { + CacheInvalidation = new global::Flipt.Ofrep.CacheInvalidation(); + } + input.ReadMessage(CacheInvalidation); + break; + } + case 18: { + if (flagEvaluation_ == null) { + FlagEvaluation = new global::Flipt.Ofrep.FlagEvaluation(); + } + input.ReadMessage(FlagEvaluation); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (cacheInvalidation_ == null) { + CacheInvalidation = new global::Flipt.Ofrep.CacheInvalidation(); + } + input.ReadMessage(CacheInvalidation); + break; + } + case 18: { + if (flagEvaluation_ == null) { + FlagEvaluation = new global::Flipt.Ofrep.FlagEvaluation(); + } + input.ReadMessage(FlagEvaluation); + break; + } + } + } + } + #endif + + } + + public sealed partial class CacheInvalidation : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CacheInvalidation()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CacheInvalidation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CacheInvalidation(CacheInvalidation other) : this() { + polling_ = other.polling_ != null ? other.polling_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CacheInvalidation Clone() { + return new CacheInvalidation(this); + } + + /// Field number for the "polling" field. + public const int PollingFieldNumber = 1; + private global::Flipt.Ofrep.Polling polling_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Ofrep.Polling Polling { + get { return polling_; } + set { + polling_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CacheInvalidation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CacheInvalidation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Polling, other.Polling)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (polling_ != null) hash ^= Polling.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (polling_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Polling); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (polling_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Polling); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (polling_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Polling); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CacheInvalidation other) { + if (other == null) { + return; + } + if (other.polling_ != null) { + if (polling_ == null) { + Polling = new global::Flipt.Ofrep.Polling(); + } + Polling.MergeFrom(other.Polling); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (polling_ == null) { + Polling = new global::Flipt.Ofrep.Polling(); + } + input.ReadMessage(Polling); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (polling_ == null) { + Polling = new global::Flipt.Ofrep.Polling(); + } + input.ReadMessage(Polling); + break; + } + } + } + } + #endif + + } + + public sealed partial class Polling : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Polling()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Polling() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Polling(Polling other) : this() { + enabled_ = other.enabled_; + minPollingIntervalMs_ = other.minPollingIntervalMs_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Polling Clone() { + return new Polling(this); + } + + /// Field number for the "enabled" field. + public const int EnabledFieldNumber = 1; + private bool enabled_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Enabled { + get { return enabled_; } + set { + enabled_ = value; + } + } + + /// Field number for the "min_polling_interval_ms" field. + public const int MinPollingIntervalMsFieldNumber = 2; + private uint minPollingIntervalMs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint MinPollingIntervalMs { + get { return minPollingIntervalMs_; } + set { + minPollingIntervalMs_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Polling); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Polling other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Enabled != other.Enabled) return false; + if (MinPollingIntervalMs != other.MinPollingIntervalMs) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Enabled != false) hash ^= Enabled.GetHashCode(); + if (MinPollingIntervalMs != 0) hash ^= MinPollingIntervalMs.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Enabled != false) { + output.WriteRawTag(8); + output.WriteBool(Enabled); + } + if (MinPollingIntervalMs != 0) { + output.WriteRawTag(16); + output.WriteUInt32(MinPollingIntervalMs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Enabled != false) { + output.WriteRawTag(8); + output.WriteBool(Enabled); + } + if (MinPollingIntervalMs != 0) { + output.WriteRawTag(16); + output.WriteUInt32(MinPollingIntervalMs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Enabled != false) { + size += 1 + 1; + } + if (MinPollingIntervalMs != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MinPollingIntervalMs); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Polling other) { + if (other == null) { + return; + } + if (other.Enabled != false) { + Enabled = other.Enabled; + } + if (other.MinPollingIntervalMs != 0) { + MinPollingIntervalMs = other.MinPollingIntervalMs; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Enabled = input.ReadBool(); + break; + } + case 16: { + MinPollingIntervalMs = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Enabled = input.ReadBool(); + break; + } + case 16: { + MinPollingIntervalMs = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class FlagEvaluation : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FlagEvaluation()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlagEvaluation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlagEvaluation(FlagEvaluation other) : this() { + supportedTypes_ = other.supportedTypes_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlagEvaluation Clone() { + return new FlagEvaluation(this); + } + + /// Field number for the "supported_types" field. + public const int SupportedTypesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_supportedTypes_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField supportedTypes_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField SupportedTypes { + get { return supportedTypes_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as FlagEvaluation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(FlagEvaluation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!supportedTypes_.Equals(other.supportedTypes_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= supportedTypes_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + supportedTypes_.WriteTo(output, _repeated_supportedTypes_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + supportedTypes_.WriteTo(ref output, _repeated_supportedTypes_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += supportedTypes_.CalculateSize(_repeated_supportedTypes_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(FlagEvaluation other) { + if (other == null) { + return; + } + supportedTypes_.Add(other.supportedTypes_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + supportedTypes_.AddEntriesFrom(input, _repeated_supportedTypes_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + supportedTypes_.AddEntriesFrom(ref input, _repeated_supportedTypes_codec); + break; + } + } + } + } + #endif + + } + + public sealed partial class EvaluateFlagRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EvaluateFlagRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluateFlagRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluateFlagRequest(EvaluateFlagRequest other) : this() { + key_ = other.key_; + context_ = other.context_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluateFlagRequest Clone() { + return new EvaluateFlagRequest(this); + } + + /// Field number for the "key" field. + public const int KeyFieldNumber = 1; + private string key_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Key { + get { return key_; } + set { + key_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "context" field. + public const int ContextFieldNumber = 2; + private static readonly pbc::MapField.Codec _map_context_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 18); + private readonly pbc::MapField context_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Context { + get { return context_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EvaluateFlagRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EvaluateFlagRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (!Context.Equals(other.Context)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Key.Length != 0) hash ^= Key.GetHashCode(); + hash ^= Context.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + context_.WriteTo(output, _map_context_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + context_.WriteTo(ref output, _map_context_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + size += context_.CalculateSize(_map_context_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EvaluateFlagRequest other) { + if (other == null) { + return; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + context_.MergeFrom(other.context_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 18: { + context_.AddEntriesFrom(input, _map_context_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 18: { + context_.AddEntriesFrom(ref input, _map_context_codec); + break; + } + } + } + } + #endif + + } + + public sealed partial class EvaluatedFlag : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EvaluatedFlag()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluatedFlag() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluatedFlag(EvaluatedFlag other) : this() { + key_ = other.key_; + reason_ = other.reason_; + variant_ = other.variant_; + metadata_ = other.metadata_ != null ? other.metadata_.Clone() : null; + value_ = other.value_ != null ? other.value_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluatedFlag Clone() { + return new EvaluatedFlag(this); + } + + /// Field number for the "key" field. + public const int KeyFieldNumber = 1; + private string key_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Key { + get { return key_; } + set { + key_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "reason" field. + public const int ReasonFieldNumber = 2; + private global::Flipt.Ofrep.EvaluateReason reason_ = global::Flipt.Ofrep.EvaluateReason.Unknown; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Flipt.Ofrep.EvaluateReason Reason { + get { return reason_; } + set { + reason_ = value; + } + } + + /// Field number for the "variant" field. + public const int VariantFieldNumber = 3; + private string variant_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Variant { + get { return variant_; } + set { + variant_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Struct metadata_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Struct Metadata { + get { return metadata_; } + set { + metadata_ = value; + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Value value_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Value Value { + get { return value_; } + set { + value_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EvaluatedFlag); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EvaluatedFlag other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Reason != other.Reason) return false; + if (Variant != other.Variant) return false; + if (!object.Equals(Metadata, other.Metadata)) return false; + if (!object.Equals(Value, other.Value)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (Reason != global::Flipt.Ofrep.EvaluateReason.Unknown) hash ^= Reason.GetHashCode(); + if (Variant.Length != 0) hash ^= Variant.GetHashCode(); + if (metadata_ != null) hash ^= Metadata.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + if (Reason != global::Flipt.Ofrep.EvaluateReason.Unknown) { + output.WriteRawTag(16); + output.WriteEnum((int) Reason); + } + if (Variant.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Variant); + } + if (metadata_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Metadata); + } + if (value_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + if (Reason != global::Flipt.Ofrep.EvaluateReason.Unknown) { + output.WriteRawTag(16); + output.WriteEnum((int) Reason); + } + if (Variant.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Variant); + } + if (metadata_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Metadata); + } + if (value_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + if (Reason != global::Flipt.Ofrep.EvaluateReason.Unknown) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Reason); + } + if (Variant.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Variant); + } + if (metadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Metadata); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EvaluatedFlag other) { + if (other == null) { + return; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + if (other.Reason != global::Flipt.Ofrep.EvaluateReason.Unknown) { + Reason = other.Reason; + } + if (other.Variant.Length != 0) { + Variant = other.Variant; + } + if (other.metadata_ != null) { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + Metadata.MergeFrom(other.Metadata); + } + if (other.value_ != null) { + if (value_ == null) { + Value = new global::Google.Protobuf.WellKnownTypes.Value(); + } + Value.MergeFrom(other.Value); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 16: { + Reason = (global::Flipt.Ofrep.EvaluateReason) input.ReadEnum(); + break; + } + case 26: { + Variant = input.ReadString(); + break; + } + case 34: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } + case 42: { + if (value_ == null) { + Value = new global::Google.Protobuf.WellKnownTypes.Value(); + } + input.ReadMessage(Value); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 16: { + Reason = (global::Flipt.Ofrep.EvaluateReason) input.ReadEnum(); + break; + } + case 26: { + Variant = input.ReadString(); + break; + } + case 34: { + if (metadata_ == null) { + Metadata = new global::Google.Protobuf.WellKnownTypes.Struct(); + } + input.ReadMessage(Metadata); + break; + } + case 42: { + if (value_ == null) { + Value = new global::Google.Protobuf.WellKnownTypes.Value(); + } + input.ReadMessage(Value); + break; + } + } + } + } + #endif + + } + + public sealed partial class EvaluateBulkRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EvaluateBulkRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluateBulkRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluateBulkRequest(EvaluateBulkRequest other) : this() { + context_ = other.context_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EvaluateBulkRequest Clone() { + return new EvaluateBulkRequest(this); + } + + /// Field number for the "context" field. + public const int ContextFieldNumber = 2; + private static readonly pbc::MapField.Codec _map_context_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 18); + private readonly pbc::MapField context_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Context { + get { return context_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EvaluateBulkRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EvaluateBulkRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Context.Equals(other.Context)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= Context.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + context_.WriteTo(output, _map_context_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + context_.WriteTo(ref output, _map_context_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += context_.CalculateSize(_map_context_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EvaluateBulkRequest other) { + if (other == null) { + return; + } + context_.MergeFrom(other.context_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 18: { + context_.AddEntriesFrom(input, _map_context_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 18: { + context_.AddEntriesFrom(ref input, _map_context_codec); + break; + } + } + } + } + #endif + + } + + public sealed partial class BulkEvaluationResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BulkEvaluationResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BulkEvaluationResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BulkEvaluationResponse(BulkEvaluationResponse other) : this() { + flags_ = other.flags_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BulkEvaluationResponse Clone() { + return new BulkEvaluationResponse(this); + } + + /// Field number for the "flags" field. + public const int FlagsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_flags_codec + = pb::FieldCodec.ForMessage(10, global::Flipt.Ofrep.EvaluatedFlag.Parser); + private readonly pbc::RepeatedField flags_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Flags { + get { return flags_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BulkEvaluationResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BulkEvaluationResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!flags_.Equals(other.flags_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= flags_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + flags_.WriteTo(output, _repeated_flags_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + flags_.WriteTo(ref output, _repeated_flags_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += flags_.CalculateSize(_repeated_flags_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BulkEvaluationResponse other) { + if (other == null) { + return; + } + flags_.Add(other.flags_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + flags_.AddEntriesFrom(input, _repeated_flags_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + flags_.AddEntriesFrom(ref input, _repeated_flags_codec); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Flipt.Grpc/OfrepGrpc.cs b/src/Flipt.Grpc/OfrepGrpc.cs new file mode 100644 index 0000000..b7d299c --- /dev/null +++ b/src/Flipt.Grpc/OfrepGrpc.cs @@ -0,0 +1,272 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: ofrep/ofrep.proto +// +#pragma warning disable 0414, 1591, 8981, 0612 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace Flipt.Ofrep { + public static partial class OFREPService + { + static readonly string __ServiceName = "flipt.ofrep.OFREPService"; + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static void __Helper_SerializeMessage(global::Google.Protobuf.IMessage message, grpc::SerializationContext context) + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (message is global::Google.Protobuf.IBufferMessage) + { + context.SetPayloadLength(message.CalculateSize()); + global::Google.Protobuf.MessageExtensions.WriteTo(message, context.GetBufferWriter()); + context.Complete(); + return; + } + #endif + context.Complete(global::Google.Protobuf.MessageExtensions.ToByteArray(message)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static class __Helper_MessageCache + { + public static readonly bool IsBufferMessage = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(global::Google.Protobuf.IBufferMessage)).IsAssignableFrom(typeof(T)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static T __Helper_DeserializeMessage(grpc::DeserializationContext context, global::Google.Protobuf.MessageParser parser) where T : global::Google.Protobuf.IMessage + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (__Helper_MessageCache.IsBufferMessage) + { + return parser.ParseFrom(context.PayloadAsReadOnlySequence()); + } + #endif + return parser.ParseFrom(context.PayloadAsNewBuffer()); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_flipt_ofrep_GetProviderConfigurationRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Flipt.Ofrep.GetProviderConfigurationRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_flipt_ofrep_GetProviderConfigurationResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Flipt.Ofrep.GetProviderConfigurationResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_flipt_ofrep_EvaluateFlagRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Flipt.Ofrep.EvaluateFlagRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_flipt_ofrep_EvaluatedFlag = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Flipt.Ofrep.EvaluatedFlag.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_flipt_ofrep_EvaluateBulkRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Flipt.Ofrep.EvaluateBulkRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_flipt_ofrep_BulkEvaluationResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Flipt.Ofrep.BulkEvaluationResponse.Parser)); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_GetProviderConfiguration = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetProviderConfiguration", + __Marshaller_flipt_ofrep_GetProviderConfigurationRequest, + __Marshaller_flipt_ofrep_GetProviderConfigurationResponse); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_EvaluateFlag = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "EvaluateFlag", + __Marshaller_flipt_ofrep_EvaluateFlagRequest, + __Marshaller_flipt_ofrep_EvaluatedFlag); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_EvaluateBulk = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "EvaluateBulk", + __Marshaller_flipt_ofrep_EvaluateBulkRequest, + __Marshaller_flipt_ofrep_BulkEvaluationResponse); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Flipt.Ofrep.OfrepReflection.Descriptor.Services[0]; } + } + + /// Client for OFREPService + public partial class OFREPServiceClient : grpc::ClientBase + { + /// Creates a new client for OFREPService + /// The channel to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public OFREPServiceClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for OFREPService that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public OFREPServiceClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected OFREPServiceClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected OFREPServiceClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + /// + /// OFREP provider configuration + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Flipt.Ofrep.GetProviderConfigurationResponse GetProviderConfiguration(global::Flipt.Ofrep.GetProviderConfigurationRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetProviderConfiguration(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// OFREP provider configuration + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Flipt.Ofrep.GetProviderConfigurationResponse GetProviderConfiguration(global::Flipt.Ofrep.GetProviderConfigurationRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetProviderConfiguration, null, options, request); + } + /// + /// OFREP provider configuration + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall GetProviderConfigurationAsync(global::Flipt.Ofrep.GetProviderConfigurationRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetProviderConfigurationAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// OFREP provider configuration + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall GetProviderConfigurationAsync(global::Flipt.Ofrep.GetProviderConfigurationRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetProviderConfiguration, null, options, request); + } + /// + /// OFREP single flag evaluation + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Flipt.Ofrep.EvaluatedFlag EvaluateFlag(global::Flipt.Ofrep.EvaluateFlagRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return EvaluateFlag(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// OFREP single flag evaluation + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Flipt.Ofrep.EvaluatedFlag EvaluateFlag(global::Flipt.Ofrep.EvaluateFlagRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_EvaluateFlag, null, options, request); + } + /// + /// OFREP single flag evaluation + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall EvaluateFlagAsync(global::Flipt.Ofrep.EvaluateFlagRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return EvaluateFlagAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// OFREP single flag evaluation + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall EvaluateFlagAsync(global::Flipt.Ofrep.EvaluateFlagRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_EvaluateFlag, null, options, request); + } + /// + /// OFREP bulk flag evaluation + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Flipt.Ofrep.BulkEvaluationResponse EvaluateBulk(global::Flipt.Ofrep.EvaluateBulkRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return EvaluateBulk(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// OFREP bulk flag evaluation + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Flipt.Ofrep.BulkEvaluationResponse EvaluateBulk(global::Flipt.Ofrep.EvaluateBulkRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_EvaluateBulk, null, options, request); + } + /// + /// OFREP bulk flag evaluation + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall EvaluateBulkAsync(global::Flipt.Ofrep.EvaluateBulkRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return EvaluateBulkAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// OFREP bulk flag evaluation + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall EvaluateBulkAsync(global::Flipt.Ofrep.EvaluateBulkRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_EvaluateBulk, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected override OFREPServiceClient NewInstance(ClientBaseConfiguration configuration) + { + return new OFREPServiceClient(configuration); + } + } + + } +} +#endregion