Metadata Schema

/**
 * Current version of the metadata schema format
 */
const VERSION: number = 3;

/**
 * Metadata structure for a complete TypeScript module
 */
interface ModuleMetadata {
  /** Symbolic marker indicating this is module metadata */
  __symbolic: 'module';
  
  /** Version of the metadata format */
  version: number;
  
  /** Map of exported symbol names to their metadata */
  metadata: {[name: string]: MetadataEntry};
  
  /** Information about re-exported symbols from other modules */
  exports?: ModuleExportMetadata[];
  
  /** Import alias for this module */
  importAs?: string;
  
  /** Origins information for symbols */
  origins?: {[name: string]: string};
}

/**
 * Metadata for TypeScript classes
 */
interface ClassMetadata {
  /** Symbolic marker indicating this is class metadata */
  __symbolic: 'class';
  
  /** Extended class information */
  extends?: MetadataSymbolicExpression | MetadataError;
  
  /** Number of type parameters */
  arity?: number;
  
  /** Array of decorators applied to the class */
  decorators?: (MetadataSymbolicExpression | MetadataError)[];
  
  /** Metadata for instance members (methods, properties) */
  members?: MetadataMap;
  
  /** Metadata for static members */
  statics?: {[name: string]: MetadataValue | FunctionMetadata};
}

/**
 * Metadata for TypeScript interfaces
 */
interface InterfaceMetadata {
  /** Symbolic marker indicating this is interface metadata */
  __symbolic: 'interface';
}

/**
 * Metadata for TypeScript functions
 */
interface FunctionMetadata {
  /** Symbolic marker indicating this is function metadata */
  __symbolic: 'function';
  
  /** Function parameter names */
  parameters: string[];
  
  /** Default parameter values */
  defaults?: MetadataValue[];
  
  /** Function body or return type metadata */
  value: MetadataValue;
}

/**
 * Metadata for class members
 */
interface MemberMetadata {
  /** Symbolic marker indicating this is member metadata */
  __symbolic: 'constructor' | 'method' | 'property';
  
  /** Decorators applied to the member */
  decorators?: (MetadataSymbolicExpression | MetadataError)[];
}

/**
 * Metadata for class methods
 */
interface MethodMetadata extends MemberMetadata {
  __symbolic: 'constructor' | 'method';
  
  /** Method parameter decorators */
  parameterDecorators?: (MetadataSymbolicExpression | MetadataError)[][];
}

/**
 * Metadata for class constructors  
 */
interface ConstructorMetadata extends MethodMetadata {
  __symbolic: 'constructor';
  
  /** Constructor parameter type information */
  parameters?: (MetadataSymbolicExpression | MetadataError | null)[];
}

/**  
 * Base interface for symbolic expressions
 */
interface MetadataSymbolicExpression {
  /** Symbolic marker indicating the expression type */
  __symbolic: string;
}

/**
 * Metadata for binary expressions (a + b, a === b, etc.)
 */
interface MetadataSymbolicBinaryExpression extends MetadataSymbolicExpression {
  __symbolic: 'binary';
  
  /** Binary operator (+, -, *, /, ===, !==, etc.) */
  operator: string;
  
  /** Left operand */
  left: MetadataValue;
  
  /** Right operand */ 
  right: MetadataValue;
}

/**
 * Metadata for function/method call expressions
 */
interface MetadataSymbolicCallExpression extends MetadataSymbolicExpression {
  __symbolic: 'call';
  
  /** Expression being called */
  expression: MetadataValue;
  
  /** Call arguments */
  arguments?: MetadataValue[];
}

/**
 * Metadata for references to symbols
 */
interface MetadataSymbolicReferenceExpression extends MetadataSymbolicExpression {
  __symbolic: 'reference';
  
  /** Name of the referenced symbol */
  name: string;
  
  /** Module containing the symbol */
  module?: string;
}

/**
 * Metadata for references to imported symbols
 */
interface MetadataImportedSymbolReferenceExpression extends MetadataSymbolicExpression {
  __symbolic: 'reference';
  
  /** Name of the imported symbol */
  name: string;
  
  /** Module the symbol is imported from */
  module: string;
}

/**
 * Metadata for references to global symbols
 */
interface MetadataGlobalReferenceExpression extends MetadataSymbolicExpression {
  __symbolic: 'reference';
  
  /** Name of the global symbol */
  name: string;
  
  /** Arguments if the global is being called */
  arguments?: MetadataValue[];
}

/**
 * Metadata for index access expressions (obj[key])
 */
interface MetadataSymbolicIndexExpression extends MetadataSymbolicExpression {
  __symbolic: 'index';
  
