@bufbuild/protobuf 0.0.1-alpha.1

package/dist/types/descriptor-registry.d.ts

@@ -0,0 +1,42 @@
+import type { FileDescriptorProto } from "./google/protobuf/descriptor_pb.js";
+import type { MessageType } from "./message-type.js";
+import type { EnumType } from "./enum.js";
+import { DescriptorSet } from "./descriptor-set.js";
+import type {
+  IEnumTypeRegistry,
+  IMessageTypeRegistry,
+  IServiceTypeRegistry,
+} from "./type-registry.js";
+import type { ServiceType } from "./service-type.js";
+/**
+ * DescriptorRegistry is a type registry that dynamically creates types
+ * from a set of google.protobuf.FileDescriptorProto.
+ *
+ * By default, all well-known types with a specialized JSON representation
+ * are replaced with their generated counterpart in this package.
+ */
+export declare class DescriptorRegistry
+  implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry
+{
+  private readonly ds;
+  private readonly enums;
+  private readonly messages;
+  private readonly services;
+  constructor(descriptorSet?: DescriptorSet, replaceWkt?: boolean);
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  add(...files: FileDescriptorProto[]): void;
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  findEnum(typeName: string): EnumType | undefined;
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  findMessage(typeName: string): MessageType | undefined;
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  findService(typeName: string): ServiceType | undefined;
+}

package/dist/types/descriptor-set.d.ts

@@ -0,0 +1,171 @@
+import type {
+  DescriptorProto,
+  EnumDescriptorProto,
+  EnumValueDescriptorProto,
+  FieldDescriptorProto,
+  OneofDescriptorProto,
+} from "./google/protobuf/descriptor_pb.js";
+import {
+  FieldDescriptorProto_Type,
+  FileDescriptorProto,
+  MethodDescriptorProto,
+  ServiceDescriptorProto,
+} from "./google/protobuf/descriptor_pb.js";
+import { ScalarType } from "./field.js";
+import { MethodIdempotency, MethodKind } from "./service-type.js";
+/**
+ * DescriptorSet wraps a set of google.protobuf.FileDescriptorProto,
+ * asserting basic expectations and providing hierarchical information.
+ *
+ * Note that all types are kept by their fully qualified type name
+ * with a leading dot.
+ */
+export declare class DescriptorSet implements UnresolvedSet {
+  readonly enums: Record<string, UnresolvedEnum | undefined>;
+  readonly messages: Record<string, UnresolvedMessage | undefined>;
+  readonly services: Record<string, UnresolvedService | undefined>;
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  add(...files: FileDescriptorProto[]): void;
+  listEnums(): UnresolvedEnum[];
+  listMessages(): UnresolvedMessage[];
+  listServices(): UnresolvedService[];
+}
+interface UnresolvedSet {
+  readonly enums: Record<string, UnresolvedEnum | undefined>;
+  readonly messages: Record<string, UnresolvedMessage | undefined>;
+  readonly services: Record<string, UnresolvedService | undefined>;
+}
+interface File {
+  readonly proto: FileDescriptorProto;
+  readonly syntax: "proto3" | "proto2";
+  readonly name: string;
+  toString(): string;
+}
+interface UnresolvedEnum {
+  readonly proto: EnumDescriptorProto;
+  readonly file: File;
+  readonly parent: UnresolvedMessage | undefined;
+  readonly name: string;
+  readonly typeName: string;
+  readonly protoTypeName: string;
+  readonly values: UnresolvedEnumValue[];
+  toString(): string;
+}
+interface UnresolvedEnumValue {
+  readonly proto: EnumValueDescriptorProto;
+  readonly parent: UnresolvedEnum;
+  readonly name: string;
+  readonly number: number;
+  toString(): string;
+}
+interface UnresolvedMessage {
+  readonly proto: DescriptorProto;
+  readonly file: File;
+  readonly parent: UnresolvedMessage | undefined;
+  readonly name: string;
+  readonly typeName: string;
+  readonly protoTypeName: string;
+  readonly fields: UnresolvedField[];
+  readonly oneofs: UnresolvedOneof[];
+  readonly nestedEnums: UnresolvedEnum[];
+  readonly nestedMessages: UnresolvedMessage[];
+  readonly nestedExtensions: UnresolvedExtension[];
+  toString(): string;
+}
+interface UnresolvedField {
+  readonly proto: FieldDescriptorProto;
+  readonly number: number;
+  readonly name: string;
+  readonly type: FieldDescriptorProto_Type;
+  readonly parent: UnresolvedMessage;
+  readonly oneof: UnresolvedOneof | undefined;
+  readonly optional: boolean;
+  readonly packed: boolean;
+  toString(): string;
+  resolve(us: UnresolvedSet): ResolvedField;
+}
+declare type ResolvedField =
+  | (UnresolvedField & {
+      repeated: boolean;
+      readonly scalarType: ScalarType;
+      readonly message: undefined;
+      readonly enum: undefined;
+      readonly map: undefined;
+    })
+  | (UnresolvedField & {
+      repeated: boolean;
+      readonly scalarType: undefined;
+      readonly message: UnresolvedMessage;
+      readonly enum: undefined;
+      readonly map: undefined;
+    })
+  | (UnresolvedField & {
+      repeated: boolean;
+      readonly scalarType: undefined;
+      readonly message: undefined;
+      readonly enum: UnresolvedEnum;
+      readonly map: undefined;
+    })
+  | (UnresolvedField & {
+      repeated: false;
+      readonly scalarType: undefined;
+      readonly message: undefined;
+      readonly enum: undefined;
+      readonly map: Map;
+    });
+declare type Map = {
+  key: Exclude<
+    ScalarType,
+    ScalarType.FLOAT | ScalarType.DOUBLE | ScalarType.BYTES
+  >;
+  value:
+    | {
+        enum: UnresolvedEnum;
+        message: undefined;
+        scalar: undefined;
+      }
+    | {
+        enum: undefined;
+        message: UnresolvedMessage;
+        scalar: undefined;
+      }
+    | {
+        enum: undefined;
+        message: undefined;
+        scalarType: ScalarType;
+      };
+};
+interface UnresolvedOneof {
+  readonly proto: OneofDescriptorProto;
+  readonly name: string;
+  readonly parent: UnresolvedMessage;
+  readonly file: File;
+  readonly fields: UnresolvedField[];
+  toString(): string;
+}
+interface UnresolvedExtension {
+  readonly proto: FieldDescriptorProto;
+  readonly parent: UnresolvedMessage | undefined;
+  readonly file: File;
+}
+interface UnresolvedService {
+  readonly proto: ServiceDescriptorProto;
+  readonly file: File;
+  readonly methods: UnresolvedMethod[];
+  readonly typeName: string;
+  readonly protoTypeName: string;
+  toString(): string;
+}
+interface UnresolvedMethod {
+  readonly proto: MethodDescriptorProto;
+  readonly parent: UnresolvedService;
+  readonly name: string;
+  readonly kind: MethodKind;
+  readonly inputTypeName: string;
+  readonly outputTypeName: string;
+  readonly idempotency?: MethodIdempotency;
+  toString(): string;
+}
+export {};

