@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/esm/to-binary.js

@@ -0,0 +1,189 @@
+// 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 { reflect } from "./reflect/reflect.js";
+import { BinaryWriter, WireType } from "./wire/binary-encoding.js";
+import { ScalarType } from "./reflect/scalar.js";
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
+const LEGACY_REQUIRED = 3;
+// Default options for serializing binary data.
+const writeDefaults = {
+    writeUnknownFields: true,
+};
+function makeWriteOptions(options) {
+    return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
+}
+export function toBinary(messageDesc, message, options) {
+    return writeFields(new BinaryWriter(), makeWriteOptions(options), reflect(messageDesc, message)).finish();
+}
+function writeFields(writer, opts, msg) {
+    var _a;
+    for (const f of msg.sortedFields) {
+        if (!msg.isSet(f)) {
+            if (f.fieldKind != "map" &&
+                f.fieldKind != "list" &&
+                f.presence == LEGACY_REQUIRED) {
+                throw new Error(`cannot encode field ${msg.desc.typeName}.${f.name} to binary: required field not set`);
+            }
+            continue;
+        }
+        writeField(writer, opts, msg, f);
+    }
+    if (opts.writeUnknownFields) {
+        for (const { no, wireType, data } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
+            writer.tag(no, wireType).raw(data);
+        }
+    }
+    return writer;
+}
+/**
+ * @private
+ */
+export function writeField(writer, opts, msg, field) {
+    var _a;
+    switch (field.fieldKind) {
+        case "scalar":
+        case "enum":
+            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, field.number, msg.get(field));
+            break;
+        case "list":
+            writeListField(writer, opts, field, msg.get(field));
+            break;
+        case "message":
+            writeMessageField(writer, opts, field, msg.get(field));
+            break;
+        case "map":
+            for (const [key, val] of msg.get(field)) {
+                writeMapEntry(writer, opts, field, key, val);
+            }
+            break;
+    }
+}
+function writeScalar(writer, scalarType, fieldNo, value) {
+    writeScalarValue(writer.tag(fieldNo, writeTypeOfScalar(scalarType)), scalarType, value);
+}
+function writeMessageField(writer, opts, field, message) {
+    if (field.delimitedEncoding) {
+        writeFields(writer.tag(field.number, WireType.StartGroup), opts, message).tag(field.number, WireType.EndGroup);
+    }
+    else {
+        writeFields(writer.tag(field.number, WireType.LengthDelimited).fork(), opts, message).join();
+    }
+}
+function writeListField(writer, opts, field, list) {
+    var _a;
+    if (field.listKind == "message") {
+        for (const item of list) {
+            writeMessageField(writer, opts, field, item);
+        }
+        return;
+    }
+    const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32;
+    if (field.packed) {
+        if (!list.size) {
+            return;
+        }
+        writer.tag(field.number, WireType.LengthDelimited).fork();
+        for (const item of list) {
+            writeScalarValue(writer, scalarType, item);
+        }
+        writer.join();
+        return;
+    }
+    for (const item of list) {
+        writeScalar(writer, scalarType, field.number, item);
+    }
+}
+function writeMapEntry(writer, opts, field, key, value) {
+    var _a;
+    writer.tag(field.number, WireType.LengthDelimited).fork();
+    // write key, expecting key field number = 1
+    writeScalar(writer, field.mapKey, 1, key);
+    // write value, expecting value field number = 2
+    switch (field.mapKind) {
+        case "scalar":
+        case "enum":
+            writeScalar(writer, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, 2, value);
+            break;
+        case "message":
+            writeFields(writer.tag(2, WireType.LengthDelimited).fork(), opts, value).join();
+            break;
+    }
+    writer.join();
+}
+function writeScalarValue(writer, type, value) {
+    switch (type) {
+        case ScalarType.STRING:
+            writer.string(value);
+            break;
+        case ScalarType.BOOL:
+            writer.bool(value);
+            break;
+        case ScalarType.DOUBLE:
+            writer.double(value);
+            break;
+        case ScalarType.FLOAT:
+            writer.float(value);
+            break;
+        case ScalarType.INT32:
+            writer.int32(value);
+            break;
+        case ScalarType.INT64:
+            writer.int64(value);
+            break;
+        case ScalarType.UINT64:
+            writer.uint64(value);
+            break;
+        case ScalarType.FIXED64:
+            writer.fixed64(value);
+            break;
+        case ScalarType.BYTES:
+            writer.bytes(value);
+            break;
+        case ScalarType.FIXED32:
+            writer.fixed32(value);
+            break;
+        case ScalarType.SFIXED32:
+            writer.sfixed32(value);
+            break;
+        case ScalarType.SFIXED64:
+            writer.sfixed64(value);
+            break;
+        case ScalarType.SINT64:
+            writer.sint64(value);
+            break;
+        case ScalarType.UINT32:
+            writer.uint32(value);
+            break;
+        case ScalarType.SINT32:
+            writer.sint32(value);
+            break;
+    }
+}
+function writeTypeOfScalar(type) {
+    switch (type) {
+        case ScalarType.BYTES:
+        case ScalarType.STRING:
+            return WireType.LengthDelimited;
+        case ScalarType.DOUBLE:
+        case ScalarType.FIXED64:
+        case ScalarType.SFIXED64:
+            return WireType.Bit64;
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+        case ScalarType.FLOAT:
+            return WireType.Bit32;
+        default:
+            return WireType.Varint;
+    }
+}

