@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/esm/private/binary-format.js

@@ -1,426 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { BinaryReader, BinaryWriter, WireType } from "../binary-encoding.js";
-import { Message } from "../message.js";
-import { wrapField } from "./field-wrapper.js";
-import { scalarZeroValue } from "./scalars.js";
-import { assert } from "./assert.js";
-import { isFieldSet } from "./reflect.js";
-import { LongType, ScalarType } from "../scalar.js";
-import { isMessage } from "../is-message.js";
-/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return */
-const unknownFieldsSymbol = Symbol("@bufbuild/protobuf/unknown-fields");
-// Default options for parsing binary data.
-const readDefaults = {
-    readUnknownFields: true,
-    readerFactory: (bytes) => new BinaryReader(bytes),
-};
-// Default options for serializing binary data.
-const writeDefaults = {
-    writeUnknownFields: true,
-    writerFactory: () => new BinaryWriter(),
-};
-function makeReadOptions(options) {
-    return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults;
-}
-function makeWriteOptions(options) {
-    return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
-}
-export function makeBinaryFormat() {
-    return {
-        makeReadOptions,
-        makeWriteOptions,
-        listUnknownFields(message) {
-            var _a;
-            return (_a = message[unknownFieldsSymbol]) !== null && _a !== void 0 ? _a : [];
-        },
-        discardUnknownFields(message) {
-            delete message[unknownFieldsSymbol];
-        },
-        writeUnknownFields(message, writer) {
-            const m = message;
-            const c = m[unknownFieldsSymbol];
-            if (c) {
-                for (const f of c) {
-                    writer.tag(f.no, f.wireType).raw(f.data);
-                }
-            }
-        },
-        onUnknownField(message, no, wireType, data) {
-            const m = message;
-            if (!Array.isArray(m[unknownFieldsSymbol])) {
-                m[unknownFieldsSymbol] = [];
-            }
-            m[unknownFieldsSymbol].push({ no, wireType, data });
-        },
-        readMessage(message, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
-            const type = message.getType();
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-            const end = delimitedMessageEncoding
-                ? reader.len
-                : reader.pos + lengthOrEndTagFieldNo;
-            let fieldNo, wireType;
-            while (reader.pos < end) {
-                [fieldNo, wireType] = reader.tag();
-                if (wireType == WireType.EndGroup) {
-                    break;
-                }
-                const field = type.fields.find(fieldNo);
-                if (!field) {
-                    const data = reader.skip(wireType);
-                    if (options.readUnknownFields) {
-                        this.onUnknownField(message, fieldNo, wireType, data);
-                    }
-                    continue;
-                }
-                readField(message, reader, field, wireType, options);
-            }
-            if (delimitedMessageEncoding && // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-                (wireType != WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo)) {
-                throw new Error(`invalid end group tag`);
-            }
-        },
-        readField,
-        writeMessage(message, writer, options) {
-            const type = message.getType();
-            for (const field of type.fields.byNumber()) {
-                if (!isFieldSet(field, message)) {
-                    if (field.req) {
-                        throw new Error(`cannot encode field ${type.typeName}.${field.name} to binary: required field not set`);
-                    }
-                    continue;
-                }
-                const value = field.oneof
-                    ? message[field.oneof.localName].value
-                    : message[field.localName];
-                writeField(field, value, writer, options);
-            }
-            if (options.writeUnknownFields) {
-                this.writeUnknownFields(message, writer);
-            }
-            return writer;
-        },
-        writeField(field, value, writer, options) {
-            // The behavior of our internal function has changed, it does no longer
-            // accept `undefined` values for singular scalar and map.
-            // For backwards-compatibility, we support the old form that is part of
-            // the public API through the interface BinaryFormat.
-            if (value === undefined) {
-                return undefined;
-            }
-            writeField(field, value, writer, options);
-        },
-    };
-}
-function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
-reader, field, wireType, options) {
-    let { repeated, localName } = field;
-    if (field.oneof) {
-        target = target[field.oneof.localName];
-        if (target.case != localName) {
-            delete target.value;
-        }
-        target.case = localName;
-        localName = "value";
-    }
-    switch (field.kind) {
-        case "scalar":
-        case "enum":
-            const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
-            let read = readScalar;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
-            if (field.kind == "scalar" && field.L > 0) {
-                read = readScalarLTString;
-            }
-            if (repeated) {
-                let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
-                const isPacked = wireType == WireType.LengthDelimited &&
-                    scalarType != ScalarType.STRING &&
-                    scalarType != ScalarType.BYTES;
-                if (isPacked) {
-                    let e = reader.uint32() + reader.pos;
-                    while (reader.pos < e) {
-                        arr.push(read(reader, scalarType));
-                    }
-                }
-                else {
-                    arr.push(read(reader, scalarType));
-                }
-            }
-            else {
-                target[localName] = read(reader, scalarType);
-            }
-            break;
-        case "message":
-            const messageType = field.T;
-            if (repeated) {
-                // safe to assume presence of array, oneof cannot contain repeated values
-                target[localName].push(readMessageField(reader, new messageType(), options, field));
-            }
-            else {
-                if (isMessage(target[localName])) {
-                    readMessageField(reader, target[localName], options, field);
-                }
-                else {
-                    target[localName] = readMessageField(reader, new messageType(), options, field);
-                    if (messageType.fieldWrapper && !field.oneof && !field.repeated) {
-                        target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
-                    }
-                }
-            }
-            break;
-        case "map":
-            let [mapKey, mapVal] = readMapEntry(field, reader, options);
-            // safe to assume presence of map object, oneof cannot contain repeated values
-            target[localName][mapKey] = mapVal;
-            break;
-    }
-}
-// Read a message, avoiding MessageType.fromBinary() to re-use the
-// BinaryReadOptions and the IBinaryReader.
-function readMessageField(reader, message, options, field) {
-    const format = message.getType().runtime.bin;
-    const delimited = field === null || field === void 0 ? void 0 : field.delimited;
-    format.readMessage(message, reader, delimited ? field.no : reader.uint32(), // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-    options, delimited);
-    return message;
-}
-// Read a map field, expecting key field = 1, value field = 2
-function readMapEntry(field, reader, options) {
-    const length = reader.uint32(), end = reader.pos + length;
-    let key, val;
-    while (reader.pos < end) {
-        const [fieldNo] = reader.tag();
-        switch (fieldNo) {
-            case 1:
-                key = readScalar(reader, field.K);
-                break;
-            case 2:
-                switch (field.V.kind) {
-                    case "scalar":
-                        val = readScalar(reader, field.V.T);
-                        break;
-                    case "enum":
-                        val = reader.int32();
-                        break;
-                    case "message":
-                        val = readMessageField(reader, new field.V.T(), options, undefined);
-                        break;
-                }
-                break;
-        }
-    }
-    if (key === undefined) {
-        key = scalarZeroValue(field.K, LongType.BIGINT);
-    }
-    if (typeof key != "string" && typeof key != "number") {
-        key = key.toString();
-    }
-    if (val === undefined) {
-        switch (field.V.kind) {
-            case "scalar":
-                val = scalarZeroValue(field.V.T, LongType.BIGINT);
-                break;
-            case "enum":
-                val = field.V.T.values[0].no;
-                break;
-            case "message":
-                val = new field.V.T();
-                break;
-        }
-    }
-    return [key, val];
-}
-// Read a scalar value, but return 64 bit integral types (int64, uint64,
-// sint64, fixed64, sfixed64) as string instead of bigint.
-function readScalarLTString(reader, type) {
-    const v = readScalar(reader, type);
-    return typeof v == "bigint" ? v.toString() : v;
-}
-// Does not use scalarTypeInfo() for better performance.
-function readScalar(reader, type) {
-    switch (type) {
-        case ScalarType.STRING:
-            return reader.string();
-        case ScalarType.BOOL:
-            return reader.bool();
-        case ScalarType.DOUBLE:
-            return reader.double();
-        case ScalarType.FLOAT:
-            return reader.float();
-        case ScalarType.INT32:
-            return reader.int32();
-        case ScalarType.INT64:
-            return reader.int64();
-        case ScalarType.UINT64:
-            return reader.uint64();
-        case ScalarType.FIXED64:
-            return reader.fixed64();
-        case ScalarType.BYTES:
-            return reader.bytes();
-        case ScalarType.FIXED32:
-            return reader.fixed32();
-        case ScalarType.SFIXED32:
-            return reader.sfixed32();
-        case ScalarType.SFIXED64:
-            return reader.sfixed64();
-        case ScalarType.SINT64:
-            return reader.sint64();
-        case ScalarType.UINT32:
-            return reader.uint32();
-        case ScalarType.SINT32:
-            return reader.sint32();
-    }
-}
-function writeField(field, value, writer, options) {
-    assert(value !== undefined);
-    const repeated = field.repeated;
-    switch (field.kind) {
-        case "scalar":
-        case "enum":
-            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
-            if (repeated) {
-                assert(Array.isArray(value));
-                if (field.packed) {
-                    writePacked(writer, scalarType, field.no, value);
-                }
-                else {
-                    for (const item of value) {
-                        writeScalar(writer, scalarType, field.no, item);
-                    }
-                }
-            }
-            else {
-                writeScalar(writer, scalarType, field.no, value);
-            }
-            break;
-        case "message":
-            if (repeated) {
-                assert(Array.isArray(value));
-                for (const item of value) {
-                    writeMessageField(writer, options, field, item);
-                }
-            }
-            else {
-                writeMessageField(writer, options, field, value);
-            }
-            break;
-        case "map":
-            assert(typeof value == "object" && value != null);
-            for (const [key, val] of Object.entries(value)) {
-                writeMapEntry(writer, options, field, key, val);
-            }
-            break;
-    }
-}
-export function writeMapEntry(writer, options, field, key, value) {
-    writer.tag(field.no, WireType.LengthDelimited);
-    writer.fork();
-    // javascript only allows number or string for object properties
-    // we convert from our representation to the protobuf type
-    let keyValue = key;
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- we deliberately handle just the special cases for map keys
-    switch (field.K) {
-        case ScalarType.INT32:
-        case ScalarType.FIXED32:
-        case ScalarType.UINT32:
-        case ScalarType.SFIXED32:
-        case ScalarType.SINT32:
-            keyValue = Number.parseInt(key);
-            break;
-        case ScalarType.BOOL:
-            assert(key == "true" || key == "false");
-            keyValue = key == "true";
-            break;
-    }
-    // write key, expecting key field number = 1
-    writeScalar(writer, field.K, 1, keyValue);
-    // write value, expecting value field number = 2
-    switch (field.V.kind) {
-        case "scalar":
-            writeScalar(writer, field.V.T, 2, value);
-            break;
-        case "enum":
-            writeScalar(writer, ScalarType.INT32, 2, value);
-            break;
-        case "message":
-            assert(value !== undefined);
-            writer.tag(2, WireType.LengthDelimited).bytes(value.toBinary(options));
-            break;
-    }
-    writer.join();
-}
-// Value must not be undefined
-function writeMessageField(writer, options, field, value) {
-    const message = wrapField(field.T, value);
-    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-    if (field.delimited)
-        writer
-            .tag(field.no, WireType.StartGroup)
-            .raw(message.toBinary(options))
-            .tag(field.no, WireType.EndGroup);
-    else
-        writer
-            .tag(field.no, WireType.LengthDelimited)
-            .bytes(message.toBinary(options));
-}
-function writeScalar(writer, type, fieldNo, value) {
-    assert(value !== undefined);
-    let [wireType, method] = scalarTypeInfo(type);
-    writer.tag(fieldNo, wireType)[method](value);
-}
-function writePacked(writer, type, fieldNo, value) {
-    if (!value.length) {
-        return;
-    }
-    writer.tag(fieldNo, WireType.LengthDelimited).fork();
-    let [, method] = scalarTypeInfo(type);
-    for (let i = 0; i < value.length; i++) {
-        writer[method](value[i]);
-    }
-    writer.join();
-}
-/**
- * Get information for writing a scalar value.
- *
- * Returns tuple:
- * [0]: appropriate WireType
- * [1]: name of the appropriate method of IBinaryWriter
- * [2]: whether the given value is a default value for proto3 semantics
- *
- * If argument `value` is omitted, [2] is always false.
- */
-// TODO replace call-sites writeScalar() and writePacked(), then remove
-function scalarTypeInfo(type) {
-    let wireType = WireType.Varint;
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
-    switch (type) {
-        case ScalarType.BYTES:
-        case ScalarType.STRING:
-            wireType = WireType.LengthDelimited;
-            break;
-        case ScalarType.DOUBLE:
-        case ScalarType.FIXED64:
-        case ScalarType.SFIXED64:
-            wireType = WireType.Bit64;
-            break;
-        case ScalarType.FIXED32:
-        case ScalarType.SFIXED32:
-        case ScalarType.FLOAT:
-            wireType = WireType.Bit32;
-            break;
-    }
-    const method = ScalarType[type].toLowerCase();
-    return [wireType, method];
-}

package/dist/esm/private/enum.d.ts

@@ -1,27 +0,0 @@
-import type { EnumType, EnumValueInfo } from "../enum.js";
-/**
- * Represents a generated enum.
- */
-export interface EnumObject {
-    [key: number]: string;
-    [k: string]: number | string;
-}
-/**
- * Get reflection information from a generated enum.
- * If this function is called on something other than a generated
- * enum, it raises an error.
- */
-export declare function getEnumType(enumObject: EnumObject): EnumType;
-/**
- * Sets reflection information on a generated enum.
- */
-export declare function setEnumType(enumObject: EnumObject, typeName: string, values: Omit<EnumValueInfo, "localName">[], opt?: {}): void;
-/**
- * Create a new EnumType with the given values.
- */
-export declare function makeEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], _opt?: {}): EnumType;
-/**
- * Create a new enum object with the given values.
- * Sets reflection information.
- */
-export declare function makeEnum(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumObject;

package/dist/esm/private/enum.js

@@ -1,87 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { assert } from "./assert.js";
-const enumTypeSymbol = Symbol("@bufbuild/protobuf/enum-type");
-/**
- * Get reflection information from a generated enum.
- * If this function is called on something other than a generated
- * enum, it raises an error.
- */
-export function getEnumType(enumObject) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-explicit-any
-    const t = enumObject[enumTypeSymbol];
-    assert(t, "missing enum type on enum object");
-    return t; // eslint-disable-line @typescript-eslint/no-unsafe-return
-}
-/**
- * Sets reflection information on a generated enum.
- */
-export function setEnumType(enumObject, typeName, values, opt) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    enumObject[enumTypeSymbol] = makeEnumType(typeName, values.map((v) => ({
-        no: v.no,
-        name: v.name,
-        localName: enumObject[v.no],
-    })), opt);
-}
-/**
- * Create a new EnumType with the given values.
- */
-export function makeEnumType(typeName, values, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_opt) {
-    const names = Object.create(null);
-    const numbers = Object.create(null);
-    const normalValues = [];
-    for (const value of values) {
-        // We do not surface options at this time
-        // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
-        const n = normalizeEnumValue(value);
-        normalValues.push(n);
-        names[value.name] = n;
-        numbers[value.no] = n;
-    }
-    return {
-        typeName,
-        values: normalValues,
-        // We do not surface options at this time
-        // options: opt?.options ?? Object.create(null),
-        findName(name) {
-            return names[name];
-        },
-        findNumber(no) {
-            return numbers[no];
-        },
-    };
-}
-/**
- * Create a new enum object with the given values.
- * Sets reflection information.
- */
-export function makeEnum(typeName, values, opt) {
-    const enumObject = {};
-    for (const value of values) {
-        const n = normalizeEnumValue(value);
-        enumObject[n.localName] = n.no;
-        enumObject[n.no] = n.localName;
-    }
-    setEnumType(enumObject, typeName, values, opt);
-    return enumObject;
-}
-function normalizeEnumValue(value) {
-    if ("localName" in value) {
-        return value;
-    }
-    return Object.assign(Object.assign({}, value), { localName: value.name });
-}