package/dist/types/enum.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reflection information for a protobuf enum.
+ */
+export interface EnumType {
+  /**
+   * The fully qualified name of the enum.
+   */
+  readonly typeName: string;
+  readonly values: readonly EnumValueInfo[];
+  /**
+   * Find an enum value by its (protobuf) name.
+   */
+  findName(name: string): EnumValueInfo | undefined;
+  /**
+   * Find an enum value by its number.
+   */
+  findNumber(no: number): EnumValueInfo | undefined;
+}
+/**
+ * Reflection information for a protobuf enum value.
+ */
+export interface EnumValueInfo {
+  /**
+   * The number of the value as specified in proto.
+   */
+  readonly no: number;
+  /**
+   * The name of the value as specified in proto.
+   */
+  readonly name: string;
+}

package/dist/types/field-list.d.ts

@@ -0,0 +1,27 @@
+import type { FieldInfo, OneofInfo } from "./field.js";
+/**
+ * Provides convenient access to field information of a message type.
+ */
+export interface FieldList {
+  /**
+   * Find field information by field name or json_name.
+   */
+  findJsonName(jsonName: string): FieldInfo | undefined;
+  /**
+   * Find field information by proto field number.
+   */
+  find(fieldNo: number): FieldInfo | undefined;
+  /**
+   * Return field information in the order they appear in the source.
+   */
+  list(): readonly FieldInfo[];
+  /**
+   * Return field information ordered by field number ascending.
+   */
+  byNumber(): readonly FieldInfo[];
+  /**
+   * In order of appearance in the source, list fields and
+   * oneof groups.
+   */
+  byMember(): readonly (FieldInfo | OneofInfo)[];
+}

