import Long from "long";
import { grpc } from "@improbable-eng/grpc-web";
import _m0 from "protobufjs/minimal";
import { ConfigTargetingRequest } from "./config_request";
import { ConfigTargetingResponse } from "./config_response";
import { BrowserHeaders } from "browser-headers";
import { ConfigResult } from "./config_result";
import { DebugTrace } from "./debug_info";
import { FeatureProvidedSignals } from "./feature_provided_signals";
import { Ruid } from "../../common/ruid";
export const protobufPackage = "snapchat.cdp.cof";
function createBaseGetAbConfigValuesRequest() {
    return {
        configNames: [],
        namespaces: [],
        cofConfigNames: [],
        includeAllConfigs: false,
        disableExposureLogging: false,
        enableDebug: false,
    };
}
export const GetAbConfigValuesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.configNames) {
            writer.uint32(10).string(v);
        }
        writer.uint32(18).fork();
        for (const v of message.namespaces) {
            writer.int32(v);
        }
        writer.ldelim();
        for (const v of message.cofConfigNames) {
            writer.uint32(26).string(v);
        }
        if (message.includeAllConfigs === true) {
            writer.uint32(32).bool(message.includeAllConfigs);
        }
        if (message.disableExposureLogging === true) {
            writer.uint32(40).bool(message.disableExposureLogging);
        }
        if (message.enableDebug === true) {
            writer.uint32(104).bool(message.enableDebug);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetAbConfigValuesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configNames.push(reader.string());
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.namespaces.push(reader.int32());
                        }
                    }
                    else {
                        message.namespaces.push(reader.int32());
                    }
                    break;
                case 3:
                    message.cofConfigNames.push(reader.string());
                    break;
                case 4:
                    message.includeAllConfigs = reader.bool();
                    break;
                case 5:
                    message.disableExposureLogging = reader.bool();
                    break;
                case 13:
                    message.enableDebug = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseGetAbConfigValuesRequest();
        message.configNames = ((_a = object.configNames) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
        message.namespaces = ((_b = object.namespaces) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
        message.cofConfigNames = ((_c = object.cofConfigNames) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
        message.includeAllConfigs = (_d = object.includeAllConfigs) !== null && _d !== void 0 ? _d : false;
        message.disableExposureLogging = (_e = object.disableExposureLogging) !== null && _e !== void 0 ? _e : false;
        message.enableDebug = (_f = object.enableDebug) !== null && _f !== void 0 ? _f : false;
        return message;
    },
};
function createBaseGetAbConfigValuesResponse() {
    return { configResults: [], debugTrace: undefined };
}
export const GetAbConfigValuesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.configResults) {
            ConfigResult.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.debugTrace !== undefined) {
            DebugTrace.encode(message.debugTrace, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetAbConfigValuesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configResults.push(ConfigResult.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.debugTrace = DebugTrace.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetAbConfigValuesResponse();
        message.configResults = ((_a = object.configResults) === null || _a === void 0 ? void 0 : _a.map((e) => ConfigResult.fromPartial(e))) || [];
        message.debugTrace =
            object.debugTrace !== undefined && object.debugTrace !== null
                ? DebugTrace.fromPartial(object.debugTrace)
                : undefined;
        return message;
    },
};
function createBaseConfigSetGenerationRequest() {
    return { targetingParameters: undefined, overrides: [] };
}
export const ConfigSetGenerationRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.targetingParameters !== undefined) {
            ConfigTargetingRequest.encode(message.targetingParameters, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.overrides) {
            ConfigResult.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseConfigSetGenerationRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.targetingParameters = ConfigTargetingRequest.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.overrides.push(ConfigResult.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseConfigSetGenerationRequest();
        message.targetingParameters =
            object.targetingParameters !== undefined && object.targetingParameters !== null
                ? ConfigTargetingRequest.fromPartial(object.targetingParameters)
                : undefined;
        message.overrides = ((_a = object.overrides) === null || _a === void 0 ? void 0 : _a.map((e) => ConfigResult.fromPartial(e))) || [];
        return message;
    },
};
function createBaseConfigSetGenerationResponse() {
    return { targetingResponse: undefined };
}
export const ConfigSetGenerationResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.targetingResponse !== undefined) {
            ConfigTargetingResponse.encode(message.targetingResponse, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseConfigSetGenerationResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.targetingResponse = ConfigTargetingResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseConfigSetGenerationResponse();
        message.targetingResponse =
            object.targetingResponse !== undefined && object.targetingResponse !== null
                ? ConfigTargetingResponse.fromPartial(object.targetingResponse)
                : undefined;
        return message;
    },
};
function createBasePinConfigRequest() {
    return { configSetToken: "", userId: "", ttlSeconds: 0 };
}
export const PinConfigRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.configSetToken !== "") {
            writer.uint32(10).string(message.configSetToken);
        }
        if (message.userId !== "") {
            writer.uint32(18).string(message.userId);
        }
        if (message.ttlSeconds !== 0) {
            writer.uint32(24).int32(message.ttlSeconds);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePinConfigRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configSetToken = reader.string();
                    break;
                case 2:
                    message.userId = reader.string();
                    break;
                case 3:
                    message.ttlSeconds = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBasePinConfigRequest();
        message.configSetToken = (_a = object.configSetToken) !== null && _a !== void 0 ? _a : "";
        message.userId = (_b = object.userId) !== null && _b !== void 0 ? _b : "";
        message.ttlSeconds = (_c = object.ttlSeconds) !== null && _c !== void 0 ? _c : 0;
        return message;
    },
};
function createBasePinConfigResponse() {
    return { debug: "" };
}
export const PinConfigResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.debug !== "") {
            writer.uint32(10).string(message.debug);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePinConfigResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.debug = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBasePinConfigResponse();
        message.debug = (_a = object.debug) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBaseUnpinConfigRequest() {
    return { configSetToken: "", userId: "" };
}
export const UnpinConfigRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.configSetToken !== "") {
            writer.uint32(10).string(message.configSetToken);
        }
        if (message.userId !== "") {
            writer.uint32(18).string(message.userId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseUnpinConfigRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configSetToken = reader.string();
                    break;
                case 2:
                    message.userId = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseUnpinConfigRequest();
        message.configSetToken = (_a = object.configSetToken) !== null && _a !== void 0 ? _a : "";
        message.userId = (_b = object.userId) !== null && _b !== void 0 ? _b : "";
        return message;
    },
};
function createBaseUnpinConfigResponse() {
    return { debug: "" };
}
export const UnpinConfigResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.debug !== "") {
            writer.uint32(10).string(message.debug);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseUnpinConfigResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.debug = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseUnpinConfigResponse();
        message.debug = (_a = object.debug) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBasePinTargetingPropertiesRequest() {
    return { userId: "", targetingProperties: undefined, ttlSeconds: 0 };
}
export const PinTargetingPropertiesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.userId !== "") {
            writer.uint32(10).string(message.userId);
        }
        if (message.targetingProperties !== undefined) {
            FeatureProvidedSignals.encode(message.targetingProperties, writer.uint32(18).fork()).ldelim();
        }
        if (message.ttlSeconds !== 0) {
            writer.uint32(24).int32(message.ttlSeconds);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePinTargetingPropertiesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.userId = reader.string();
                    break;
                case 2:
                    message.targetingProperties = FeatureProvidedSignals.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.ttlSeconds = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBasePinTargetingPropertiesRequest();
        message.userId = (_a = object.userId) !== null && _a !== void 0 ? _a : "";
        message.targetingProperties =
            object.targetingProperties !== undefined && object.targetingProperties !== null
                ? FeatureProvidedSignals.fromPartial(object.targetingProperties)
                : undefined;
        message.ttlSeconds = (_b = object.ttlSeconds) !== null && _b !== void 0 ? _b : 0;
        return message;
    },
};
function createBasePinTargetingPropertiesResponse() {
    return { message: "" };
}
export const PinTargetingPropertiesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.message !== "") {
            writer.uint32(10).string(message.message);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePinTargetingPropertiesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.message = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBasePinTargetingPropertiesResponse();
        message.message = (_a = object.message) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBaseUnpinTargetingPropertiesRequest() {
    return { userId: "" };
}
export const UnpinTargetingPropertiesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.userId !== "") {
            writer.uint32(10).string(message.userId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseUnpinTargetingPropertiesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.userId = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseUnpinTargetingPropertiesRequest();
        message.userId = (_a = object.userId) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBaseUnpinTargetingPropertiesResponse() {
    return { message: "" };
}
export const UnpinTargetingPropertiesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.message !== "") {
            writer.uint32(10).string(message.message);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseUnpinTargetingPropertiesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.message = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseUnpinTargetingPropertiesResponse();
        message.message = (_a = object.message) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBaseGetPinnedTargetingPropertiesRequest() {
    return { userId: "" };
}
export const GetPinnedTargetingPropertiesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.userId !== "") {
            writer.uint32(10).string(message.userId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetPinnedTargetingPropertiesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.userId = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetPinnedTargetingPropertiesRequest();
        message.userId = (_a = object.userId) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBaseGetPinnedTargetingPropertiesResponse() {
    return { targetingProperties: undefined };
}
export const GetPinnedTargetingPropertiesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.targetingProperties !== undefined) {
            FeatureProvidedSignals.encode(message.targetingProperties, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetPinnedTargetingPropertiesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.targetingProperties = FeatureProvidedSignals.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseGetPinnedTargetingPropertiesResponse();
        message.targetingProperties =
            object.targetingProperties !== undefined && object.targetingProperties !== null
                ? FeatureProvidedSignals.fromPartial(object.targetingProperties)
                : undefined;
        return message;
    },
};
function createBaseConfigWithNamespace() {
    return { configName: "", namespace: 0 };
}
export const ConfigWithNamespace = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.configName !== "") {
            writer.uint32(10).string(message.configName);
        }
        if (message.namespace !== 0) {
            writer.uint32(16).int32(message.namespace);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseConfigWithNamespace();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configName = reader.string();
                    break;
                case 2:
                    message.namespace = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseConfigWithNamespace();
        message.configName = (_a = object.configName) !== null && _a !== void 0 ? _a : "";
        message.namespace = (_b = object.namespace) !== null && _b !== void 0 ? _b : 0;
        return message;
    },
};
function createBaseGetConfigValuesByTokenRequest() {
    return { token: "", configNames: [], namespaces: [], disableExposureLogging: false, getAllConfigs: false };
}
export const GetConfigValuesByTokenRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.token !== "") {
            writer.uint32(10).string(message.token);
        }
        for (const v of message.configNames) {
            ConfigWithNamespace.encode(v, writer.uint32(18).fork()).ldelim();
        }
        writer.uint32(26).fork();
        for (const v of message.namespaces) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.disableExposureLogging === true) {
            writer.uint32(32).bool(message.disableExposureLogging);
        }
        if (message.getAllConfigs === true) {
            writer.uint32(40).bool(message.getAllConfigs);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetConfigValuesByTokenRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.token = reader.string();
                    break;
                case 2:
                    message.configNames.push(ConfigWithNamespace.decode(reader, reader.uint32()));
                    break;
                case 3:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.namespaces.push(reader.int32());
                        }
                    }
                    else {
                        message.namespaces.push(reader.int32());
                    }
                    break;
                case 4:
                    message.disableExposureLogging = reader.bool();
                    break;
                case 5:
                    message.getAllConfigs = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseGetConfigValuesByTokenRequest();
        message.token = (_a = object.token) !== null && _a !== void 0 ? _a : "";
        message.configNames = ((_b = object.configNames) === null || _b === void 0 ? void 0 : _b.map((e) => ConfigWithNamespace.fromPartial(e))) || [];
        message.namespaces = ((_c = object.namespaces) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
        message.disableExposureLogging = (_d = object.disableExposureLogging) !== null && _d !== void 0 ? _d : false;
        message.getAllConfigs = (_e = object.getAllConfigs) !== null && _e !== void 0 ? _e : false;
        return message;
    },
};
function createBaseGetConfigValuesByTokenResponse() {
    return { configResults: [] };
}
export const GetConfigValuesByTokenResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.configResults) {
            ConfigResult.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetConfigValuesByTokenResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configResults.push(ConfigResult.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetConfigValuesByTokenResponse();
        message.configResults = ((_a = object.configResults) === null || _a === void 0 ? void 0 : _a.map((e) => ConfigResult.fromPartial(e))) || [];
        return message;
    },
};
function createBaseGetCachedConfigResultSequenceIdsRequest() {
    return {};
}
export const GetCachedConfigResultSequenceIdsRequest = {
    encode(_, writer = _m0.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetCachedConfigResultSequenceIdsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseGetCachedConfigResultSequenceIdsRequest();
        return message;
    },
};
function createBaseGetCachedConfigResultSequenceIdsResponse() {
    return { serializedBitmap: new Uint8Array() };
}
export const GetCachedConfigResultSequenceIdsResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.serializedBitmap.length !== 0) {
            writer.uint32(10).bytes(message.serializedBitmap);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetCachedConfigResultSequenceIdsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.serializedBitmap = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetCachedConfigResultSequenceIdsResponse();
        message.serializedBitmap = (_a = object.serializedBitmap) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    },
};
function createBaseGetConfigResultsBySequenceIdsRequest() {
    return { sequenceIds: [] };
}
export const GetConfigResultsBySequenceIdsRequest = {
    encode(message, writer = _m0.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.sequenceIds) {
            writer.int32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetConfigResultsBySequenceIdsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.sequenceIds.push(reader.int32());
                        }
                    }
                    else {
                        message.sequenceIds.push(reader.int32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetConfigResultsBySequenceIdsRequest();
        message.sequenceIds = ((_a = object.sequenceIds) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
        return message;
    },
};
function createBaseConfigResultWithSequenceId() {
    return { sequenceId: 0, configResult: undefined };
}
export const ConfigResultWithSequenceId = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.sequenceId !== 0) {
            writer.uint32(8).int32(message.sequenceId);
        }
        if (message.configResult !== undefined) {
            ConfigResult.encode(message.configResult, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseConfigResultWithSequenceId();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sequenceId = reader.int32();
                    break;
                case 2:
                    message.configResult = ConfigResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseConfigResultWithSequenceId();
        message.sequenceId = (_a = object.sequenceId) !== null && _a !== void 0 ? _a : 0;
        message.configResult =
            object.configResult !== undefined && object.configResult !== null
                ? ConfigResult.fromPartial(object.configResult)
                : undefined;
        return message;
    },
};
function createBaseGetConfigResultsBySequenceIdsResponse() {
    return { configResultWithSequenceIds: [] };
}
export const GetConfigResultsBySequenceIdsResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.configResultWithSequenceIds) {
            ConfigResultWithSequenceId.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetConfigResultsBySequenceIdsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configResultWithSequenceIds.push(ConfigResultWithSequenceId.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetConfigResultsBySequenceIdsResponse();
        message.configResultWithSequenceIds =
            ((_a = object.configResultWithSequenceIds) === null || _a === void 0 ? void 0 : _a.map((e) => ConfigResultWithSequenceId.fromPartial(e))) || [];
        return message;
    },
};
function createBaseGetBitmapByTokenRequest() {
    return { token: "" };
}
export const GetBitmapByTokenRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.token !== "") {
            writer.uint32(10).string(message.token);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetBitmapByTokenRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.token = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetBitmapByTokenRequest();
        message.token = (_a = object.token) !== null && _a !== void 0 ? _a : "";
        return message;
    },
};
function createBaseGetBitmapByTokenResponse() {
    return { idBitmap: new Uint8Array() };
}
export const GetBitmapByTokenResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.idBitmap.length !== 0) {
            writer.uint32(10).bytes(message.idBitmap);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetBitmapByTokenResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.idBitmap = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetBitmapByTokenResponse();
        message.idBitmap = (_a = object.idBitmap) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    },
};
function createBaseGetUnevaluatedConfigResultsWithAbTargetingRequest() {
    return { namespaces: [], edgeConfigClientVersion: "" };
}
export const GetUnevaluatedConfigResultsWithAbTargetingRequest = {
    encode(message, writer = _m0.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.namespaces) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.edgeConfigClientVersion !== "") {
            writer.uint32(18).string(message.edgeConfigClientVersion);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetUnevaluatedConfigResultsWithAbTargetingRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.namespaces.push(reader.int32());
                        }
                    }
                    else {
                        message.namespaces.push(reader.int32());
                    }
                    break;
                case 2:
                    message.edgeConfigClientVersion = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseGetUnevaluatedConfigResultsWithAbTargetingRequest();
        message.namespaces = ((_a = object.namespaces) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
        message.edgeConfigClientVersion = (_b = object.edgeConfigClientVersion) !== null && _b !== void 0 ? _b : "";
        return message;
    },
};
function createBaseGetUnevaluatedConfigResultsWithAbTargetingResponse() {
    return { configResults: [] };
}
export const GetUnevaluatedConfigResultsWithAbTargetingResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.configResults) {
            ConfigResult.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGetUnevaluatedConfigResultsWithAbTargetingResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.configResults.push(ConfigResult.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetUnevaluatedConfigResultsWithAbTargetingResponse();
        message.configResults = ((_a = object.configResults) === null || _a === void 0 ? void 0 : _a.map((e) => ConfigResult.fromPartial(e))) || [];
        return message;
    },
};
function createBaseAddRuidsForDebuggingRequest() {
    return { ruids: [], configNames: [], maxSnapshots: 0 };
}
export const AddRuidsForDebuggingRequest = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.ruids) {
            Ruid.encode(v, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.configNames) {
            writer.uint32(18).string(v);
        }
        if (message.maxSnapshots !== 0) {
            writer.uint32(24).int32(message.maxSnapshots);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseAddRuidsForDebuggingRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ruids.push(Ruid.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.configNames.push(reader.string());
                    break;
                case 3:
                    message.maxSnapshots = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseAddRuidsForDebuggingRequest();
        message.ruids = ((_a = object.ruids) === null || _a === void 0 ? void 0 : _a.map((e) => Ruid.fromPartial(e))) || [];
        message.configNames = ((_b = object.configNames) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
        message.maxSnapshots = (_c = object.maxSnapshots) !== null && _c !== void 0 ? _c : 0;
        return message;
    },
};
function createBaseAddRuidsForDebuggingResponse() {
    return {};
}
export const AddRuidsForDebuggingResponse = {
    encode(_, writer = _m0.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseAddRuidsForDebuggingResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseAddRuidsForDebuggingResponse();
        return message;
    },
};
export class CircumstancesServiceClientImpl {
    constructor(rpc) {
        this.rpc = rpc;
        this.targetingQuery = this.targetingQuery.bind(this);
        this.getAbConfigValues = this.getAbConfigValues.bind(this);
        this.getConfigValuesByToken = this.getConfigValuesByToken.bind(this);
        this.getConfigResultsBySequenceIds = this.getConfigResultsBySequenceIds.bind(this);
        this.getCachedConfigResultSequenceIds = this.getCachedConfigResultSequenceIds.bind(this);
        this.getBitmapByToken = this.getBitmapByToken.bind(this);
        this.generateConfigSet = this.generateConfigSet.bind(this);
        this.pinConfigSet = this.pinConfigSet.bind(this);
        this.unpinConfigSet = this.unpinConfigSet.bind(this);
        this.getUnevaluatedConfigResultsWithAbTargeting = this.getUnevaluatedConfigResultsWithAbTargeting.bind(this);
        this.addRuidsForDebugging = this.addRuidsForDebugging.bind(this);
        this.pinTargetingProperties = this.pinTargetingProperties.bind(this);
        this.unpinTargetingProperties = this.unpinTargetingProperties.bind(this);
        this.getPinnedTargetingProperties = this.getPinnedTargetingProperties.bind(this);
    }
    targetingQuery(request, metadata) {
        return this.rpc.unary(CircumstancesServicetargetingQueryDesc, ConfigTargetingRequest.fromPartial(request), metadata);
    }
    getAbConfigValues(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetAbConfigValuesDesc, GetAbConfigValuesRequest.fromPartial(request), metadata);
    }
    getConfigValuesByToken(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetConfigValuesByTokenDesc, GetConfigValuesByTokenRequest.fromPartial(request), metadata);
    }
    getConfigResultsBySequenceIds(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetConfigResultsBySequenceIdsDesc, GetConfigResultsBySequenceIdsRequest.fromPartial(request), metadata);
    }
    getCachedConfigResultSequenceIds(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetCachedConfigResultSequenceIdsDesc, GetCachedConfigResultSequenceIdsRequest.fromPartial(request), metadata);
    }
    getBitmapByToken(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetBitmapByTokenDesc, GetBitmapByTokenRequest.fromPartial(request), metadata);
    }
    generateConfigSet(request, metadata) {
        return this.rpc.unary(CircumstancesServicegenerateConfigSetDesc, ConfigSetGenerationRequest.fromPartial(request), metadata);
    }
    pinConfigSet(request, metadata) {
        return this.rpc.unary(CircumstancesServicepinConfigSetDesc, PinConfigRequest.fromPartial(request), metadata);
    }
    unpinConfigSet(request, metadata) {
        return this.rpc.unary(CircumstancesServiceunpinConfigSetDesc, UnpinConfigRequest.fromPartial(request), metadata);
    }
    getUnevaluatedConfigResultsWithAbTargeting(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetUnevaluatedConfigResultsWithAbTargetingDesc, GetUnevaluatedConfigResultsWithAbTargetingRequest.fromPartial(request), metadata);
    }
    addRuidsForDebugging(request, metadata) {
        return this.rpc.unary(CircumstancesServiceaddRuidsForDebuggingDesc, AddRuidsForDebuggingRequest.fromPartial(request), metadata);
    }
    pinTargetingProperties(request, metadata) {
        return this.rpc.unary(CircumstancesServicepinTargetingPropertiesDesc, PinTargetingPropertiesRequest.fromPartial(request), metadata);
    }
    unpinTargetingProperties(request, metadata) {
        return this.rpc.unary(CircumstancesServiceunpinTargetingPropertiesDesc, UnpinTargetingPropertiesRequest.fromPartial(request), metadata);
    }
    getPinnedTargetingProperties(request, metadata) {
        return this.rpc.unary(CircumstancesServicegetPinnedTargetingPropertiesDesc, GetPinnedTargetingPropertiesRequest.fromPartial(request), metadata);
    }
}
export const CircumstancesServiceDesc = {
    serviceName: "snapchat.cdp.cof.CircumstancesService",
};
export const CircumstancesServicetargetingQueryDesc = {
    methodName: "targetingQuery",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return ConfigTargetingRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, ConfigTargetingResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetAbConfigValuesDesc = {
    methodName: "getAbConfigValues",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetAbConfigValuesRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetAbConfigValuesResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetConfigValuesByTokenDesc = {
    methodName: "getConfigValuesByToken",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetConfigValuesByTokenRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetConfigValuesByTokenResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetConfigResultsBySequenceIdsDesc = {
    methodName: "getConfigResultsBySequenceIds",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetConfigResultsBySequenceIdsRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetConfigResultsBySequenceIdsResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetCachedConfigResultSequenceIdsDesc = {
    methodName: "getCachedConfigResultSequenceIds",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetCachedConfigResultSequenceIdsRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetCachedConfigResultSequenceIdsResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetBitmapByTokenDesc = {
    methodName: "getBitmapByToken",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetBitmapByTokenRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetBitmapByTokenResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegenerateConfigSetDesc = {
    methodName: "generateConfigSet",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return ConfigSetGenerationRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, ConfigSetGenerationResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicepinConfigSetDesc = {
    methodName: "pinConfigSet",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return PinConfigRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, PinConfigResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServiceunpinConfigSetDesc = {
    methodName: "unpinConfigSet",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return UnpinConfigRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, UnpinConfigResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetUnevaluatedConfigResultsWithAbTargetingDesc = {
    methodName: "getUnevaluatedConfigResultsWithAbTargeting",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetUnevaluatedConfigResultsWithAbTargetingRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetUnevaluatedConfigResultsWithAbTargetingResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServiceaddRuidsForDebuggingDesc = {
    methodName: "addRuidsForDebugging",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return AddRuidsForDebuggingRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, AddRuidsForDebuggingResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicepinTargetingPropertiesDesc = {
    methodName: "pinTargetingProperties",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return PinTargetingPropertiesRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, PinTargetingPropertiesResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServiceunpinTargetingPropertiesDesc = {
    methodName: "unpinTargetingProperties",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return UnpinTargetingPropertiesRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, UnpinTargetingPropertiesResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export const CircumstancesServicegetPinnedTargetingPropertiesDesc = {
    methodName: "getPinnedTargetingProperties",
    service: CircumstancesServiceDesc,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return GetPinnedTargetingPropertiesRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            return Object.assign(Object.assign({}, GetPinnedTargetingPropertiesResponse.decode(data)), { toObject() {
                    return this;
                } });
        },
    },
};
export class GrpcWebImpl {
    constructor(host, options) {
        this.host = host;
        this.options = options;
    }
    unary(methodDesc, _request, metadata) {
        var _a;
        const request = Object.assign(Object.assign({}, _request), methodDesc.requestType);
        const maybeCombinedMetadata = metadata && this.options.metadata
            ? new BrowserHeaders(Object.assign(Object.assign({}, (_a = this.options) === null || _a === void 0 ? void 0 : _a.metadata.headersMap), metadata === null || metadata === void 0 ? void 0 : metadata.headersMap))
            : metadata || this.options.metadata;
        return new Promise((resolve, reject) => {
            grpc.unary(methodDesc, {
                request,
                host: this.host,
                metadata: maybeCombinedMetadata,
                transport: this.options.transport,
                debug: this.options.debug,
                onEnd: function (response) {
                    if (response.status === grpc.Code.OK) {
                        resolve(response.message);
                    }
                    else {
                        const err = new Error(response.statusMessage);
                        err.code = response.status;
                        err.metadata = response.trailers;
                        reject(err);
                    }
                },
            });
        });
    }
}
if (_m0.util.Long !== Long) {
    _m0.util.Long = Long;
    _m0.configure();
}
//# sourceMappingURL=circumstance_service.js.map