@bufbuild/protobuf 1.3.1 → 1.3.2

package/dist/esm/google/protobuf/wrappers_pb.d.ts

@@ -0,0 +1,267 @@
+import type { PartialMessage, PlainMessage } from "../../message.js";
+import { Message } from "../../message.js";
+import { proto3 } from "../../proto3.js";
+import type { JsonReadOptions, JsonValue, JsonWriteOptions } from "../../json-format.js";
+import type { FieldList } from "../../field-list.js";
+import type { BinaryReadOptions } from "../../binary-format.js";
+/**
+ * Wrapper message for `double`.
+ *
+ * The JSON representation for `DoubleValue` is JSON number.
+ *
+ * @generated from message google.protobuf.DoubleValue
+ */
+export declare class DoubleValue extends Message<DoubleValue> {
+    /**
+     * The double value.
+     *
+     * @generated from field: double value = 1;
+     */
+    value: number;
+    constructor(data?: PartialMessage<DoubleValue>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.DoubleValue";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: number): DoubleValue;
+        unwrapField(value: DoubleValue): number;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DoubleValue;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DoubleValue;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DoubleValue;
+    static equals(a: DoubleValue | PlainMessage<DoubleValue> | undefined, b: DoubleValue | PlainMessage<DoubleValue> | undefined): boolean;
+}
+/**
+ * Wrapper message for `float`.
+ *
+ * The JSON representation for `FloatValue` is JSON number.
+ *
+ * @generated from message google.protobuf.FloatValue
+ */
+export declare class FloatValue extends Message<FloatValue> {
+    /**
+     * The float value.
+     *
+     * @generated from field: float value = 1;
+     */
+    value: number;
+    constructor(data?: PartialMessage<FloatValue>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.FloatValue";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: number): FloatValue;
+        unwrapField(value: FloatValue): number;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FloatValue;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FloatValue;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FloatValue;
+    static equals(a: FloatValue | PlainMessage<FloatValue> | undefined, b: FloatValue | PlainMessage<FloatValue> | undefined): boolean;
+}
+/**
+ * Wrapper message for `int64`.
+ *
+ * The JSON representation for `Int64Value` is JSON string.
+ *
+ * @generated from message google.protobuf.Int64Value
+ */
+export declare class Int64Value extends Message<Int64Value> {
+    /**
+     * The int64 value.
+     *
+     * @generated from field: int64 value = 1;
+     */
+    value: bigint;
+    constructor(data?: PartialMessage<Int64Value>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.Int64Value";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: bigint): Int64Value;
+        unwrapField(value: Int64Value): bigint;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Int64Value;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Int64Value;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Int64Value;
+    static equals(a: Int64Value | PlainMessage<Int64Value> | undefined, b: Int64Value | PlainMessage<Int64Value> | undefined): boolean;
+}
+/**
+ * Wrapper message for `uint64`.
+ *
+ * The JSON representation for `UInt64Value` is JSON string.
+ *
+ * @generated from message google.protobuf.UInt64Value
+ */
+export declare class UInt64Value extends Message<UInt64Value> {
+    /**
+     * The uint64 value.
+     *
+     * @generated from field: uint64 value = 1;
+     */
+    value: bigint;
+    constructor(data?: PartialMessage<UInt64Value>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.UInt64Value";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: bigint): UInt64Value;
+        unwrapField(value: UInt64Value): bigint;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UInt64Value;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UInt64Value;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UInt64Value;
+    static equals(a: UInt64Value | PlainMessage<UInt64Value> | undefined, b: UInt64Value | PlainMessage<UInt64Value> | undefined): boolean;
+}
+/**
+ * Wrapper message for `int32`.
+ *
+ * The JSON representation for `Int32Value` is JSON number.
+ *
+ * @generated from message google.protobuf.Int32Value
+ */
+export declare class Int32Value extends Message<Int32Value> {
+    /**
+     * The int32 value.
+     *
+     * @generated from field: int32 value = 1;
+     */
+    value: number;
+    constructor(data?: PartialMessage<Int32Value>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.Int32Value";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: number): Int32Value;
+        unwrapField(value: Int32Value): number;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Int32Value;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Int32Value;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Int32Value;
+    static equals(a: Int32Value | PlainMessage<Int32Value> | undefined, b: Int32Value | PlainMessage<Int32Value> | undefined): boolean;
+}
+/**
+ * Wrapper message for `uint32`.
+ *
+ * The JSON representation for `UInt32Value` is JSON number.
+ *
+ * @generated from message google.protobuf.UInt32Value
+ */
+export declare class UInt32Value extends Message<UInt32Value> {
+    /**
+     * The uint32 value.
+     *
+     * @generated from field: uint32 value = 1;
+     */
+    value: number;
+    constructor(data?: PartialMessage<UInt32Value>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.UInt32Value";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: number): UInt32Value;
+        unwrapField(value: UInt32Value): number;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UInt32Value;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UInt32Value;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UInt32Value;
+    static equals(a: UInt32Value | PlainMessage<UInt32Value> | undefined, b: UInt32Value | PlainMessage<UInt32Value> | undefined): boolean;
+}
+/**
+ * Wrapper message for `bool`.
+ *
+ * The JSON representation for `BoolValue` is JSON `true` and `false`.
+ *
+ * @generated from message google.protobuf.BoolValue
+ */
+export declare class BoolValue extends Message<BoolValue> {
+    /**
+     * The bool value.
+     *
+     * @generated from field: bool value = 1;
+     */
+    value: boolean;
+    constructor(data?: PartialMessage<BoolValue>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.BoolValue";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: boolean): BoolValue;
+        unwrapField(value: BoolValue): boolean;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BoolValue;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BoolValue;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BoolValue;
+    static equals(a: BoolValue | PlainMessage<BoolValue> | undefined, b: BoolValue | PlainMessage<BoolValue> | undefined): boolean;
+}
+/**
+ * Wrapper message for `string`.
+ *
+ * The JSON representation for `StringValue` is JSON string.
+ *
+ * @generated from message google.protobuf.StringValue
+ */
+export declare class StringValue extends Message<StringValue> {
+    /**
+     * The string value.
+     *
+     * @generated from field: string value = 1;
+     */
+    value: string;
+    constructor(data?: PartialMessage<StringValue>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.StringValue";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: string): StringValue;
+        unwrapField(value: StringValue): string;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StringValue;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StringValue;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StringValue;
+    static equals(a: StringValue | PlainMessage<StringValue> | undefined, b: StringValue | PlainMessage<StringValue> | undefined): boolean;
+}
+/**
+ * Wrapper message for `bytes`.
+ *
+ * The JSON representation for `BytesValue` is JSON string.
+ *
+ * @generated from message google.protobuf.BytesValue
+ */
+export declare class BytesValue extends Message<BytesValue> {
+    /**
+     * The bytes value.
+     *
+     * @generated from field: bytes value = 1;
+     */
+    value: Uint8Array;
+    constructor(data?: PartialMessage<BytesValue>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.BytesValue";
+    static readonly fields: FieldList;
+    static readonly fieldWrapper: {
+        wrapField(value: Uint8Array): BytesValue;
+        unwrapField(value: BytesValue): Uint8Array;
+    };
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BytesValue;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BytesValue;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BytesValue;
+    static equals(a: BytesValue | PlainMessage<BytesValue> | undefined, b: BytesValue | PlainMessage<BytesValue> | undefined): boolean;
+}

package/dist/esm/google/varint.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export declare function varint64read(this: ReaderLike): [number, number];
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export declare function varint64write(lo: number, hi: number, bytes: number[]): void;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64ToString(lo: number, hi: number): string;
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function uInt64ToString(lo: number, hi: number): string;
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export declare function varint32write(value: number, bytes: number[]): void;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export declare function varint32read(this: ReaderLike): number;
+type ReaderLike = {
+    buf: Uint8Array;
+    pos: number;
+    len: number;
+    assertBounds(): void;
+};
+export {};

package/dist/esm/index.d.ts

@@ -0,0 +1,38 @@
+export { proto3 } from "./proto3.js";
+export { proto2 } from "./proto2.js";
+export { protoDouble } from "./proto-double.js";
+export { protoInt64 } from "./proto-int64.js";
+export { protoBase64 } from "./proto-base64.js";
+export { protoDelimited } from "./proto-delimited.js";
+export { codegenInfo } from "./codegen-info.js";
+export { Message } from "./message.js";
+export type { AnyMessage, PartialMessage, PlainMessage } from "./message.js";
+export type { FieldInfo } from "./field.js";
+export type { FieldList } from "./field-list.js";
+export { ScalarType } from "./field.js";
+export type { MessageType } from "./message-type.js";
+export type { EnumType, EnumValueInfo } from "./enum.js";
+export type { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, } from "./service-type.js";
+export { MethodKind, MethodIdempotency } from "./service-type.js";
+export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
+export type { IBinaryReader, IBinaryWriter } from "./binary-encoding.js";
+export type { BinaryFormat, BinaryWriteOptions, BinaryReadOptions, } from "./binary-format.js";
+export type { JsonFormat, JsonObject, JsonValue, JsonReadOptions, JsonWriteOptions, JsonWriteStringOptions, } from "./json-format.js";
+export type { DescriptorSet, AnyDesc, DescFile, DescEnum, DescEnumValue, DescMessage, DescOneof, DescField, DescService, DescMethod, DescExtension, DescComments, } from "./descriptor-set.js";
+export { createDescriptorSet } from "./create-descriptor-set.js";
+export type { IMessageTypeRegistry } from "./type-registry.js";
+export { createRegistry } from "./create-registry.js";
+export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
+export { toPlainMessage } from "./to-plain-message.js";
+export * from "./google/protobuf/compiler/plugin_pb.js";
+export * from "./google/protobuf/api_pb.js";
+export * from "./google/protobuf/any_pb.js";
+export * from "./google/protobuf/descriptor_pb.js";
+export * from "./google/protobuf/duration_pb.js";
+export * from "./google/protobuf/empty_pb.js";
+export * from "./google/protobuf/field_mask_pb.js";
+export * from "./google/protobuf/source_context_pb.js";
+export * from "./google/protobuf/struct_pb.js";
+export * from "./google/protobuf/timestamp_pb.js";
+export * from "./google/protobuf/type_pb.js";
+export * from "./google/protobuf/wrappers_pb.js";

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

@@ -0,0 +1,110 @@
+import type { Message } from "./message.js";
+import type { MessageType } from "./message-type.js";
+import type { ScalarType } from "./field.js";
+import type { IMessageTypeRegistry } from "./type-registry.js";
+/**
+ * JsonFormat is the contract for serializing messages to and from JSON.
+ * Implementations may be specific to a proto syntax, and can be reflection
+ * based, or delegate to speed optimized generated code.
+ */
+export interface JsonFormat {
+    /**
+     * Provide options for parsing JSON data.
+     */
+    makeReadOptions(options?: Partial<JsonReadOptions>): Readonly<JsonReadOptions>;
+    /**
+     * Provide options for serializing to JSON.
+     */
+    makeWriteOptions(options?: Partial<JsonWriteStringOptions>): Readonly<JsonWriteStringOptions>;
+    /**
+     * Parse a message from JSON.
+     */
+    readMessage<T extends Message<T>>(type: MessageType<T>, jsonValue: JsonValue, options: JsonReadOptions, message?: T): T;
+    /**
+     * Serialize a message to JSON.
+     */
+    writeMessage(message: Message, options: JsonWriteOptions): JsonValue;
+    /**
+     * Parse a single scalar value from JSON.
+     * This method may throw an error, but it may have a blank error message.
+     * Callers are expected to provide context.
+     */
+    readScalar(type: ScalarType, json: JsonValue): any;
+    /**
+     * Serialize a single scalar value to JSON.
+     */
+    writeScalar(type: ScalarType, value: any, emitDefaultValues: boolean): JsonValue | undefined;
+    /**
+     * Returns a short string representation of a JSON value, suitable for error messages.
+     */
+    debug(json: JsonValue): string;
+}
+/**
+ * Options for parsing JSON data.
+ */
+export interface JsonReadOptions {
+    /**
+     * Ignore unknown fields: Proto3 JSON parser should reject unknown fields
+     * by default. This option ignores unknown fields in parsing, as well as
+     * unrecognized enum string representations.
+     */
+    ignoreUnknownFields: boolean;
+    /**
+     * This option is required to read `google.protobuf.Any`
+     * from JSON format.
+     */
+    typeRegistry?: IMessageTypeRegistry;
+}
+/**
+ * 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`
+     * to JSON format.
+     */
+    typeRegistry?: IMessageTypeRegistry;
+}
+/**
+ * Options for serializing to JSON.
+ */
+export interface JsonWriteStringOptions extends JsonWriteOptions {
+    prettySpaces: number;
+}
+/**
+ * Represents any possible JSON value:
+ * - number
+ * - string
+ * - boolean
+ * - null
+ * - object (with any JSON value as property)
+ * - array (with any JSON value as element)
+ */
+export type JsonValue = number | string | boolean | null | JsonObject | JsonValue[];
+/**
+ * Represents a JSON object.
+ */
+export type JsonObject = {
+    [k: string]: JsonValue;
+};

package/dist/esm/message-type.d.ts

@@ -0,0 +1,51 @@
+import type { FieldList } from "./field-list.js";
+import type { ProtoRuntime } from "./private/proto-runtime.js";
+import type { JsonReadOptions, JsonValue } from "./json-format.js";
+import type { BinaryReadOptions } from "./binary-format.js";
+import type { AnyMessage, Message, PartialMessage, PlainMessage } from "./message.js";
+import type { FieldWrapper } from "./private/field-wrapper.js";
+/**
+ * MessageType represents a protobuf message. It provides:
+ * - a constructor that produces an instance of the message
+ * - metadata for reflection-based operations
+ * - common functionality like serialization
+ */
+export interface MessageType<T extends Message<T> = AnyMessage> {
+    /**
+     * Create a new instance of this type.
+     */
+    new (data?: PartialMessage<T>): T;
+    /**
+     * The fully qualified name of the message.
+     */
+    readonly typeName: string;
+    /**
+     * Field metadata.
+     */
+    readonly fields: FieldList;
+    /**
+     * Provides serialization and other functionality.
+     */
+    readonly runtime: ProtoRuntime;
+    /**
+     * When used as a field, unwrap this message to a simple value.
+     */
+    readonly fieldWrapper?: FieldWrapper<T>;
+    /**
+     * Parse serialized binary data.
+     */
+    fromBinary(data: Uint8Array, options?: Partial<BinaryReadOptions>): T;
+    /**
+     * Parse a JSON object.
+     */
+    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): T;
+    /**
+     * Parse a JSON string.
+     */
+    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): T;
+    /**
+     * Returns true if the given arguments have equal field values, recursively.
+     * Will also return true if both messages are `undefined` or `null`.
+     */
+    equals(a: T | PlainMessage<T> | undefined | null, b: T | PlainMessage<T> | undefined | null): boolean;
+}

package/dist/esm/message.d.ts

@@ -0,0 +1,130 @@
+import type { BinaryReadOptions, BinaryWriteOptions } from "./binary-format.js";
+import type { JsonReadOptions, JsonValue, JsonWriteOptions, JsonWriteStringOptions } from "./json-format.js";
+import type { MessageType } from "./message-type.js";
+/**
+ * AnyMessage is an interface implemented by all messages. If you need to
+ * handle messages of unknown type, this interface provides a convenient
+ * index signature to access fields with message["fieldname"].
+ */
+export interface AnyMessage extends Message<AnyMessage> {
+    [k: string]: any;
+}
+/**
+ * Message is the base class of every message, generated, or created at
+ * runtime.
+ *
+ * It is _not_ safe to extend this class. If you want to create a message at
+ * run time, use proto3.makeMessageType().
+ */
+export declare class Message<T extends Message<T> = AnyMessage> {
+    /**
+     * Compare with a message of the same type.
+     */
+    equals(other: T | PlainMessage<T> | undefined | null): boolean;
+    /**
+     * Create a deep copy.
+     */
+    clone(): T;
+    /**
+     * Parse from binary data, merging fields.
+     *
+     * Repeated fields are appended. Map entries are added, overwriting
+     * existing keys.
+     *
+     * If a message field is already present, it will be merged with the
+     * new data.
+     */
+    fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): this;
+    /**
+     * Parse a message from a JSON value.
+     */
+    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): this;
+    /**
+     * Parse a message from a JSON string.
+     */
+    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): this;
+    /**
+     * Serialize the message to binary data.
+     */
+    toBinary(options?: Partial<BinaryWriteOptions>): Uint8Array;
+    /**
+     * Serialize the message to a JSON value, a JavaScript value that can be
+     * passed to JSON.stringify().
+     */
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    /**
+     * Serialize the message to a JSON string.
+     */
+    toJsonString(options?: Partial<JsonWriteStringOptions>): string;
+    /**
+     * Override for serialization behavior. This will be invoked when calling
+     * JSON.stringify on this message (i.e. JSON.stringify(msg)).
+     *
+     * Note that this will not serialize google.protobuf.Any with a packed
+     * message because the protobuf JSON format specifies that it needs to be
+     * unpacked, and this is only possible with a type registry to look up the
+     * message type.  As a result, attempting to serialize a message with this
+     * type will throw an Error.
+     *
+     * This method is protected because you should not need to invoke it
+     * directly -- instead use JSON.stringify or toJsonString for
+     * stringified JSON.  Alternatively, if actual JSON is desired, you should
+     * use toJson.
+     */
+    protected toJSON(): JsonValue;
+    /**
+     * Retrieve the MessageType of this message - a singleton that represents
+     * the protobuf message declaration and provides metadata for reflection-
+     * based operations.
+     */
+    getType(): MessageType<T>;
+}
+/**
+ * PlainMessage<T> strips all methods from a message, leaving only fields
+ * and oneof groups.  It is recursive, meaning it applies this same logic to all
+ * nested message fields as well.
+ */
+export type PlainMessage<T extends Message<T>> = {
+    [P in keyof T as T[P] extends Function ? never : P]: PlainField<T[P]>;
+};
+type PlainField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PlainField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PlainField<U>> : F extends Message<infer U> ? PlainMessage<U> : F extends OneofSelectedMessage<infer C, infer V> ? {
+    case: C;
+    value: PlainField<V>;
+} : F extends {
+    case: string | undefined;
+    value?: unknown;
+} ? F : F extends {
+    [key: string | number]: Message<infer U>;
+} ? {
+    [key: string | number]: PlainField<U>;
+} : F;
+/**
+ * PartialMessage<T> constructs a type from a message. The resulting type
+ * only contains the protobuf field members of the message, and all of them
+ * are optional.
+ *
+ * Note that the optionality of the fields is the only difference between
+ * PartialMessage and PlainMessage.
+ *
+ * PartialMessage is similar to the built-in type Partial<T>, but recursive,
+ * and respects `oneof` groups.
+ */
+export type PartialMessage<T extends Message<T>> = {
+    [P in keyof T as T[P] extends Function ? never : P]?: PartialField<T[P]>;
+};
+type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PartialField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PartialField<U>> : F extends Message<infer U> ? PartialMessage<U> : F extends OneofSelectedMessage<infer C, infer V> ? {
+    case: C;
+    value: PartialMessage<V>;
+} : F extends {
+    case: string | undefined;
+    value?: unknown;
+} ? F : F extends {
+    [key: string | number]: Message<infer U>;
+} ? {
+    [key: string | number]: PartialMessage<U>;
+} : F;
+type OneofSelectedMessage<K extends string, M extends Message<M>> = {
+    case: K;
+    value: M;
+};
+export {};

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

@@ -0,0 +1,16 @@
+/**
+ * Assert that condition is truthy or throw error (with message)
+ */
+export declare function assert(condition: unknown, msg?: string): asserts condition;
+/**
+ * Assert a valid signed protobuf 32-bit integer.
+ */
+export declare function assertInt32(arg: unknown): asserts arg is number;
+/**
+ * Assert a valid unsigned protobuf 32-bit integer.
+ */
+export declare function assertUInt32(arg: unknown): asserts arg is number;
+/**
+ * Assert a valid protobuf float value.
+ */
+export declare function assertFloat32(arg: unknown): asserts arg is number;