@bufbuild/protobuf 1.3.1 → 1.3.3

package/dist/esm/field.d.ts

@@ -0,0 +1,255 @@
+import type { EnumType } from "./enum.js";
+import type { MessageType } from "./message-type.js";
+/**
+ * FieldInfo describes a field of a protobuf message for runtime reflection. We
+ * distinguish between the following kinds of fields:
+ *
+ * - "scalar": string, bool, float, int32, etc. The scalar type is "T".
+ * - "enum": The field was declared with an enum type. The enum type is "T".
+ * - "message": The field was declared with a message type. The message type is "T".
+ * - "map": The field was declared with map<K,V>. The key type is "K", the value type is "V".
+ *
+ * Every field always has the following properties:
+ *
+ * - "no": The field number of the protobuf field.
+ * - "name": The original name of the protobuf field.
+ * - "localName": The name of the field as used in generated code.
+ * - "jsonName": The name for JSON serialization / deserialization.
+ * - "opt": Whether the field is optional.
+ * - "repeated": Whether the field is repeated.
+ * - "packed": Whether the repeated field is packed.
+ *
+ * Additionally, fields may have the following properties:
+ *
+ * - "oneof": If the field is member of a oneof group.
+ * - "default": Only proto2: An explicit default value.
+ */
+export type FieldInfo = fiRules<fiScalar> | fiRules<fiEnum> | fiRules<fiMessage> | fiRules<fiMap>;
+/**
+ * Version of `FieldInfo` that allows the following properties
+ * to be omitted:
+ *
+ * - "localName", "jsonName": can be omitted if equal to lowerCamelCase(name)
+ * - "opt": Can be omitted if false.
+ * - "repeated": Can be omitted if false.
+ * - "packed": Can be omitted if equal to the standard packing of the field.
+ */
+export type PartialFieldInfo = fiPartialRules<fiScalar> | fiPartialRules<fiEnum> | fiPartialRules<fiMessage> | fiPartialRules<fiMap>;
+/**
+ * Provides convenient access to field information of a oneof.
+ */
+export interface OneofInfo {
+    readonly kind: "oneof";
+    readonly name: string;
+    readonly localName: string;
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: false;
+    readonly default: undefined;
+    readonly fields: readonly FieldInfo[];
+    /**
+     * Return field information by local name.
+     */
+    findField(localName: string): FieldInfo | undefined;
+}
+interface fiShared {
+    /**
+     * The field number of the .proto field.
+     */
+    readonly no: number;
+    /**
+     * The original name of the .proto field.
+     */
+    readonly name: string;
+    /**
+     * The name of the field as used in generated code.
+     */
+    readonly localName: string;
+    /**
+     * The name for JSON serialization / deserialization.
+     */
+    readonly jsonName: string;
+    /**
+     * The `oneof` group, if this field belongs to one.
+     */
+    readonly oneof?: OneofInfo | undefined;
+}
+interface fiScalar extends fiShared {
+    readonly kind: "scalar";
+    /**
+     * Scalar type of the field.
+     */
+    readonly T: ScalarType;
+    /**
+     * Is the field repeated?
+     */
+    readonly repeated: boolean;
+    /**
+     * Is this repeated field packed?
+     * BYTES and STRING can never be packed, since they are length-delimited.
+     * Other types can be packed with the field option "packed".
+     * For proto3, fields are packed by default.
+     */
+    readonly packed: boolean;
+    /**
+     * Is the field optional?
+     */
+    readonly opt: boolean;
+    /**
+     * Only proto2: An explicit default value.
+     */
+    readonly default: number | boolean | string | bigint | Uint8Array | undefined;
+}
+interface fiMessage extends fiShared {
+    readonly kind: "message";
+    /**
+     * Message handler for the field.
+     */
+    readonly T: MessageType;
+    /**
+     * Is the field repeated?
+     */
+    readonly repeated: boolean;
+    /**
+     * Is this repeated field packed? Never true for messages.
+     */
+    readonly packed: false;
+    /**
+     * An explicit default value (only proto2). Never set for messages.
+     */
+    readonly default: undefined;
+}
+interface fiEnum extends fiShared {
+    readonly kind: "enum";
+    /**
+     * Enum type information for the field.
+     */
+    readonly T: EnumType;
+    /**
+     * Is the field repeated?
+     */
+    readonly repeated: boolean;
+    /**
+     * Is this repeated field packed?
+     * Repeated enums can be packed with the field option "packed".
+     * For proto3, they are packed by default.
+     */
+    readonly packed: boolean;
+    /**
+     * Is the field optional?
+     */
+    readonly opt: boolean;
+    /**
+     * Only proto2: An explicit default value.
+     */
+    readonly default: number | undefined;
+}
+interface fiMap extends fiShared {
+    readonly kind: "map";
+    /**
+     * Map key type.
+     *
+     * The key_type can be any integral or string type
+     * (so, any scalar type except for floating point
+     * types and bytes)
+     */
+    readonly K: Exclude<ScalarType, ScalarType.FLOAT | ScalarType.DOUBLE | ScalarType.BYTES>;
+    /**
+     * Map value type. Can be scalar, enum, or message.
+     */
+    readonly V: {
+        readonly kind: "scalar";
+        readonly T: ScalarType;
+    } | {
+        readonly kind: "enum";
+        readonly T: EnumType;
+    } | {
+        readonly kind: "message";
+        readonly T: MessageType;
+    };
+    /**
+     * Is the field repeated? Never true for maps.
+     */
+    readonly repeated: false;
+    /**
+     * Is this repeated field packed? Never true for maps.
+     */
+    readonly packed: false;
+    /**
+     * An explicit default value (only proto2). Never set for maps.
+     */
+    readonly default: undefined;
+}
+type fiRules<T> = Omit<T, "oneof" | "repeat" | "repeated" | "packed" | "opt"> & ({
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: false;
+    readonly oneof: undefined;
+} | {
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: true;
+    readonly oneof: undefined;
+} | {
+    readonly repeated: boolean;
+    readonly packed: boolean;
+    readonly opt: false;
+    readonly oneof: undefined;
+} | {
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: false;
+    readonly oneof: OneofInfo;
+});
+type fiPartialRules<T extends fiScalar | fiMap | fiEnum | fiMessage> = Omit<T, "jsonName" | "localName" | "oneof" | "repeat" | "repeated" | "packed" | "opt" | "default"> & ({
+    readonly jsonName?: string;
+    readonly repeated?: false;
+    readonly packed?: false;
+    readonly opt?: false;
+    readonly oneof?: undefined;
+    default?: T["default"];
+} | {
+    readonly jsonName?: string;
+    readonly repeated?: false;
+    readonly packed?: false;
+    readonly opt: true;
+    readonly oneof?: undefined;
+    default?: T["default"];
+} | {
+    readonly jsonName?: string;
+    readonly repeated?: boolean;
+    readonly packed?: boolean;
+    readonly opt?: false;
+    readonly oneof?: undefined;
+    default?: T["default"];
+} | {
+    readonly jsonName?: string;
+    readonly repeated?: false;
+    readonly packed?: false;
+    readonly opt?: false;
+    readonly oneof: string;
+    default?: T["default"];
+});
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export declare enum ScalarType {
+    DOUBLE = 1,
+    FLOAT = 2,
+    INT64 = 3,
+    UINT64 = 4,
+    INT32 = 5,
+    FIXED64 = 6,
+    FIXED32 = 7,
+    BOOL = 8,
+    STRING = 9,
+    BYTES = 12,
+    UINT32 = 13,
+    SFIXED32 = 15,
+    SFIXED64 = 16,
+    SINT32 = 17,
+    SINT64 = 18
+}
+export {};

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