  /** Object being indexed */
  expression: MetadataValue;
  
  /** Index value */
  index: MetadataValue;
}

/**
 * Metadata for property access expressions (obj.prop)
 */
interface MetadataSymbolicSelectExpression extends MetadataSymbolicExpression {
  __symbolic: 'select';
  
  /** Object being accessed */
  expression: MetadataValue;
  
  /** Property name */
  member: string;
}

/**
 * Metadata for spread expressions (...array)
 */
interface MetadataSymbolicSpreadExpression extends MetadataSymbolicExpression {
  __symbolic: 'spread';
  
  /** Expression being spread */
  expression: MetadataValue;
}

/**
 * Metadata for prefix expressions (!x, -x, etc.)
 */
interface MetadataSymbolicPrefixExpression extends MetadataSymbolicExpression {
  __symbolic: 'pre';
  
  /** Prefix operator (!, -, +, etc.) */
  operator: string;
  
  /** Operand */
  operand: MetadataValue;
}

/**
 * Metadata for conditional expressions (condition ? true : false)
 */
interface MetadataSymbolicIfExpression extends MetadataSymbolicExpression {
  __symbolic: 'if';
  
  /** Condition expression */
  condition: MetadataValue;
  
  /** Value if condition is true */
  thenExpression: MetadataValue;
  
  /** Value if condition is false */
  elseExpression: MetadataValue;
}

/**
 * Map of metadata values
 */
interface MetadataMap {
  [name: string]: MemberMetadata[];
}

/**
 * Object containing metadata values
 */
interface MetadataObject {
  /** Symbolic marker indicating this is an object */
  __symbolic: 'object';
  
  /** Object properties */
  [name: string]: MetadataValue;
}

/**
 * Array containing metadata values
 */
interface MetadataArray {
  /** Symbolic marker indicating this is an array */
  __symbolic: 'array';
  
  /** Array elements */
  [index: number]: MetadataValue;
}

/**
 * Union of all possible metadata entry types
 */
type MetadataEntry = 
  | ClassMetadata 
  | InterfaceMetadata 
  | FunctionMetadata 
  | MetadataValue;

/**
 * Union of all possible metadata values
 */
type MetadataValue = 
  | string 
  | number 
  | boolean 
  | undefined 
  | null 
  | MetadataObject 
  | MetadataArray
  | MetadataSymbolicExpression;

/**
 * Type guard functions for metadata validation
 */
function isModuleMetadata(value: any): value is ModuleMetadata;
function isClassMetadata(value: any): value is ClassMetadata;
function isInterfaceMetadata(value: any): value is InterfaceMetadata;
function isFunctionMetadata(value: any): value is FunctionMetadata;
function isMemberMetadata(value: any): value is MemberMetadata;
function isMethodMetadata(value: any): value is MethodMetadata;
function isConstructorMetadata(value: any): value is ConstructorMetadata;

function isMetadataSymbolicExpression(value: any): value is MetadataSymbolicExpression;
function isMetadataSymbolicBinaryExpression(value: any): value is MetadataSymbolicBinaryExpression;
function isMetadataSymbolicCallExpression(value: any): value is MetadataSymbolicCallExpression;
function isMetadataSymbolicReferenceExpression(value: any): value is MetadataSymbolicReferenceExpression;
function isMetadataSymbolicIndexExpression(value: any): value is MetadataSymbolicIndexExpression;
function isMetadataSymbolicSelectExpression(value: any): value is MetadataSymbolicSelectExpression;
function isMetadataSymbolicSpreadExpression(value: any): value is MetadataSymbolicSpreadExpression;
function isMetadataSymbolicPrefixExpression(value: any): value is MetadataSymbolicPrefixExpression;
function isMetadataSymbolicIfExpression(value: any): value is MetadataSymbolicIfExpression;

function isMetadataGlobalReferenceExpression(value: any): value is MetadataGlobalReferenceExpression;
function isMetadataModuleReferenceExpression(value: any): value is MetadataModuleReferenceExpression;
function isMetadataImportedSymbolReferenceExpression(value: any): value is MetadataImportedSymbolReferenceExpression;

function isMetadataError(value: any): value is MetadataError;

import { isClassMetadata, isMethodMetadata } from "@angular/tsc-wrapped";

function processMetadata(metadata: any) {
  if (isClassMetadata(metadata)) {
    console.log("Processing class metadata");
    if (metadata.members) {
      for (const [memberName, memberMetadata] of Object.entries(metadata.members)) {
        if (memberMetadata.some(isMethodMetadata)) {
          console.log(`Found method: ${memberName}`);
        }
      }
    }
  }
}