ts-proto 1.170.0 → 1.172.0

package/README.markdown

@@ -547,6 +547,58 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=comments=false`, comments won't be copied from the proto files to the generated code.
 
+- With `--ts_proto_opt=useNullAsOptional=true`, `undefined` values will be converted to `null`, and if you use `optional` label in your `.proto` file, the field will have `undefined` type as well. for example:
+
+```protobuf
+message ProfileInfo {
+    int32 id = 1;
+    string bio = 2;
+    string phone = 3;
+}
+
+message Department {
+    int32 id = 1;
+    string name = 2;
+}
+
+message User {
+    int32 id = 1;
+    string username = 2;
+    /*
+     ProfileInfo will be optional in typescript, the type will be ProfileInfo | null | undefined
+     this is needed in cases where you don't wanna provide any value for the profile.
+    */
+    optional ProfileInfo profile = 3;
+
+    /*
+      Department only accepts a Department type or null, so this means you have to pass it null if there is no value available.
+    */
+    Department  department = 4;
+}
+```
+
+the generated interfaces will be:
+
+```typescript
+export interface ProfileInfo {
+  id: number;
+  bio: string;
+  phone: string;
+}
+
+export interface Department {
+  id: number;
+  name: string;
+}
+
+export interface User {
+  id: number;
+  username: string;
+  profile?: ProfileInfo | null | undefined; // check this one
+  department: Department | null; // check this one
+}
+```
+
 ### NestJS Support
 
 We have a great way of working together with [nestjs](https://docs.nestjs.com/microservices/grpc). `ts-proto` generates `interfaces` and `decorators` for you controller, client. For more information see the [nestjs readme](NESTJS.markdown).
@@ -724,6 +776,28 @@ As this will automatically enforce only one of `field_a` or `field_b` "being set
 
 In ts-proto's currently-unscheduled 2.x release, `oneof=unions` will become the default behavior.
 
+## OneOf Type Helpers
+
+The following helper types may make it easier to work with the types generated from `oneof=unions`:
+
+```ts
+/** Extracts all the case names from a oneOf field. */
+type OneOfCases<T> = T extends { $case: infer U extends string } ? U : never;
+
+/** Extracts a union of all the value types from a oneOf field */
+type OneOfValues<T> = T extends { $case: infer U extends string; [key: string]: unknown }
+  ? T[U]
+  : never;
+
+/** Extracts the specific type of a oneOf case based on its field name */
+type OneOfCase<T, K extends OneOfCases<T>> = T extends {
+  $case: infer U extends K;
+  [key: string]: unknown;
+}
+  ? T[U]
+  : never;
+```
+
 # Default values and unset fields
 
 In core Protobuf (and so also `ts-proto`), values that are _unset_ or equal to the default value are not sent over the wire.

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

@@ -715,7 +715,7 @@ function generateOneofProperty(ctx, messageDesc, oneofIndex, sourceInfo) {
         return (0, ts_poet_1.code) `{ ${mbReadonly}$case: '${fieldName}', ${mbReadonly}${fieldName}: ${typeName} }`;
     }), { on: " | " });
     const name = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[oneofIndex].name, options);
-    return (0, ts_poet_1.code) `${mbReadonly}${name}?: ${unionType} | undefined,`;
+    return (0, ts_poet_1.code) `${mbReadonly}${name}?: ${unionType} | ${(0, utils_1.nullOrUndefined)(options)},`;
     /*
     // Ideally we'd put the comments for each oneof field next to the anonymous
     // type we've created in the type union above, but ts-poet currently lacks
@@ -751,7 +751,7 @@ function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
                 const name = options.useJsonName
                     ? (0, utils_1.getFieldName)(field, options)
                     : (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[oneofIndex].name, ctx.options);
-                fields.push((0, ts_poet_1.code) `${(0, utils_1.safeAccessor)(name)}: undefined`);
+                fields.push((0, ts_poet_1.code) `${(0, utils_1.safeAccessor)(name)}: ${(0, utils_1.nullOrUndefined)(options)}`);
             }
             continue;
         }
@@ -761,7 +761,7 @@ function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
         }
         const fieldKey = (0, utils_1.safeAccessor)((0, utils_1.getFieldName)(field, options));
         const val = (0, types_1.isWithinOneOf)(field)
-            ? "undefined"
+            ? (0, utils_1.nullOrUndefined)(options)
             : (0, types_1.isMapType)(ctx, messageDesc, field)
                 ? (0, types_1.shouldGenerateJSMapType)(ctx, messageDesc, field)
                     ? "new Map()"
@@ -910,14 +910,14 @@ function generateDecode(ctx, fullName, messageDesc) {
                 }
                 const initializerSnippet = initializerNecessary
                     ? `
