ts-proto 1.171.0 → 1.173.0

package/README.markdown

@@ -796,6 +796,14 @@ type OneOfCase<T, K extends OneOfCases<T>> = T extends {
 }
   ? T[U]
   : never;
+
+/** Extracts the specific type of a value type from a oneOf field */
+export type OneOfValue<T, K extends OneOfCases<T>> = T extends {
+  $case: K;
+  [key: string]: unknown;
+}
+  ? T
+  : never;
 ```
 
 # Default values and unset fields

package/build/case.d.ts

@@ -0,0 +1,8 @@
+import { Options } from "./options";
+/** Converts `key` to TS/JS camel-case idiom, unless overridden not to. */
+export declare function maybeSnakeToCamel(key: string, options: Pick<Options, "snakeToCamel">): string;
+export declare function snakeToCamel(s: string): string;
+export declare function camelToSnake(s: string): string;
+export declare function capitalize(s: string): string;
+export declare function uncapitalize(s: string): string;
+export declare function camelCaseGrpc(s: string): string;

package/build/context.d.ts

@@ -0,0 +1,19 @@
+import { TypeMap } from "./types";
+import { Utils } from "./main";
+import { Options } from "./options";
+import { FileDescriptorProto } from "ts-proto-descriptors";
+/** Provides a parameter object for passing around the various context/config data. */
+export interface BaseContext {
+    options: Options;
+    typeMap: TypeMap;
+    utils: Utils;
+}
+export interface Context extends BaseContext {
+    currentFile: FileContext;
+}
+export interface FileContext {
+    isProto3Syntax: boolean;
+}
+export declare function createFileContext(file: FileDescriptorProto): {
+    isProto3Syntax: boolean;
+};

package/build/encode.d.ts

@@ -0,0 +1,4 @@
+import { Context } from "./context";
+import { Code } from "ts-poet";
+export declare function generateEncoder(ctx: Context, typeName: string): Code;
+export declare function generateDecoder(ctx: Context, typeName: string): Code;

package/build/enums.d.ts

@@ -0,0 +1,19 @@
+import { Code } from "ts-poet";
+import { EnumDescriptorProto, EnumValueDescriptorProto } from "ts-proto-descriptors";
+import SourceInfo from "./sourceInfo";
+import { Context } from "./context";
+type UnrecognizedEnum = {
+    present: false;
+} | {
+    present: true;
+    name: string;
+};
+export declare function generateEnum(ctx: Context, fullName: string, enumDesc: EnumDescriptorProto, sourceInfo: SourceInfo): Code;
+/** Generates a function with a big switch statement to decode JSON -> our enum. */
+export declare function generateEnumFromJson(ctx: Context, fullName: string, enumDesc: EnumDescriptorProto, unrecognizedEnum: UnrecognizedEnum): Code;
+/** Generates a function with a big switch statement to encode our enum -> JSON. */
+export declare function generateEnumToJson(ctx: Context, fullName: string, enumDesc: EnumDescriptorProto, unrecognizedEnum: UnrecognizedEnum): Code;
+/** Generates a function with a big switch statement to encode our string enum -> int value. */
+export declare function generateEnumToNumber(ctx: Context, fullName: string, enumDesc: EnumDescriptorProto, unrecognizedEnum: UnrecognizedEnum): Code;
+export declare function getMemberName(ctx: Context, enumDesc: EnumDescriptorProto, valueDesc: EnumValueDescriptorProto): string;
+export {};

package/build/generate-async-iterable.d.ts

@@ -0,0 +1,6 @@
+import { Code } from "ts-poet";
+import { Utils } from "./main";
+/** Creates a function to transform a message Source to a Uint8Array Source. */
+export declare function generateEncodeTransform(utils: Utils, fullName: string): Code;
+/** Creates a function to transform a Uint8Array Source to a message Source. */
+export declare function generateDecodeTransform(utils: Utils, fullName: string): Code;

package/build/generate-generic-service-definition.d.ts

@@ -0,0 +1,8 @@
+import { Code } from "ts-poet";
+import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Context } from "./context";
+import SourceInfo from "./sourceInfo";
+/**
+ * Generates a framework-agnostic service descriptor.
+ */
+export declare function generateGenericServiceDefinition(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;

package/build/generate-grpc-js.d.ts

@@ -0,0 +1,9 @@
+import { Code } from "ts-poet";
+import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Context } from "./context";
+import SourceInfo from "./sourceInfo";
+/**
+ * Generates a service definition and server / client stubs for the
+ * `@grpc/grpc-js` library.
+ */
+export declare function generateGrpcJsService(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;

package/build/generate-grpc-web.d.ts

@@ -0,0 +1,17 @@
+import { MethodDescriptorProto, FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Code } from "ts-poet";
+import { Context } from "./context";
+/** Generates a client that uses the `@improbable-web/grpc-web` library. */
+export declare function generateGrpcClientImpl(ctx: Context, _fileDesc: FileDescriptorProto, serviceDesc: ServiceDescriptorProto): Code;
+/** Creates the service descriptor that grpc-web needs at runtime. */
+export declare function generateGrpcServiceDesc(fileDesc: FileDescriptorProto, serviceDesc: ServiceDescriptorProto): Code;
+/**
+ * Creates the method descriptor that grpc-web needs at runtime to make `unary` calls.
+ *
+ * Note that we take a few liberties in the implementation give we don't 100% match
+ * what grpc-web's existing output is, but it works out; see comments in the method
+ * implementation.
+ */
+export declare function generateGrpcMethodDesc(ctx: Context, serviceDesc: ServiceDescriptorProto, methodDesc: MethodDescriptorProto): Code;
+/** Adds misc top-level definitions for grpc-web functionality. */
+export declare function addGrpcWebMisc(ctx: Context, hasStreamingMethods: boolean): Code;

package/build/generate-nestjs.d.ts

@@ -0,0 +1,7 @@
+import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Code } from "ts-poet";
+import SourceInfo from "./sourceInfo";
+import { Context } from "./context";
+export declare function generateNestjsServiceController(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;
+export declare function generateNestjsServiceClient(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;
+export declare function generateNestjsGrpcServiceMethodsDecorator(ctx: Context, serviceDesc: ServiceDescriptorProto): Code;

package/build/generate-nice-grpc.d.ts

@@ -0,0 +1,8 @@
+import { Code } from "ts-poet";
+import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Context } from "./context";
+import SourceInfo from "./sourceInfo";
+/**
+ * Generates server / client stubs for `nice-grpc` library.
+ */
+export declare function generateNiceGrpcService(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;

package/build/generate-services.d.ts

@@ -0,0 +1,31 @@
+import { FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Code } from "ts-poet";
+import SourceInfo from "./sourceInfo";
+import { Context } from "./context";
+/**
+ * Generates an interface for `serviceDesc`.
+ *
+ * Some RPC frameworks (i.e. Twirp) can use the same interface, i.e.
+ * `getFoo(req): Promise<res>` for the client-side and server-side,
+ * which is the intent for this interface.
+ *
+ * Other RPC frameworks (i.e. NestJS) that need different client-side
+ * vs. server-side code/interfaces are handled separately.
+ */
+export declare function generateService(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;
+export declare function generateServiceClientImpl(ctx: Context, fileDesc: FileDescriptorProto, serviceDesc: ServiceDescriptorProto): Code;
+/**
+ * Creates an `Rpc.request(service, method, data)` abstraction.
+ *
+ * This lets clients pass in their own request-promise-ish client.
+ *
+ * This also requires clientStreamingRequest, serverStreamingRequest and
+ * bidirectionalStreamingRequest methods if any of the RPCs is streaming.
+ *
+ * We don't export this because if a project uses multiple `*.proto` files,
+ * we don't want our the barrel imports in `index.ts` to have multiple `Rpc`
+ * types.
+ */
+export declare function generateRpcType(ctx: Context, hasStreamingMethods: boolean): Code;
+export declare function generateDataLoadersType(): Code;
+export declare function generateDataLoaderOptionsType(): Code;

package/build/generate-struct-wrappers.d.ts

@@ -0,0 +1,36 @@
+import { Context } from "./context";
+import { Code } from "ts-poet";
+export type StructFieldNames = {
+    nullValue: string;
+    numberValue: string;
+    stringValue: string;
+    boolValue: string;
+    structValue: string;
+    listValue: string;
+};
+/** Whether we need to generate `.wrap` and `.unwrap` methods for the given type. */
+export declare function isWrapperType(fullProtoTypeName: string): boolean;
+/**
+ * Converts ts-proto's idiomatic Struct/Value/ListValue representation to the proto messages.
+ *
+ * We do this deeply b/c NestJS does not invoke wrappers recursively.
+ */
+export declare function generateWrapDeep(ctx: Context, fullProtoTypeName: string, fieldNames: StructFieldNames): Code[];
+/**
+ * Converts proto's Struct/Value?listValue messages to ts-proto's idiomatic representation.
+ *
+ * We do this deeply b/c NestJS does not invoke wrappers recursively.
+ */
+export declare function generateUnwrapDeep(ctx: Context, fullProtoTypeName: string, fieldNames: StructFieldNames): Code[];
+/**
+ * Converts ts-proto's idiomatic Struct/Value/ListValue representation to the proto messages.
+ *
+ * We do this shallow's b/c ts-proto's encode methods handle the recursion.
+ */
+export declare function generateWrapShallow(ctx: Context, fullProtoTypeName: string, fieldNames: StructFieldNames): Code[];
+/**
+ * Converts proto's Struct/Value?listValue messages to ts-proto's idiomatic representation.
+ *
+ * We do this shallowly b/c ts-proto's decode methods handle recursion.
+ */
+export declare function generateUnwrapShallow(ctx: Context, fullProtoTypeName: string, fieldNames: StructFieldNames): Code[];

package/build/generate-type-registry.d.ts

@@ -0,0 +1,3 @@
+import { Code } from "ts-poet";
+import { BaseContext } from "./context";
+export declare function generateTypeRegistry(ctx: BaseContext): Code;

package/build/index.d.ts

@@ -0,0 +1 @@
+export { DateOption, EnvOption, JsonTimestampOption, LongOption, OneofOption, Options, ServiceOption } from "./options";

package/build/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceOption = exports.OneofOption = exports.LongOption = exports.JsonTimestampOption = exports.EnvOption = exports.DateOption = void 0;
+var options_1 = require("./options");
+Object.defineProperty(exports, "DateOption", { enumerable: true, get: function () { return options_1.DateOption; } });
+Object.defineProperty(exports, "EnvOption", { enumerable: true, get: function () { return options_1.EnvOption; } });
+Object.defineProperty(exports, "JsonTimestampOption", { enumerable: true, get: function () { return options_1.JsonTimestampOption; } });
+Object.defineProperty(exports, "LongOption", { enumerable: true, get: function () { return options_1.LongOption; } });
+Object.defineProperty(exports, "OneofOption", { enumerable: true, get: function () { return options_1.OneofOption; } });
+Object.defineProperty(exports, "ServiceOption", { enumerable: true, get: function () { return options_1.ServiceOption; } });

package/build/main.d.ts

@@ -0,0 +1,54 @@
+import { Code } from "ts-poet";
+import { ConditionalOutput } from "ts-poet/build/ConditionalOutput";
+import { FileDescriptorProto } from "ts-proto-descriptors";
+import { Context } from "./context";
+import { Options } from "./options";
+export declare function generateFile(ctx: Context, fileDesc: FileDescriptorProto): [string, Code];
+export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils>;
+/** These are runtime utility methods used by the generated code. */
+export declare function makeUtils(options: Options): Utils;
+declare function makeLongUtils(options: Options, bytes: ReturnType<typeof makeByteUtils>): {
+    numberToLong: ConditionalOutput;
+    longToNumber: ConditionalOutput;
+    longToString: ConditionalOutput;
+    longToBigint: ConditionalOutput;
+    Long: ConditionalOutput;
+};
+declare function makeByteUtils(options: Options): {
+    globalThis: ConditionalOutput;
+    bytesFromBase64: ConditionalOutput;
+    base64FromBytes: ConditionalOutput;
+};
+declare function makeDeepPartial(options: Options, longs: ReturnType<typeof makeLongUtils>): {
+    Builtin: ConditionalOutput;
+    DeepPartial: ConditionalOutput;
+    Exact: ConditionalOutput;
+};
+declare function makeObjectIdMethods(): {
+    fromJsonObjectId: ConditionalOutput;
+    fromProtoObjectId: ConditionalOutput;
+    toProtoObjectId: ConditionalOutput;
+};
+declare function makeTimestampMethods(options: Options, longs: ReturnType<typeof makeLongUtils>, bytes: ReturnType<typeof makeByteUtils>): {
+    toTimestamp: ConditionalOutput;
+    fromTimestamp: ConditionalOutput;
+    fromJsonTimestamp: ConditionalOutput;
+};
+declare function makeComparisonUtils(): {
+    isObject: ConditionalOutput;
+    isSet: ConditionalOutput;
+};
+declare function makeNiceGrpcServerStreamingMethodResult(options: Options): {
+    NiceGrpcServerStreamingMethodResult: ConditionalOutput;
+};
+declare function makeGrpcWebErrorClass(bytes: ReturnType<typeof makeByteUtils>): {
+    GrpcWebError: ConditionalOutput;
+};
+declare function makeExtensionClass(options: Options): {
+    Extension: ConditionalOutput;
+};
+declare function makeAssertionUtils(bytes: ReturnType<typeof makeByteUtils>): {
+    fail: ConditionalOutput;
+};
+export declare const contextTypeVar = "Context extends DataLoaders";
+export {};

package/build/main.js

@@ -794,7 +794,17 @@ function getDecodeReadSnippet(ctx, field) {
             }
         }
         else if ((0, types_1.basicLongWireType)(field.type) !== undefined) {
-            if (options.forceLong === options_1.LongOption.LONG) {
+            if ((0, types_1.isJsTypeFieldOption)(options, field)) {
+                switch (field.options.jstype) {
+                    case ts_proto_descriptors_1.FieldOptions_JSType.JS_NUMBER:
+                        readSnippet = (0, ts_poet_1.code) `${utils.longToNumber}(${readSnippet} as Long)`;
+                        break;
+                    case ts_proto_descriptors_1.FieldOptions_JSType.JS_STRING:
+                        readSnippet = (0, ts_poet_1.code) `${utils.longToString}(${readSnippet} as Long)`;
+                        break;
+                }
+            }
+            else if (options.forceLong === options_1.LongOption.LONG) {
                 readSnippet = (0, ts_poet_1.code) `${readSnippet} as Long`;
             }
             else if (options.forceLong === options_1.LongOption.STRING) {
@@ -1038,13 +1048,13 @@ function getEncodeWriteSnippet(ctx, field) {
             case "int64":
             case "sint64":
             case "sfixed64":
-                return (place) => (0, ts_poet_1.code) `if (BigInt.asIntN(64, ${place}) !== ${place}) {
+                return (place, placeAlt) => (0, ts_poet_1.code) `if (BigInt.asIntN(64, ${place}) !== ${placeAlt !== null && placeAlt !== void 0 ? placeAlt : place}) {
           throw new ${utils.globalThis}.Error('value provided for field ${place} of type ${fieldType} too large');
         }
         writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
             case "uint64":
             case "fixed64":
-                return (place) => (0, ts_poet_1.code) `if (BigInt.asUintN(64, ${place}) !== ${place}) {
+                return (place, placeAlt) => (0, ts_poet_1.code) `if (BigInt.asUintN(64, ${place}) !== ${placeAlt !== null && placeAlt !== void 0 ? placeAlt : place}) {
           throw new ${utils.globalThis}.Error('value provided for field ${place} of type ${fieldType} too large');
         }
         writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
@@ -1277,9 +1287,13 @@ function generateEncode(ctx, fullName, messageDesc) {
       `);
         }
         else if ((0, types_1.isScalar)(field) || (0, types_1.isEnum)(field)) {
+            const isJsType = (0, types_1.isScalar)(field) && (0, types_1.isJsTypeFieldOption)(options, field);
+            const body = isJsType && options.forceLong === options_1.LongOption.BIGINT
+                ? writeSnippet(`BigInt(${messageProperty})`)
+                : writeSnippet(`${messageProperty}`);
             chunks.push((0, ts_poet_1.code) `
         if (${(0, types_1.notDefaultCheck)(ctx, field, messageDesc.options, `${messageProperty}`)}) {
-          ${writeSnippet(`${messageProperty}`)};
+          ${body};
         }
       `);
         }
