@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/esm/google/protobuf/duration_pb.js

@@ -1,165 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Message } from "../../message.js";
-import { protoInt64 } from "../../proto-int64.js";
-import { proto3 } from "../../proto3.js";
-/**
- * A Duration represents a signed, fixed-length span of time represented
- * as a count of seconds and fractions of seconds at nanosecond
- * resolution. It is independent of any calendar and concepts like "day"
- * or "month". It is related to Timestamp in that the difference between
- * two Timestamp values is a Duration and it can be added or subtracted
- * from a Timestamp. Range is approximately +-10,000 years.
- *
- * # Examples
- *
- * Example 1: Compute Duration from two Timestamps in pseudo code.
- *
- *     Timestamp start = ...;
- *     Timestamp end = ...;
- *     Duration duration = ...;
- *
- *     duration.seconds = end.seconds - start.seconds;
- *     duration.nanos = end.nanos - start.nanos;
- *
- *     if (duration.seconds < 0 && duration.nanos > 0) {
- *       duration.seconds += 1;
- *       duration.nanos -= 1000000000;
- *     } else if (duration.seconds > 0 && duration.nanos < 0) {
- *       duration.seconds -= 1;
- *       duration.nanos += 1000000000;
- *     }
- *
- * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
- *
- *     Timestamp start = ...;
- *     Duration duration = ...;
- *     Timestamp end = ...;
- *
- *     end.seconds = start.seconds + duration.seconds;
- *     end.nanos = start.nanos + duration.nanos;
- *
- *     if (end.nanos < 0) {
- *       end.seconds -= 1;
- *       end.nanos += 1000000000;
- *     } else if (end.nanos >= 1000000000) {
- *       end.seconds += 1;
- *       end.nanos -= 1000000000;
- *     }
- *
- * Example 3: Compute Duration from datetime.timedelta in Python.
- *
- *     td = datetime.timedelta(days=3, minutes=10)
- *     duration = Duration()
- *     duration.FromTimedelta(td)
- *
- * # JSON Mapping
- *
- * In JSON format, the Duration type is encoded as a string rather than an
- * object, where the string ends in the suffix "s" (indicating seconds) and
- * is preceded by the number of seconds, with nanoseconds expressed as
- * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
- * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
- * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
- * microsecond should be expressed in JSON format as "3.000001s".
- *
- *
- * @generated from message google.protobuf.Duration
- */
-export class Duration extends Message {
-    constructor(data) {
-        super();
-        /**
-         * Signed seconds of the span of time. Must be from -315,576,000,000
-         * to +315,576,000,000 inclusive. Note: these bounds are computed from:
-         * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-         *
-         * @generated from field: int64 seconds = 1;
-         */
-        this.seconds = protoInt64.zero;
-        /**
-         * Signed fractions of a second at nanosecond resolution of the span
-         * of time. Durations less than one second are represented with a 0
-         * `seconds` field and a positive or negative `nanos` field. For durations
-         * of one second or more, a non-zero value for the `nanos` field must be
-         * of the same sign as the `seconds` field. Must be from -999,999,999
-         * to +999,999,999 inclusive.
-         *
-         * @generated from field: int32 nanos = 2;
-         */
-        this.nanos = 0;
-        proto3.util.initPartial(data, this);
-    }
-    fromJson(json, options) {
-        if (typeof json !== "string") {
-            throw new Error(`cannot decode google.protobuf.Duration from JSON: ${proto3.json.debug(json)}`);
-        }
-        const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/);
-        if (match === null) {
-            throw new Error(`cannot decode google.protobuf.Duration from JSON: ${proto3.json.debug(json)}`);
-        }
-        const longSeconds = Number(match[1]);
-        if (longSeconds > 315576000000 || longSeconds < -315576000000) {
-            throw new Error(`cannot decode google.protobuf.Duration from JSON: ${proto3.json.debug(json)}`);
-        }
-        this.seconds = protoInt64.parse(longSeconds);
-        if (typeof match[2] == "string") {
-            const nanosStr = match[2] + "0".repeat(9 - match[2].length);
-            this.nanos = parseInt(nanosStr);
-            if (longSeconds < 0 || Object.is(longSeconds, -0)) {
-                this.nanos = -this.nanos;
-            }
-        }
-        return this;
-    }
-    toJson(options) {
-        if (Number(this.seconds) > 315576000000 || Number(this.seconds) < -315576000000) {
-            throw new Error(`cannot encode google.protobuf.Duration to JSON: value out of range`);
-        }
-        let text = this.seconds.toString();
-        if (this.nanos !== 0) {
-            let nanosStr = Math.abs(this.nanos).toString();
-            nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr;
-            if (nanosStr.substring(3) === "000000") {
-                nanosStr = nanosStr.substring(0, 3);
-            }
-            else if (nanosStr.substring(6) === "000") {
-                nanosStr = nanosStr.substring(0, 6);
-            }
-            text += "." + nanosStr;
-            if (this.nanos < 0 && Number(this.seconds) == 0) {
-                text = "-" + text;
-            }
-        }
-        return text + "s";
-    }
-    static fromBinary(bytes, options) {
-        return new Duration().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new Duration().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new Duration().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(Duration, a, b);
-    }
-}
-Duration.runtime = proto3;
-Duration.typeName = "google.protobuf.Duration";
-Duration.fields = proto3.util.newFieldList(() => [
-    { no: 1, name: "seconds", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
-    { no: 2, name: "nanos", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-]);

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

@@ -1,28 +0,0 @@
-import type { PartialMessage, PlainMessage } from "../../message.js";
-import { Message } from "../../message.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";
-/**
- * A generic empty message that you can re-use to avoid defining duplicated
- * empty messages in your APIs. A typical example is to use it as the request
- * or the response type of an API method. For instance:
- *
- *     service Foo {
- *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
- *     }
- *
- *
- * @generated from message google.protobuf.Empty
- */
-export declare class Empty extends Message<Empty> {
-    constructor(data?: PartialMessage<Empty>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "google.protobuf.Empty";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Empty;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Empty;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Empty;
-    static equals(a: Empty | PlainMessage<Empty> | undefined, b: Empty | PlainMessage<Empty> | undefined): boolean;
-}

package/dist/esm/google/protobuf/empty_pb.js

@@ -1,48 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Message } from "../../message.js";
-import { proto3 } from "../../proto3.js";
-/**
- * A generic empty message that you can re-use to avoid defining duplicated
- * empty messages in your APIs. A typical example is to use it as the request
- * or the response type of an API method. For instance:
- *
- *     service Foo {
- *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
- *     }
- *
- *
- * @generated from message google.protobuf.Empty
- */
-export class Empty extends Message {
-    constructor(data) {
-        super();
-        proto3.util.initPartial(data, this);
-    }
-    static fromBinary(bytes, options) {
-        return new Empty().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new Empty().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new Empty().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(Empty, a, b);
-    }
-}
-Empty.runtime = proto3;
-Empty.typeName = "google.protobuf.Empty";
-Empty.fields = proto3.util.newFieldList(() => []);

package/dist/esm/google/protobuf/field_mask_pb.js

@@ -1,307 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Message } from "../../message.js";
-import { proto3 } from "../../proto3.js";
-/**
- * `FieldMask` represents a set of symbolic field paths, for example:
- *
- *     paths: "f.a"
- *     paths: "f.b.d"
- *
- * Here `f` represents a field in some root message, `a` and `b`
- * fields in the message found in `f`, and `d` a field found in the
- * message in `f.b`.
- *
- * Field masks are used to specify a subset of fields that should be
- * returned by a get operation or modified by an update operation.
- * Field masks also have a custom JSON encoding (see below).
- *
- * # Field Masks in Projections
- *
- * When used in the context of a projection, a response message or
- * sub-message is filtered by the API to only contain those fields as
- * specified in the mask. For example, if the mask in the previous
- * example is applied to a response message as follows:
- *
- *     f {
- *       a : 22
- *       b {
- *         d : 1
- *         x : 2
- *       }
- *       y : 13
- *     }
- *     z: 8
- *
- * The result will not contain specific values for fields x,y and z
- * (their value will be set to the default, and omitted in proto text
- * output):
- *
- *
- *     f {
- *       a : 22
- *       b {
- *         d : 1
- *       }
- *     }
- *
- * A repeated field is not allowed except at the last position of a
- * paths string.
- *
- * If a FieldMask object is not present in a get operation, the
- * operation applies to all fields (as if a FieldMask of all fields
- * had been specified).
- *
- * Note that a field mask does not necessarily apply to the
- * top-level response message. In case of a REST get operation, the
- * field mask applies directly to the response, but in case of a REST
- * list operation, the mask instead applies to each individual message
- * in the returned resource list. In case of a REST custom method,
- * other definitions may be used. Where the mask applies will be
- * clearly documented together with its declaration in the API.  In
- * any case, the effect on the returned resource/resources is required
- * behavior for APIs.
- *
- * # Field Masks in Update Operations
- *
- * A field mask in update operations specifies which fields of the
- * targeted resource are going to be updated. The API is required
- * to only change the values of the fields as specified in the mask
- * and leave the others untouched. If a resource is passed in to
- * describe the updated values, the API ignores the values of all
- * fields not covered by the mask.
- *
- * If a repeated field is specified for an update operation, new values will
- * be appended to the existing repeated field in the target resource. Note that
- * a repeated field is only allowed in the last position of a `paths` string.
- *
- * If a sub-message is specified in the last position of the field mask for an
- * update operation, then new value will be merged into the existing sub-message
- * in the target resource.
- *
- * For example, given the target message:
- *
- *     f {
- *       b {
- *         d: 1
- *         x: 2
- *       }
- *       c: [1]
- *     }
- *
- * And an update message:
- *
- *     f {
- *       b {
- *         d: 10
- *       }
- *       c: [2]
- *     }
- *
- * then if the field mask is:
- *
- *  paths: ["f.b", "f.c"]
- *
- * then the result will be:
- *
- *     f {
- *       b {
- *         d: 10
- *         x: 2
- *       }
- *       c: [1, 2]
- *     }
- *
- * An implementation may provide options to override this default behavior for
- * repeated and message fields.
- *
- * In order to reset a field's value to the default, the field must
- * be in the mask and set to the default value in the provided resource.
- * Hence, in order to reset all fields of a resource, provide a default
- * instance of the resource and set all fields in the mask, or do
- * not provide a mask as described below.
- *
- * If a field mask is not present on update, the operation applies to
- * all fields (as if a field mask of all fields has been specified).
- * Note that in the presence of schema evolution, this may mean that
- * fields the client does not know and has therefore not filled into
- * the request will be reset to their default. If this is unwanted
- * behavior, a specific service may require a client to always specify
- * a field mask, producing an error if not.
- *
- * As with get operations, the location of the resource which
- * describes the updated values in the request message depends on the
- * operation kind. In any case, the effect of the field mask is
- * required to be honored by the API.
- *
- * ## Considerations for HTTP REST
- *
- * The HTTP kind of an update operation which uses a field mask must
- * be set to PATCH instead of PUT in order to satisfy HTTP semantics
- * (PUT must only be used for full updates).
- *
- * # JSON Encoding of Field Masks
- *
- * In JSON, a field mask is encoded as a single string where paths are
- * separated by a comma. Fields name in each path are converted
- * to/from lower-camel naming conventions.
- *
- * As an example, consider the following message declarations:
- *
- *     message Profile {
- *       User user = 1;
- *       Photo photo = 2;
- *     }
- *     message User {
- *       string display_name = 1;
- *       string address = 2;
- *     }
- *
- * In proto a field mask for `Profile` may look as such:
- *
- *     mask {
- *       paths: "user.display_name"
- *       paths: "photo"
- *     }
- *
- * In JSON, the same mask is represented as below:
- *
- *     {
- *       mask: "user.displayName,photo"
- *     }
- *
- * # Field Masks and Oneof Fields
- *
- * Field masks treat fields in oneofs just as regular fields. Consider the
- * following message:
- *
- *     message SampleMessage {
- *       oneof test_oneof {
- *         string name = 4;
- *         SubMessage sub_message = 9;
- *       }
- *     }
- *
- * The field mask can be:
- *
- *     mask {
- *       paths: "name"
- *     }
- *
- * Or:
- *
- *     mask {
- *       paths: "sub_message"
- *     }
- *
- * Note that oneof type names ("test_oneof" in this case) cannot be used in
- * paths.
- *
- * ## Field Mask Verification
- *
- * The implementation of any API method which has a FieldMask type field in the
- * request should verify the included field paths, and return an
- * `INVALID_ARGUMENT` error if any path is unmappable.
- *
- * @generated from message google.protobuf.FieldMask
- */
-export class FieldMask extends Message {
-    constructor(data) {
-        super();
-        /**
-         * The set of field mask paths.
-         *
-         * @generated from field: repeated string paths = 1;
-         */
-        this.paths = [];
-        proto3.util.initPartial(data, this);
-    }
-    toJson(options) {
-        // 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('');
-        }
-        return this.paths.map(p => {
-            if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) {
-                throw new Error("cannot encode google.protobuf.FieldMask to JSON: lowerCamelCase of path name \"" + p + "\" is irreversible");
-            }
-            return protoCamelCase(p);
-        }).join(",");
-    }
-    fromJson(json, options) {
-        if (typeof json !== "string") {
-            throw new Error("cannot decode google.protobuf.FieldMask from JSON: " + proto3.json.debug(json));
-        }
-        if (json === "") {
-            return this;
-        }
-        function camelToSnake(str) {
-            if (str.includes("_")) {
-                throw new Error("cannot decode google.protobuf.FieldMask from JSON: path names must be lowerCamelCase");
-            }
-            const sc = str.replace(/[A-Z]/g, letter => "_" + letter.toLowerCase());
-            return (sc[0] === "_") ? sc.substring(1) : sc;
-        }
-        this.paths = json.split(",").map(camelToSnake);
-        return this;
-    }
-    static fromBinary(bytes, options) {
-        return new FieldMask().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new FieldMask().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new FieldMask().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(FieldMask, a, b);
-    }
-}
-FieldMask.runtime = proto3;
-FieldMask.typeName = "google.protobuf.FieldMask";
-FieldMask.fields = proto3.util.newFieldList(() => [
-    { no: 1, name: "paths", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
-]);

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

@@ -1,29 +0,0 @@
-import type { PartialMessage, PlainMessage } from "../../message.js";
-import { Message } from "../../message.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";
-/**
- * `SourceContext` represents information about the source of a
- * protobuf element, like the file in which it is defined.
- *
- * @generated from message google.protobuf.SourceContext
- */
-export declare class SourceContext extends Message<SourceContext> {
-    /**
-     * The path-qualified name of the .proto file that contained the associated
-     * protobuf element.  For example: `"google/protobuf/source_context.proto"`.
-     *
-     * @generated from field: string file_name = 1;
-     */
-    fileName: string;
-    constructor(data?: PartialMessage<SourceContext>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "google.protobuf.SourceContext";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceContext;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceContext;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceContext;
-    static equals(a: SourceContext | PlainMessage<SourceContext> | undefined, b: SourceContext | PlainMessage<SourceContext> | undefined): boolean;
-}

package/dist/esm/google/protobuf/source_context_pb.js

@@ -1,51 +0,0 @@
-// Copyright 2021-2024 Buf Technologies, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Message } from "../../message.js";
-import { proto3 } from "../../proto3.js";
-/**
- * `SourceContext` represents information about the source of a
- * protobuf element, like the file in which it is defined.
- *
- * @generated from message google.protobuf.SourceContext
- */
-export class SourceContext extends Message {
-    constructor(data) {
-        super();
-        /**
-         * The path-qualified name of the .proto file that contained the associated
-         * protobuf element.  For example: `"google/protobuf/source_context.proto"`.
-         *
-         * @generated from field: string file_name = 1;
-         */
-        this.fileName = "";
-        proto3.util.initPartial(data, this);
-    }
-    static fromBinary(bytes, options) {
-        return new SourceContext().fromBinary(bytes, options);
-    }
-    static fromJson(jsonValue, options) {
-        return new SourceContext().fromJson(jsonValue, options);
-    }
-    static fromJsonString(jsonString, options) {
-        return new SourceContext().fromJsonString(jsonString, options);
-    }
-    static equals(a, b) {
-        return proto3.util.equals(SourceContext, a, b);
-    }
-}
-SourceContext.runtime = proto3;
-SourceContext.typeName = "google.protobuf.SourceContext";
-SourceContext.fields = proto3.util.newFieldList(() => [
-    { no: 1, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-]);