package/dist/esm/to-json.d.ts

@@ -0,0 +1,50 @@
+import type { DescMessage } from "./desc-types.js";
+import type { JsonValue } from "./json-value.js";
+import type { Registry } from "./reflect/registry.js";
+import type { MessageShape } from "./types.js";
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteOptions {
+    /**
+     * Emit fields with default values: Fields with default values are omitted
+     * by default in proto3 JSON output. This option overrides this behavior
+     * and outputs fields with their default values.
+     */
+    emitDefaultValues: boolean;
+    /**
+     * Emit enum values as integers instead of strings: The name of an enum
+     * value is used by default in JSON output. An option may be provided to
+     * use the numeric value of the enum value instead.
+     */
+    enumAsInteger: boolean;
+    /**
+     * Use proto field name instead of lowerCamelCase name: By default proto3
+     * JSON printer should convert the field name to lowerCamelCase and use
+     * that as the JSON name. An implementation may provide an option to use
+     * proto field name as the JSON name instead. Proto3 JSON parsers are
+     * required to accept both the converted lowerCamelCase name and the proto
+     * field name.
+     */
+    useProtoFieldName: boolean;
+    /**
+     * This option is required to write `google.protobuf.Any` and extensions
+     * to JSON format.
+     */
+    registry?: Registry;
+}
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteStringOptions extends JsonWriteOptions {
+    prettySpaces: number;
+}
+/**
+ * Serialize the message to a JSON value, a JavaScript value that can be
+ * passed to JSON.stringify().
+ */
+export declare function toJson<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: Partial<JsonWriteOptions>): JsonValue;
+/**
+ * Serialize the message to a JSON string.
+ */
+export declare function toJsonString<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: Partial<JsonWriteStringOptions>): string;

package/dist/esm/to-json.js

