@aptre/protobuf-es-lite 0.2.6 → 0.2.8

package/dist/enum.d.ts

@@ -1,4 +1,38 @@
-import { EnumType, EnumValueInfo } from "@bufbuild/protobuf";
+/**
+ * Reflection information for a protobuf enumeration.
+ */
+export interface EnumType {
+    /**
+     * The fully qualified name of the enumeration.
+     */
+    readonly typeName: string;
+    readonly values: readonly EnumValueInfo[];
+    /**
+     * Find an enum value by its (protobuf) name.
+     */
+    findName(name: string): EnumValueInfo | undefined;
+    /**
+     * Find an enum value by its number.
+     */
+    findNumber(no: number): EnumValueInfo | undefined;
+}
+/**
+ * Reflection information for a protobuf enumeration value.
+ */
+export interface EnumValueInfo {
+    /**
+     * The numeric enumeration value, as specified in the protobuf source.
+     */
+    readonly no: number;
+    /**
+     * The name of the enumeration value, as specified in the protobuf source.
+     */
+    readonly name: string;
+    /**
+     * The name of the enumeration value in generated code.
+     */
+    readonly localName: string;
+}
 export declare function normalizeEnumValue(value: EnumValueInfo | Omit<EnumValueInfo, "localName">): EnumValueInfo;
 /**
  * Create a new EnumType with the given values.

package/dist/feature-set.d.ts

@@ -0,0 +1,19 @@
+import { Edition, FeatureSet, FeatureSetDefaults } from "./google/protobuf/descriptor.pb.js";
+import type { BinaryReadOptions, BinaryWriteOptions } from "./binary.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;

package/dist/feature-set.js

@@ -0,0 +1,103 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeatureResolver = void 0;
+const descriptor_pb_js_1 = require("./google/protobuf/descriptor.pb.js");
+const proto_base64_js_1 = require("./proto-base64.js");
+const partial_js_1 = require("./partial.js");
+/**
+ * Return the edition feature defaults supported by @bufbuild/protobuf.
+ */
+function getFeatureSetDefaults(options) {
+    return descriptor_pb_js_1.FeatureSetDefaults.fromBinary(proto_base64_js_1.protoBase64.dec("ChESDAgBEAIYAiADKAEwAhjmBwoREgwIAhABGAEgAigBMAEY5wcKERIMCAEQARgBIAIoATABGOgHIOYHKOgH"), options);
+}
+/**
+ * Create an edition feature resolver with the given feature set defaults, or
+ * the feature set defaults supported by @bufbuild/protobuf.
+ */
+function createFeatureResolver(edition, compiledFeatureSetDefaults, serializationOptions) {
+    const fds = descriptor_pb_js_1.FeatureSetDefaults.create(compiledFeatureSetDefaults ?? getFeatureSetDefaults(serializationOptions));
+    const min = fds.minimumEdition ?? 0;
+    const max = fds.maximumEdition ?? 0;
+    if (edition === 0) {
+        throw new Error(`Edition ${descriptor_pb_js_1.Edition[edition]} is unknown and not supported.`);
+    }
+    if (edition < min) {
+        throw new Error(`Edition ${descriptor_pb_js_1.Edition[edition]} is earlier than the minimum supported edition ${descriptor_pb_js_1.Edition[min]}`);
+    }
+    if (max < edition) {
+        throw new Error(`Edition ${descriptor_pb_js_1.Edition[edition]} is later than the maximum supported edition ${descriptor_pb_js_1.Edition[max]}`);
+    }
+    let highestMatch = undefined;
+    for (const c of fds.defaults ?? []) {
+        const e = c?.edition;
+        if (e === undefined || e > edition) {
+            continue;
+        }
+        if (highestMatch !== undefined && highestMatch.e > e) {
+            continue;
+        }
+        highestMatch = {
+            e,
+            f: c.features ?? descriptor_pb_js_1.FeatureSet.create(),
+        };
+    }
+    if (highestMatch === undefined) {
+        throw new Error(`No valid default found for edition ${descriptor_pb_js_1.Edition[edition]}`);
+    }
+    const featureSetBin = descriptor_pb_js_1.FeatureSet.toBinary(highestMatch.f, serializationOptions);
+    return (...rest) => {
+        const f = descriptor_pb_js_1.FeatureSet.fromBinary(featureSetBin, serializationOptions);
+        for (const c of rest) {
+            if (c !== undefined) {
+                (0, partial_js_1.applyPartialMessage)(c, f, descriptor_pb_js_1.FeatureSet.fields);
+            }
+        }
+        if (!validateMergedFeatures(f)) {
+            throw new Error(`Invalid FeatureSet for edition ${descriptor_pb_js_1.Edition[edition]}`);
+        }
+        return f;
+    };
+}
+exports.createFeatureResolver = createFeatureResolver;
+// When protoc generates google.protobuf.FeatureSetDefaults, it ensures that
+// fields are not repeated or required, do not use oneof, and have a default
+// value.
+//
+// When features for an element are resolved, features of the element and its
+// parents are merged into the default FeatureSet for the edition. Because unset
+// fields in the FeatureSet of an element do not unset the default FeatureSet
+// values, a resolved FeatureSet is guaranteed to have all fields set. This is
+// also the case for extensions to FeatureSet that a user might provide, and for
+// features from the future.
+//
+// We cannot exhaustively validate correctness of FeatureSetDefaults at runtime
+// without knowing the schema: If no value for a feature is provided, we do not
+// know that it exists at all.
+//
+// As a sanity check, we validate that all fields known to our version of
+// FeatureSet are set.
+function validateMergedFeatures(featureSet) {
+    for (const fi of descriptor_pb_js_1.FeatureSet.fields.list()) {
+        const v = featureSet[fi.localName];
+        if (v === undefined) {
+            return false;
+        }
+        if (fi.kind == "enum" && v === 0) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/field-wrapper.d.ts

@@ -1,9 +1,8 @@
+import { DescExtension, DescField } from "./descriptor-set.js";
+import { ScalarType } from "./scalar.js";
 /**
  * A field wrapper unwraps a message to a primitive value that is more
  * ergonomic for use as a message field.
- *
- * Note that this feature exists for google/protobuf/wrappers.proto
- * and cannot be used to arbitrarily modify types in generated code.
  */
 export interface FieldWrapper<T = any, U = any> {
     wrapField(value: U): T;
@@ -14,3 +13,8 @@ export interface FieldWrapper<T = any, U = any> {
  * message. This function is idempotent.
  */
 export declare function wrapField<T>(fieldWrapper: FieldWrapper<T> | undefined, value: any): T;
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the primitive type it wraps.
+ */
+export declare function getUnwrappedFieldType(field: DescField | DescExtension): ScalarType | undefined;

package/dist/field-wrapper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapField = void 0;
+exports.getUnwrappedFieldType = exports.wrapField = void 0;
+const scalar_js_1 = require("./scalar.js");
 /**
  * Wrap a primitive message field value in its corresponding wrapper
  * message. This function is idempotent.
@@ -12,3 +13,31 @@ function wrapField(fieldWrapper, value) {
     return fieldWrapper.wrapField(value);
 }
 exports.wrapField = wrapField;
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the primitive type it wraps.
+ */
+function getUnwrappedFieldType(field) {
+    if (field.fieldKind !== "message") {
+        return undefined;
+    }
+    if (field.repeated) {
+        return undefined;
+    }
+    if (field.oneof != undefined) {
+        return undefined;
+    }
+    return wktWrapperToScalarType[field.message.typeName];
+}
+exports.getUnwrappedFieldType = getUnwrappedFieldType;
+const wktWrapperToScalarType = {
+    "google.protobuf.DoubleValue": scalar_js_1.ScalarType.DOUBLE,
+    "google.protobuf.FloatValue": scalar_js_1.ScalarType.FLOAT,
+    "google.protobuf.Int64Value": scalar_js_1.ScalarType.INT64,
+    "google.protobuf.UInt64Value": scalar_js_1.ScalarType.UINT64,
+    "google.protobuf.Int32Value": scalar_js_1.ScalarType.INT32,
+    "google.protobuf.UInt32Value": scalar_js_1.ScalarType.UINT32,
+    "google.protobuf.BoolValue": scalar_js_1.ScalarType.BOOL,
+    "google.protobuf.StringValue": scalar_js_1.ScalarType.STRING,
+    "google.protobuf.BytesValue": scalar_js_1.ScalarType.BYTES,
+};

package/dist/field.d.ts

@@ -1,5 +1,7 @@
-import { EnumType, LongType, ScalarType } from "@bufbuild/protobuf";
-import { MessageType } from "./message.js";
+import { EnumType } from "./enum.js";
+import { Message, MessageType } from "./message.js";
+import { LongType, ScalarType } from "./scalar.js";
+import { protoCamelCase } from "./names.js";
 /**
  * FieldInfo describes a field of a protobuf message for runtime reflection. We
  * distinguish between the following kinds of fields:
@@ -73,7 +75,6 @@ export declare class FieldList {
 export type PartialFieldInfo = fiPartialRules<fiScalar> | fiPartialRules<fiEnum> | fiPartialRules<fiMessage> | fiPartialRules<fiMap>;
 export type FieldListSource = readonly PartialFieldInfo[] | readonly FieldInfo[] | (() => readonly PartialFieldInfo[]) | (() => readonly FieldInfo[]);
 export declare function newFieldList(fields: FieldListSource, packedByDefault: boolean): FieldList;
-export declare function protoCamelCase(snakeCase: string): string;
 /**
  * Returns true if the field is set.
  */
@@ -82,19 +83,7 @@ export declare function isFieldSet(field: FieldInfo, target: Record<string, any>
  * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
 export declare const fieldJsonName: typeof protoCamelCase;
-/**
- * Returns the name of a field in generated code.
- */
-export declare function localFieldName(protoName: string, inOneof: boolean): string;
-/**
- * Names that cannot be used for object properties because they are reserved
- * by built-in JavaScript properties.
- */
-export declare const safeObjectProperty: (name: string) => string;
-/**
- * Returns the name of a oneof group in generated code.
- */
-export declare function localOneofName(protoName: string): string;
+export declare function resolveMessageType<T extends Message<T>>(t: fiMessage<T>["T"]): MessageType<T>;
 export declare class InternalOneofInfo implements OneofInfo {
     readonly kind = "oneof";
     readonly name: string;
@@ -215,12 +204,12 @@ interface fiScalar extends fiShared {
      */
     readonly delimited?: undefined;
 }
-interface fiMessage extends fiShared {
+interface fiMessage<T extends Message<T> = any> extends fiShared {
     readonly kind: "message";
     /**
      * Message handler for the field.
      */
-    readonly T: MessageType;
+    readonly T: MessageType<T> | (() => MessageType<T>);
     /**
      * Is the field repeated?
      */
@@ -302,7 +291,7 @@ interface fiMap extends fiShared {
         readonly T: EnumType;
     } | {
         readonly kind: "message";
-        readonly T: MessageType;
+        readonly T: MessageType<any> | (() => MessageType<any>);
     };
     /**
      * Is the field repeated? Never true for maps.

package/dist/field.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeFieldInfos = exports.InternalOneofInfo = exports.localOneofName = exports.safeObjectProperty = exports.localFieldName = exports.fieldJsonName = exports.isFieldSet = exports.protoCamelCase = exports.newFieldList = exports.FieldList = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
+exports.normalizeFieldInfos = exports.InternalOneofInfo = exports.resolveMessageType = exports.fieldJsonName = exports.isFieldSet = exports.newFieldList = exports.FieldList = void 0;
 const assert_js_1 = require("./assert.js");
 const scalar_js_1 = require("./scalar.js");
+const names_js_1 = require("./names.js");
 /**
  * Provides convenient access to field information of a message type.
  */
@@ -88,44 +88,6 @@ function newFieldList(fields, packedByDefault) {
     return new FieldList(fields, (source) => normalizeFieldInfos(source, packedByDefault));
 }
 exports.newFieldList = newFieldList;
-/*
- * Converts snake_case to protoCamelCase according to the convention
- * used by protoc to convert a field name to a JSON name.
- */
-function protoCamelCase(snakeCase) {
-    let capNext = false;
-    const b = [];
-    for (let i = 0; i < snakeCase.length; i++) {
-        let c = snakeCase.charAt(i);
-        switch (c) {
-            case "_":
-                capNext = true;
-                break;
-            case "0":
-            case "1":
-            case "2":
-            case "3":
-            case "4":
-            case "5":
-            case "6":
-            case "7":
-            case "8":
-            case "9":
-                b.push(c);
-                capNext = false;
-                break;
-            default:
-                if (capNext) {
-                    capNext = false;
-                    c = c.toUpperCase();
-                }
-                b.push(c);
-                break;
-        }
-    }
-    return b.join("");
-}
-exports.protoCamelCase = protoCamelCase;
 /**
  * Returns true if the field is set.
  */
@@ -159,77 +121,15 @@ exports.isFieldSet = isFieldSet;
 /**
  * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
-exports.fieldJsonName = protoCamelCase;
-/**
- * Returns the name of a field in generated code.
- */
-function localFieldName(protoName, inOneof) {
-    const name = protoCamelCase(protoName);
-    if (inOneof) {
-        // oneof member names are not properties, but values of the `case` property.
-        return name;
+exports.fieldJsonName = names_js_1.protoCamelCase;
+// resolveMessageType returns the message type calling the function if necessary.
+function resolveMessageType(t) {
+    if (t instanceof Function) {
+        return t();
     }
-    return (0, exports.safeObjectProperty)(safeMessageProperty(name));
-}
-exports.localFieldName = localFieldName;
-/**
- * Names that cannot be used for object properties because they are reserved
- * by built-in JavaScript properties.
- */
-const reservedObjectProperties = new Set([
-    // names reserved by JavaScript
-    "constructor",
-    "toString",
-    "toJSON",
-    "valueOf",
-]);
-/*
- * Names that cannot be used for object properties because they are reserved
- * by the runtime.
- */
-const reservedMessageProperties = new Set([
-    // names reserved by the runtime
-    "getType",
-    "clone",
-    "equals",
-    "fromBinary",
-    "fromJson",
-    "fromJsonString",
-    "toBinary",
-    "toJson",
-    "toJsonString",
-    // names reserved by the runtime for the future
-    "toObject",
-]);
-const fallback = (name) => `${name}$`;
-/**
- * Will wrap names that are Object prototype properties or names reserved
- * for `Message`s.
- */
-const safeMessageProperty = (name) => {
-    if (reservedMessageProperties.has(name)) {
-        return fallback(name);
-    }
-    return name;
-};
-/**
- * Names that cannot be used for object properties because they are reserved
- * by built-in JavaScript properties.
- */
-const safeObjectProperty = (name) => {
-    if (reservedObjectProperties.has(name)) {
-        return fallback(name);
-    }
-    return name;
-};
-exports.safeObjectProperty = safeObjectProperty;
-/**
- * Returns the name of a oneof group in generated code.
- */
-function localOneofName(protoName) {
-    return localFieldName(protoName, false);
+    return t;
 }
-exports.localOneofName = localOneofName;
+exports.resolveMessageType = resolveMessageType;
 // InternarlOneofInfo implements OneofInfo.
 class InternalOneofInfo {
     constructor(name) {
@@ -241,7 +141,7 @@ class InternalOneofInfo {
         this.default = undefined;
         this.fields = [];
         this.name = name;
-        this.localName = localOneofName(name);
+        this.localName = (0, names_js_1.localOneofName)(name);
     }
     addField(field) {
         (0, assert_js_1.assert)(field.oneof === this, `field ${field.name} not one of ${this.name}`);
@@ -267,15 +167,13 @@ exports.InternalOneofInfo = InternalOneofInfo;
 function normalizeFieldInfos(fieldInfos, packedByDefault) {
     const r = [];
     let o;
-    for (const field of typeof fieldInfos == "function"
-        ? fieldInfos()
-        : fieldInfos) {
+    for (const field of typeof fieldInfos == "function" ? fieldInfos() : (fieldInfos)) {
         const f = field;
-        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.localName = (0, names_js_1.localFieldName)(field.name, field.oneof !== undefined);
         f.jsonName = field.jsonName ?? (0, exports.fieldJsonName)(field.name);
         f.repeated = field.repeated ?? false;
         if (field.kind == "scalar") {
-            f.L = field.L ?? protobuf_1.LongType.BIGINT;
+            f.L = field.L ?? scalar_js_1.LongType.BIGINT;
         }
         f.delimited = field.delimited ?? false;
         f.req = field.req ?? false;
@@ -285,8 +183,8 @@ function normalizeFieldInfos(fieldInfos, packedByDefault) {
                 f.packed =
                     field.kind == "enum" ||
                         (field.kind == "scalar" &&
-                            field.T != protobuf_1.ScalarType.BYTES &&
-                            field.T != protobuf_1.ScalarType.STRING);
+                            field.T != scalar_js_1.ScalarType.BYTES &&
+                            field.T != scalar_js_1.ScalarType.STRING);
             }
             else {
                 f.packed = false;

package/dist/google/index.d.ts

@@ -0,0 +1,9 @@
+export { Type, Field, Field_Kind, Field_Cardinality, Enum, EnumValue, Option, Syntax, } from "./protobuf/type.pb.js";
+export { Timestamp } from "./protobuf/timestamp.pb.js";
+export { Duration } from "./protobuf/duration.pb.js";
+export { Any } from "./protobuf/any.pb.js";
+export { Empty } from "./protobuf/empty.pb.js";
+export { DoubleValue, FloatValue, Int64Value, UInt64Value, Int32Value, UInt32Value, BoolValue, StringValue, BytesValue, } from "./protobuf/wrappers.pb.js";
+export { Value, NullValue, ListValue, Struct } from "./protobuf/struct.pb.js";
+export { Api, Method, Mixin } from "./protobuf/api.pb.js";
+export { SourceContext } from "./protobuf/source_context.pb.js";

package/dist/google/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceContext = exports.Mixin = exports.Method = exports.Api = exports.Struct = exports.ListValue = exports.NullValue = exports.Value = exports.BytesValue = exports.StringValue = exports.BoolValue = exports.UInt32Value = exports.Int32Value = exports.UInt64Value = exports.Int64Value = exports.FloatValue = exports.DoubleValue = exports.Empty = exports.Any = exports.Duration = exports.Timestamp = exports.Syntax = exports.Option = exports.EnumValue = exports.Enum = exports.Field_Cardinality = exports.Field_Kind = exports.Field = exports.Type = void 0;
+var type_pb_js_1 = require("./protobuf/type.pb.js");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return type_pb_js_1.Type; } });
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return type_pb_js_1.Field; } });
+Object.defineProperty(exports, "Field_Kind", { enumerable: true, get: function () { return type_pb_js_1.Field_Kind; } });
+Object.defineProperty(exports, "Field_Cardinality", { enumerable: true, get: function () { return type_pb_js_1.Field_Cardinality; } });
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return type_pb_js_1.Enum; } });
+Object.defineProperty(exports, "EnumValue", { enumerable: true, get: function () { return type_pb_js_1.EnumValue; } });
+Object.defineProperty(exports, "Option", { enumerable: true, get: function () { return type_pb_js_1.Option; } });
+Object.defineProperty(exports, "Syntax", { enumerable: true, get: function () { return type_pb_js_1.Syntax; } });
+var timestamp_pb_js_1 = require("./protobuf/timestamp.pb.js");
+Object.defineProperty(exports, "Timestamp", { enumerable: true, get: function () { return timestamp_pb_js_1.Timestamp; } });
+var duration_pb_js_1 = require("./protobuf/duration.pb.js");
+Object.defineProperty(exports, "Duration", { enumerable: true, get: function () { return duration_pb_js_1.Duration; } });
+var any_pb_js_1 = require("./protobuf/any.pb.js");
+Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return any_pb_js_1.Any; } });
+var empty_pb_js_1 = require("./protobuf/empty.pb.js");
+Object.defineProperty(exports, "Empty", { enumerable: true, get: function () { return empty_pb_js_1.Empty; } });
+var wrappers_pb_js_1 = require("./protobuf/wrappers.pb.js");
+Object.defineProperty(exports, "DoubleValue", { enumerable: true, get: function () { return wrappers_pb_js_1.DoubleValue; } });
+Object.defineProperty(exports, "FloatValue", { enumerable: true, get: function () { return wrappers_pb_js_1.FloatValue; } });
+Object.defineProperty(exports, "Int64Value", { enumerable: true, get: function () { return wrappers_pb_js_1.Int64Value; } });
+Object.defineProperty(exports, "UInt64Value", { enumerable: true, get: function () { return wrappers_pb_js_1.UInt64Value; } });
+Object.defineProperty(exports, "Int32Value", { enumerable: true, get: function () { return wrappers_pb_js_1.Int32Value; } });
+Object.defineProperty(exports, "UInt32Value", { enumerable: true, get: function () { return wrappers_pb_js_1.UInt32Value; } });
+Object.defineProperty(exports, "BoolValue", { enumerable: true, get: function () { return wrappers_pb_js_1.BoolValue; } });
+Object.defineProperty(exports, "StringValue", { enumerable: true, get: function () { return wrappers_pb_js_1.StringValue; } });
+Object.defineProperty(exports, "BytesValue", { enumerable: true, get: function () { return wrappers_pb_js_1.BytesValue; } });
+var struct_pb_js_1 = require("./protobuf/struct.pb.js");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return struct_pb_js_1.Value; } });
+Object.defineProperty(exports, "NullValue", { enumerable: true, get: function () { return struct_pb_js_1.NullValue; } });
+Object.defineProperty(exports, "ListValue", { enumerable: true, get: function () { return struct_pb_js_1.ListValue; } });
+Object.defineProperty(exports, "Struct", { enumerable: true, get: function () { return struct_pb_js_1.Struct; } });
+var api_pb_js_1 = require("./protobuf/api.pb.js");
+Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return api_pb_js_1.Api; } });
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return api_pb_js_1.Method; } });
+Object.defineProperty(exports, "Mixin", { enumerable: true, get: function () { return api_pb_js_1.Mixin; } });
+var source_context_pb_js_1 = require("./protobuf/source_context.pb.js");
+Object.defineProperty(exports, "SourceContext", { enumerable: true, get: function () { return source_context_pb_js_1.SourceContext; } });

package/dist/google/protobuf/any.pb.d.ts

@@ -0,0 +1,139 @@
+import type { MessageType } from "../../";
+import { Message } from "../../";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *     // or ...
+ *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
+ *       foo = any.unpack(Foo.getDefaultInstance());
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := any.UnmarshalTo(foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ *
+ *
+ *
+ * @generated from message google.protobuf.Any
+ */
+export type Any = Message<{
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     *
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     *
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com. As of May 2023, there are no widely used type server
+     * implementations and no plans to implement one.
+     *
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     *
+     *
+     *
+     * @generated from field: string type_url = 1 [packed = false, default = "", jstype = JS_NORMAL];
+     */
+    typeUrl?: string;
+    /**
+     * Must be a valid serialized protocol buffer of the above specified type.
+     *
+     *
+     * @generated from field: bytes value = 2 [packed = false, default = "", jstype = JS_NORMAL];
+     */
+    value?: Uint8Array;
+}>;
+export declare const Any: MessageType<Any>;