@in-human-resources/backend-proto 0.1.4 → 0.1.6

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/binary-encoding.js

@@ -0,0 +1,439 @@
+// 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 { varint32read, varint32write, varint64read, varint64write, } from "./google/varint.js";
+import { assertFloat32, assertInt32, assertUInt32 } from "./private/assert.js";
+import { protoInt64 } from "./proto-int64.js";
+/* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
+/**
+ * Protobuf binary format wire types.
+ *
+ * A wire type provides just enough information to find the length of the
+ * following value.
+ *
+ * See https://developers.google.com/protocol-buffers/docs/encoding#structure
+ */
+export var WireType;
+(function (WireType) {
+    /**
+     * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
+     */
+    WireType[WireType["Varint"] = 0] = "Varint";
+    /**
+     * Used for fixed64, sfixed64, double.
+     * Always 8 bytes with little-endian byte order.
+     */
+    WireType[WireType["Bit64"] = 1] = "Bit64";
+    /**
+     * Used for string, bytes, embedded messages, packed repeated fields
+     *
+     * Only repeated numeric types (types which use the varint, 32-bit,
+     * or 64-bit wire types) can be packed. In proto3, such fields are
+     * packed by default.
+     */
+    WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited";
+    /**
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
+     */
+    WireType[WireType["StartGroup"] = 3] = "StartGroup";
+    /**
+     * End of a tag-delimited aggregate.
+     */
+    WireType[WireType["EndGroup"] = 4] = "EndGroup";
+    /**
+     * Used for fixed32, sfixed32, float.
+     * Always 4 bytes with little-endian byte order.
+     */
+    WireType[WireType["Bit32"] = 5] = "Bit32";
+})(WireType || (WireType = {}));
+export class BinaryWriter {
+    constructor(textEncoder) {
+        /**
+         * Previous fork states.
+         */
+        this.stack = [];
+        this.textEncoder = textEncoder !== null && textEncoder !== void 0 ? textEncoder : new TextEncoder();
+        this.chunks = [];
+        this.buf = [];
+    }
+    /**
+     * Return all bytes written and reset this writer.
+     */
+    finish() {
+        this.chunks.push(new Uint8Array(this.buf)); // flush the buffer
+        let len = 0;
+        for (let i = 0; i < this.chunks.length; i++)
+            len += this.chunks[i].length;
+        let bytes = new Uint8Array(len);
+        let offset = 0;
+        for (let i = 0; i < this.chunks.length; i++) {
+            bytes.set(this.chunks[i], offset);
+            offset += this.chunks[i].length;
+        }
+        this.chunks = [];
+        return bytes;
+    }
+    /**
+     * Start a new fork for length-delimited data like a message
+     * or a packed repeated field.
+     *
+     * Must be joined later with `join()`.
+     */
+    fork() {
+        this.stack.push({ chunks: this.chunks, buf: this.buf });
+        this.chunks = [];
+        this.buf = [];
+        return this;
+    }
+    /**
+     * Join the last fork. Write its length and bytes, then
+     * return to the previous state.
+     */
+    join() {
+        // get chunk of fork
+        let chunk = this.finish();
+        // restore previous state
+        let prev = this.stack.pop();
+        if (!prev)
+            throw new Error("invalid state, fork stack empty");
+        this.chunks = prev.chunks;
+        this.buf = prev.buf;
+        // write length of chunk as varint
+        this.uint32(chunk.byteLength);
+        return this.raw(chunk);
+    }
+    /**
+     * Writes a tag (field number and wire type).
+     *
+     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+     *
+     * Generated code should compute the tag ahead of time and call `uint32()`.
+     */
+    tag(fieldNo, type) {
+        return this.uint32(((fieldNo << 3) | type) >>> 0);
+    }
+    /**
+     * Write a chunk of raw bytes.
+     */
+    raw(chunk) {
+        if (this.buf.length) {
+            this.chunks.push(new Uint8Array(this.buf));
+            this.buf = [];
+        }
+        this.chunks.push(chunk);
+        return this;
+    }
+    /**
+     * Write a `uint32` value, an unsigned 32 bit varint.
+     */
+    uint32(value) {
+        assertUInt32(value);
+        // write value as varint 32, inlined for speed
+        while (value > 0x7f) {
+            this.buf.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
+        }
+        this.buf.push(value);
+        return this;
+    }
+    /**
+     * Write a `int32` value, a signed 32 bit varint.
+     */
+    int32(value) {
+        assertInt32(value);
+        varint32write(value, this.buf);
+        return this;
+    }
+    /**
+     * Write a `bool` value, a variant.
+     */
+    bool(value) {
+        this.buf.push(value ? 1 : 0);
+        return this;
+    }
+    /**
+     * Write a `bytes` value, length-delimited arbitrary data.
+     */
+    bytes(value) {
+        this.uint32(value.byteLength); // write length of chunk as varint
+        return this.raw(value);
+    }
+    /**
+     * Write a `string` value, length-delimited data converted to UTF-8 text.
+     */
+    string(value) {
+        let chunk = this.textEncoder.encode(value);
+        this.uint32(chunk.byteLength); // write length of chunk as varint
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `float` value, 32-bit floating point number.
+     */
+    float(value) {
+        assertFloat32(value);
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setFloat32(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `double` value, a 64-bit floating point number.
+     */
+    double(value) {
+        let chunk = new Uint8Array(8);
+        new DataView(chunk.buffer).setFloat64(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(value) {
+        assertUInt32(value);
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setUint32(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(value) {
+        assertInt32(value);
+        let chunk = new Uint8Array(4);
+        new DataView(chunk.buffer).setInt32(0, value, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(value) {
+        assertInt32(value);
+        // zigzag encode
+        value = ((value << 1) ^ (value >> 31)) >>> 0;
+        varint32write(value, this.buf);
+        return this;
+    }
+    /**
+     * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(value) {
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
+        view.setInt32(0, tc.lo, true);
+        view.setInt32(4, tc.hi, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(value) {
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
+        view.setInt32(0, tc.lo, true);
+        view.setInt32(4, tc.hi, true);
+        return this.raw(chunk);
+    }
+    /**
+     * Write a `int64` value, a signed 64-bit varint.
+     */
+    int64(value) {
+        let tc = protoInt64.enc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
+        return this;
+    }
+    /**
+     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(value) {
+        let tc = protoInt64.enc(value), 
+        // zigzag encode
+        sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
+        varint64write(lo, hi, this.buf);
+        return this;
+    }
+    /**
+     * Write a `uint64` value, an unsigned 64-bit varint.
+     */
+    uint64(value) {
+        let tc = protoInt64.uEnc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
+        return this;
+    }
+}
+export class BinaryReader {
+    constructor(buf, textDecoder) {
+        this.varint64 = varint64read; // dirty cast for `this`
+        /**
+         * Read a `uint32` field, an unsigned 32 bit varint.
+         */
+        this.uint32 = varint32read; // dirty cast for `this` and access to protected `buf`
+        this.buf = buf;
+        this.len = buf.length;
+        this.pos = 0;
+        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        this.textDecoder = textDecoder !== null && textDecoder !== void 0 ? textDecoder : new TextDecoder();
+    }
+    /**
+     * Reads a tag - field number and wire type.
+     */
+    tag() {
+        let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+        if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+            throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+        return [fieldNo, wireType];
+    }
+    /**
+     * Skip one element and return the skipped data.
+     *
+     * When skipping StartGroup, provide the tags field number to check for
+     * matching field number in the EndGroup tag.
+     */
+    skip(wireType, fieldNo) {
+        let start = this.pos;
+        switch (wireType) {
+            case WireType.Varint:
+                while (this.buf[this.pos++] & 0x80) {
+                    // ignore
+                }
+                break;
+            // eslint-disable-next-line
+            // @ts-ignore TS7029: Fallthrough case in switch
+            case WireType.Bit64:
+                this.pos += 4;
+            // eslint-disable-next-line
+            // @ts-ignore TS7029: Fallthrough case in switch
+            case WireType.Bit32:
+                this.pos += 4;
+                break;
+            case WireType.LengthDelimited:
+                let len = this.uint32();
+                this.pos += len;
+                break;
+            case WireType.StartGroup:
+                for (;;) {
+                    const [fn, wt] = this.tag();
+                    if (wt === WireType.EndGroup) {
+                        if (fieldNo !== undefined && fn !== fieldNo) {
+                            throw new Error("invalid end group tag");
+                        }
+                        break;
+                    }
+                    this.skip(wt, fn);
+                }
+                break;
+            default:
+                throw new Error("cant skip wire type " + wireType);
+        }
+        this.assertBounds();
+        return this.buf.subarray(start, this.pos);
+    }
+    /**
+     * Throws error if position in byte array is out of range.
+     */
+    assertBounds() {
+        if (this.pos > this.len)
+            throw new RangeError("premature EOF");
+    }
+    /**
+     * Read a `int32` field, a signed 32 bit varint.
+     */
+    int32() {
+        return this.uint32() | 0;
+    }
+    /**
+     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32() {
+        let zze = this.uint32();
+        // decode zigzag
+        return (zze >>> 1) ^ -(zze & 1);
+    }
+    /**
+     * Read a `int64` field, a signed 64-bit varint.
+     */
+    int64() {
+        return protoInt64.dec(...this.varint64());
+    }
+    /**
+     * Read a `uint64` field, an unsigned 64-bit varint.
+     */
+    uint64() {
+        return protoInt64.uDec(...this.varint64());
+    }
+    /**
+     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64() {
+        let [lo, hi] = this.varint64();
+        // decode zig zag
+        let s = -(lo & 1);
+        lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s;
+        hi = (hi >>> 1) ^ s;
+        return protoInt64.dec(lo, hi);
+    }
+    /**
+     * Read a `bool` field, a variant.
+     */
+    bool() {
+        let [lo, hi] = this.varint64();
+        return lo !== 0 || hi !== 0;
+    }
+    /**
+     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32() {
+        return this.view.getUint32((this.pos += 4) - 4, true);
+    }
+    /**
+     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32() {
+        return this.view.getInt32((this.pos += 4) - 4, true);
+    }
+    /**
+     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64() {
+        return protoInt64.uDec(this.sfixed32(), this.sfixed32());
+    }
+    /**
+     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64() {
+        return protoInt64.dec(this.sfixed32(), this.sfixed32());
+    }
+    /**
+     * Read a `float` field, 32-bit floating point number.
+     */
+    float() {
+        return this.view.getFloat32((this.pos += 4) - 4, true);
+    }
+    /**
+     * Read a `double` field, a 64-bit floating point number.
+     */
+    double() {
+        return this.view.getFloat64((this.pos += 8) - 8, true);
+    }
+    /**
+     * Read a `bytes` field, length-delimited arbitrary data.
+     */
+    bytes() {
+        let len = this.uint32(), start = this.pos;
+        this.pos += len;
+        this.assertBounds();
+        return this.buf.subarray(start, start + len);
+    }
+    /**
+     * Read a `string` field, length-delimited data converted to UTF-8 text.
+     */
+    string() {
+        return this.textDecoder.decode(this.bytes());
+    }
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/binary-format.d.ts

@@ -0,0 +1,113 @@
+import type { Message } from "./message.js";
+import type { IBinaryReader, IBinaryWriter, WireType } from "./binary-encoding.js";
+import type { FieldInfo } from "./field.js";
+/**
+ * BinaryFormat is the contract for serializing messages to and from binary
+ * data. Implementations may be specific to a proto syntax, and can be
+ * reflection based, or delegate to speed optimized generated code.
+ */
+export interface BinaryFormat {
+    /**
+     * Provide options for parsing binary data.
+     */
+    makeReadOptions(options?: Partial<BinaryReadOptions>): Readonly<BinaryReadOptions>;
+    /**
+     * Provide options for serializing binary data.
+     */
+    makeWriteOptions(options?: Partial<BinaryWriteOptions>): Readonly<BinaryWriteOptions>;
+    /**
+     * Parse a message from binary data, merging fields.
+     *
+     * Supports two message encodings:
+     * - length-prefixed: delimitedMessageEncoding is false or omitted, and
+     *   lengthOrEndTagFieldNo is the expected length of the message in the reader.
+     * - delimited: delimitedMessageEncoding is true, and lengthOrEndTagFieldNo is
+     *   the field number in a tag with wire type end-group signalling the end of
+     *   the message in the reader.
+     *
+     * delimitedMessageEncoding is optional for backwards compatibility.
+     */
+    readMessage(message: Message, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
+    /**
+     * Parse a field from binary data, and store it in the given target.
+     *
+     * The target must be an initialized message object, with oneof groups,
+     * repeated fields and maps already present.
+     */
+    readField(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+    reader: IBinaryReader, field: FieldInfo, wireType: WireType, options: BinaryReadOptions): void;
+    /**
+     * Serialize a message to binary data.
+     */
+    writeMessage(message: Message, writer: IBinaryWriter, options: BinaryWriteOptions): void;
+    /**
+     * Serialize a field value to binary data.
+     *
+     * The value must be an array for repeated fields, a record object for map
+     * fields. Only selected oneof fields should be passed to this method.
+     */
+    writeField(field: FieldInfo, value: any, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+    writer: IBinaryWriter, options: BinaryWriteOptions): void;
+    /**
+     * Retrieve the unknown fields for the given message.
+     *
+     * Unknown fields are well-formed protocol buffer serialized data for
+     * fields that the parserdoes not recognize.
+     *
+     * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+     */
+    listUnknownFields(message: Message): ReadonlyArray<{
+        no: number;
+        wireType: WireType;
+        data: Uint8Array;
+    }>;
+    /**
+     * Discard unknown fields for the given message.
+     */
+    discardUnknownFields(message: Message): void;
+    /**
+     * Retrieve the unknown fields for the given message and write them to
+     * the given writer. This method is called when a message is serialized,
+     * so the fields that are unknown to the parser persist through a round
+     * trip.
+     */
+    writeUnknownFields(message: Message, writer: IBinaryWriter): void;
+    /**
+     * Store an unknown field for the given message. The parser will use this
+     * method if it does not recognize a field, unless the option
+     * `readUnknownFields` has been disabled.
+     */
+    onUnknownField(message: Message, no: number, wireType: WireType, data: Uint8Array): void;
+}
+/**
+ * Options for parsing binary data.
+ */
+export interface BinaryReadOptions {
+    /**
+     * Retain unknown fields during parsing? The default behavior is to retain
+     * unknown fields and include them in the serialized output.
+     *
+     * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+     */
+    readUnknownFields: boolean;
+    /**
+     * Allows to use a custom implementation to decode binary data.
+     */
+    readerFactory: (bytes: Uint8Array) => IBinaryReader;
+}
+/**
+ * Options for serializing to binary data.
+ */
+export interface BinaryWriteOptions {
+    /**
+     * Include unknown fields in the serialized output? The default behavior
+     * is to retain unknown fields and include them in the serialized output.
+     *
+     * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns
+     */
+    writeUnknownFields: boolean;
+    /**
+     * Allows to use a custom implementation to encode binary data.
+     */
+    writerFactory: () => IBinaryWriter;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/binary-format.js

@@ -0,0 +1,14 @@
+// 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.
+export {};

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/codegen-info.d.ts

@@ -0,0 +1,33 @@
+import { reifyWkt } from "./private/reify-wkt.js";
+import type { DescEnum, DescEnumValue, DescField, DescExtension, DescMessage, DescMethod, DescOneof, DescService } from "./descriptor-set.js";
+import type { ScalarValue } from "./scalar.js";
+import { LongType, ScalarType } from "./scalar.js";
+interface CodegenInfo {
+    /**
+     * Name of the runtime library NPM package.
+     */
+    readonly packageName: string;
+    readonly localName: (desc: DescEnum | DescEnumValue | DescMessage | DescExtension | DescOneof | DescField | DescService | DescMethod) => string;
+    readonly symbols: Record<RuntimeSymbolName, RuntimeSymbolInfo>;
+    readonly getUnwrappedFieldType: (field: DescField | DescExtension) => ScalarType | undefined;
+    readonly wktSourceFiles: readonly string[];
+    /**
+     * @deprecated please use scalarZeroValue instead
+     */
+    readonly scalarDefaultValue: (type: ScalarType, longType: LongType) => any;
+    readonly scalarZeroValue: <T extends ScalarType, L extends LongType>(type: T, longType: L) => ScalarValue<T, L>;
+    /**
+     * @deprecated please use reifyWkt from @bufbuild/protoplugin/ecmascript instead
+     */
+    readonly reifyWkt: typeof reifyWkt;
+    readonly safeIdentifier: (name: string) => string;
+    readonly safeObjectProperty: (name: string) => string;
+}
+type RuntimeSymbolName = "proto2" | "proto3" | "Message" | "PartialMessage" | "PlainMessage" | "FieldList" | "MessageType" | "Extension" | "BinaryReadOptions" | "BinaryWriteOptions" | "JsonReadOptions" | "JsonWriteOptions" | "JsonValue" | "JsonObject" | "protoDouble" | "protoInt64" | "ScalarType" | "LongType" | "MethodKind" | "MethodIdempotency" | "IMessageTypeRegistry";
+type RuntimeSymbolInfo = {
+    typeOnly: boolean;
+    publicImportPath: string;
+    privateImportPath: string;
+};
+export declare const codegenInfo: CodegenInfo;
+export {};

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/codegen-info.js

@@ -0,0 +1,67 @@
+// 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 { localName, safeIdentifier, safeObjectProperty, } from "./private/names.js";
+import { getUnwrappedFieldType } from "./private/field-wrapper.js";
+import { scalarZeroValue } from "./private/scalars.js";
+import { reifyWkt } from "./private/reify-wkt.js";
+import { LongType, ScalarType } from "./scalar.js";
+const packageName = "@bufbuild/protobuf";
+export const codegenInfo = {
+    packageName: "@bufbuild/protobuf",
+    localName,
+    reifyWkt,
+    getUnwrappedFieldType,
+    scalarDefaultValue: scalarZeroValue,
+    scalarZeroValue,
+    safeIdentifier,
+    safeObjectProperty,
+    // prettier-ignore
+    symbols: {
+        proto2: { typeOnly: false, privateImportPath: "./proto2.js", publicImportPath: packageName },
+        proto3: { typeOnly: false, privateImportPath: "./proto3.js", publicImportPath: packageName },
+        Message: { typeOnly: false, privateImportPath: "./message.js", publicImportPath: packageName },
+        PartialMessage: { typeOnly: true, privateImportPath: "./message.js", publicImportPath: packageName },
+        PlainMessage: { typeOnly: true, privateImportPath: "./message.js", publicImportPath: packageName },
+        FieldList: { typeOnly: true, privateImportPath: "./field-list.js", publicImportPath: packageName },
+        MessageType: { typeOnly: true, privateImportPath: "./message-type.js", publicImportPath: packageName },
+        Extension: { typeOnly: true, privateImportPath: "./extension.js", publicImportPath: packageName },
+        BinaryReadOptions: { typeOnly: true, privateImportPath: "./binary-format.js", publicImportPath: packageName },
+        BinaryWriteOptions: { typeOnly: true, privateImportPath: "./binary-format.js", publicImportPath: packageName },
+        JsonReadOptions: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        JsonWriteOptions: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        JsonValue: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        JsonObject: { typeOnly: true, privateImportPath: "./json-format.js", publicImportPath: packageName },
+        protoDouble: { typeOnly: false, privateImportPath: "./proto-double.js", publicImportPath: packageName },
+        protoInt64: { typeOnly: false, privateImportPath: "./proto-int64.js", publicImportPath: packageName },
+        ScalarType: { typeOnly: false, privateImportPath: "./scalar.js", publicImportPath: packageName },
+        LongType: { typeOnly: false, privateImportPath: "./scalar.js", publicImportPath: packageName },
+        MethodKind: { typeOnly: false, privateImportPath: "./service-type.js", publicImportPath: packageName },
+        MethodIdempotency: { typeOnly: false, privateImportPath: "./service-type.js", publicImportPath: packageName },
+        IMessageTypeRegistry: { typeOnly: true, privateImportPath: "./type-registry.js", publicImportPath: packageName },
+    },
+    wktSourceFiles: [
+        "google/protobuf/compiler/plugin.proto",
+        "google/protobuf/any.proto",
+        "google/protobuf/api.proto",
+        "google/protobuf/descriptor.proto",
+        "google/protobuf/duration.proto",
+        "google/protobuf/empty.proto",
+        "google/protobuf/field_mask.proto",
+        "google/protobuf/source_context.proto",
+        "google/protobuf/struct.proto",
+        "google/protobuf/timestamp.proto",
+        "google/protobuf/type.proto",
+        "google/protobuf/wrappers.proto",
+    ],
+};