package/dist/esm/private/extensions.d.ts

@@ -1,34 +0,0 @@
-import type { Extension } from "../extension.js";
-import type { AnyMessage, Message } from "../message.js";
-import type { FieldInfo, OneofInfo, PartialFieldInfo } from "../field.js";
-import { WireType } from "../binary-encoding.js";
-import type { ProtoRuntime } from "./proto-runtime.js";
-import type { MessageType } from "../message-type.js";
-export type ExtensionFieldSource = extensionFieldRules<FieldInfo> | extensionFieldRules<PartialFieldInfo> | (() => extensionFieldRules<FieldInfo>) | (() => extensionFieldRules<PartialFieldInfo>);
-type extensionFieldRules<T extends FieldInfo | PartialFieldInfo> = T extends {
-    kind: "map";
-} ? never : T extends {
-    oneof: string;
-} ? never : T extends {
-    oneof: OneofInfo;
-} ? never : Omit<T, "name"> & Partial<Pick<T, "name">>;
-/**
- * Create a new extension using the given runtime.
- */
-export declare function makeExtension<E extends Message<E> = AnyMessage, V = unknown>(runtime: ProtoRuntime, typeName: string, extendee: MessageType<E>, field: ExtensionFieldSource): Extension<E, V>;
-/**
- * Create a container that allows us to read extension fields into it with the
- * same logic as regular fields.
- */
-export declare function createExtensionContainer<E extends Message<E> = AnyMessage, V = unknown>(extension: Extension<E, V>): [Record<string, V>, () => V];
-type UnknownField = {
-    no: number;
-    wireType: WireType;
-    data: Uint8Array;
-};
-type UnknownFields = ReadonlyArray<UnknownField>;
-/**
- * Helper to filter unknown fields, optimized based on field type.
- */
-export declare function filterUnknownFields(unknownFields: UnknownFields, field: Pick<FieldInfo, "no" | "kind" | "repeated">): UnknownField[];
-export {};