package/dist/types/field.d.ts

@@ -0,0 +1,295 @@
+import type { EnumType } from "./enum.js";
+import type { MessageType } from "./message-type.js";
+/**
+ * FieldInfo describes a field of a protobuf message for runtime reflection. We
+ * distinguish between the following kinds of fields:
+ *
+ * - "scalar": string, bool, float, int32, etc. The scalar type is "T".
+ * - "enum": The field was declared with an enum type. The enum type is "T".
+ * - "message": The field was declared with a message type. The message type is "T".
+ * - "map": The field was declared with map<K,V>. The key type is "K", the value type is "V".
+ *
+ * Every field always has the following properties:
+ *
+ * - "no": The field number of the protobuf field.
+ * - "name": The original name of the protobuf field.
+ * - "localName": The name of the field as used in generated code.
+ * - "jsonName": The name for JSON serialization / deserialization.
+ * - "opt": Whether the field is optional.
+ * - "repeated": Whether the field is repeated.
+ * - "packed": Whether the repeated field is packed.
+ *
+ * Additionally, fields may have the following properties:
+ *
+ * - "oneof": If the field is member of a oneof group.
+ * - "default": Only proto2: An explicit default value.
+ */
+export declare type FieldInfo =
+  | fiRules<fiScalar>
+  | fiRules<fiEnum>
+  | fiRules<fiMessage>
+  | fiRules<fiMap>;
+/**
+ * Version of `FieldInfo` that allows the following properties
+ * to be omitted:
+ *
+ * - "localName", "jsonName": can be omitted if equal to lowerCamelCase(name)
+ * - "opt": Can be omitted if false.
+ * - "repeated": Can be omitted if false.
+ * - "packed": Can be omitted if equal to the standard packing of the field.
+ */
+export declare type PartialFieldInfo =
+  | fiPartialRules<fiScalar>
+  | fiPartialRules<fiEnum>
+  | fiPartialRules<fiMessage>
+  | fiPartialRules<fiMap>;
+/**
+ * Provides convenient access to field information of a oneof.
+ */
+export interface OneofInfo {
+  readonly kind: "oneof";
+  readonly name: string;
+  readonly localName: string;
+  readonly repeated: false;
+  readonly packed: false;
+  readonly opt: false;
+  readonly default: undefined;
+  readonly fields: readonly FieldInfo[];
+  /**
+   * Return field information by local name.
+   */
+  findField(localName: string): FieldInfo | undefined;
+}
+interface fiShared {
+  /**
+   * The field number of the .proto field.
+   */
+  readonly no: number;
+  /**
+   * The original name of the .proto field.
+   */
+  readonly name: string;
+  /**
+   * The name of the field as used in generated code.
+   */
+  readonly localName: string;
+  /**
+   * The name for JSON serialization / deserialization.
+   */
+  readonly jsonName: string;
+  /**
+   * The `oneof` group, if this field belongs to one.
+   */
+  readonly oneof?: OneofInfo | undefined;
+}
+interface fiScalar extends fiShared {
+  readonly kind: "scalar";
+  /**
+   * Scalar type of the field.
+   */
+  readonly T: ScalarType;
+  /**
+   * Is the field repeated?
+   */
+  readonly repeated: boolean;
+  /**
+   * Is this repeated field packed?
+   * BYTES and STRING can never be packed, since they are length-delimited.
+   * Other types can be packed with the field option "packed".
+   * For proto3, fields are packed by default.
+   */
+  readonly packed: boolean;
+  /**
+   * Is the field optional?
+   */
+  readonly opt: boolean;
+  /**
+   * Only proto2: An explicit default value.
+   */
+  readonly default: number | boolean | string | bigint | Uint8Array | undefined;
+}
+interface fiMessage extends fiShared {
+  readonly kind: "message";
+  /**
+   * Message handler for the field.
+   */
+  readonly T: MessageType;
+  /**
+   * Is the field repeated?
+   */
+  readonly repeated: boolean;
+  /**
+   * Is this repeated field packed? Never true for messages.
+   */
+  readonly packed: false;
+  /**
+   * An explicit default value (only proto2). Never set for messages.
+   */
+  readonly default: undefined;
+}
+interface fiEnum extends fiShared {
+  readonly kind: "enum";
+  /**
+   * Enum type information for the field.
+   */
+  readonly T: EnumType;
+  /**
+   * Is the field repeated?
+   */
+  readonly repeated: boolean;
+  /**
+   * Is this repeated field packed?
+   * Repeated enums can be packed with the field option "packed".
+   * For proto3, they are packed by default.
+   */
+  readonly packed: boolean;
+  /**
+   * Is the field optional?
+   */
+  readonly opt: boolean;
+  /**
+   * Only proto2: An explicit default value.
+   */
+  readonly default: number | undefined;
+}
+interface fiMap extends fiShared {
+  readonly kind: "map";
+  /**
+   * Map key type.
+   *
+   * The key_type can be any integral or string type
+   * (so, any scalar type except for floating point
+   * types and bytes)
+   */
+  readonly K: Exclude<
+    ScalarType,
+    ScalarType.FLOAT | ScalarType.DOUBLE | ScalarType.BYTES
+  >;
+  /**
+   * Map value type. Can be scalar, enum, or message.
+   */
+  readonly V:
+    | {
+        readonly kind: "scalar";
+        readonly T: ScalarType;
+      }
+    | {
+        readonly kind: "enum";
+        readonly T: EnumType;
+      }
+    | {
+        readonly kind: "message";
+        readonly T: MessageType;
+      };
+  /**
+   * Is the field repeated? Never true for maps.
+   */
+  readonly repeated: false;
+  /**
+   * Is this repeated field packed? Never true for maps.
+   */
+  readonly packed: false;
+  /**
+   * An explicit default value (only proto2). Never set for maps.
+   */
+  readonly default: undefined;
+}
+declare type fiRules<T> = Omit<
+  T,
+  "oneof" | "repeat" | "repeated" | "packed" | "opt"
+> &
+  (
+    | {
+        readonly repeated: false;
+        readonly packed: false;
+        readonly opt: false;
+        readonly oneof: undefined;
+      }
+    | {
+        readonly repeated: false;
+        readonly packed: false;
+        readonly opt: true;
+        readonly oneof: undefined;
+      }
+    | {
+        readonly repeated: boolean;
+        readonly packed: boolean;
+        readonly opt: false;
+        readonly oneof: undefined;
+      }
+    | {
+        readonly repeated: false;
+        readonly packed: false;
+        readonly opt: false;
+        readonly oneof: OneofInfo;
+      }
+  );
+declare type fiPartialRules<T extends fiScalar | fiMap | fiEnum | fiMessage> =
+  Omit<
+    T,
+    | "jsonName"
+    | "localName"
+    | "oneof"
+    | "repeat"
+    | "repeated"
+    | "packed"
+    | "opt"
+    | "default"
+  > &
+    (
+      | {
+          readonly jsonName?: string;
+          readonly repeated?: false;
+          readonly packed?: false;
+          readonly opt?: false;
+          readonly oneof?: undefined;
+          default?: T["default"];
+        }
+      | {
+          readonly jsonName?: string;
+          readonly repeated?: false;
+          readonly packed?: false;
+          readonly opt: true;
+          readonly oneof?: undefined;
+          default?: T["default"];
+        }
+      | {
+          readonly jsonName?: string;
+          readonly repeated?: boolean;
+          readonly packed?: boolean;
+          readonly opt?: false;
+          readonly oneof?: undefined;
+          default?: T["default"];
+        }
+      | {
+          readonly jsonName?: string;
+          readonly repeated?: false;
+          readonly packed?: false;
+          readonly opt?: false;
+          readonly oneof: string;
+          default?: T["default"];
+        }
+    );
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+export declare enum ScalarType {
+  DOUBLE = 1,
+  FLOAT = 2,
+  INT64 = 3,
+  UINT64 = 4,
+  INT32 = 5,
+  FIXED64 = 6,
+  FIXED32 = 7,
+  BOOL = 8,
+  STRING = 9,
+  BYTES = 12,
+  UINT32 = 13,
+  SFIXED32 = 15,
+  SFIXED64 = 16,
+  SINT32 = 17,
+  SINT64 = 18,
+}
+export {};