@aptre/protobuf-es-lite 0.5.1 → 0.5.2

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,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/protobuf/any.pb.d.ts

@@ -0,0 +1,148 @@
+import type { IMessageTypeRegistry, JsonReadOptions, JsonValue, JsonWriteOptions, MessageType } from "../../index.js";
+import { Message } from "../../index.js";
+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 interface Any {
+    /**
+     * 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;
+     */
+    typeUrl?: string;
+    /**
+     * Must be a valid serialized protocol buffer of the above specified type.
+     *
+     * @generated from field: bytes value = 2;
+     */
+    value?: Uint8Array;
+}
+declare const Any_Wkt: {
+    toJson(msg: Any, options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): Any;
+    packFrom<T extends Message<T>>(out: Any, message: Message<T>, messageType: MessageType<T>): void;
+    unpackTo<T extends Message<T>>(msg: Any, target: Message<T>, targetMessageType: MessageType<T>): boolean;
+    unpack<T extends Message<T>>(msg: Any, registry: IMessageTypeRegistry): {
+        message: Message<T>;
+        messageType: MessageType<T>;
+    } | undefined;
+    is(msg: Any, msgType: MessageType | string): boolean;
+};
+export declare const Any: MessageType<Any> & typeof Any_Wkt;
+export {};

package/dist/google/protobuf/any.pb.js