@@ -0,0 +1,379 @@
+// 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 "./reflect/assert.js";
+import { protoCamelCase } from "./reflect/names.js";
+import { reflect } from "./reflect/reflect.js";
+import { ScalarType } from "./reflect/scalar.js";
+import { anyUnpack } from "./wkt/index.js";
+import { isWrapperDesc } from "./wkt/wrappers.js";
+import { base64Encode } from "./wire/index.js";
+import { createExtensionContainer, getExtension } from "./extensions.js";
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number;
+const LEGACY_REQUIRED = 3;
+// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_OPTIONAL: const $name: FieldDescriptorProto_Label.$localName = $number;
+const LABEL_OPTIONAL = 1;
+// Default options for serializing to JSON.
+const jsonWriteDefaults = {
+    emitDefaultValues: false,
+    enumAsInteger: false,
+    useProtoFieldName: false,
+};
+function makeWriteOptions(options) {
+    return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults;
+}
+/**
+ * Serialize the message to a JSON value, a JavaScript value that can be
+ * passed to JSON.stringify().
+ */
+export function toJson(messageDesc, message, options) {
+    return reflectToJson(reflect(messageDesc, message), makeWriteOptions(options));
+}
+/**
+ * Serialize the message to a JSON string.
+ */
+export function toJsonString(messageDesc, message, options) {
+    var _a;
+    const jsonValue = toJson(messageDesc, message, options);
+    return JSON.stringify(jsonValue, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
+}
+function reflectToJson(msg, opts) {
+    var _a;
+    const wktJson = tryWktToJson(msg, opts);
+    if (wktJson !== undefined)
+        return wktJson;
+    const json = {};
+    for (const f of msg.sortedFields) {
+        if (!msg.isSet(f)) {
+            if (f.fieldKind != "map" &&
+                f.fieldKind != "list" &&
+                f.presence == LEGACY_REQUIRED) {
+                throw new Error(`cannot encode field ${msg.desc.typeName}.${f.name} to binary: required field not set`);
+            }
+            if (!opts.emitDefaultValues) {
+                continue;
+            }
+            if (!canEmitFieldDefaultValue(f)) {
+                continue;
+            }
+        }
+        const jsonValue = fieldToJson(f, msg.get(f), opts);
+        if (jsonValue !== undefined) {
+            json[jsonName(f, opts)] = jsonValue;
+        }
+    }
+    if (opts.registry) {
+        const tagSeen = new Set();
+        for (const uf of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) {
+            // Same tag can appear multiple times, so we
+            // keep track and skip identical ones.
+            if (tagSeen.has(uf.no)) {
+                continue;
+            }
+            const extension = opts.registry.getExtensionFor(msg.desc, uf.no);
+            if (!extension) {
+                continue;
+            }
+            const value = getExtension(msg.message, extension);
+            const [, field] = createExtensionContainer(extension);
+            const jsonValue = fieldToJson(field, value, opts);
+            if (jsonValue !== undefined) {
+                json[extension.jsonName] = jsonValue;
+            }
+        }
+    }
+    return json;
+}
+function fieldToJson(f, val, opts) {
+    switch (f.fieldKind) {
+        case "scalar":
+            return scalarToJson(f.scalar, val);
+        case "message":
+            return reflectToJson(val, opts);
+        case "enum":
+            return enumToJson(f.enum, val, opts.enumAsInteger);
+        case "list":
+            return listToJson(val, opts);
+        case "map":
+            return mapToJson(val, opts);
+    }
+}
+function mapToJson(map, opts) {
+    const f = map.field();
+    const jsonObj = {};
+    switch (f.mapKind) {
+        case "scalar":
+            for (const [entryKey, entryValue] of map) {
+                jsonObj[entryKey.toString()] = scalarToJson(f.scalar, entryValue); // JSON standard allows only (double quoted) string as property key
+            }
+            break;
+        case "message":
+            for (const [entryKey, entryValue] of map) {
+                // JSON standard allows only (double quoted) string as property key
+                jsonObj[entryKey.toString()] = reflectToJson(entryValue, opts);
+            }
+            break;
+        case "enum":
+            for (const [entryKey, entryValue] of map) {
+                // JSON standard allows only (double quoted) string as property key
+                jsonObj[entryKey.toString()] = enumToJson(f.enum, entryValue, opts.enumAsInteger);
+            }
+            break;
+    }
+    return opts.emitDefaultValues || map.size > 0 ? jsonObj : undefined;
+}
+function listToJson(list, opts) {
+    const f = list.field();
+    const jsonArr = [];
+    switch (f.listKind) {
+        case "scalar":
+            for (const item of list) {
+                jsonArr.push(scalarToJson(f.scalar, item));
+            }
+            break;
+        case "enum":
+            for (const item of list) {
+                jsonArr.push(enumToJson(f.enum, item, opts.enumAsInteger));
+            }
+            break;
+        case "message":
+            for (const item of list) {
+                jsonArr.push(reflectToJson(item, opts));
+            }
+            break;
+    }
+    return opts.emitDefaultValues || jsonArr.length > 0 ? jsonArr : undefined;
+}
+function enumToJson(desc, value, enumAsInteger) {
+    var _a;
+    assert(typeof value == "number");
+    if (desc.typeName == "google.protobuf.NullValue") {
+        return null;
+    }
+    if (enumAsInteger) {
+        return value;
+    }
+    const val = desc.values.find((v) => v.number == value);
+    return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number
+}
+function scalarToJson(type, value) {
+    switch (type) {
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case ScalarType.INT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+            assert(typeof value == "number");
+            return value;
+        // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+        // Either numbers or strings are accepted. Exponent notation is also accepted.
+        case ScalarType.FLOAT:
+        // assertFloat32(value);
+        case ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+            assert(typeof value == "number");
+            if (Number.isNaN(value))
+                return "NaN";
+            if (value === Number.POSITIVE_INFINITY)
+                return "Infinity";
+            if (value === Number.NEGATIVE_INFINITY)
+                return "-Infinity";
+            return value;
+        // string:
+        case ScalarType.STRING:
+            assert(typeof value == "string");
+            return value;
+        // bool:
+        case ScalarType.BOOL:
+            assert(typeof value == "boolean");
+            return value;
+        // JSON value will be a decimal string. Either numbers or strings are accepted.
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            assert(typeof value == "bigint" ||
+                typeof value == "string" ||
+                typeof value == "number");
+            return value.toString();
+        // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+        // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+        case ScalarType.BYTES:
+            assert(value instanceof Uint8Array);
+            return base64Encode(value);
+    }
+}
+// Decide whether an unset field should be emitted with JSON write option `emitDefaultValues`
+function canEmitFieldDefaultValue(field) {
+    switch (true) {
+        // oneof fields are never emitted
+        case field.oneof !== undefined:
+        // singular message field are allowed to emit JSON null, but we do not
+        // eslint-disable-next-line no-fallthrough
+        case field.fieldKind === "message":
+        // the field uses explicit presence, so we cannot emit a zero value
+        // eslint-disable-next-line no-fallthrough
+        case field.proto.label === LABEL_OPTIONAL:
+            return false;
+        default:
+            return true;
+    }
+}
+function jsonName(f, opts) {
+    return opts.useProtoFieldName ? f.name : f.jsonName;
+}
+// returns a json value if wkt, otherwise returns undefined.
+function tryWktToJson(msg, opts) {
+    if (!msg.desc.typeName.startsWith("google.protobuf.")) {
+        return undefined;
+    }
+    switch (msg.desc.typeName) {
+        case "google.protobuf.Any":
+            return anyToJson(msg.message, opts);
+        case "google.protobuf.Timestamp":
+            return timestampToJson(msg.message);
+        case "google.protobuf.Duration":
+            return durationToJson(msg.message);
+        case "google.protobuf.FieldMask":
+            return fieldMaskToJson(msg.message);
+        case "google.protobuf.Struct":
+            return structToJson(msg.message);
+        case "google.protobuf.Value":
+            return valueToJson(msg.message);
+        case "google.protobuf.ListValue":
+            return listValueToJson(msg.message);
+        default:
+            if (isWrapperDesc(msg.desc)) {
+                const valueField = msg.desc.fields[0];
+                return scalarToJson(valueField.scalar, msg.get(valueField));
+            }
+            return undefined;
+    }
+}
+function anyToJson(val, opts) {
+    if (val.typeUrl === "") {
+        return {};
+    }
+    const { registry } = opts;
+    let message;
+    let desc;
+    if (registry) {
+        message = anyUnpack(val, registry);
+        if (message) {
+            desc = registry.getMessage(message.$typeName);
+        }
+    }
+    if (!desc || !message) {
+        throw new Error(`cannot encode message ${val.$typeName} to JSON: "${val.typeUrl}" is not in the type registry`);
+    }
+    let json = reflectToJson(reflect(desc, message), opts);
+    if (desc.typeName.startsWith("google.protobuf.") ||
+        json === null ||
+        Array.isArray(json) ||
+        typeof json !== "object") {
+        json = { value: json };
+    }
+    json["@type"] = val.typeUrl;
+    return json;
+}
+function durationToJson(val) {
+    if (Number(val.seconds) > 315576000000 ||
+        Number(val.seconds) < -315576000000) {
+        throw new Error(`cannot encode ${val.$typeName} to JSON: value out of range`);
+    }
+    let text = val.seconds.toString();
+    if (val.nanos !== 0) {
+        let nanosStr = Math.abs(val.nanos).toString();
+        nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr;
+        if (nanosStr.substring(3) === "000000") {
+            nanosStr = nanosStr.substring(0, 3);
+        }
+        else if (nanosStr.substring(6) === "000") {
+            nanosStr = nanosStr.substring(0, 6);
+        }
+        text += "." + nanosStr;
+        if (val.nanos < 0 && Number(val.seconds) == 0) {
+            text = "-" + text;
+        }
+    }
+    return text + "s";
+}
+function fieldMaskToJson(val) {
+    return val.paths
+        .map((p) => {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) {
+            throw new Error(`cannot encode ${val.$typeName} to JSON: lowerCamelCase of path name "` +
+                p +
+                '" is irreversible');
+        }
+        return protoCamelCase(p);
+    })
+        .join(",");
+}
+function structToJson(val) {
+    const json = {};
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = valueToJson(v);
+    }
+    return json;
+}
+function valueToJson(val) {
+    switch (val.kind.case) {
+        case "nullValue":
+            return null;
+        case "numberValue":
+            if (!Number.isFinite(val.kind.value)) {
+                throw new Error(`${val.$typeName} cannot be NaN or Infinity`);
+            }
+            return val.kind.value;
+        case "boolValue":
+            return val.kind.value;
+        case "stringValue":
+            return val.kind.value;
+        case "structValue":
+            return structToJson(val.kind.value);
+        case "listValue":
+            return listValueToJson(val.kind.value);
+        default:
+            throw new Error(`${val.$typeName} must have a value`);
+    }
+}
+function listValueToJson(val) {
+    return val.values.map(valueToJson);
+}
+function timestampToJson(val) {
+    const ms = Number(val.seconds) * 1000;
+    if (ms < Date.parse("0001-01-01T00:00:00Z") ||
+        ms > Date.parse("9999-12-31T23:59:59Z")) {
+        throw new Error(`cannot encode ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+    }
+    if (val.nanos < 0) {
+        throw new Error(`cannot encode ${val.$typeName} to JSON: nanos must not be negative`);
+    }
+    let z = "Z";
+    if (val.nanos > 0) {
+        const nanosStr = (val.nanos + 1000000000).toString().substring(1);
+        if (nanosStr.substring(3) === "000000") {
+            z = "." + nanosStr.substring(0, 3) + "Z";
+        }
+        else if (nanosStr.substring(6) === "000") {
+            z = "." + nanosStr.substring(0, 6) + "Z";
+        }
+        else {
+            z = "." + nanosStr + "Z";
+        }
+    }
+    return new Date(ms).toISOString().replace(".000Z", z);
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,68 @@
+import type { GenDescEnum, GenDescExtension, GenDescMessage } from "./codegenv1/types.js";
+import type { DescEnum, DescExtension, DescMessage } from "./desc-types.js";
+import type { OneofADT } from "./reflect/guard.js";
+import type { WireType } from "./wire/index.js";
+/**
+ * The type `Message` contains the properties shared by all messages.
+ */
+export type Message<TypeName extends string = string> = {
+    /**
+     * The fully qualified Protobuf type-name of the message.
+     */
+    readonly $typeName: TypeName;
+    /**
+     * Unknown fields and extensions stored on the message.
+     */
+    $unknown?: UnknownField[];
+};
+/**
+ * Extract the message type from a message descriptor.
+ */
+export type MessageShape<Desc extends DescMessage> = Desc extends GenDescMessage<infer RuntimeShape> ? RuntimeShape : Message;
+/**
+ * Extract the init type from a message descriptor.
+ * The init type is accepted by the function create().
+ */
+export type MessageInitShape<Desc extends DescMessage> = Desc extends GenDescMessage<infer RuntimeShape> ? RuntimeShape | MessageInit<RuntimeShape> : Record<string, unknown>;
+/**
+ * Extract the enum type of from an enum descriptor.
+ */
+export type EnumShape<Desc extends DescEnum> = Desc extends GenDescEnum<infer RuntimeShape> ? RuntimeShape : number;
+/**
+ * Extract the value type from an extension descriptor.
+ */
+export type ExtensionValueShape<Desc extends DescExtension> = Desc extends GenDescExtension<Message, infer RuntimeShape> ? RuntimeShape : unknown;
+/**
+ * Extract the type of the extended message from an extension descriptor.
+ */
+export type Extendee<Desc extends DescExtension> = Desc extends GenDescExtension<infer Extendee> ? Extendee : Message;
+/**
+ * Unknown fields are fields that were not recognized during parsing, or
+ * extension.
+ */
+export type UnknownField = {
+    readonly no: number;
+    readonly wireType: WireType;
+    readonly data: Uint8Array;
+};
+/**
+ * The init type for a message, which makes all fields optional.
+ * The init type is accepted by the function create().
+ */
+type MessageInit<T extends Message> = {
+    [P in keyof T as P extends "$typeName" | "$unknown" ? never : P]?: FieldInit<T[P]>;
+};
+type FieldInit<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<FieldInit<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<FieldInit<U>> : F extends Message ? MessageInit<F> : F extends OneofSelectedMessage<infer C, infer V> ? {
+    case: C;
+    value: MessageInit<V>;
+} : F extends OneofADT ? F : F extends MapWithMessage<infer V> ? {
+    [key: string | number]: MessageInit<V>;
+} : F;
+type MapWithMessage<V extends Message> = {
+    [key: string | number]: V;
+};
+type OneofSelectedMessage<K extends string, M extends Message> = {
+    case: K;
+    value: M;
+};
+export {};