@@ -0,0 +1,156 @@
+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 { IMessageTypeRegistry } from "../../type-registry.js";
+import type { MessageType } from "../../message-type.js";
+import type { FieldList } from "../../field-list.js";
+import type { BinaryReadOptions } from "../../binary-format.js";
+/**
+ * `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 declare class Any extends Message<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.
+     *
+     * 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;
+    constructor(data?: PartialMessage<Any>);
+    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
+    packFrom(message: Message): void;
+    unpackTo(target: Message): boolean;
+    unpack(registry: IMessageTypeRegistry): Message | undefined;
+    is(type: MessageType | string): boolean;
+    private typeNameToUrl;
+    private typeUrlToName;
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.Any";
+    static readonly fields: FieldList;
+    static pack(message: Message): Any;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Any;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Any;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Any;
+    static equals(a: Any | PlainMessage<Any> | undefined, b: Any | PlainMessage<Any> | undefined): boolean;
+}

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

@@ -0,0 +1,256 @@
+import type { PartialMessage, PlainMessage } from "../../message.js";
+import { Message } from "../../message.js";
+import { Option, Syntax } from "./type_pb.js";
+import { SourceContext } from "./source_context_pb.js";
+import { proto3 } from "../../proto3.js";
+import type { FieldList } from "../../field-list.js";
+import type { BinaryReadOptions } from "../../binary-format.js";
+import type { JsonReadOptions, JsonValue } from "../../json-format.js";
+/**
+ * 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 declare class Api extends Message<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;
+    constructor(data?: PartialMessage<Api>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.Api";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Api;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Api;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Api;
+    static equals(a: Api | PlainMessage<Api> | undefined, b: Api | PlainMessage<Api> | undefined): boolean;
+}
+/**
+ * Method represents a method of an API interface.
+ *
+ * @generated from message google.protobuf.Method
+ */
+export declare class Method extends Message<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;
+    constructor(data?: PartialMessage<Method>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.Method";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Method;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Method;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Method;
+    static equals(a: Method | PlainMessage<Method> | undefined, b: Method | PlainMessage<Method> | undefined): boolean;
+}
+/**
+ * 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 declare class Mixin extends Message<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;
+    constructor(data?: PartialMessage<Mixin>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "google.protobuf.Mixin";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mixin;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mixin;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mixin;
+    static equals(a: Mixin | PlainMessage<Mixin> | undefined, b: Mixin | PlainMessage<Mixin> | undefined): boolean;
+}