ts-proto 1.171.0 → 1.172.0

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/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/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/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.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",