@varavel/vdl-plugin-sdk 0.0.0

package/src/ir.ts

@@ -0,0 +1,978 @@
+// Code generated by VDL v0.4.0-alpha.5. DO NOT EDIT.
+// If you edit this file, it will be overwritten the next time it is generated.
+//
+// For more information about VDL, visit https://vdl.varavel.com
+
+/* eslint-disable */
+/* tslint:disable */
+// biome-ignore-all lint: Generated by VDL
+
+// -----------------------------------------------------------------------------
+// Enumerations
+// -----------------------------------------------------------------------------
+
+/**
+ * Underlying storage kind used by an enum
+ */
+export type EnumValueType = "string" | "int";
+
+export const EnumValueTypeList: EnumValueType[] = ["string", "int"];
+
+export function isEnumValueType(value: unknown): value is EnumValueType {
+  return EnumValueTypeList.includes(value as EnumValueType);
+}
+
+/**
+ * Kind discriminator for LiteralValue.
+ *
+ * LiteralValue is used for fully resolved literal data in:
+ *
+ * - constant values
+ * - annotation arguments
+ */
+export type LiteralKind =
+  | "string"
+  | "int"
+  | "float"
+  | "bool"
+  | "object"
+  | "array";
+
+export const LiteralKindList: LiteralKind[] = [
+  "string",
+  "int",
+  "float",
+  "bool",
+  "object",
+  "array",
+];
+
+export function isLiteralKind(value: unknown): value is LiteralKind {
+  return LiteralKindList.includes(value as LiteralKind);
+}
+
+/**
+ * Primitive scalar type names
+ */
+export type PrimitiveType = "string" | "int" | "float" | "bool" | "datetime";
+
+export const PrimitiveTypeList: PrimitiveType[] = [
+  "string",
+  "int",
+  "float",
+  "bool",
+  "datetime",
+];
+
+export function isPrimitiveType(value: unknown): value is PrimitiveType {
+  return PrimitiveTypeList.includes(value as PrimitiveType);
+}
+
+/**
+ * Kind discriminator for TypeRef
+ */
+export type TypeKind =
+  | "primitive"
+  | "type"
+  | "enum"
+  | "array"
+  | "map"
+  | "object";
+
+export const TypeKindList: TypeKind[] = [
+  "primitive",
+  "type",
+  "enum",
+  "array",
+  "map",
+  "object",
+];
+
+export function isTypeKind(value: unknown): value is TypeKind {
+  return TypeKindList.includes(value as TypeKind);
+}
+
+// -----------------------------------------------------------------------------
+// Domain Types
+// -----------------------------------------------------------------------------
+
+/**
+ * Annotation Annotation metadata preserved in IR.
+ *
+ * `name` is the annotation identifier without the `@` prefix.
+ * `argument`, when present, is fully resolved as a LiteralValue.
+ */
+export type Annotation = {
+  position: Position;
+  name: string;
+  argument?: LiteralValue;
+};
+
+export function hydrateAnnotation(input: Annotation): Annotation {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedName = input.name;
+  const hydratedArgument = input.argument
+    ? hydrateLiteralValue(input.argument)
+    : input.argument;
+  return {
+    position: hydratedPosition,
+    name: hydratedName,
+    argument: hydratedArgument,
+  };
+}
+
+export function validateAnnotation(
+  input: unknown,
+  path = "Annotation",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.argument !== undefined && obj.argument !== null) {
+    {
+      const err = validateLiteralValue(obj.argument, `${path}.argument`);
+      if (err !== null) return err;
+    }
+  }
+  return null;
+}
+
+/**
+ * ConstantDef Fully resolved constant definition.
+ *
+ * `typeRef` is explicit or inferred by analysis.
+ * `value` contains the fully resolved literal payload.
+ */
+export type ConstantDef = {
+  position: Position;
+  name: string;
+  doc?: string;
+  annotations: Annotation[];
+  typeRef: TypeRef;
+  value: LiteralValue;
+};
+
+export function hydrateConstantDef(input: ConstantDef): ConstantDef {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedName = input.name;
+  const hydratedDoc = input.doc ? input.doc : input.doc;
+  const hydratedAnnotations = input.annotations.map((el) =>
+    hydrateAnnotation(el),
+  );
+  const hydratedTypeRef = hydrateTypeRef(input.typeRef);
+  const hydratedValue = hydrateLiteralValue(input.value);
+  return {
+    position: hydratedPosition,
+    name: hydratedName,
+    doc: hydratedDoc,
+    annotations: hydratedAnnotations,
+    typeRef: hydratedTypeRef,
+    value: hydratedValue,
+  };
+}
+
+export function validateConstantDef(
+  input: unknown,
+  path = "ConstantDef",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.annotations === undefined || obj.annotations === null) {
+    return `${path}.annotations: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.annotations)) {
+      return `${path}.annotations: expected array, got ${typeof obj.annotations}`;
+    }
+    for (let i = 0; i < obj.annotations.length; i++) {
+      {
+        const err = validateAnnotation(
+          obj.annotations[i],
+          `${path}.annotations[${i}]`,
+        );
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.typeRef === undefined || obj.typeRef === null) {
+    return `${path}.typeRef: required field is missing`;
+  }
+  {
+    const err = validateTypeRef(obj.typeRef, `${path}.typeRef`);
+    if (err !== null) return err;
+  }
+  if (obj.value === undefined || obj.value === null) {
+    return `${path}.value: required field is missing`;
+  }
+  {
+    const err = validateLiteralValue(obj.value, `${path}.value`);
+    if (err !== null) return err;
+  }
+  return null;
+}
+
+/**
+ * EnumDef Flattened enum definition.
+ *
+ * All enum spreads are already expanded into `members`.
+ */
+export type EnumDef = {
+  position: Position;
+  name: string;
+  doc?: string;
+  annotations: Annotation[];
+  enumType: EnumValueType;
+  members: EnumMember[];
+};
+
+export function hydrateEnumDef(input: EnumDef): EnumDef {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedName = input.name;
+  const hydratedDoc = input.doc ? input.doc : input.doc;
+  const hydratedAnnotations = input.annotations.map((el) =>
+    hydrateAnnotation(el),
+  );
+  const hydratedEnumType = input.enumType;
+  const hydratedMembers = input.members.map((el) => hydrateEnumMember(el));
+  return {
+    position: hydratedPosition,
+    name: hydratedName,
+    doc: hydratedDoc,
+    annotations: hydratedAnnotations,
+    enumType: hydratedEnumType,
+    members: hydratedMembers,
+  };
+}
+
+export function validateEnumDef(
+  input: unknown,
+  path = "EnumDef",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.annotations === undefined || obj.annotations === null) {
+    return `${path}.annotations: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.annotations)) {
+      return `${path}.annotations: expected array, got ${typeof obj.annotations}`;
+    }
+    for (let i = 0; i < obj.annotations.length; i++) {
+      {
+        const err = validateAnnotation(
+          obj.annotations[i],
+          `${path}.annotations[${i}]`,
+        );
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.enumType === undefined || obj.enumType === null) {
+    return `${path}.enumType: required field is missing`;
+  }
+  {
+    if (!isEnumValueType(obj.enumType)) {
+      return `${path}.enumType: invalid enum value '${obj.enumType}' for EnumValueType`;
+    }
+  }
+  if (obj.members === undefined || obj.members === null) {
+    return `${path}.members: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.members)) {
+      return `${path}.members: expected array, got ${typeof obj.members}`;
+    }
+    for (let i = 0; i < obj.members.length; i++) {
+      {
+        const err = validateEnumMember(obj.members[i], `${path}.members[${i}]`);
+        if (err !== null) return err;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * EnumMember Enum member definition
+ */
+export type EnumMember = {
+  position: Position;
+  name: string;
+  value: LiteralValue;
+  doc?: string;
+  annotations: Annotation[];
+};
+
+export function hydrateEnumMember(input: EnumMember): EnumMember {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedName = input.name;
+  const hydratedValue = hydrateLiteralValue(input.value);
+  const hydratedDoc = input.doc ? input.doc : input.doc;
+  const hydratedAnnotations = input.annotations.map((el) =>
+    hydrateAnnotation(el),
+  );
+  return {
+    position: hydratedPosition,
+    name: hydratedName,
+    value: hydratedValue,
+    doc: hydratedDoc,
+    annotations: hydratedAnnotations,
+  };
+}
+
+export function validateEnumMember(
+  input: unknown,
+  path = "EnumMember",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.value === undefined || obj.value === null) {
+    return `${path}.value: required field is missing`;
+  }
+  {
+    const err = validateLiteralValue(obj.value, `${path}.value`);
+    if (err !== null) return err;
+  }
+  if (obj.annotations === undefined || obj.annotations === null) {
+    return `${path}.annotations: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.annotations)) {
+      return `${path}.annotations: expected array, got ${typeof obj.annotations}`;
+    }
+    for (let i = 0; i < obj.annotations.length; i++) {
+      {
+        const err = validateAnnotation(
+          obj.annotations[i],
+          `${path}.annotations[${i}]`,
+        );
+        if (err !== null) return err;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Field Flattened object/type field definition
+ */
+export type Field = {
+  position: Position;
+  name: string;
+  doc?: string;
+  optional: boolean;
+  annotations: Annotation[];
+  typeRef: TypeRef;
+};
+
+export function hydrateField(input: Field): Field {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedName = input.name;
+  const hydratedDoc = input.doc ? input.doc : input.doc;
+  const hydratedOptional = input.optional;
+  const hydratedAnnotations = input.annotations.map((el) =>
+    hydrateAnnotation(el),
+  );
+  const hydratedTypeRef = hydrateTypeRef(input.typeRef);
+  return {
+    position: hydratedPosition,
+    name: hydratedName,
+    doc: hydratedDoc,
+    optional: hydratedOptional,
+    annotations: hydratedAnnotations,
+    typeRef: hydratedTypeRef,
+  };
+}
+
+export function validateField(input: unknown, path = "Field"): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.annotations === undefined || obj.annotations === null) {
+    return `${path}.annotations: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.annotations)) {
+      return `${path}.annotations: expected array, got ${typeof obj.annotations}`;
+    }
+    for (let i = 0; i < obj.annotations.length; i++) {
+      {
+        const err = validateAnnotation(
+          obj.annotations[i],
+          `${path}.annotations[${i}]`,
+        );
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.typeRef === undefined || obj.typeRef === null) {
+    return `${path}.typeRef: required field is missing`;
+  }
+  {
+    const err = validateTypeRef(obj.typeRef, `${path}.typeRef`);
+    if (err !== null) return err;
+  }
+  return null;
+}
+
+/**
+ * IrSchema IrSchema is the generator-facing representation of a VDL program.
+ *
+ * This model is intentionally "flat" and "resolved":
+ *
+ * - spreads are already expanded
+ * - references are already resolved
+ * - collections are in deterministic order
+ *
+ * A code generator should be able to consume IrSchema directly, without needing
+ * to re-run parser or semantic-analysis logic.
+ */
+export type IrSchema = {
+  entryPoint: string;
+  constants: ConstantDef[];
+  enums: EnumDef[];
+  types: TypeDef[];
+  docs: TopLevelDoc[];
+};
+
+export function hydrateIrSchema(input: IrSchema): IrSchema {
+  const hydratedEntryPoint = input.entryPoint;
+  const hydratedConstants = input.constants.map((el) => hydrateConstantDef(el));
+  const hydratedEnums = input.enums.map((el) => hydrateEnumDef(el));
+  const hydratedTypes = input.types.map((el) => hydrateTypeDef(el));
+  const hydratedDocs = input.docs.map((el) => hydrateTopLevelDoc(el));
+  return {
+    entryPoint: hydratedEntryPoint,
+    constants: hydratedConstants,
+    enums: hydratedEnums,
+    types: hydratedTypes,
+    docs: hydratedDocs,
+  };
+}
+
+export function validateIrSchema(
+  input: unknown,
+  path = "IrSchema",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.constants === undefined || obj.constants === null) {
+    return `${path}.constants: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.constants)) {
+      return `${path}.constants: expected array, got ${typeof obj.constants}`;
+    }
+    for (let i = 0; i < obj.constants.length; i++) {
+      {
+        const err = validateConstantDef(
+          obj.constants[i],
+          `${path}.constants[${i}]`,
+        );
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.enums === undefined || obj.enums === null) {
+    return `${path}.enums: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.enums)) {
+      return `${path}.enums: expected array, got ${typeof obj.enums}`;
+    }
+    for (let i = 0; i < obj.enums.length; i++) {
+      {
+        const err = validateEnumDef(obj.enums[i], `${path}.enums[${i}]`);
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.types === undefined || obj.types === null) {
+    return `${path}.types: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.types)) {
+      return `${path}.types: expected array, got ${typeof obj.types}`;
+    }
+    for (let i = 0; i < obj.types.length; i++) {
+      {
+        const err = validateTypeDef(obj.types[i], `${path}.types[${i}]`);
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.docs === undefined || obj.docs === null) {
+    return `${path}.docs: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.docs)) {
+      return `${path}.docs: expected array, got ${typeof obj.docs}`;
+    }
+    for (let i = 0; i < obj.docs.length; i++) {
+      {
+        const err = validateTopLevelDoc(obj.docs[i], `${path}.docs[${i}]`);
+        if (err !== null) return err;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * LiteralValue Fully resolved literal value.
+ *
+ * The selected payload is determined by `kind`:
+ *
+ * - `string` -> `stringValue`
+ * - `int` -> `intValue`
+ * - `float` -> `floatValue`
+ * - `bool` -> `boolValue`
+ * - `object` -> `objectEntries`
+ * - `array` -> `arrayItems`
+ */
+export type LiteralValue = {
+  position: Position;
+  kind: LiteralKind;
+  stringValue?: string;
+  intValue?: number;
+  floatValue?: number;
+  boolValue?: boolean;
+  objectEntries?: ObjectEntry[];
+  arrayItems?: LiteralValue[];
+};
+
+export function hydrateLiteralValue(input: LiteralValue): LiteralValue {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedKind = input.kind;
+  const hydratedStringValue = input.stringValue
+    ? input.stringValue
+    : input.stringValue;
+  const hydratedIntValue = input.intValue ? input.intValue : input.intValue;
+  const hydratedFloatValue = input.floatValue
+    ? input.floatValue
+    : input.floatValue;
+  const hydratedBoolValue = input.boolValue ? input.boolValue : input.boolValue;
+  const hydratedObjectEntries = input.objectEntries
+    ? input.objectEntries.map((el) => hydrateObjectEntry(el))
+    : input.objectEntries;
+  const hydratedArrayItems = input.arrayItems
+    ? input.arrayItems.map((el) => hydrateLiteralValue(el))
+    : input.arrayItems;
+  return {
+    position: hydratedPosition,
+    kind: hydratedKind,
+    stringValue: hydratedStringValue,
+    intValue: hydratedIntValue,
+    floatValue: hydratedFloatValue,
+    boolValue: hydratedBoolValue,
+    objectEntries: hydratedObjectEntries,
+    arrayItems: hydratedArrayItems,
+  };
+}
+
+export function validateLiteralValue(
+  input: unknown,
+  path = "LiteralValue",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.kind === undefined || obj.kind === null) {
+    return `${path}.kind: required field is missing`;
+  }
+  {
+    if (!isLiteralKind(obj.kind)) {
+      return `${path}.kind: invalid enum value '${obj.kind}' for LiteralKind`;
+    }
+  }
+  if (obj.objectEntries !== undefined && obj.objectEntries !== null) {
+    {
+      if (!Array.isArray(obj.objectEntries)) {
+        return `${path}.objectEntries: expected array, got ${typeof obj.objectEntries}`;
+      }
+      for (let i = 0; i < obj.objectEntries.length; i++) {
+        {
+          const err = validateObjectEntry(
+            obj.objectEntries[i],
+            `${path}.objectEntries[${i}]`,
+          );
+          if (err !== null) return err;
+        }
+      }
+    }
+  }
+  if (obj.arrayItems !== undefined && obj.arrayItems !== null) {
+    {
+      if (!Array.isArray(obj.arrayItems)) {
+        return `${path}.arrayItems: expected array, got ${typeof obj.arrayItems}`;
+      }
+      for (let i = 0; i < obj.arrayItems.length; i++) {
+        {
+          const err = validateLiteralValue(
+            obj.arrayItems[i],
+            `${path}.arrayItems[${i}]`,
+          );
+          if (err !== null) return err;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * ObjectEntry Key/value pair inside an object LiteralValue payload
+ */
+export type ObjectEntry = {
+  position: Position;
+  key: string;
+  value: LiteralValue;
+};
+
+export function hydrateObjectEntry(input: ObjectEntry): ObjectEntry {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedKey = input.key;
+  const hydratedValue = hydrateLiteralValue(input.value);
+  return {
+    position: hydratedPosition,
+    key: hydratedKey,
+    value: hydratedValue,
+  };
+}
+
+export function validateObjectEntry(
+  input: unknown,
+  path = "ObjectEntry",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.value === undefined || obj.value === null) {
+    return `${path}.value: required field is missing`;
+  }
+  {
+    const err = validateLiteralValue(obj.value, `${path}.value`);
+    if (err !== null) return err;
+  }
+  return null;
+}
+
+/**
+ * Position It represents a position within a file and is used for error
+ * reporting, diagnostics, plugins, and tooling support.
+ */
+export type Position = {
+  file: string;
+  line: number;
+  column: number;
+};
+
+export function hydratePosition(input: Position): Position {
+  const hydratedFile = input.file;
+  const hydratedLine = input.line;
+  const hydratedColumn = input.column;
+  return {
+    file: hydratedFile,
+    line: hydratedLine,
+    column: hydratedColumn,
+  };
+}
+
+export function validatePosition(
+  _input: unknown,
+  _path = "Position",
+): string | null {
+  return null;
+}
+
+/**
+ * TopLevelDoc Standalone documentation block.
+ *
+ * Used for top-level docstrings that are not attached to a type/enum/constant.
+ */
+export type TopLevelDoc = {
+  position: Position;
+  content: string;
+};
+
+export function hydrateTopLevelDoc(input: TopLevelDoc): TopLevelDoc {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedContent = input.content;
+  return {
+    position: hydratedPosition,
+    content: hydratedContent,
+  };
+}
+
+export function validateTopLevelDoc(
+  input: unknown,
+  path = "TopLevelDoc",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  return null;
+}
+
+/**
+ * TypeDef Flattened type definition.
+ *
+ * All spreads are already expanded. The unified `typeRef` describes what this
+ * type IS, a primitive, custom reference, map, array, or object with fields.
+ */
+export type TypeDef = {
+  position: Position;
+  name: string;
+  doc?: string;
+  annotations: Annotation[];
+  typeRef: TypeRef;
+};
+
+export function hydrateTypeDef(input: TypeDef): TypeDef {
+  const hydratedPosition = hydratePosition(input.position);
+  const hydratedName = input.name;
+  const hydratedDoc = input.doc ? input.doc : input.doc;
+  const hydratedAnnotations = input.annotations.map((el) =>
+    hydrateAnnotation(el),
+  );
+  const hydratedTypeRef = hydrateTypeRef(input.typeRef);
+  return {
+    position: hydratedPosition,
+    name: hydratedName,
+    doc: hydratedDoc,
+    annotations: hydratedAnnotations,
+    typeRef: hydratedTypeRef,
+  };
+}
+
+export function validateTypeDef(
+  input: unknown,
+  path = "TypeDef",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.position === undefined || obj.position === null) {
+    return `${path}.position: required field is missing`;
+  }
+  {
+    const err = validatePosition(obj.position, `${path}.position`);
+    if (err !== null) return err;
+  }
+  if (obj.annotations === undefined || obj.annotations === null) {
+    return `${path}.annotations: required field is missing`;
+  }
+  {
+    if (!Array.isArray(obj.annotations)) {
+      return `${path}.annotations: expected array, got ${typeof obj.annotations}`;
+    }
+    for (let i = 0; i < obj.annotations.length; i++) {
+      {
+        const err = validateAnnotation(
+          obj.annotations[i],
+          `${path}.annotations[${i}]`,
+        );
+        if (err !== null) return err;
+      }
+    }
+  }
+  if (obj.typeRef === undefined || obj.typeRef === null) {
+    return `${path}.typeRef: required field is missing`;
+  }
+  {
+    const err = validateTypeRef(obj.typeRef, `${path}.typeRef`);
+    if (err !== null) return err;
+  }
+  return null;
+}
+
+/**
+ * TypeRef Normalized type reference used by fields and constants.
+ *
+ * `kind` selects which payload fields are meaningful. Generators should inspect
+ * `kind` first, then read the related payload fields.
+ */
+export type TypeRef = {
+  kind: TypeKind;
+  primitiveName?: PrimitiveType;
+  typeName?: string;
+  enumName?: string;
+  enumType?: EnumValueType;
+  arrayType?: TypeRef;
+  arrayDims?: number;
+  mapType?: TypeRef;
+  objectFields?: Field[];
+};
+
+export function hydrateTypeRef(input: TypeRef): TypeRef {
+  const hydratedKind = input.kind;
+  const hydratedPrimitiveName = input.primitiveName
+    ? input.primitiveName
+    : input.primitiveName;
+  const hydratedTypeName = input.typeName ? input.typeName : input.typeName;
+  const hydratedEnumName = input.enumName ? input.enumName : input.enumName;
+  const hydratedEnumType = input.enumType ? input.enumType : input.enumType;
+  const hydratedArrayType = input.arrayType
+    ? hydrateTypeRef(input.arrayType)
+    : input.arrayType;
+  const hydratedArrayDims = input.arrayDims ? input.arrayDims : input.arrayDims;
+  const hydratedMapType = input.mapType
+    ? hydrateTypeRef(input.mapType)
+    : input.mapType;
+  const hydratedObjectFields = input.objectFields
+    ? input.objectFields.map((el) => hydrateField(el))
+    : input.objectFields;
+  return {
+    kind: hydratedKind,
+    primitiveName: hydratedPrimitiveName,
+    typeName: hydratedTypeName,
+    enumName: hydratedEnumName,
+    enumType: hydratedEnumType,
+    arrayType: hydratedArrayType,
+    arrayDims: hydratedArrayDims,
+    mapType: hydratedMapType,
+    objectFields: hydratedObjectFields,
+  };
+}
+
+export function validateTypeRef(
+  input: unknown,
+  path = "TypeRef",
+): string | null {
+  if (input === null || input === undefined || typeof input !== "object") {
+    return `${path}: expected object, got ${typeof input}`;
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj.kind === undefined || obj.kind === null) {
+    return `${path}.kind: required field is missing`;
+  }
+  {
+    if (!isTypeKind(obj.kind)) {
+      return `${path}.kind: invalid enum value '${obj.kind}' for TypeKind`;
+    }
+  }
+  if (obj.primitiveName !== undefined && obj.primitiveName !== null) {
+    {
+      if (!isPrimitiveType(obj.primitiveName)) {
+        return `${path}.primitiveName: invalid enum value '${obj.primitiveName}' for PrimitiveType`;
+      }
+    }
+  }
+  if (obj.enumType !== undefined && obj.enumType !== null) {
+    {
+      if (!isEnumValueType(obj.enumType)) {
+        return `${path}.enumType: invalid enum value '${obj.enumType}' for EnumValueType`;
+      }
+    }
+  }
+  if (obj.arrayType !== undefined && obj.arrayType !== null) {
+    {
+      const err = validateTypeRef(obj.arrayType, `${path}.arrayType`);
+      if (err !== null) return err;
+    }
+  }
+  if (obj.mapType !== undefined && obj.mapType !== null) {
+    {
+      const err = validateTypeRef(obj.mapType, `${path}.mapType`);
+      if (err !== null) return err;
+    }
+  }
+  if (obj.objectFields !== undefined && obj.objectFields !== null) {
+    {
+      if (!Array.isArray(obj.objectFields)) {
+        return `${path}.objectFields: expected array, got ${typeof obj.objectFields}`;
+      }
+      for (let i = 0; i < obj.objectFields.length; i++) {
+        {
+          const err = validateField(
+            obj.objectFields[i],
+            `${path}.objectFields[${i}]`,
+          );
+          if (err !== null) return err;
+        }
+      }
+    }
+  }
+  return null;
+}