@@ -0,0 +1,120 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import { applyPartialMessage, createMessageType, ScalarType, } from "../../index.js";
+export const protobufPackage = "google.protobuf";
+// Any_Wkt contains the well-known-type overrides for Any.
+const Any_Wkt = {
+    toJson(msg, options) {
+        const typeName = msg?.typeUrl;
+        if (!typeName) {
+            return {};
+        }
+        const messageType = options?.typeRegistry?.findMessage(typeName);
+        if (!messageType) {
+            throw new Error(`cannot encode message google.protobuf.Any to JSON: "${typeName}" is not in the type registry`);
+        }
+        const message = messageType.fromBinary(msg.value);
+        let json = messageType.toJson(message, options);
+        if (typeName.startsWith("google.protobuf.") ||
+            json === null ||
+            Array.isArray(json) ||
+            typeof json !== "object") {
+            json = { value: json };
+        }
+        json["@type"] = typeName;
+        return json;
+    },
+    fromJson(json, options) {
+        if (json === null || Array.isArray(json) || typeof json != "object") {
+            throw new Error(`cannot decode message google.protobuf.Any from JSON: expected object but got ${json === null ? "null"
+                : Array.isArray(json) ? "array"
+                    : typeof json}`);
+        }
+        if (Object.keys(json).length == 0) {
+            return {};
+        }
+        const typeUrl = json["@type"];
+        if (typeof typeUrl != "string" || typeUrl == "") {
+            throw new Error(`cannot decode message google.protobuf.Any from JSON: "@type" is empty`);
+        }
+        const typeName = typeUrl, messageType = options?.typeRegistry?.findMessage(typeName);
+        if (!messageType) {
+            throw new Error(`cannot decode message google.protobuf.Any from JSON: ${typeUrl} is not in the type registry`);
+        }
+        let message;
+        if (typeName.startsWith("google.protobuf.") &&
+            Object.prototype.hasOwnProperty.call(json, "value")) {
+            message = messageType.fromJson(json["value"], options);
+        }
+        else {
+            const copy = Object.assign({}, json);
+            delete copy["@type"];
+            message = messageType.fromJson(copy, options);
+        }
+        const out = {};
+        Any.packFrom(out, message, messageType);
+        return out;
+    },
+    packFrom(out, message, messageType) {
+        out.value = messageType.toBinary(message);
+        out.typeUrl = messageType.typeName;
+    },
+    unpackTo(msg, target, targetMessageType) {
+        if (!Any.is(msg, targetMessageType)) {
+            return false;
+        }
+        const partial = targetMessageType.fromBinary(msg.value);
+        applyPartialMessage(partial, target, targetMessageType.fields);
+        return true;
+    },
+    unpack(msg, registry) {
+        const typeUrl = msg.typeUrl;
+        const messageType = !!typeUrl && registry.findMessage(typeUrl);
+        return messageType ?
+            { message: messageType.fromBinary(msg.value), messageType }
+            : undefined;
+    },
+    is(msg, msgType) {
+        const name = msg.typeUrl;
+        return (!!name &&
+            (typeof msgType === "string" ?
+                name === msgType
+                : name === msgType.typeName));
+    },
+};
+// Any contains the message type declaration for Any.
+export const Any = createMessageType({
+    typeName: "google.protobuf.Any",
+    fields: [
+        { no: 1, name: "type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "value", kind: "scalar", T: ScalarType.BYTES },
+    ],
+    packedByDefault: true,
+}, Any_Wkt);

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

@@ -0,0 +1,232 @@
+import type { Syntax } from "./type.pb.js";
+import { Option } from "./type.pb.js";
+import type { MessageType } from "../../index.js";
+import { SourceContext } from "./source_context.pb.js";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * Method represents a method of an API interface.
+ *
+ * @generated from message google.protobuf.Method
+ */
+export interface Method {
+    /**
+     * The simple name of this method.
+     *
+     * @generated from field: string name = 1;
+     */
+    name?: string;
+    /**
+     * A URL of the input message type.
+     *
+     * @generated from field: string request_type_url = 2;
+     */
+    requestTypeUrl?: string;
+    /**
+     * If true, the request is streamed.
+     *
+     * @generated from field: bool request_streaming = 3;
+     */
+    requestStreaming?: boolean;
+    /**
+     * The URL of the output message type.
+     *
+     * @generated from field: string response_type_url = 4;
+     */
+    responseTypeUrl?: string;
+    /**
+     * If true, the response is streamed.
+     *
+     * @generated from field: bool response_streaming = 5;
+     */
+    responseStreaming?: boolean;
+    /**
+     * Any metadata attached to the method.
+     *
+     * @generated from field: repeated google.protobuf.Option options = 6;
+     */
+    options?: Option[];
+    /**
+     * The source syntax of this method.
+     *
+     * @generated from field: google.protobuf.Syntax syntax = 7;
+     */
+    syntax?: Syntax;
+}
+export declare const Method: MessageType<Method>;
+/**
+ * Declares an API Interface to be included in this interface. The including
+ * interface must redeclare all the methods from the included interface, but
+ * documentation and options are inherited as follows:
+ *
+ * - If after comment and whitespace stripping, the documentation
+ *   string of the redeclared method is empty, it will be inherited
+ *   from the original method.
+ *
+ * - Each annotation belonging to the service config (http,
+ *   visibility) which is not set in the redeclared method will be
+ *   inherited.
+ *
+ * - If an http annotation is inherited, the path pattern will be
+ *   modified as follows. Any version prefix will be replaced by the
+ *   version of the including interface plus the [root][] path if
+ *   specified.
+ *
+ * Example of a simple mixin:
+ *
+ *     package google.acl.v1;
+ *     service AccessControl {
+ *       // Get the underlying ACL object.
+ *       rpc GetAcl(GetAclRequest) returns (Acl) {
+ *         option (google.api.http).get = "/v1/{resource=**}:getAcl";
+ *       }
+ *     }
+ *
+ *     package google.storage.v2;
+ *     service Storage {
+ *       rpc GetAcl(GetAclRequest) returns (Acl);
+ *
+ *       // Get a data record.
+ *       rpc GetData(GetDataRequest) returns (Data) {
+ *         option (google.api.http).get = "/v2/{resource=**}";
+ *       }
+ *     }
+ *
+ * Example of a mixin configuration:
+ *
+ *     apis:
+ *     - name: google.storage.v2.Storage
+ *       mixins:
+ *       - name: google.acl.v1.AccessControl
+ *
+ * The mixin construct implies that all methods in `AccessControl` are
+ * also declared with same name and request/response types in
+ * `Storage`. A documentation generator or annotation processor will
+ * see the effective `Storage.GetAcl` method after inherting
+ * documentation and annotations as follows:
+ *
+ *     service Storage {
+ *       // Get the underlying ACL object.
+ *       rpc GetAcl(GetAclRequest) returns (Acl) {
+ *         option (google.api.http).get = "/v2/{resource=**}:getAcl";
+ *       }
+ *       ...
+ *     }
+ *
+ * Note how the version in the path pattern changed from `v1` to `v2`.
+ *
+ * If the `root` field in the mixin is specified, it should be a
+ * relative path under which inherited HTTP paths are placed. Example:
+ *
+ *     apis:
+ *     - name: google.storage.v2.Storage
+ *       mixins:
+ *       - name: google.acl.v1.AccessControl
+ *         root: acls
+ *
+ * This implies the following inherited HTTP annotation:
+ *
+ *     service Storage {
+ *       // Get the underlying ACL object.
+ *       rpc GetAcl(GetAclRequest) returns (Acl) {
+ *         option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
+ *       }
+ *       ...
+ *     }
+ *
+ * @generated from message google.protobuf.Mixin
+ */
+export interface Mixin {
+    /**
+     * The fully qualified name of the interface which is included.
+     *
+     * @generated from field: string name = 1;
+     */
+    name?: string;
+    /**
+     * If non-empty specifies a path under which inherited HTTP paths
+     * are rooted.
+     *
+     * @generated from field: string root = 2;
+     */
+    root?: string;
+}
+export declare const Mixin: MessageType<Mixin>;
+/**
+ * Api is a light-weight descriptor for an API Interface.
+ *
+ * Interfaces are also described as "protocol buffer services" in some contexts,
+ * such as by the "service" keyword in a .proto file, but they are different
+ * from API Services, which represent a concrete implementation of an interface
+ * as opposed to simply a description of methods and bindings. They are also
+ * sometimes simply referred to as "APIs" in other contexts, such as the name of
+ * this message itself. See https://cloud.google.com/apis/design/glossary for
+ * detailed terminology.
+ *
+ * @generated from message google.protobuf.Api
+ */
+export interface Api {
+    /**
+     * The fully qualified name of this interface, including package name
+     * followed by the interface's simple name.
+     *
+     * @generated from field: string name = 1;
+     */
+    name?: string;
+    /**
+     * The methods of this interface, in unspecified order.
+     *
+     * @generated from field: repeated google.protobuf.Method methods = 2;
+     */
+    methods?: Method[];
+    /**
+     * Any metadata attached to the interface.
+     *
+     * @generated from field: repeated google.protobuf.Option options = 3;
+     */
+    options?: Option[];
+    /**
+     * A version string for this interface. If specified, must have the form
+     * `major-version.minor-version`, as in `1.10`. If the minor version is
+     * omitted, it defaults to zero. If the entire version field is empty, the
+     * major version is derived from the package name, as outlined below. If the
+     * field is not empty, the version in the package name will be verified to be
+     * consistent with what is provided here.
+     *
+     * The versioning schema uses [semantic
+     * versioning](http://semver.org) where the major version number
+     * indicates a breaking change and the minor version an additive,
+     * non-breaking change. Both version numbers are signals to users
+     * what to expect from different versions, and should be carefully
+     * chosen based on the product plan.
+     *
+     * The major version is also reflected in the package name of the
+     * interface, which must end in `v<major-version>`, as in
+     * `google.feature.v1`. For major versions 0 and 1, the suffix can
+     * be omitted. Zero major versions must only be used for
+     * experimental, non-GA interfaces.
+     *
+     *
+     * @generated from field: string version = 4;
+     */
+    version?: string;
+    /**
+     * Source context for the protocol buffer service represented by this
+     * message.
+     *
+     * @generated from field: google.protobuf.SourceContext source_context = 5;
+     */
+    sourceContext?: SourceContext;
+    /**
+     * Included interfaces. See [Mixin][].
+     *
+     * @generated from field: repeated google.protobuf.Mixin mixins = 6;
+     */
+    mixins?: Mixin[];
+    /**
+     * The source syntax of the service.
+     *
+     * @generated from field: google.protobuf.Syntax syntax = 7;
+     */
+    syntax?: Syntax;
+}
+export declare const Api: MessageType<Api>;

package/dist/google/protobuf/api.pb.js

@@ -0,0 +1,88 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import { Option, Syntax_Enum } from "./type.pb.js";
+import { createMessageType, ScalarType } from "../../index.js";
+import { SourceContext } from "./source_context.pb.js";
+export const protobufPackage = "google.protobuf";
+// Method contains the message type declaration for Method.
+export const Method = createMessageType({
+    typeName: "google.protobuf.Method",
+    fields: [
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "request_type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 3, name: "request_streaming", kind: "scalar", T: ScalarType.BOOL },
+        { no: 4, name: "response_type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 5, name: "response_streaming", kind: "scalar", T: ScalarType.BOOL },
+        {
+            no: 6,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
+        { no: 7, name: "syntax", kind: "enum", T: Syntax_Enum },
+    ],
+    packedByDefault: true,
+});
+// Mixin contains the message type declaration for Mixin.
+export const Mixin = createMessageType({
+    typeName: "google.protobuf.Mixin",
+    fields: [
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "root", kind: "scalar", T: ScalarType.STRING },
+    ],
+    packedByDefault: true,
+});
+// Api contains the message type declaration for Api.
+export const Api = createMessageType({
+    typeName: "google.protobuf.Api",
+    fields: [
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        {
+            no: 2,
+            name: "methods",
+            kind: "message",
+            T: () => Method,
+            repeated: true,
+        },
+        {
+            no: 3,
+            name: "options",
+            kind: "message",
+            T: () => Option,
+            repeated: true,
+        },
+        { no: 4, name: "version", kind: "scalar", T: ScalarType.STRING },
+        { no: 5, name: "source_context", kind: "message", T: () => SourceContext },
+        { no: 6, name: "mixins", kind: "message", T: () => Mixin, repeated: true },
+        { no: 7, name: "syntax", kind: "enum", T: Syntax_Enum },
+    ],
+    packedByDefault: true,
+});