package/dist/esm/private/extensions.js

@@ -1,81 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { scalarZeroValue } from "./scalars.js";
-import { WireType } from "../binary-encoding.js";
-/**
- * Create a new extension using the given runtime.
- */
-export function makeExtension(runtime, typeName, extendee, field) {
-    let fi;
-    return {
-        typeName,
-        extendee,
-        get field() {
-            if (!fi) {
-                const i = (typeof field == "function" ? field() : field);
-                i.name = typeName.split(".").pop();
-                i.jsonName = `[${typeName}]`;
-                fi = runtime.util.newFieldList([i]).list()[0];
-            }
-            return fi;
-        },
-        runtime,
-    };
-}
-/**
- * Create a container that allows us to read extension fields into it with the
- * same logic as regular fields.
- */
-export function createExtensionContainer(extension) {
-    const localName = extension.field.localName;
-    const container = Object.create(null);
-    container[localName] = initExtensionField(extension);
-    return [container, () => container[localName]];
-}
-function initExtensionField(ext) {
-    const field = ext.field;
-    if (field.repeated) {
-        return [];
-    }
-    if (field.default !== undefined) {
-        return field.default;
-    }
-    switch (field.kind) {
-        case "enum":
-            return field.T.values[0].no;
-        case "scalar":
-            return scalarZeroValue(field.T, field.L);
-        case "message":
-            // eslint-disable-next-line no-case-declarations
-            const T = field.T, value = new T();
-            return T.fieldWrapper ? T.fieldWrapper.unwrapField(value) : value;
-        case "map":
-            throw "map fields are not allowed to be extensions";
-    }
-}
-/**
- * Helper to filter unknown fields, optimized based on field type.
- */
-export function filterUnknownFields(unknownFields, field) {
-    if (!field.repeated && (field.kind == "enum" || field.kind == "scalar")) {
-        // singular scalar fields do not merge, we pick the last
-        for (let i = unknownFields.length - 1; i >= 0; --i) {
-            if (unknownFields[i].no == field.no) {
-                return [unknownFields[i]];
-            }
-        }
-        return [];
-    }
-    return unknownFields.filter((uf) => uf.no === field.no);
-}

package/dist/esm/private/feature-set.d.ts

@@ -1,19 +0,0 @@
-import { Edition, FeatureSet, FeatureSetDefaults } from "../google/protobuf/descriptor_pb.js";
-import type { BinaryReadOptions, BinaryWriteOptions } from "../binary-format.js";
-/**
- * A merged google.protobuf.FeaturesSet, with all fields guaranteed to be set.
- */
-export type MergedFeatureSet = FeatureSet & Required<FeatureSet>;
-/**
- * A function that resolves features.
- *
- * If no feature set is provided, the default feature set for the edition is
- * returned. If features are provided, they are merged into the edition default
- * features.
- */
-export type FeatureResolverFn = (a?: FeatureSet, b?: FeatureSet) => MergedFeatureSet;
-/**
- * Create an edition feature resolver with the given feature set defaults, or
- * the feature set defaults supported by @bufbuild/protobuf.
- */
-export declare function createFeatureResolver(edition: Edition, compiledFeatureSetDefaults?: FeatureSetDefaults, serializationOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>): FeatureResolverFn;