@openfeature/flagd-provider 0.7.2 → 0.7.4

package/index.js

@@ -1,14 +1,35 @@
-import 'core-js/modules/es.object.assign.js';
 import * as grpc from '@grpc/grpc-js';
 import { GeneralError, FlagNotFoundError, TypeMismatchError, ParseError } from '@openfeature/js-sdk';
 import { GrpcTransport } from '@protobuf-ts/grpc-transport';
-import 'core-js/modules/es.array.iterator.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import 'core-js/modules/esnext.global-this.js';
-import 'core-js/modules/es.regexp.to-string.js';
 import { ServiceType, stackIntercept } from '@protobuf-ts/runtime-rpc';
 
-const DEFAULT_CONFIG={host:"localhost",port:8013,tls:!1};var ENV_VAR;(function(a){a.FLAGD_HOST="FLAGD_HOST",a.FLAGD_PORT="FLAGD_PORT",a.FLAGD_TLS="FLAGD_TLS",a.FLAGD_SOCKET_PATH="FLAGD_SOCKET_PATH";})(ENV_VAR||(ENV_VAR={}));const getEnvVarConfig=()=>{var a;return Object.assign(Object.assign(Object.assign(Object.assign({},process.env[ENV_VAR.FLAGD_HOST]&&{host:process.env[ENV_VAR.FLAGD_HOST]}),+process.env[ENV_VAR.FLAGD_PORT]&&{port:+process.env[ENV_VAR.FLAGD_PORT]}),process.env[ENV_VAR.FLAGD_TLS]&&{tls:"true"===(null===(a=process.env[ENV_VAR.FLAGD_TLS])||void 0===a?void 0:a.toLowerCase())}),process.env[ENV_VAR.FLAGD_SOCKET_PATH]&&{socketPath:process.env[ENV_VAR.FLAGD_SOCKET_PATH]})};function getConfig(a={}){return Object.assign(Object.assign(Object.assign({},DEFAULT_CONFIG),getEnvVarConfig()),a)}
+const DEFAULT_CONFIG = {
+    host: 'localhost',
+    port: 8013,
+    tls: false,
+};
+var ENV_VAR;
+(function (ENV_VAR) {
+    ENV_VAR["FLAGD_HOST"] = "FLAGD_HOST";
+    ENV_VAR["FLAGD_PORT"] = "FLAGD_PORT";
+    ENV_VAR["FLAGD_TLS"] = "FLAGD_TLS";
+    ENV_VAR["FLAGD_SOCKET_PATH"] = "FLAGD_SOCKET_PATH";
+})(ENV_VAR || (ENV_VAR = {}));
+const getEnvVarConfig = () => {
+    var _a;
+    return (Object.assign(Object.assign(Object.assign(Object.assign({}, (process.env[ENV_VAR.FLAGD_HOST] && {
+        host: process.env[ENV_VAR.FLAGD_HOST],
+    })), (Number(process.env[ENV_VAR.FLAGD_PORT]) && {
+        port: Number(process.env[ENV_VAR.FLAGD_PORT]),
+    })), (process.env[ENV_VAR.FLAGD_TLS] && {
+        tls: ((_a = process.env[ENV_VAR.FLAGD_TLS]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'true',
+    })), (process.env[ENV_VAR.FLAGD_SOCKET_PATH] && {
+        socketPath: process.env[ENV_VAR.FLAGD_SOCKET_PATH],
+    })));
+};
+function getConfig(options = {}) {
+    return Object.assign(Object.assign(Object.assign({}, DEFAULT_CONFIG), getEnvVarConfig()), options);
+}
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -2964,94 +2985,1406 @@ class MessageType {
  *  The JSON representation for `NullValue` is JSON `null`.
  *
  * @generated from protobuf enum google.protobuf.NullValue
- */var NullValue;(function(a){/**
+ */
+var NullValue;
+(function (NullValue) {
+    /**
      * Null value.
      *
      * @generated from protobuf enum value: NULL_VALUE = 0;
-     */a[a.NULL_VALUE=0]="NULL_VALUE";})(NullValue||(NullValue={}));// @generated message type with reflection information, may provide speed optimized methods
-class Struct$Type extends MessageType{constructor(){super("google.protobuf.Struct",[{no:1,name:"fields",kind:"map",K:9/*ScalarType.STRING*/,V:{kind:"message",T:()=>Value}}]);}/**
+     */
+    NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
+})(NullValue || (NullValue = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class Struct$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Struct", [
+            { no: 1, name: "fields", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Value } }
+        ]);
+    }
+    /**
      * Encode `Struct` to JSON object.
-     */internalJsonWrite(a){let b={};for(let[c,d]of Object.entries(a.fields))b[c]=Value.toJson(d);return b}/**
+     */
+    internalJsonWrite(message, options) {
+        let json = {};
+        for (let [k, v] of Object.entries(message.fields)) {
+            json[k] = Value.toJson(v);
+        }
+        return json;
+    }
+    /**
      * Decode `Struct` from JSON object.
-     */internalJsonRead(a,b,c){if(!isJsonObject(a))throw new globalThis.Error("Unable to parse message "+this.typeName+" from JSON "+typeofJsonValue(a)+".");c||(c=this.create());for(let[d,e]of globalThis.Object.entries(a))c.fields[d]=Value.fromJson(e);return c}create(a){const b={fields:{}};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* map<string, google.protobuf.Value> fields */1:this.binaryReadMap1(e.fields,a,c);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}binaryReadMap1(a,b,c){let d,e,f=b.uint32(),g=b.pos+f;for(;b.pos<g;){let[a,f]=b.tag();switch(a){case 1:d=b.string();break;case 2:e=Value.internalBinaryRead(b,b.uint32(),c);break;default:throw new globalThis.Error("unknown map entry field for field google.protobuf.Struct.fields");}}a[null!==d&&void 0!==d?d:""]=null!==e&&void 0!==e?e:Value.create();}internalBinaryWrite(a,b,c){/* map<string, google.protobuf.Value> fields = 1; */for(let d of Object.keys(a.fields))b.tag(1,WireType.LengthDelimited).fork().tag(1,WireType.LengthDelimited).string(d),b.tag(2,WireType.LengthDelimited).fork(),Value.internalBinaryWrite(a.fields[d],b,c),b.join().join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+     */
+    internalJsonRead(json, options, target) {
+        if (!isJsonObject(json))
+            throw new globalThis.Error("Unable to parse message " + this.typeName + " from JSON " + typeofJsonValue(json) + ".");
+        if (!target)
+            target = this.create();
+        for (let [k, v] of globalThis.Object.entries(json)) {
+            target.fields[k] = Value.fromJson(v);
+        }
+        return target;
+    }
+    create(value) {
+        const message = { fields: {} };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* map<string, google.protobuf.Value> fields */ 1:
+                    this.binaryReadMap1(message.fields, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    binaryReadMap1(map, reader, options) {
+        let len = reader.uint32(), end = reader.pos + len, key, val;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = Value.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field google.protobuf.Struct.fields");
+            }
+        }
+        map[key !== null && key !== void 0 ? key : ""] = val !== null && val !== void 0 ? val : Value.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* map<string, google.protobuf.Value> fields = 1; */
+        for (let k of Object.keys(message.fields)) {
+            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            Value.internalBinaryWrite(message.fields[k], writer, options);
+            writer.join().join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message google.protobuf.Struct
- */const Struct=new Struct$Type;// @generated message type with reflection information, may provide speed optimized methods
-class Value$Type extends MessageType{constructor(){super("google.protobuf.Value",[{no:1,name:"null_value",kind:"enum",oneof:"kind",T:()=>["google.protobuf.NullValue",NullValue]},{no:2,name:"number_value",kind:"scalar",oneof:"kind",T:1/*ScalarType.DOUBLE*/},{no:3,name:"string_value",kind:"scalar",oneof:"kind",T:9/*ScalarType.STRING*/},{no:4,name:"bool_value",kind:"scalar",oneof:"kind",T:8/*ScalarType.BOOL*/},{no:5,name:"struct_value",kind:"message",oneof:"kind",T:()=>Struct},{no:6,name:"list_value",kind:"message",oneof:"kind",T:()=>ListValue}]);}/**
+ */
+const Struct = new Struct$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Value$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Value", [
+            { no: 1, name: "null_value", kind: "enum", oneof: "kind", T: () => ["google.protobuf.NullValue", NullValue] },
+            { no: 2, name: "number_value", kind: "scalar", oneof: "kind", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 3, name: "string_value", kind: "scalar", oneof: "kind", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "bool_value", kind: "scalar", oneof: "kind", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "struct_value", kind: "message", oneof: "kind", T: () => Struct },
+            { no: 6, name: "list_value", kind: "message", oneof: "kind", T: () => ListValue }
+        ]);
+    }
+    /**
      * Encode `Value` to JSON value.
-     */internalJsonWrite(a){if(a.kind.oneofKind===void 0)throw new globalThis.Error;switch(a.kind.oneofKind){case void 0:throw new globalThis.Error;case"boolValue":return a.kind.boolValue;case"nullValue":return null;case"numberValue":return a.kind.numberValue;case"stringValue":return a.kind.stringValue;case"listValue":let b=this.fields.find(a=>6===a.no);if("message"!==(null===b||void 0===b?void 0:b.kind))throw new globalThis.Error;return b.T().toJson(a.kind.listValue);case"structValue":let c=this.fields.find(a=>5===a.no);if("message"!==(null===c||void 0===c?void 0:c.kind))throw new globalThis.Error;return c.T().toJson(a.kind.structValue);}}/**
+     */
+    internalJsonWrite(message, options) {
+        if (message.kind.oneofKind === undefined)
+            throw new globalThis.Error();
+        switch (message.kind.oneofKind) {
+            case undefined: throw new globalThis.Error();
+            case "boolValue": return message.kind.boolValue;
+            case "nullValue": return null;
+            case "numberValue": return message.kind.numberValue;
+            case "stringValue": return message.kind.stringValue;
+            case "listValue":
+                let listValueField = this.fields.find(f => f.no === 6);
+                if ((listValueField === null || listValueField === void 0 ? void 0 : listValueField.kind) !== "message")
+                    throw new globalThis.Error();
+                return listValueField.T().toJson(message.kind.listValue);
+            case "structValue":
+                let structValueField = this.fields.find(f => f.no === 5);
+                if ((structValueField === null || structValueField === void 0 ? void 0 : structValueField.kind) !== "message")
+                    throw new globalThis.Error();
+                return structValueField.T().toJson(message.kind.structValue);
+        }
+    }
+    /**
      * Decode `Value` from JSON value.
-     */internalJsonRead(a,b,c){switch(c||(c=this.create()),typeof a){case"number":c.kind={oneofKind:"numberValue",numberValue:a};break;case"string":c.kind={oneofKind:"stringValue",stringValue:a};break;case"boolean":c.kind={oneofKind:"boolValue",boolValue:a};break;case"object":if(null===a)c.kind={oneofKind:"nullValue",nullValue:NullValue.NULL_VALUE};else if(globalThis.Array.isArray(a))c.kind={oneofKind:"listValue",listValue:ListValue.fromJson(a)};else {Struct.fromJson(a);c.kind={oneofKind:"structValue",structValue:Struct.fromJson(a)};}break;default:throw new globalThis.Error("Unable to parse "+this.typeName+" from JSON "+typeofJsonValue(a));}return c}create(a){const b={kind:{oneofKind:void 0}};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* google.protobuf.NullValue null_value */1:e.kind={oneofKind:"nullValue",nullValue:a.int32()};break;case/* double number_value */2:e.kind={oneofKind:"numberValue",numberValue:a.double()};break;case/* string string_value */3:e.kind={oneofKind:"stringValue",stringValue:a.string()};break;case/* bool bool_value */4:e.kind={oneofKind:"boolValue",boolValue:a.bool()};break;case/* google.protobuf.Struct struct_value */5:e.kind={oneofKind:"structValue",structValue:Struct.internalBinaryRead(a,a.uint32(),c,e.kind.structValue)};break;case/* google.protobuf.ListValue list_value */6:e.kind={oneofKind:"listValue",listValue:ListValue.internalBinaryRead(a,a.uint32(),c,e.kind.listValue)};break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){"nullValue"===a.kind.oneofKind&&b.tag(1,WireType.Varint).int32(a.kind.nullValue),"numberValue"===a.kind.oneofKind&&b.tag(2,WireType.Bit64).double(a.kind.numberValue),"stringValue"===a.kind.oneofKind&&b.tag(3,WireType.LengthDelimited).string(a.kind.stringValue),"boolValue"===a.kind.oneofKind&&b.tag(4,WireType.Varint).bool(a.kind.boolValue),"structValue"===a.kind.oneofKind&&Struct.internalBinaryWrite(a.kind.structValue,b.tag(5,WireType.LengthDelimited).fork(),c).join(),"listValue"===a.kind.oneofKind&&ListValue.internalBinaryWrite(a.kind.listValue,b.tag(6,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+     */
+    internalJsonRead(json, options, target) {
+        if (!target)
+            target = this.create();
+        switch (typeof json) {
+            case "number":
+                target.kind = { oneofKind: "numberValue", numberValue: json };
+                break;
+            case "string":
+                target.kind = { oneofKind: "stringValue", stringValue: json };
+                break;
+            case "boolean":
+                target.kind = { oneofKind: "boolValue", boolValue: json };
+                break;
+            case "object":
+                if (json === null) {
+                    target.kind = { oneofKind: "nullValue", nullValue: NullValue.NULL_VALUE };
+                }
+                else if (globalThis.Array.isArray(json)) {
+                    target.kind = { oneofKind: "listValue", listValue: ListValue.fromJson(json) };
+                }
+                else {
+                    Struct.fromJson(json);
+                    target.kind = { oneofKind: "structValue", structValue: Struct.fromJson(json) };
+                }
+                break;
+            default: throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+        }
+        return target;
+    }
+    create(value) {
+        const message = { kind: { oneofKind: undefined } };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.NullValue null_value */ 1:
+                    message.kind = {
+                        oneofKind: "nullValue",
+                        nullValue: reader.int32()
+                    };
+                    break;
+                case /* double number_value */ 2:
+                    message.kind = {
+                        oneofKind: "numberValue",
+                        numberValue: reader.double()
+                    };
+                    break;
+                case /* string string_value */ 3:
+                    message.kind = {
+                        oneofKind: "stringValue",
+                        stringValue: reader.string()
+                    };
+                    break;
+                case /* bool bool_value */ 4:
+                    message.kind = {
+                        oneofKind: "boolValue",
+                        boolValue: reader.bool()
+                    };
+                    break;
+                case /* google.protobuf.Struct struct_value */ 5:
+                    message.kind = {
+                        oneofKind: "structValue",
+                        structValue: Struct.internalBinaryRead(reader, reader.uint32(), options, message.kind.structValue)
+                    };
+                    break;
+                case /* google.protobuf.ListValue list_value */ 6:
+                    message.kind = {
+                        oneofKind: "listValue",
+                        listValue: ListValue.internalBinaryRead(reader, reader.uint32(), options, message.kind.listValue)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* google.protobuf.NullValue null_value = 1; */
+        if (message.kind.oneofKind === "nullValue")
+            writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
+        /* double number_value = 2; */
+        if (message.kind.oneofKind === "numberValue")
+            writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
+        /* string string_value = 3; */
+        if (message.kind.oneofKind === "stringValue")
+            writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
+        /* bool bool_value = 4; */
+        if (message.kind.oneofKind === "boolValue")
+            writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
+        /* google.protobuf.Struct struct_value = 5; */
+        if (message.kind.oneofKind === "structValue")
+            Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.ListValue list_value = 6; */
+        if (message.kind.oneofKind === "listValue")
+            ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message google.protobuf.Value
- */const Value=new Value$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ListValue$Type extends MessageType{constructor(){super("google.protobuf.ListValue",[{no:1,name:"values",kind:"message",repeat:1/*RepeatType.PACKED*/,T:()=>Value}]);}/**
+ */
+const Value = new Value$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListValue$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.ListValue", [
+            { no: 1, name: "values", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Value }
+        ]);
+    }
+    /**
      * Encode `ListValue` to JSON array.
-     */internalJsonWrite(a){return a.values.map(a=>Value.toJson(a))}/**
+     */
+    internalJsonWrite(message, options) {
+        return message.values.map(v => Value.toJson(v));
+    }
+    /**
      * Decode `ListValue` from JSON array.
-     */internalJsonRead(a,b,c){if(!globalThis.Array.isArray(a))throw new globalThis.Error("Unable to parse "+this.typeName+" from JSON "+typeofJsonValue(a));c||(c=this.create());let d=a.map(a=>Value.fromJson(a));return c.values.push(...d),c}create(a){const b={values:[]};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* repeated google.protobuf.Value values */1:e.values.push(Value.internalBinaryRead(a,a.uint32(),c));break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){/* repeated google.protobuf.Value values = 1; */for(let d=0;d<a.values.length;d++)Value.internalBinaryWrite(a.values[d],b.tag(1,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+     */
+    internalJsonRead(json, options, target) {
+        if (!globalThis.Array.isArray(json))
+            throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+        if (!target)
+            target = this.create();
+        let values = json.map(v => Value.fromJson(v));
+        target.values.push(...values);
+        return target;
+    }
+    create(value) {
+        const message = { values: [] };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated google.protobuf.Value values */ 1:
+                    message.values.push(Value.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated google.protobuf.Value values = 1; */
+        for (let i = 0; i < message.values.length; i++)
+            Value.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message google.protobuf.ListValue
- */const ListValue=new ListValue$Type;
+ */
+const ListValue = new ListValue$Type();
 
-class ResolveBooleanRequest$Type extends MessageType{constructor(){super("schema.v1.ResolveBooleanRequest",[{no:1,name:"flag_key",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"context",kind:"message",T:()=>Struct}]);}create(a){const b={flagKey:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string flag_key */1:e.flagKey=a.string();break;case/* google.protobuf.Struct context */2:e.context=Struct.internalBinaryRead(a,a.uint32(),c,e.context);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.flagKey&&b.tag(1,WireType.LengthDelimited).string(a.flagKey),a.context&&Struct.internalBinaryWrite(a.context,b.tag(2,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+// @generated by protobuf-ts 2.2.2 with parameter long_type_string,generate_dependencies
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveAllRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveAllRequest", [
+            { no: 1, name: "context", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.Struct context */ 1:
+                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* google.protobuf.Struct context = 1; */
+        if (message.context)
+            Struct.internalBinaryWrite(message.context, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message schema.v1.ResolveAllRequest
+ */
+const ResolveAllRequest = new ResolveAllRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveAllResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveAllResponse", [
+            { no: 1, name: "flags", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => AnyFlag } }
+        ]);
+    }
+    create(value) {
+        const message = { flags: {} };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* map<string, schema.v1.AnyFlag> flags */ 1:
+                    this.binaryReadMap1(message.flags, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    binaryReadMap1(map, reader, options) {
+        let len = reader.uint32(), end = reader.pos + len, key, val;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = AnyFlag.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field schema.v1.ResolveAllResponse.flags");
+            }
+        }
+        map[key !== null && key !== void 0 ? key : ""] = val !== null && val !== void 0 ? val : AnyFlag.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* map<string, schema.v1.AnyFlag> flags = 1; */
+        for (let k of Object.keys(message.flags)) {
+            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            AnyFlag.internalBinaryWrite(message.flags[k], writer, options);
+            writer.join().join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message schema.v1.ResolveAllResponse
+ */
+const ResolveAllResponse = new ResolveAllResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AnyFlag$Type extends MessageType {
+    constructor() {
+        super("schema.v1.AnyFlag", [
+            { no: 1, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "variant", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "bool_value", kind: "scalar", oneof: "value", T: 8 /*ScalarType.BOOL*/ },
+            { no: 4, name: "string_value", kind: "scalar", oneof: "value", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "double_value", kind: "scalar", oneof: "value", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 6, name: "object_value", kind: "message", oneof: "value", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { reason: "", variant: "", value: { oneofKind: undefined } };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string reason */ 1:
+                    message.reason = reader.string();
+                    break;
+                case /* string variant */ 2:
+                    message.variant = reader.string();
+                    break;
+                case /* bool bool_value */ 3:
+                    message.value = {
+                        oneofKind: "boolValue",
+                        boolValue: reader.bool()
+                    };
+                    break;
+                case /* string string_value */ 4:
+                    message.value = {
+                        oneofKind: "stringValue",
+                        stringValue: reader.string()
+                    };
+                    break;
+                case /* double double_value */ 5:
+                    message.value = {
+                        oneofKind: "doubleValue",
+                        doubleValue: reader.double()
+                    };
+                    break;
+                case /* google.protobuf.Struct object_value */ 6:
+                    message.value = {
+                        oneofKind: "objectValue",
+                        objectValue: Struct.internalBinaryRead(reader, reader.uint32(), options, message.value.objectValue)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string reason = 1; */
+        if (message.reason !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.reason);
+        /* string variant = 2; */
+        if (message.variant !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.variant);
+        /* bool bool_value = 3; */
+        if (message.value.oneofKind === "boolValue")
+            writer.tag(3, WireType.Varint).bool(message.value.boolValue);
+        /* string string_value = 4; */
+        if (message.value.oneofKind === "stringValue")
+            writer.tag(4, WireType.LengthDelimited).string(message.value.stringValue);
+        /* double double_value = 5; */
+        if (message.value.oneofKind === "doubleValue")
+            writer.tag(5, WireType.Bit64).double(message.value.doubleValue);
+        /* google.protobuf.Struct object_value = 6; */
+        if (message.value.oneofKind === "objectValue")
+            Struct.internalBinaryWrite(message.value.objectValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message schema.v1.AnyFlag
+ */
+const AnyFlag = new AnyFlag$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveBooleanRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveBooleanRequest", [
+            { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "context", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { flagKey: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string flag_key */ 1:
+                    message.flagKey = reader.string();
+                    break;
+                case /* google.protobuf.Struct context */ 2:
+                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string flag_key = 1; */
+        if (message.flagKey !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+        /* google.protobuf.Struct context = 2; */
+        if (message.context)
+            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveBooleanRequest
- */const ResolveBooleanRequest=new ResolveBooleanRequest$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveBooleanResponse$Type extends MessageType{constructor(){super("schema.v1.ResolveBooleanResponse",[{no:1,name:"value",kind:"scalar",T:8/*ScalarType.BOOL*/},{no:2,name:"reason",kind:"scalar",T:9/*ScalarType.STRING*/},{no:3,name:"variant",kind:"scalar",T:9/*ScalarType.STRING*/}]);}create(a){const b={value:!1,reason:"",variant:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* bool value */1:e.value=a.bool();break;case/* string reason */2:e.reason=a.string();break;case/* string variant */3:e.variant=a.string();break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){!1!==a.value&&b.tag(1,WireType.Varint).bool(a.value),""!==a.reason&&b.tag(2,WireType.LengthDelimited).string(a.reason),""!==a.variant&&b.tag(3,WireType.LengthDelimited).string(a.variant);let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveBooleanRequest = new ResolveBooleanRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveBooleanResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveBooleanResponse", [
+            { no: 1, name: "value", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "variant", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = { value: false, reason: "", variant: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool value */ 1:
+                    message.value = reader.bool();
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                case /* string variant */ 3:
+                    message.variant = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool value = 1; */
+        if (message.value !== false)
+            writer.tag(1, WireType.Varint).bool(message.value);
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        /* string variant = 3; */
+        if (message.variant !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveBooleanResponse
- */const ResolveBooleanResponse=new ResolveBooleanResponse$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveStringRequest$Type extends MessageType{constructor(){super("schema.v1.ResolveStringRequest",[{no:1,name:"flag_key",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"context",kind:"message",T:()=>Struct}]);}create(a){const b={flagKey:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string flag_key */1:e.flagKey=a.string();break;case/* google.protobuf.Struct context */2:e.context=Struct.internalBinaryRead(a,a.uint32(),c,e.context);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.flagKey&&b.tag(1,WireType.LengthDelimited).string(a.flagKey),a.context&&Struct.internalBinaryWrite(a.context,b.tag(2,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveBooleanResponse = new ResolveBooleanResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveStringRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveStringRequest", [
+            { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "context", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { flagKey: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string flag_key */ 1:
+                    message.flagKey = reader.string();
+                    break;
+                case /* google.protobuf.Struct context */ 2:
+                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string flag_key = 1; */
+        if (message.flagKey !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+        /* google.protobuf.Struct context = 2; */
+        if (message.context)
+            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveStringRequest
- */const ResolveStringRequest=new ResolveStringRequest$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveStringResponse$Type extends MessageType{constructor(){super("schema.v1.ResolveStringResponse",[{no:1,name:"value",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"reason",kind:"scalar",T:9/*ScalarType.STRING*/},{no:3,name:"variant",kind:"scalar",T:9/*ScalarType.STRING*/}]);}create(a){const b={value:"",reason:"",variant:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string value */1:e.value=a.string();break;case/* string reason */2:e.reason=a.string();break;case/* string variant */3:e.variant=a.string();break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.value&&b.tag(1,WireType.LengthDelimited).string(a.value),""!==a.reason&&b.tag(2,WireType.LengthDelimited).string(a.reason),""!==a.variant&&b.tag(3,WireType.LengthDelimited).string(a.variant);let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveStringRequest = new ResolveStringRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveStringResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveStringResponse", [
+            { no: 1, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "variant", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = { value: "", reason: "", variant: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string value */ 1:
+                    message.value = reader.string();
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                case /* string variant */ 3:
+                    message.variant = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string value = 1; */
+        if (message.value !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.value);
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        /* string variant = 3; */
+        if (message.variant !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveStringResponse
- */const ResolveStringResponse=new ResolveStringResponse$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveFloatRequest$Type extends MessageType{constructor(){super("schema.v1.ResolveFloatRequest",[{no:1,name:"flag_key",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"context",kind:"message",T:()=>Struct}]);}create(a){const b={flagKey:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string flag_key */1:e.flagKey=a.string();break;case/* google.protobuf.Struct context */2:e.context=Struct.internalBinaryRead(a,a.uint32(),c,e.context);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.flagKey&&b.tag(1,WireType.LengthDelimited).string(a.flagKey),a.context&&Struct.internalBinaryWrite(a.context,b.tag(2,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveStringResponse = new ResolveStringResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveFloatRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveFloatRequest", [
+            { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "context", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { flagKey: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string flag_key */ 1:
+                    message.flagKey = reader.string();
+                    break;
+                case /* google.protobuf.Struct context */ 2:
+                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string flag_key = 1; */
+        if (message.flagKey !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+        /* google.protobuf.Struct context = 2; */
+        if (message.context)
+            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveFloatRequest
- */const ResolveFloatRequest=new ResolveFloatRequest$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveFloatResponse$Type extends MessageType{constructor(){super("schema.v1.ResolveFloatResponse",[{no:1,name:"value",kind:"scalar",T:1/*ScalarType.DOUBLE*/},{no:2,name:"reason",kind:"scalar",T:9/*ScalarType.STRING*/},{no:3,name:"variant",kind:"scalar",T:9/*ScalarType.STRING*/}]);}create(a){const b={value:0,reason:"",variant:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* double value */1:e.value=a.double();break;case/* string reason */2:e.reason=a.string();break;case/* string variant */3:e.variant=a.string();break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){0!==a.value&&b.tag(1,WireType.Bit64).double(a.value),""!==a.reason&&b.tag(2,WireType.LengthDelimited).string(a.reason),""!==a.variant&&b.tag(3,WireType.LengthDelimited).string(a.variant);let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveFloatRequest = new ResolveFloatRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveFloatResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveFloatResponse", [
+            { no: 1, name: "value", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "variant", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = { value: 0, reason: "", variant: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* double value */ 1:
+                    message.value = reader.double();
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                case /* string variant */ 3:
+                    message.variant = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* double value = 1; */
+        if (message.value !== 0)
+            writer.tag(1, WireType.Bit64).double(message.value);
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        /* string variant = 3; */
+        if (message.variant !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveFloatResponse
- */const ResolveFloatResponse=new ResolveFloatResponse$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveIntRequest$Type extends MessageType{constructor(){super("schema.v1.ResolveIntRequest",[{no:1,name:"flag_key",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"context",kind:"message",T:()=>Struct}]);}create(a){const b={flagKey:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string flag_key */1:e.flagKey=a.string();break;case/* google.protobuf.Struct context */2:e.context=Struct.internalBinaryRead(a,a.uint32(),c,e.context);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.flagKey&&b.tag(1,WireType.LengthDelimited).string(a.flagKey),a.context&&Struct.internalBinaryWrite(a.context,b.tag(2,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveFloatResponse = new ResolveFloatResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveIntRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveIntRequest", [
+            { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "context", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { flagKey: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string flag_key */ 1:
+                    message.flagKey = reader.string();
+                    break;
+                case /* google.protobuf.Struct context */ 2:
+                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string flag_key = 1; */
+        if (message.flagKey !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+        /* google.protobuf.Struct context = 2; */
+        if (message.context)
+            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveIntRequest
- */const ResolveIntRequest=new ResolveIntRequest$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveIntResponse$Type extends MessageType{constructor(){super("schema.v1.ResolveIntResponse",[{no:1,name:"value",kind:"scalar",T:3/*ScalarType.INT64*/},{no:2,name:"reason",kind:"scalar",T:9/*ScalarType.STRING*/},{no:3,name:"variant",kind:"scalar",T:9/*ScalarType.STRING*/}]);}create(a){const b={value:"0",reason:"",variant:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* int64 value */1:e.value=a.int64().toString();break;case/* string reason */2:e.reason=a.string();break;case/* string variant */3:e.variant=a.string();break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){"0"!==a.value&&b.tag(1,WireType.Varint).int64(a.value),""!==a.reason&&b.tag(2,WireType.LengthDelimited).string(a.reason),""!==a.variant&&b.tag(3,WireType.LengthDelimited).string(a.variant);let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveIntRequest = new ResolveIntRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveIntResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveIntResponse", [
+            { no: 1, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "variant", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = { value: "0", reason: "", variant: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 value */ 1:
+                    message.value = reader.int64().toString();
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                case /* string variant */ 3:
+                    message.variant = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 value = 1; */
+        if (message.value !== "0")
+            writer.tag(1, WireType.Varint).int64(message.value);
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        /* string variant = 3; */
+        if (message.variant !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveIntResponse
- */const ResolveIntResponse=new ResolveIntResponse$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveObjectRequest$Type extends MessageType{constructor(){super("schema.v1.ResolveObjectRequest",[{no:1,name:"flag_key",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"context",kind:"message",T:()=>Struct}]);}create(a){const b={flagKey:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string flag_key */1:e.flagKey=a.string();break;case/* google.protobuf.Struct context */2:e.context=Struct.internalBinaryRead(a,a.uint32(),c,e.context);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.flagKey&&b.tag(1,WireType.LengthDelimited).string(a.flagKey),a.context&&Struct.internalBinaryWrite(a.context,b.tag(2,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveIntResponse = new ResolveIntResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveObjectRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveObjectRequest", [
+            { no: 1, name: "flag_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "context", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { flagKey: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string flag_key */ 1:
+                    message.flagKey = reader.string();
+                    break;
+                case /* google.protobuf.Struct context */ 2:
+                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string flag_key = 1; */
+        if (message.flagKey !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.flagKey);
+        /* google.protobuf.Struct context = 2; */
+        if (message.context)
+            Struct.internalBinaryWrite(message.context, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveObjectRequest
- */const ResolveObjectRequest=new ResolveObjectRequest$Type;// @generated message type with reflection information, may provide speed optimized methods
-class ResolveObjectResponse$Type extends MessageType{constructor(){super("schema.v1.ResolveObjectResponse",[{no:1,name:"value",kind:"message",T:()=>Struct},{no:2,name:"reason",kind:"scalar",T:9/*ScalarType.STRING*/},{no:3,name:"variant",kind:"scalar",T:9/*ScalarType.STRING*/}]);}create(a){const b={reason:"",variant:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* google.protobuf.Struct value */1:e.value=Struct.internalBinaryRead(a,a.uint32(),c,e.value);break;case/* string reason */2:e.reason=a.string();break;case/* string variant */3:e.variant=a.string();break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){a.value&&Struct.internalBinaryWrite(a.value,b.tag(1,WireType.LengthDelimited).fork(),c).join(),""!==a.reason&&b.tag(2,WireType.LengthDelimited).string(a.reason),""!==a.variant&&b.tag(3,WireType.LengthDelimited).string(a.variant);let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveObjectRequest = new ResolveObjectRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResolveObjectResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.ResolveObjectResponse", [
+            { no: 1, name: "value", kind: "message", T: () => Struct },
+            { no: 2, name: "reason", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "variant", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = { reason: "", variant: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.Struct value */ 1:
+                    message.value = Struct.internalBinaryRead(reader, reader.uint32(), options, message.value);
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                case /* string variant */ 3:
+                    message.variant = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* google.protobuf.Struct value = 1; */
+        if (message.value)
+            Struct.internalBinaryWrite(message.value, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string reason = 2; */
+        if (message.reason !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        /* string variant = 3; */
+        if (message.variant !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.variant);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.ResolveObjectResponse
- */const ResolveObjectResponse=new ResolveObjectResponse$Type;// @generated message type with reflection information, may provide speed optimized methods
-class EventStreamResponse$Type extends MessageType{constructor(){super("schema.v1.EventStreamResponse",[{no:1,name:"type",kind:"scalar",T:9/*ScalarType.STRING*/},{no:2,name:"data",kind:"message",T:()=>Struct}]);}create(a){const b={type:""};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){let e=null!==d&&void 0!==d?d:this.create(),f=a.pos+b;for(;a.pos<f;){let[b,f]=a.tag();switch(b){case/* string type */1:e.type=a.string();break;case/* google.protobuf.Struct data */2:e.data=Struct.internalBinaryRead(a,a.uint32(),c,e.data);break;default:let g=c.readUnknownField;if("throw"===g)throw new globalThis.Error(`Unknown field ${b} (wire type ${f}) for ${this.typeName}`);let h=a.skip(f);!1!==g&&(!0===g?UnknownFieldHandler.onRead:g)(this.typeName,e,b,f,h);}}return e}internalBinaryWrite(a,b,c){""!==a.type&&b.tag(1,WireType.LengthDelimited).string(a.type),a.data&&Struct.internalBinaryWrite(a.data,b.tag(2,WireType.LengthDelimited).fork(),c).join();let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const ResolveObjectResponse = new ResolveObjectResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EventStreamResponse$Type extends MessageType {
+    constructor() {
+        super("schema.v1.EventStreamResponse", [
+            { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "data", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value) {
+        const message = { type: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* google.protobuf.Struct data */ 2:
+                    message.data = Struct.internalBinaryRead(reader, reader.uint32(), options, message.data);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string type = 1; */
+        if (message.type !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* google.protobuf.Struct data = 2; */
+        if (message.data)
+            Struct.internalBinaryWrite(message.data, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.EventStreamResponse
- */const EventStreamResponse=new EventStreamResponse$Type;// @generated message type with reflection information, may provide speed optimized methods
-class EventStreamRequest$Type extends MessageType{constructor(){super("schema.v1.EventStreamRequest",[]);}create(a){const b={};return globalThis.Object.defineProperty(b,MESSAGE_TYPE,{enumerable:!1,value:this}),void 0!==a&&reflectionMergePartial(this,b,a),b}internalBinaryRead(a,b,c,d){return null!==d&&void 0!==d?d:this.create()}internalBinaryWrite(a,b,c){let d=c.writeUnknownFields;return !1!==d&&(!0==d?UnknownFieldHandler.onWrite:d)(this.typeName,a,b),b}}/**
+ */
+const EventStreamResponse = new EventStreamResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EventStreamRequest$Type extends MessageType {
+    constructor() {
+        super("schema.v1.EventStreamRequest", []);
+    }
+    create(value) {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        return target !== null && target !== void 0 ? target : this.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
  * @generated MessageType for protobuf message schema.v1.EventStreamRequest
- */const EventStreamRequest=new EventStreamRequest$Type;/**
+ */
+const EventStreamRequest = new EventStreamRequest$Type();
+/**
  * @generated ServiceType for protobuf service schema.v1.Service
- */const Service=new ServiceType("schema.v1.Service",[{name:"ResolveBoolean",options:{},I:ResolveBooleanRequest,O:ResolveBooleanResponse},{name:"ResolveString",options:{},I:ResolveStringRequest,O:ResolveStringResponse},{name:"ResolveFloat",options:{},I:ResolveFloatRequest,O:ResolveFloatResponse},{name:"ResolveInt",options:{},I:ResolveIntRequest,O:ResolveIntResponse},{name:"ResolveObject",options:{},I:ResolveObjectRequest,O:ResolveObjectResponse},{name:"EventStream",serverStreaming:!0,options:{},I:EventStreamRequest,O:EventStreamResponse}]);
+ */
+const Service = new ServiceType("schema.v1.Service", [
+    { name: "ResolveAll", options: {}, I: ResolveAllRequest, O: ResolveAllResponse },
+    { name: "ResolveBoolean", options: {}, I: ResolveBooleanRequest, O: ResolveBooleanResponse },
+    { name: "ResolveString", options: {}, I: ResolveStringRequest, O: ResolveStringResponse },
+    { name: "ResolveFloat", options: {}, I: ResolveFloatRequest, O: ResolveFloatResponse },
+    { name: "ResolveInt", options: {}, I: ResolveIntRequest, O: ResolveIntResponse },
+    { name: "ResolveObject", options: {}, I: ResolveObjectRequest, O: ResolveObjectResponse },
+    { name: "EventStream", serverStreaming: true, options: {}, I: EventStreamRequest, O: EventStreamResponse }
+]);
 
 /**
  * Service defines the exposed rpcs of flagd
  *
  * @generated from protobuf service schema.v1.Service
- */class ServiceClient{constructor(a){this._transport=a,this.typeName=Service.typeName,this.methods=Service.methods,this.options=Service.options;}/**
+ */
+class ServiceClient {
+    constructor(_transport) {
+        this._transport = _transport;
+        this.typeName = Service.typeName;
+        this.methods = Service.methods;
+        this.options = Service.options;
+    }
+    /**
+     * @generated from protobuf rpc: ResolveAll(schema.v1.ResolveAllRequest) returns (schema.v1.ResolveAllResponse);
+     */
+    resolveAll(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
      * @generated from protobuf rpc: ResolveBoolean(schema.v1.ResolveBooleanRequest) returns (schema.v1.ResolveBooleanResponse);
-     */resolveBoolean(a,b){const c=this.methods[0],d=this._transport.mergeOptions(b);return stackIntercept("unary",this._transport,c,d,a)}/**
+     */
+    resolveBoolean(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
      * @generated from protobuf rpc: ResolveString(schema.v1.ResolveStringRequest) returns (schema.v1.ResolveStringResponse);
-     */resolveString(a,b){const c=this.methods[1],d=this._transport.mergeOptions(b);return stackIntercept("unary",this._transport,c,d,a)}/**
+     */
+    resolveString(input, options) {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
      * @generated from protobuf rpc: ResolveFloat(schema.v1.ResolveFloatRequest) returns (schema.v1.ResolveFloatResponse);
-     */resolveFloat(a,b){const c=this.methods[2],d=this._transport.mergeOptions(b);return stackIntercept("unary",this._transport,c,d,a)}/**
+     */
+    resolveFloat(input, options) {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
      * @generated from protobuf rpc: ResolveInt(schema.v1.ResolveIntRequest) returns (schema.v1.ResolveIntResponse);
-     */resolveInt(a,b){const c=this.methods[3],d=this._transport.mergeOptions(b);return stackIntercept("unary",this._transport,c,d,a)}/**
+     */
+    resolveInt(input, options) {
+        const method = this.methods[4], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
      * @generated from protobuf rpc: ResolveObject(schema.v1.ResolveObjectRequest) returns (schema.v1.ResolveObjectResponse);
-     */resolveObject(a,b){const c=this.methods[4],d=this._transport.mergeOptions(b);return stackIntercept("unary",this._transport,c,d,a)}/**
+     */
+    resolveObject(input, options) {
+        const method = this.methods[5], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
      * @generated from protobuf rpc: EventStream(schema.v1.EventStreamRequest) returns (stream schema.v1.EventStreamResponse);
-     */eventStream(a,b){const c=this.methods[5],d=this._transport.mergeOptions(b);return stackIntercept("serverStreaming",this._transport,c,d,a)}}
+     */
+    eventStream(input, options) {
+        const method = this.methods[6], opt = this._transport.mergeOptions(options);
+        return stackIntercept("serverStreaming", this._transport, method, opt, input);
+    }
+}
 
-const Codes={InvalidArgument:"INVALID_ARGUMENT",NotFound:"NOT_FOUND",DataLoss:"DATA_LOSS",Unavailable:"UNAVAILABLE"};class GRPCService{constructor(a,b){this.onFulfilled=a=>a,this.onRejected=a=>{// map the errors
-switch(null===a||void 0===a?void 0:a.code){case Codes.DataLoss:throw new ParseError(a.message);case Codes.InvalidArgument:throw new TypeMismatchError(a.message);case Codes.NotFound:throw new FlagNotFoundError(a.message);case Codes.Unavailable:throw new FlagNotFoundError(a.message);default:throw new GeneralError(a.message);}};const{host:c,port:d,tls:e,socketPath:f}=a;this.client=b?b:new ServiceClient(new GrpcTransport({host:f?`unix://${f}`:`${c}:${d}`,channelCredentials:e?grpc.credentials.createSsl():grpc.credentials.createInsecure()}));}resolveBoolean(a,b,c){return __awaiter(this,void 0,void 0,function*(){const{response:d}=yield this.client.resolveBoolean({flagKey:a,context:this.convertContext(b,c)}).then(this.onFulfilled,this.onRejected);return {value:d.value,reason:d.reason,variant:d.variant}})}resolveString(a,b,c){return __awaiter(this,void 0,void 0,function*(){const{response:d}=yield this.client.resolveString({flagKey:a,context:this.convertContext(b,c)}).then(this.onFulfilled,this.onRejected);return {value:d.value,reason:d.reason,variant:d.variant}})}resolveNumber(a,b,c){return __awaiter(this,void 0,void 0,function*(){const{response:d}=yield this.client.resolveFloat({flagKey:a,context:this.convertContext(b,c)}).then(this.onFulfilled,this.onRejected);return {value:d.value,reason:d.reason,variant:d.variant}})}resolveObject(a,b,c){return __awaiter(this,void 0,void 0,function*(){const{response:d}=yield this.client.resolveObject({flagKey:a,context:this.convertContext(b,c)}).then(this.onFulfilled,this.onRejected);if(d.value!==void 0)return {value:Struct.toJson(d.value),reason:d.reason,variant:d.variant};throw new ParseError("Object value undefined or missing.")})}convertContext(a,b){try{// stringify to remove invalid js props
-return Struct.fromJsonString(JSON.stringify(a))}catch(a){const c=a;throw b.error(`${"Error serializing context."}: ${null===c||void 0===c?void 0:c.message}`),b.error(null===c||void 0===c?void 0:c.stack),new ParseError("Error serializing context.")}}}
+// see: https://grpc.github.io/grpc/core/md_doc_statuscodes.html
+const Codes = {
+    InvalidArgument: 'INVALID_ARGUMENT',
+    NotFound: 'NOT_FOUND',
+    DataLoss: 'DATA_LOSS',
+    Unavailable: 'UNAVAILABLE'
+};
+class GRPCService {
+    constructor(config, client) {
+        this.onFulfilled = (value) => {
+            // no-op, just return the value
+            return value;
+        };
+        this.onRejected = (err) => {
+            // map the errors
+            switch (err === null || err === void 0 ? void 0 : err.code) {
+                case Codes.DataLoss:
+                    throw new ParseError(err.message);
+                case Codes.InvalidArgument:
+                    throw new TypeMismatchError(err.message);
+                case Codes.NotFound:
+                    throw new FlagNotFoundError(err.message);
+                case Codes.Unavailable:
+                    throw new FlagNotFoundError(err.message);
+                default:
+                    throw new GeneralError(err.message);
+            }
+        };
+        const { host, port, tls, socketPath } = config;
+        this.client = client
+            ? client
+            : new ServiceClient(new GrpcTransport({
+                host: socketPath ? `unix://${socketPath}` : `${host}:${port}`,
+                channelCredentials: tls
+                    ? grpc.credentials.createSsl()
+                    : grpc.credentials.createInsecure(),
+            }));
+    }
+    resolveBoolean(flagKey, context, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { response } = yield this.client.resolveBoolean({
+                flagKey,
+                context: this.convertContext(context, logger),
+            }).then(this.onFulfilled, this.onRejected);
+            return {
+                value: response.value,
+                reason: response.reason,
+                variant: response.variant,
+            };
+        });
+    }
+    resolveString(flagKey, context, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { response } = yield this.client.resolveString({
+                flagKey,
+                context: this.convertContext(context, logger),
+            }).then(this.onFulfilled, this.onRejected);
+            return {
+                value: response.value,
+                reason: response.reason,
+                variant: response.variant,
+            };
+        });
+    }
+    resolveNumber(flagKey, context, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { response } = yield this.client.resolveFloat({
+                flagKey,
+                context: this.convertContext(context, logger),
+            }).then(this.onFulfilled, this.onRejected);
+            return {
+                value: response.value,
+                reason: response.reason,
+                variant: response.variant,
+            };
+        });
+    }
+    resolveObject(flagKey, context, logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { response } = yield this.client.resolveObject({
+                flagKey,
+                context: this.convertContext(context, logger),
+            }).then(this.onFulfilled, this.onRejected);
+            if (response.value !== undefined) {
+                return {
+                    value: Struct.toJson(response.value),
+                    reason: response.reason,
+                    variant: response.variant,
+                };
+            }
+            else {
+                throw new ParseError('Object value undefined or missing.');
+            }
+        });
+    }
+    convertContext(context, logger) {
+        try {
+            // stringify to remove invalid js props
+            return Struct.fromJsonString(JSON.stringify(context));
+        }
+        catch (e) {
+            const message = 'Error serializing context.';
+            const error = e;
+            logger.error(`${message}: ${error === null || error === void 0 ? void 0 : error.message}`);
+            logger.error(error === null || error === void 0 ? void 0 : error.stack);
+            throw new ParseError(message);
+        }
+    }
+}
 
-class FlagdProvider{constructor(a,b){this.metadata={name:"flagd Provider"},this.logRejected=(a,b,c)=>{throw c.error(`Error resolving flag ${b}: ${null===a||void 0===a?void 0:a.message}`),c.error(null===a||void 0===a?void 0:a.stack),a},this._service=b?b:new GRPCService(getConfig(a));}resolveBooleanEvaluation(a,b,c,d){return this._service.resolveBoolean(a,c,d).catch(b=>this.logRejected(b,a,d))}resolveStringEvaluation(a,b,c,d){return this._service.resolveString(a,c,d).catch(b=>this.logRejected(b,a,d))}resolveNumberEvaluation(a,b,c,d){return this._service.resolveNumber(a,c,d).catch(b=>this.logRejected(b,a,d))}resolveObjectEvaluation(a,b,c,d){return this._service.resolveObject(a,c,d).catch(b=>this.logRejected(b,a,d))}}
+class FlagdProvider {
+    constructor(options, service) {
+        this.metadata = {
+            name: 'flagd Provider',
+        };
+        this.logRejected = (err, flagKey, logger) => {
+            logger.error(`Error resolving flag ${flagKey}: ${err === null || err === void 0 ? void 0 : err.message}`);
+            logger.error(err === null || err === void 0 ? void 0 : err.stack);
+            throw err;
+        };
+        this._service = service ? service : new GRPCService(getConfig(options));
+    }
+    resolveBooleanEvaluation(flagKey, _, transformedContext, logger) {
+        return this._service.resolveBoolean(flagKey, transformedContext, logger)
+            .catch((err) => this.logRejected(err, flagKey, logger));
+    }
+    resolveStringEvaluation(flagKey, _, transformedContext, logger) {
+        return this._service.resolveString(flagKey, transformedContext, logger)
+            .catch((err) => this.logRejected(err, flagKey, logger));
+    }
+    resolveNumberEvaluation(flagKey, _, transformedContext, logger) {
+        return this._service.resolveNumber(flagKey, transformedContext, logger)
+            .catch((err) => this.logRejected(err, flagKey, logger));
+    }
+    resolveObjectEvaluation(flagKey, _, transformedContext, logger) {
+        return this._service.resolveObject(flagKey, transformedContext, logger)
+            .catch((err) => this.logRejected(err, flagKey, logger));
+    }
+}
 
 export { FlagdProvider };