@@ -1566,6 +1580,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
         const jsonPropertyOptional = (0, utils_1.getPropertyAccessor)("object", jsonName, true);
         // get code that extracts value from incoming object
         const readSnippet = (from) => {
+            var _a;
             if ((0, types_1.isEnum)(field)) {
                 const fromJson = (0, types_1.getEnumMethod)(ctx, field.typeName, "FromJSON");
                 return (0, ts_poet_1.code) `${fromJson}(${from})`;
@@ -1580,6 +1595,11 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                         return (0, ts_poet_1.code) `${utils.bytesFromBase64}(${from})`;
                     }
                 }
+                else if ((0, types_1.isLong)(field) && (0, types_1.isJsTypeFieldOption)(options, field)) {
+                    const fieldType = (_a = (0, types_1.getFieldOptionsJsType)(field, ctx.options)) !== null && _a !== void 0 ? _a : field.type;
+                    const cstr = (0, case_1.capitalize)((0, types_1.basicTypeName)(ctx, { ...field, type: fieldType }, { keepValueType: true }).toCodeString([]));
+                    return (0, ts_poet_1.code) `${utils.globalThis}.${cstr}(${from})`;
+                }
                 else if ((0, types_1.isLong)(field) && options.forceLong === options_1.LongOption.LONG) {
                     const cstr = (0, case_1.capitalize)((0, types_1.basicTypeName)(ctx, field, { keepValueType: true }).toCodeString([]));
                     return (0, ts_poet_1.code) `${cstr}.fromValue(${from})`;
@@ -1812,6 +1832,7 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
         const jsonProperty = (0, utils_1.getPropertyAccessor)("obj", jsonName);
         const messageProperty = (0, utils_1.getPropertyAccessor)("message", fieldName);
         const readSnippet = (from) => {
+            var _a;
             if ((0, types_1.isEnum)(field)) {
                 const toJson = (0, types_1.getEnumMethod)(ctx, field.typeName, "ToJSON");
                 return (0, ts_poet_1.code) `${toJson}(${from})`;
@@ -1889,6 +1910,14 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
             else if ((0, types_1.isBytes)(field)) {
                 return (0, ts_poet_1.code) `${utils.base64FromBytes}(${from})`;
             }
+            else if ((0, types_1.isLong)(field) && (0, types_1.isJsTypeFieldOption)(options, field)) {
+                const fieldType = (_a = (0, types_1.getFieldOptionsJsType)(field, ctx.options)) !== null && _a !== void 0 ? _a : field.type;
+                if (!fieldType) {
+                    return (0, ts_poet_1.code) `${from}`;
+                }
+                const cstr = (0, case_1.capitalize)((0, types_1.basicTypeName)(ctx, { ...field, type: fieldType }, { keepValueType: true }).toCodeString([]));
+                return (0, ts_poet_1.code) `${utils.globalThis}.${cstr}(${from})`;
+            }
             else if ((0, types_1.isLong)(field) && options.forceLong === options_1.LongOption.LONG) {
                 return (0, ts_poet_1.code) `(${from} || ${(0, types_1.defaultValue)(ctx, field)}).toString()`;
             }
@@ -2007,7 +2036,9 @@ function generateFromPartial(ctx, fullName, messageDesc) {
         const messageProperty = (0, utils_1.getPropertyAccessor)("message", fieldName);
         const objectProperty = (0, utils_1.getPropertyAccessor)("object", fieldName);
         const readSnippet = (from) => {
-            if (((0, types_1.isLong)(field) || (0, types_1.isLongValueType)(field)) && options.forceLong === options_1.LongOption.LONG) {
+            if (((0, types_1.isLong)(field) || (0, types_1.isLongValueType)(field)) &&
+                options.forceLong === options_1.LongOption.LONG &&
+                !(0, types_1.isJsTypeFieldOption)(options, field)) {
                 return (0, ts_poet_1.code) `Long.fromValue(${from})`;
             }
             else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {

package/build/options.d.ts

@@ -0,0 +1,102 @@
+import { ToStringOpts } from "ts-poet/build/Code";
+export declare enum LongOption {
+    NUMBER = "number",
+    LONG = "long",
+    STRING = "string",
+    BIGINT = "bigint"
+}
+export declare enum DateOption {
+    DATE = "date",
+    STRING = "string",
+    STRING_NANO = "string-nano",
+    TIMESTAMP = "timestamp"
+}
+export declare enum JsonTimestampOption {
+    RFC3339 = "rfc3339",
+    RAW = "raw"
+}
+export declare enum EnvOption {
+    NODE = "node",
+    BROWSER = "browser",
+    BOTH = "both"
+}
+export declare enum OneofOption {
+    PROPERTIES = "properties",
+    UNIONS = "unions"
+}
+export declare enum ServiceOption {
+    GRPC = "grpc-js",
+    NICE_GRPC = "nice-grpc",
+    GENERIC = "generic-definitions",
+    DEFAULT = "default",
+    NONE = "none"
+}
+export type Options = {
+    context: boolean;
+    snakeToCamel: Array<"json" | "keys">;
+    forceLong: LongOption;
+    useJsTypeOverride: boolean;
+    globalThisPolyfill: boolean;
+    useOptionals: boolean | "none" | "deprecatedOnly" | "messages" | "all";
+    emitDefaultValues: Array<"json-methods">;
+    useDate: DateOption;
+    useJsonTimestamp: JsonTimestampOption;
+    useMongoObjectId: boolean;
+    oneof: OneofOption;
+    esModuleInterop: boolean;
+    fileSuffix: string;
+    importSuffix: string;
+    outputEncodeMethods: true | false | "encode-only" | "decode-only" | "encode-no-creation";
+    outputJsonMethods: true | false | "to-only" | "from-only";
+    outputPartialMethods: boolean;
+    outputTypeAnnotations: boolean | "static-only" | "optional";
+    outputTypeRegistry: boolean;
+    stringEnums: boolean;
+    constEnums: boolean;
+    removeEnumPrefix: boolean;
+    enumsAsLiterals: boolean;
+    outputClientImpl: boolean | "grpc-web";
+    outputServices: ServiceOption[];
+    addGrpcMetadata: boolean;
+    metadataType: string | undefined;
+    addNestjsRestParameter: boolean;
+    returnObservable: boolean;
+    lowerCaseServiceMethods: boolean;
+    nestJs: boolean;
+    env: EnvOption;
+    unrecognizedEnum: boolean;
+    unrecognizedEnumName: string;
+    unrecognizedEnumValue: number;
+    exportCommonSymbols: boolean;
+    outputSchema: boolean;
+    onlyTypes: boolean;
+    emitImportedFiles: boolean;
+    useAbortSignal: boolean;
+    useExactTypes: boolean;
+    useAsyncIterable: boolean;
+    unknownFields: boolean;
+    usePrototypeForDefaults: boolean;
+    useJsonName: boolean;
+    useJsonWireFormat: boolean;
+    useNumericEnumForJson: boolean;
+    initializeFieldsAsUndefined: boolean;
+    useMapType: boolean;
+    useReadonlyTypes: boolean;
+    useSnakeTypeName: boolean;
+    outputExtensions: boolean;
+    outputIndex: boolean;
+    M: {
+        [from: string]: string;
+    };
+    rpcBeforeRequest: boolean;
+    rpcAfterResponse: boolean;
+    rpcErrorHandler: boolean;
+    comments: boolean;
+    disableProto2Optionals: boolean;
+    disableProto2DefaultValues: boolean;
+    useNullAsOptional: boolean;
+};
+export declare function defaultOptions(): Options;
+export declare function optionsFromParameter(parameter: string | undefined): Options;
+export declare function getTsPoetOpts(options: Options): ToStringOpts;
+export declare function addTypeToMessages(options: Options): boolean;

package/build/options.js

@@ -46,6 +46,7 @@ function defaultOptions() {
         emitDefaultValues: [],
         globalThisPolyfill: false,
         forceLong: LongOption.NUMBER,
+        useJsTypeOverride: false,
         useOptionals: "none",
         useDate: DateOption.DATE,
         useJsonTimestamp: JsonTimestampOption.RFC3339,

package/build/plugin.d.ts

@@ -0,0 +1 @@
+export {};

package/build/schema.d.ts

@@ -0,0 +1,5 @@
+import { FileDescriptorProto } from "ts-proto-descriptors";
+import { Code } from "ts-poet";
+import { Context } from "./context";
+import SourceInfo from "./sourceInfo";
+export declare function generateSchema(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo): Code[];

package/build/sourceInfo.d.ts

@@ -0,0 +1,78 @@
+import { FileDescriptorProto } from "ts-proto-descriptors";
+/** This type is expecting a value from the Fields constant. */
+export type FieldID = number;
+/**
+ * The field values here represent the proto field IDs associated with the types
+ * (file,message,enum,service).
+ *
+ * For more information read the comments for SourceCodeInfo declared in
+ * google's 'descriptor.proto' file, see:
+ * https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/descriptor.proto#L730
+ */
+export declare const Fields: {
+    file: {
+        syntax: number;
+        message_type: number;
+        enum_type: number;
+        service: number;
+        extension: number;
+    };
+    message: {
+        field: number;
+        nested_type: number;
+        enum_type: number;
+        oneof_decl: number;
+    };
+    enum: {
+        value: number;
+    };
+    service: {
+        method: number;
+    };
+};
+/**
+ * This type is simply an interface on the SourceCodeInfo.Location message.
+ */
+export interface SourceDescription {
+    readonly span: number[];
+    readonly leadingComments: string;
+    readonly trailingComments: string;
+    readonly leadingDetachedComments: string[];
+}
+/**
+ * Mapping from a string of dotted notation `path` parts to efficiently
+ * lookup the related source information.
+ */
+export type SourceInfoMap = {
+    [key: string]: SourceDescription;
+};
+/**
+ * This class provides direct lookup and navigation through the type
+ * system by the use of lookup/open to access the source info for types
+ * defined in a protocol buffer.
+ */
+export default class SourceInfo implements SourceDescription {
+    private readonly sourceCode;
+    private readonly selfDescription;
+    /** Returns an empty SourceInfo */
+    static empty(): SourceInfo;
+    /**
+     * Creates the SourceInfo from the FileDescriptorProto given to you
+     * by the protoc compiler. It indexes file.sourceCodeInfo by dotted
+     * path notation and returns the root SourceInfo.
+     */
+    static fromDescriptor(file: FileDescriptorProto): SourceInfo;
+    private constructor();
+    /** Returns the code span [start line, start column, end line] */
+    get span(): number[];
+    /** Leading consecutive comment lines prior to the current element */
+    get leadingComments(): string;
+    /** Documentation is unclear about what exactly this is */
+    get trailingComments(): string;
+    /** Detached comments are those preceeding but separated by a blank non-comment line */
+    get leadingDetachedComments(): string[];
+    /** Return the source info for the field id and index specficied */
+    lookup(type: FieldID, index?: number): SourceDescription;
+    /** Returns a new SourceInfo class representing the field id and index specficied */
+    open(type: FieldID, index: number): SourceInfo;
+}

package/build/types.d.ts

@@ -0,0 +1,105 @@
+import { CodeGeneratorRequest, DescriptorProto, EnumDescriptorProto, FieldDescriptorProto, FieldDescriptorProto_Type, FileDescriptorProto, MessageOptions, MethodDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import { Code, Import } from "ts-poet";
+import { Options } from "./options";
+import { Context } from "./context";
+/** Based on https://github.com/dcodeIO/protobuf.js/blob/master/src/types.js#L37. */
+export declare function basicWireType(type: FieldDescriptorProto_Type): number;
+export declare function basicLongWireType(type: FieldDescriptorProto_Type): number | undefined;
+/** Returns the type name without any repeated/required/etc. labels. */
+export declare function basicTypeName(ctx: Context, field: FieldDescriptorProto, typeOptions?: {
+    keepValueType?: boolean;
+}): Code;
+/** Returns the Reader method for the primitive's read/write call. */
+export declare function toReaderCall(field: FieldDescriptorProto): string;
+export declare function packedType(type: FieldDescriptorProto_Type): number | undefined;
+export declare function getFieldOptionsJsType(field: FieldDescriptorProto, options: Options): FieldDescriptorProto_Type | undefined;
+export declare function defaultValue(ctx: Context, field: FieldDescriptorProto): any;
+/** Creates code that checks that the field is not the default value. Supports scalars and enums. */
+export declare function notDefaultCheck(ctx: Context, field: FieldDescriptorProto, messageOptions: MessageOptions | undefined, place: string): Code;
+/** A map of proto type name, e.g. `foo.Message.Inner`, to module/class name, e.g. `foo`, `Message_Inner`. */
+export type TypeMap = Map<string, [string, string, DescriptorProto | EnumDescriptorProto]>;
+/** Scans all of the proto files in `request` and builds a map of proto typeName -> TS module/name. */
+export declare function createTypeMap(request: CodeGeneratorRequest, options: Options): TypeMap;
+/** A "Scalar Value Type" as defined in https://developers.google.com/protocol-buffers/docs/proto3#scalar */
+export declare function isScalar(field: FieldDescriptorProto): boolean;
+export declare function isOptionalProperty(field: FieldDescriptorProto, messageOptions: MessageOptions | undefined, options: Options, isProto3Syntax: boolean): boolean;
+/** This includes all scalars, enums and the [groups type](https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/DescriptorProtos.FieldDescriptorProto.Type.html#TYPE_GROUP) */
+export declare function isPrimitive(field: FieldDescriptorProto): boolean;
+export declare function isBytes(field: FieldDescriptorProto): boolean;
+export declare function isMessage(field: FieldDescriptorProto): boolean;
+export declare function isEnum(field: FieldDescriptorProto): boolean;
+export declare function isWithinOneOf(field: FieldDescriptorProto): boolean;
+export declare function isWithinOneOfThatShouldBeUnion(options: Options, field: FieldDescriptorProto): boolean;
+export declare function isRepeated(field: FieldDescriptorProto): boolean;
+export declare function isLong(field: FieldDescriptorProto): boolean;
+export declare function isWholeNumber(field: FieldDescriptorProto): boolean;
+export declare function isMapType(ctx: Context, messageDesc: DescriptorProto, field: FieldDescriptorProto): boolean;
+export declare function isObjectId(field: FieldDescriptorProto): boolean;
+export declare function isTimestamp(field: FieldDescriptorProto): boolean;
+export declare function isValueType(ctx: Context, field: FieldDescriptorProto): boolean;
+export declare function isAnyValueType(field: FieldDescriptorProto): boolean;
+export declare function isAnyValueTypeName(typeName: string): boolean;
+export declare function isBytesValueType(field: FieldDescriptorProto): boolean;
+export declare function isFieldMaskType(field: FieldDescriptorProto): boolean;
+export declare function isFieldMaskTypeName(typeName: string): boolean;
+export declare function isListValueType(field: FieldDescriptorProto): boolean;
+export declare function isListValueTypeName(typeName: string): boolean;
+export declare function isStructType(field: FieldDescriptorProto): boolean;
+export declare function isStructTypeName(typeName: string): boolean;
+export declare function isLongValueType(field: FieldDescriptorProto): boolean;
+export declare function isEmptyType(typeName: string): boolean;
+export declare function valueTypeName(ctx: Context, typeName: string): Code | undefined;
+export declare function wrapperTypeName(typeName: string): string | undefined;
+/** Maps `.some_proto_namespace.Message` to a TypeName. */
+export declare function messageToTypeName(ctx: Context, protoType: string, typeOptions?: {
+    keepValueType?: boolean;
+    repeated?: boolean;
+}): Code;
+export declare function getEnumMethod(ctx: Context, enumProtoType: string, methodSuffix: string): Import;
+/** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */
+export declare function toTypeName(ctx: Context, messageDesc: DescriptorProto | undefined, field: FieldDescriptorProto, ensureOptional?: boolean): Code;
+/**
+ * For a protobuf map field, if the generated code should use the javascript Map type.
+ *
+ * If the type of a protobuf map key corresponds to the Long type, we always use the Map type. This avoids generating
+ * invalid code such as below (using Long as key of a javascript object):
+ *
+ * export interface Foo {
+ *  bar: { [key: Long]: Long }
+ * }
+ *
+ * See https://github.com/stephenh/ts-proto/issues/708 for more details.
+ */
+export declare function shouldGenerateJSMapType(ctx: Context, message: DescriptorProto, field: FieldDescriptorProto): boolean;
+export declare function detectMapType(ctx: Context, messageDesc: DescriptorProto, fieldDesc: FieldDescriptorProto): {
+    messageDesc: DescriptorProto;
+    keyField: FieldDescriptorProto;
+    keyType: Code;
+    valueField: FieldDescriptorProto;
+    valueType: Code;
+} | undefined;
+export declare function rawRequestType(ctx: Context, methodDesc: MethodDescriptorProto, typeOptions?: {
+    keepValueType?: boolean;
+    repeated?: boolean;
+}): Code;
+export declare function observableType(ctx: Context, asType?: boolean): Code;
+export declare function requestType(ctx: Context, methodDesc: MethodDescriptorProto, partial?: boolean): Code;
+export declare function responseType(ctx: Context, methodDesc: MethodDescriptorProto, typeOptions?: {
+    keepValueType?: boolean;
+    repeated?: boolean;
+}): Code;
+export declare function responsePromise(ctx: Context, methodDesc: MethodDescriptorProto): Code;
+export declare function responseObservable(ctx: Context, methodDesc: MethodDescriptorProto): Code;
+export declare function responsePromiseOrObservable(ctx: Context, methodDesc: MethodDescriptorProto): Code;
+export interface BatchMethod {
+    methodDesc: MethodDescriptorProto;
+    uniqueIdentifier: string;
+    singleMethodName: string;
+    inputFieldName: string;
+    inputType: Code;
+    outputFieldName: string;
+    outputType: Code;
+    mapType: boolean;
+}
+export declare function detectBatchMethod(ctx: Context, fileDesc: FileDescriptorProto, serviceDesc: ServiceDescriptorProto, methodDesc: MethodDescriptorProto): BatchMethod | undefined;
+export declare function isJsTypeFieldOption(options: Options, field: FieldDescriptorProto): boolean;

package/build/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectBatchMethod = exports.responsePromiseOrObservable = exports.responseObservable = exports.responsePromise = exports.responseType = exports.requestType = exports.observableType = exports.rawRequestType = exports.detectMapType = exports.shouldGenerateJSMapType = exports.toTypeName = exports.getEnumMethod = exports.messageToTypeName = exports.wrapperTypeName = exports.valueTypeName = exports.isEmptyType = exports.isLongValueType = exports.isStructTypeName = exports.isStructType = exports.isListValueTypeName = exports.isListValueType = exports.isFieldMaskTypeName = exports.isFieldMaskType = exports.isBytesValueType = exports.isAnyValueTypeName = exports.isAnyValueType = exports.isValueType = exports.isTimestamp = exports.isObjectId = exports.isMapType = exports.isWholeNumber = exports.isLong = exports.isRepeated = exports.isWithinOneOfThatShouldBeUnion = exports.isWithinOneOf = exports.isEnum = exports.isMessage = exports.isBytes = exports.isPrimitive = exports.isOptionalProperty = exports.isScalar = exports.createTypeMap = exports.notDefaultCheck = exports.defaultValue = exports.packedType = exports.toReaderCall = exports.basicTypeName = exports.basicLongWireType = exports.basicWireType = void 0;
+exports.detectBatchMethod = exports.responsePromiseOrObservable = exports.responseObservable = exports.responsePromise = exports.responseType = exports.requestType = exports.observableType = exports.rawRequestType = exports.detectMapType = exports.shouldGenerateJSMapType = exports.toTypeName = exports.getEnumMethod = exports.messageToTypeName = exports.wrapperTypeName = exports.valueTypeName = exports.isEmptyType = exports.isLongValueType = exports.isStructTypeName = exports.isStructType = exports.isListValueTypeName = exports.isListValueType = exports.isFieldMaskTypeName = exports.isFieldMaskType = exports.isBytesValueType = exports.isAnyValueTypeName = exports.isAnyValueType = exports.isValueType = exports.isTimestamp = exports.isObjectId = exports.isMapType = exports.isWholeNumber = exports.isLong = exports.isRepeated = exports.isWithinOneOfThatShouldBeUnion = exports.isWithinOneOf = exports.isEnum = exports.isMessage = exports.isBytes = exports.isPrimitive = exports.isOptionalProperty = exports.isScalar = exports.createTypeMap = exports.notDefaultCheck = exports.defaultValue = exports.getFieldOptionsJsType = exports.packedType = exports.toReaderCall = exports.basicTypeName = exports.basicLongWireType = exports.basicWireType = void 0;
+exports.isJsTypeFieldOption = void 0;
 const ts_proto_descriptors_1 = require("ts-proto-descriptors");
 const ts_poet_1 = require("ts-poet");
 const options_1 = require("./options");
@@ -60,8 +61,10 @@ function basicLongWireType(type) {
 exports.basicLongWireType = basicLongWireType;
 /** Returns the type name without any repeated/required/etc. labels. */
 function basicTypeName(ctx, field, typeOptions = {}) {
+    var _a, _b;
     const { options } = ctx;
-    switch (field.type) {
+    const fieldType = (_a = getFieldOptionsJsType(field, ctx.options)) !== null && _a !== void 0 ? _a : field.type;
+    switch (fieldType) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT32:
@@ -75,8 +78,10 @@ function basicTypeName(ctx, field, typeOptions = {}) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
-            // this handles 2^53, Long is only needed for 2^64; this is effectively pbjs's forceNumber
-            return longTypeName(ctx);
+            return isJsTypeFieldOption(options, field)
+                ? (_b = jsTypeName(field)) !== null && _b !== void 0 ? _b : longTypeName(ctx)
+                : // this handles 2^53, Long is only needed for 2^64; this is effectively pbjs's forceNumber
+                    longTypeName(ctx);
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
             return (0, ts_poet_1.code) `boolean`;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
@@ -164,10 +169,28 @@ function packedType(type) {
     }
 }
 exports.packedType = packedType;
+function getFieldOptionsJsType(field, options) {
+    var _a;
+    if (!options.useJsTypeOverride || ((_a = field.options) === null || _a === void 0 ? void 0 : _a.jstype) === undefined) {
+        return;
+    }
+    switch (field.options.jstype) {
+        case ts_proto_descriptors_1.FieldOptions_JSType.JS_STRING:
+            return ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING;
+        case ts_proto_descriptors_1.FieldOptions_JSType.JS_NUMBER:
+            return ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64;
+        // In the case of JS_NORMAL, we don't want to override the type, so we return
+        case ts_proto_descriptors_1.FieldOptions_JSType.JS_NORMAL:
+        // In the case of UNRECOGNIZED, we assume default behavior and we don't want to override the type, so we return
+        case ts_proto_descriptors_1.FieldOptions_JSType.UNRECOGNIZED:
+            return;
+    }
+}
+exports.getFieldOptionsJsType = getFieldOptionsJsType;
 function defaultValue(ctx, field) {
     const { typeMap, options, utils, currentFile } = ctx;
     const useDefaultValue = !currentFile.isProto3Syntax && !options.disableProto2DefaultValues && field.defaultValue;
-    const numbericDefaultVal = useDefaultValue ? field.defaultValue : 0;
+    const numericDefaultVal = useDefaultValue ? field.defaultValue : 0;
     switch (field.type) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
@@ -176,7 +199,7 @@ function defaultValue(ctx, field) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT32:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED32:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED32:
-            return numbericDefaultVal;
+            return numericDefaultVal;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_ENUM:
             // proto3 enforces enums starting at 0, however proto2 does not, so we have
             // to probe and see if zero is an allowed value. If it's not, pick the first one.
@@ -193,34 +216,33 @@ function defaultValue(ctx, field) {
             else {
                 return defaultEnum.number;
             }
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
-            if (options.forceLong === options_1.LongOption.LONG) {
-                return (0, ts_poet_1.code) `${utils.Long}.${useDefaultValue ? "fromNumber" : "UZERO"}${useDefaultValue ? `(${numbericDefaultVal})` : ""}`;
-            }
-            else if (options.forceLong === options_1.LongOption.STRING) {
-                return `"${numbericDefaultVal}"`;
-            }
-            else if (options.forceLong === options_1.LongOption.BIGINT) {
-                return `BigInt("${numbericDefaultVal}")`;
-            }
-            else {
-                return numbericDefaultVal;
-            }
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
+            if (isJsTypeFieldOption(options, field)) {
+                switch (field.options.jstype) {
+                    case ts_proto_descriptors_1.FieldOptions_JSType.JS_STRING:
+                        return `"${numericDefaultVal}"`;
+                    case ts_proto_descriptors_1.FieldOptions_JSType.JS_NUMBER:
+                        return numericDefaultVal;
+                }
+            }
             if (options.forceLong === options_1.LongOption.LONG) {
-                return (0, ts_poet_1.code) `${utils.Long}.${useDefaultValue ? "fromNumber" : "ZERO"}${useDefaultValue ? `(${numbericDefaultVal})` : ""}`;
+                const value = field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64 || field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64
+                    ? "UZERO"
+                    : "ZERO";
+                return (0, ts_poet_1.code) `${utils.Long}.${useDefaultValue ? "fromNumber" : value}${useDefaultValue ? `(${numericDefaultVal})` : ""}`;
             }
             else if (options.forceLong === options_1.LongOption.STRING) {
-                return `"${numbericDefaultVal}"`;
+                return `"${numericDefaultVal}"`;
             }
             else if (options.forceLong === options_1.LongOption.BIGINT) {
-                return `BigInt("${numbericDefaultVal}")`;
+                return `BigInt("${numericDefaultVal}")`;
             }
             else {
-                return numbericDefaultVal;
+                return numericDefaultVal;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
             return useDefaultValue ? field.defaultValue : false;
@@ -278,7 +300,7 @@ function notDefaultCheck(ctx, field, messageOptions, place) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
-            if (options.forceLong === options_1.LongOption.LONG) {
+            if (options.forceLong === options_1.LongOption.LONG && !isJsTypeFieldOption(options, field)) {
                 return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} !${place}.equals(${defaultValue(ctx, field)})`;
             }
             else {
@@ -541,6 +563,15 @@ function longTypeName(ctx) {
         return (0, ts_poet_1.code) `number`;
     }
 }
+function jsTypeName(field) {
+    var _a, _b;
+    if (((_a = field.options) === null || _a === void 0 ? void 0 : _a.jstype) === ts_proto_descriptors_1.FieldOptions_JSType.JS_STRING) {
+        return (0, ts_poet_1.code) `string`;
+    }
+    else if (((_b = field.options) === null || _b === void 0 ? void 0 : _b.jstype) === ts_proto_descriptors_1.FieldOptions_JSType.JS_NUMBER) {
+        return (0, ts_poet_1.code) `number`;
+    }
+}
 /** Maps `.some_proto_namespace.Message` to a TypeName. */
 function messageToTypeName(ctx, protoType, typeOptions = {}) {
     var _a;
@@ -584,13 +615,15 @@ function getEnumMethod(ctx, enumProtoType, methodSuffix) {
 exports.getEnumMethod = getEnumMethod;
 /** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */
 function toTypeName(ctx, messageDesc, field, ensureOptional = false) {
+    var _a;
     function finalize(type, isOptional) {
         if (isOptional) {
             return (0, ts_poet_1.code) `${type} | ${(0, utils_1.nullOrUndefined)(ctx.options, field.proto3Optional)}`;
         }
         return type;
     }
-    let type = basicTypeName(ctx, field, { keepValueType: false });
+    const fieldType = (_a = getFieldOptionsJsType(field, ctx.options)) !== null && _a !== void 0 ? _a : field.type;
+    const type = basicTypeName(ctx, { ...field, type: fieldType }, { keepValueType: false });
     if (isRepeated(field)) {
         const mapType = messageDesc ? detectMapType(ctx, messageDesc, field) : false;
         if (mapType) {
@@ -756,3 +789,9 @@ exports.detectBatchMethod = detectBatchMethod;
 function hasSingleRepeatedField(messageDesc) {
     return messageDesc.field.length == 1 && messageDesc.field[0].label === ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_REPEATED;
 }
+function isJsTypeFieldOption(options, field) {
+    var _a, _b;
+    return (options.useJsTypeOverride &&
+        (((_a = field.options) === null || _a === void 0 ? void 0 : _a.jstype) === ts_proto_descriptors_1.FieldOptions_JSType.JS_NUMBER || ((_b = field.options) === null || _b === void 0 ? void 0 : _b.jstype) === ts_proto_descriptors_1.FieldOptions_JSType.JS_STRING));
+}
+exports.isJsTypeFieldOption = isJsTypeFieldOption;

package/build/utils.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Code, Import } from "ts-poet";
+import { CodeGeneratorRequest, FieldDescriptorProto, FileDescriptorProto, MethodDescriptorProto, MethodOptions } from "ts-proto-descriptors";
+import ReadStream = NodeJS.ReadStream;
+import { SourceDescription } from "./sourceInfo";
+import { Options } from "./options";
+export declare function protoFilesToGenerate(request: CodeGeneratorRequest): FileDescriptorProto[];
+export declare function generateIndexFiles(files: FileDescriptorProto[], options: Options): [string, Code][];
+export declare function readToBuffer(stream: ReadStream): Promise<Buffer>;
+export declare function fail(message: string): never;
+export declare function singular(name: string): string;
+export declare function lowerFirst(name: string): string;
+export declare function upperFirst(name: string): string;
+/** Removes potentially harmful characters from comments and pushes it into chunks. */
+export declare function maybeAddComment(options: Pick<Options, "comments">, desc: Partial<Pick<SourceDescription, "leadingComments" | "trailingComments">>, chunks: Code[], deprecated?: boolean, prefix?: string): void;
+export declare function prefixDisableLinter(spec: string): string;
+export declare function maybePrefixPackage(fileDesc: FileDescriptorProto, rest: string): string;
+/**
+ * Asserts that an object is an instance of a certain class
+ * @param obj The object to check
+ * @param constructor The constructor of the class to check
+ */
+export declare function assertInstanceOf<T>(obj: unknown, constructor: {
+    new (...args: any[]): T;
+}): asserts obj is T;
+/**
+ * A MethodDescriptorProto subclass that adds formatted properties
+ */
+export declare class FormattedMethodDescriptor implements MethodDescriptorProto {
+    name: string;
+    inputType: string;
+    outputType: string;
+    options: MethodOptions | undefined;
+    clientStreaming: boolean;
+    serverStreaming: boolean;
+    private original;
+    private ctxOptions;
+    /**
+     * The name of this method with formatting applied according to the `Options` object passed to the constructor.
+     * Automatically updates to any changes to the `Options` or `name` of this object
+     */
+    get formattedName(): string;
+    constructor(src: MethodDescriptorProto, options: Options);
+    /**
+     * Retrieve the source `MethodDescriptorProto` used to construct this object
+     * @returns The source `MethodDescriptorProto` used to construct this object
+     */
+    getSource(): MethodDescriptorProto;
+    /**
+     * Applies formatting rules to a gRPC method name.
+     * @param methodName The original method name
+     * @param options The options object containing rules to apply
+     * @returns The formatted method name
+     */
+    static formatName(methodName: string, options: Options): string;
+}
+export declare function getFieldJsonName(field: Pick<FieldDescriptorProto, "name" | "jsonName">, options: Pick<Options, "snakeToCamel" | "useJsonName">): string;
+export declare function getFieldName(field: Pick<FieldDescriptorProto, "name" | "jsonName">, options: Pick<Options, "snakeToCamel" | "useJsonName">): string;
+/** Returns `bar` or `"bar"` if `propertyName` isn't a safe property name. */
+export declare function safeAccessor(propertyName: string): string;
+/**
+ * Returns a snippet for reading an object's property, such as `foo.bar`, or `foo['bar']` if the property name contains unusual characters.
+ * For simplicity, we don't match the ECMA 5/6 rules for valid identifiers exactly, and return array syntax liberally.
+ * @param objectName
+ * @param propertyName
+ * @param optional
+ */
+export declare function getPropertyAccessor(objectName: string, propertyName: string, optional?: boolean): string;
+export declare function impFile(options: Options, spec: string): Import;
+export declare function impProto(options: Options, module: string, type: string): Import;
+export declare function tryCatchBlock(tryBlock: Code | string, handleErrorBlock: Code | string): Code;
+export declare function arrowFunction(params: string, body: Code | string, isOneLine?: boolean): Code;
+export declare function nullOrUndefined(options: Pick<Options, "useNullAsOptional">, hasProto3Optional?: boolean): string;
+export declare function maybeCheckIsNotNull(options: Pick<Options, "useNullAsOptional">, typeName: string, prefix?: string): string;
+export declare function maybeCheckIsNull(options: Pick<Options, "useNullAsOptional">, typeName: string, prefix?: string): string;
+export declare function withOrMaybeCheckIsNotNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;
+export declare function withOrMaybeCheckIsNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;
+export declare function withAndMaybeCheckIsNotNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;
+export declare function withAndMaybeCheckIsNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;

package/build/visit.d.ts

@@ -0,0 +1,8 @@
+import { DescriptorProto, EnumDescriptorProto, FileDescriptorProto, ServiceDescriptorProto } from "ts-proto-descriptors";
+import SourceInfo from "./sourceInfo";
+import { Options } from "./options";
+type MessageVisitor = (fullName: string, desc: DescriptorProto, sourceInfo: SourceInfo, fullProtoTypeName: string) => void;
+type EnumVisitor = (fullName: string, desc: EnumDescriptorProto, sourceInfo: SourceInfo, fullProtoTypeName: string) => void;
+export declare function visit(proto: FileDescriptorProto | DescriptorProto, sourceInfo: SourceInfo, messageFn: MessageVisitor, options: Options, enumFn?: EnumVisitor, tsPrefix?: string, protoPrefix?: string): void;
+export declare function visitServices(proto: FileDescriptorProto, sourceInfo: SourceInfo, serviceFn: (desc: ServiceDescriptorProto, sourceInfo: SourceInfo) => void): void;
+export {};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "ts-proto",
-  "version": "1.171.0",
+  "version": "1.173.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",
   "bin": {
     "protoc-gen-ts_proto": "./protoc-gen-ts_proto"
   },
+  "types": "build/index.d.ts",
   "scripts": {
     "build": "yarn tsc",
     "build:test": "yarn proto2bin && yarn proto2pbjs && yarn bin2ts",
@@ -61,7 +62,7 @@
     "rxjs": "^7.8.1",
     "semantic-release": "^21.0.7",
     "ts-jest": "^29.1.1",
-    "tsx": "^3.12.7",
+    "tsx": "^3.14.0",
     "typescript": "^5.1.6",
     "uglify-js": "^3.17.4"
   },