-            if (${messageProperty} === undefined) {
+            if (${messageProperty} === undefined ${(0, utils_1.withOrMaybeCheckIsNull)(options, messageProperty)}) {
               ${messageProperty} = ${generateMapType ? "new Map()" : "{}"};
             }`
                     : "";
                 chunks.push((0, ts_poet_1.code) `
           ${tagCheck}
           const ${varName} = ${readSnippet};
-          if (${varName}.value !== undefined) {
+          if (${varName}.value !== undefined ${(0, utils_1.withAndMaybeCheckIsNotNull)(options, `${varName}.value`)}) {
             ${initializerSnippet}
             ${valueSetterSnippet};
           }
@@ -926,7 +926,7 @@ function generateDecode(ctx, fullName, messageDesc) {
             else {
                 const initializerSnippet = initializerNecessary
                     ? `
-            if (${messageProperty} === undefined) {
+            if (${messageProperty} === undefined ${(0, utils_1.withOrMaybeCheckIsNull)(options, messageProperty)}) {
               ${messageProperty} = [];
             }`
                     : "";
@@ -992,7 +992,7 @@ function generateDecode(ctx, fullName, messageDesc) {
         let maybeNonNullAssertion = options.initializeFieldsAsUndefined ? "!" : "";
         if (!options.initializeFieldsAsUndefined) {
             unknownFieldsInitializerSnippet = `
-        if (message._unknownFields === undefined) {
+        if (message._unknownFields === undefined ${(0, utils_1.withOrMaybeCheckIsNull)(options, `message._unknownFields`)}) {
           message._unknownFields = {};
         }
       `;
@@ -1005,7 +1005,7 @@ function generateDecode(ctx, fullName, messageDesc) {
       ${unknownFieldsInitializerSnippet}
       const list = message._unknownFields${maybeNonNullAssertion}[tag];
 
-      if (list === undefined) {
+      if (list === undefined ${(0, utils_1.withOrMaybeCheckIsNull)(options, `message._unknownFields`)}) {
         message._unknownFields${maybeNonNullAssertion}[tag] = [buf];
       } else {
         list.push(buf);
@@ -1123,7 +1123,7 @@ function generateEncode(ctx, fullName, messageDesc) {
                 const maybeTypeField = (0, options_1.addTypeToMessages)(options) ? `$type: '${field.typeName.slice(1)}',` : "";
                 const entryWriteSnippet = (0, types_1.isValueType)(ctx, valueType)
                     ? (0, ts_poet_1.code) `
-              if (value !== undefined) {
+              if (value !== undefined ${(0, utils_1.withOrMaybeCheckIsNotNull)(options, `value`)}) {
                 ${writeSnippet(`{ ${maybeTypeField} key: key as any, value }`)};
               }
             `
@@ -1234,7 +1234,7 @@ function generateEncode(ctx, fullName, messageDesc) {
                 }
                 if (isOptional) {
                     chunks.push((0, ts_poet_1.code) `
-            if (${messageProperty} !== undefined && ${messageProperty}.length !== 0) {
+            if (${messageProperty} !== undefined ${(0, utils_1.withAndMaybeCheckIsNotNull)(options, messageProperty)} && ${messageProperty}.length !== 0) {
               ${listWriteSnippet}
             }
           `);
@@ -1264,14 +1264,14 @@ function generateEncode(ctx, fullName, messageDesc) {
         else if ((0, types_1.isWithinOneOf)(field)) {
             // Oneofs don't have a default value check b/c they need to denote which-oneof presence
             chunks.push((0, ts_poet_1.code) `
-        if (${messageProperty} !== undefined) {
+        if (${messageProperty} !== undefined ${(0, utils_1.withAndMaybeCheckIsNotNull)(options, messageProperty)}) {
           ${writeSnippet(`${messageProperty}`)};
         }
       `);
         }
         else if ((0, types_1.isMessage)(field)) {
             chunks.push((0, ts_poet_1.code) `
-        if (${messageProperty} !== undefined) {
+        if (${messageProperty} !== undefined ${(0, utils_1.withAndMaybeCheckIsNotNull)(options, messageProperty)}) {
           ${writeSnippet(`${messageProperty}`)};
         }
       `);
@@ -1697,7 +1697,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 const fieldType = (0, types_1.toTypeName)(ctx, messageDesc, field);
                 const i = convertFromObjectKey(ctx, messageDesc, field, "key");
                 if ((0, types_1.shouldGenerateJSMapType)(ctx, messageDesc, field)) {
-                    const fallback = noDefaultValue ? "undefined" : "new Map()";
+                    const fallback = noDefaultValue ? (0, utils_1.nullOrUndefined)(options) : "new Map()";
                     chunks.push((0, ts_poet_1.code) `
             ${fieldKey}: ${ctx.utils.isObject}(${jsonProperty})
               ? Object.entries(${jsonProperty}).reduce<${fieldType}>((acc, [key, value]) => {
@@ -1708,7 +1708,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
           `);
                 }
                 else {
-                    const fallback = noDefaultValue ? "undefined" : "{}";
+                    const fallback = noDefaultValue ? (0, utils_1.nullOrUndefined)(options) : "{}";
                     chunks.push((0, ts_poet_1.code) `
             ${fieldKey}: ${ctx.utils.isObject}(${jsonProperty})
               ? Object.entries(${jsonProperty}).reduce<${fieldType}>((acc, [key, value]) => {
@@ -1720,7 +1720,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 }
             }
             else {
-                const fallback = noDefaultValue ? "undefined" : "[]";
+                const fallback = noDefaultValue ? (0, utils_1.nullOrUndefined)(options) : "[]";
                 const readValueSnippet = readSnippet("e");
                 if (readValueSnippet.toString() === (0, ts_poet_1.code) `e`.toString()) {
                     chunks.push((0, ts_poet_1.code) `${fieldKey}: ${ctx.utils.globalThis}.Array.isArray(${jsonPropertyOptional}) ? [...${jsonProperty}] : [],`);
@@ -1745,29 +1745,29 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
             const ternaryThen = (0, ts_poet_1.code) `{ $case: '${fieldName}', ${fieldKey}: ${readSnippet(`${jsonProperty}`)}`;
             chunks.push((0, ts_poet_1.code) `${ternaryIf} ? ${ternaryThen}} : `);
             if (field === lastCase) {
-                chunks.push((0, ts_poet_1.code) `undefined,`);
+                chunks.push((0, ts_poet_1.code) `${(0, utils_1.nullOrUndefined)(options)},`);
             }
         }
         else if ((0, types_1.isAnyValueType)(field)) {
             chunks.push((0, ts_poet_1.code) `${fieldKey}: ${ctx.utils.isSet}(${jsonPropertyOptional})
         ? ${readSnippet(`${jsonProperty}`)}
-        : undefined,
+        : ${(0, utils_1.nullOrUndefined)(options)},
       `);
         }
         else if ((0, types_1.isStructType)(field)) {
             chunks.push((0, ts_poet_1.code) `${fieldKey}: ${ctx.utils.isObject}(${jsonProperty})
           ? ${readSnippet(`${jsonProperty}`)}
-          : undefined,`);
+          : ${(0, utils_1.nullOrUndefined)(options)},`);
         }
         else if ((0, types_1.isListValueType)(field)) {
             chunks.push((0, ts_poet_1.code) `
         ${fieldKey}: ${ctx.utils.globalThis}.Array.isArray(${jsonProperty})
           ? ${readSnippet(`${jsonProperty}`)}
-          : undefined,
+          : ${(0, utils_1.nullOrUndefined)(options)},
       `);
         }
         else {
-            const fallback = (0, types_1.isWithinOneOf)(field) || noDefaultValue ? "undefined" : (0, types_1.defaultValue)(ctx, field);
+            const fallback = (0, types_1.isWithinOneOf)(field) || noDefaultValue ? (0, utils_1.nullOrUndefined)(options) : (0, types_1.defaultValue)(ctx, field);
             chunks.push((0, ts_poet_1.code) `
         ${fieldKey}: ${ctx.utils.isSet}(${jsonProperty})
           ? ${readSnippet(`${jsonProperty}`)}
@@ -1780,9 +1780,9 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
-function generateCanonicalToJson(fullName, fullProtobufTypeName, { useOptionals }) {
+function generateCanonicalToJson(fullName, fullProtobufTypeName, { useOptionals, useNullAsOptional }) {
     if ((0, types_1.isFieldMaskTypeName)(fullProtobufTypeName)) {
-        const returnType = useOptionals === "all" ? "string | undefined" : "string";
+        const returnType = useOptionals === "all" ? `string | ${(0, utils_1.nullOrUndefined)({ useNullAsOptional })}` : "string";
         const pathModifier = useOptionals === "all" ? "?" : "";
         return (0, ts_poet_1.code) `
     toJSON(message: ${fullName}): ${returnType} {
@@ -1954,7 +1954,7 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
             let emitDefaultValuesForJson = ctx.options.emitDefaultValues.includes("json-methods");
             const check = ((0, types_1.isScalar)(field) || (0, types_1.isEnum)(field)) && !((0, types_1.isWithinOneOf)(field) || emitDefaultValuesForJson)
                 ? (0, types_1.notDefaultCheck)(ctx, field, messageDesc.options, `${messageProperty}`)
-                : `${messageProperty} !== undefined`;
+                : `${messageProperty} !== undefined ${(0, utils_1.withAndMaybeCheckIsNotNull)(options, messageProperty)}`;
             chunks.push((0, ts_poet_1.code) `
         if (${check}) {
           ${jsonProperty} = ${readSnippet(`${messageProperty}`)};

package/build/options.d.ts

@@ -0,0 +1,101 @@
+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;
+    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

@@ -100,6 +100,7 @@ function defaultOptions() {
         comments: true,
         disableProto2Optionals: false,
         disableProto2DefaultValues: false,
+        useNullAsOptional: false,
     };
 }
 exports.defaultOptions = defaultOptions;

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,103 @@
+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 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;

package/build/types.js

@@ -235,7 +235,7 @@ function defaultValue(ctx, field) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP:
         default:
-            return "undefined";
+            return (0, utils_1.nullOrUndefined)(options);
     }
 }
 exports.defaultValue = defaultValue;
@@ -243,7 +243,9 @@ exports.defaultValue = defaultValue;
 function notDefaultCheck(ctx, field, messageOptions, place) {
     const { typeMap, options, currentFile } = ctx;
     const isOptional = isOptionalProperty(field, messageOptions, options, currentFile.isProto3Syntax);
-    const maybeNotUndefinedAnd = isOptional ? `${place} !== undefined && ` : "";
+    const maybeNotUndefinedAnd = isOptional
+        ? `${place} !== undefined ${(0, utils_1.withAndMaybeCheckIsNotNull)(options, place)} &&`
+        : "";
     switch (field.type) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
@@ -552,7 +554,7 @@ function messageToTypeName(ctx, protoType, typeOptions = {}) {
         if ((_a = typeOptions.repeated) !== null && _a !== void 0 ? _a : false) {
             return valueType;
         }
-        return (0, ts_poet_1.code) `${valueType} | undefined`;
+        return (0, ts_poet_1.code) `${valueType} | ${(0, utils_1.nullOrUndefined)(options)}`;
     }
     // Look for other special prototypes like Timestamp that aren't technically wrapper types
     if (!typeOptions.keepValueType && protoType === ".google.protobuf.Timestamp") {
@@ -584,7 +586,7 @@ exports.getEnumMethod = getEnumMethod;
 function toTypeName(ctx, messageDesc, field, ensureOptional = false) {
     function finalize(type, isOptional) {
         if (isOptional) {
-            return (0, ts_poet_1.code) `${type} | undefined`;
+            return (0, ts_poet_1.code) `${type} | ${(0, utils_1.nullOrUndefined)(ctx.options, field.proto3Optional)}`;
         }
         return type;
     }

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/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrowFunction = exports.tryCatchBlock = exports.impProto = exports.impFile = exports.getPropertyAccessor = exports.safeAccessor = exports.getFieldName = exports.getFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.prefixDisableLinter = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.generateIndexFiles = exports.protoFilesToGenerate = void 0;
+exports.withAndMaybeCheckIsNull = exports.withAndMaybeCheckIsNotNull = exports.withOrMaybeCheckIsNull = exports.withOrMaybeCheckIsNotNull = exports.maybeCheckIsNull = exports.maybeCheckIsNotNull = exports.nullOrUndefined = exports.arrowFunction = exports.tryCatchBlock = exports.impProto = exports.impFile = exports.getPropertyAccessor = exports.safeAccessor = exports.getFieldName = exports.getFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.prefixDisableLinter = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.generateIndexFiles = exports.protoFilesToGenerate = void 0;
 const path = require("path");
 const ts_poet_1 = require("ts-poet");
 const options_1 = require("./options");
@@ -261,3 +261,31 @@ function arrowFunction(params, body, isOneLine = true) {
     return (0, ts_poet_1.code) `(${params}) => { ${body} }`;
 }
 exports.arrowFunction = arrowFunction;
+function nullOrUndefined(options, hasProto3Optional = false) {
+    return options.useNullAsOptional ? `null ${hasProto3Optional ? "| undefined" : ""}` : "undefined";
+}
+exports.nullOrUndefined = nullOrUndefined;
+function maybeCheckIsNotNull(options, typeName, prefix) {
+    return options.useNullAsOptional ? ` ${prefix} ${typeName} !== null` : "";
+}
+exports.maybeCheckIsNotNull = maybeCheckIsNotNull;
+function maybeCheckIsNull(options, typeName, prefix) {
+    return options.useNullAsOptional ? ` ${prefix} ${typeName} === null` : "";
+}
+exports.maybeCheckIsNull = maybeCheckIsNull;
+function withOrMaybeCheckIsNotNull(options, typeName) {
+    return maybeCheckIsNotNull(options, typeName, "||");
+}
+exports.withOrMaybeCheckIsNotNull = withOrMaybeCheckIsNotNull;
+function withOrMaybeCheckIsNull(options, typeName) {
+    return maybeCheckIsNull(options, typeName, "||");
+}
+exports.withOrMaybeCheckIsNull = withOrMaybeCheckIsNull;
+function withAndMaybeCheckIsNotNull(options, typeName) {
+    return maybeCheckIsNotNull(options, typeName, "&&");
+}
+exports.withAndMaybeCheckIsNotNull = withAndMaybeCheckIsNotNull;
+function withAndMaybeCheckIsNull(options, typeName) {
+    return maybeCheckIsNotNull(options, typeName, "&&");
+}
+exports.withAndMaybeCheckIsNull = withAndMaybeCheckIsNull;

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.170.0",
+  "version": "1.172.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",