@emfts/codegen 0.0.1-next.1

package/dist/templates/partials/emf/interface-file.ejs

@@ -0,0 +1,72 @@
+<%- header %>
+
+import type { EObject } from '@emfts/core';
+<%# Generate imports for referenced types -%>
+<%
+const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'emf');
+// Skip emfts types and self-references
+for (const imp of imports) {
+  if (imp.typeName !== interfaceName && imp.importPath !== '@emfts/core') {
+-%>
+import type { <%- imp.typeName %> } from '<%- imp.importPath %>';
+<%
+  }
+}
+-%>
+
+/**
+ * <%- genClass.documentation || interfaceName %>
+ * @generated
+ */
+export interface <%- interfaceName %><%
+if (typeParameters && typeParameters.length > 0) {
+  const params = [];
+  for (const tp of typeParameters) {
+    params.push(getName(tp));
+  }
+%><<%- params.join(', ') %>><%
+}
+%> extends <%
+if (superTypes && superTypes.length > 0) {
+  const superNames = [];
+  for (const st of superTypes) {
+    const stName = getName(st);
+    if (stName) {
+      superNames.push(stName);
+    }
+  }
+  if (superNames.length > 0) {
+%><%- superNames.join(', ') %><%
+  } else {
+%><%- rootExtendsInterface %><%
+  }
+} else {
+%><%- rootExtendsInterface %><%
+}
+%> {
+<% for (const genFeature of features) {
+  const feature = genFeature.ecoreFeature;
+  const featureName = getName(feature);
+  const featureType = typeMapper.mapFeature(feature);
+  const many = isMany(feature);
+  const lower = getLowerBound(feature);
+  const isReadonly = genFeature.property === 'readonly';
+-%>
+  <% if (isReadonly) { %>readonly <% } %><%- featureName %><% if (lower === 0 && !many) { %>?<% } %>: <%- featureType %>;
+<% } -%>
+
+<% for (const genOp of operations) {
+  const op = genOp.ecoreOperation;
+  const opName = getName(op);
+  const opType = getEType(op);
+  const returnType = opType ? typeMapper.mapClassifier(opType) : 'void';
+  const params = [];
+  for (const param of getEParameters(op)) {
+    const paramName = getName(param);
+    const paramType = typeMapper.mapClassifier(getEType(param));
+    params.push(`${paramName}: ${paramType}`);
+  }
+-%>
+  <%- opName %>(<%- params.join(', ') %>): <%- returnType %>;
+<% } -%>
+}

package/dist/templates/partials/emf/package-file.ejs

@@ -0,0 +1,149 @@
+<%- header %>
+
+import { BasicEPackage, BasicEClass, BasicEAttribute, BasicEReference } from '@emfts/core';
+import type { EClass, EAttribute, EReference, EEnum } from '@emfts/core';
+
+/**
+ * <%- packageName %> Package
+ * @generated
+ */
+export class <%- packageName %>Package extends BasicEPackage {
+  static readonly eNAME = '<%- getName(ePackage) %>';
+  static readonly eNS_URI = '<%- nsURI %>';
+  static readonly eNS_PREFIX = '<%- nsPrefix %>';
+
+  // Singleton instance
+  private static _instance: <%- packageName %>Package;
+
+  static get eINSTANCE(): <%- packageName %>Package {
+    if (!this._instance) {
+      this._instance = new <%- packageName %>Package();
+      this._instance.init();
+    }
+    return this._instance;
+  }
+
+  /**
+   * Literals for quick access to metaclasses and features
+   */
+  static readonly Literals = {
+<% for (const cls of classLiterals) { -%>
+    <%- cls.upperName %>: null as unknown as EClass,
+<% for (const feat of cls.features) { -%>
+    <%- cls.upperName %>__<%- feat.upperName %>: null as unknown as EAttribute | EReference,
+<% } -%>
+<% } -%>
+  };
+
+  private constructor() {
+    super();
+    this.setName(<%- packageName %>Package.eNAME);
+    this.setNsURI(<%- packageName %>Package.eNS_URI);
+    this.setNsPrefix(<%- packageName %>Package.eNS_PREFIX);
+  }
+
+  /**
+   * Initialize package contents
+   */
+  private init(): void {
+<% for (const genClass of genClasses) {
+  const eClass = genClass.ecoreClass;
+  const className = getName(eClass);
+  const upperName = className.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+-%>
+    // Create <%- className %> class
+    const <%- uncapitalize(className) %>Class = new BasicEClass();
+    <%- uncapitalize(className) %>Class.setName('<%- className %>');
+    <%- uncapitalize(className) %>Class.setAbstract(<%- checkIsAbstract(eClass) %>);
+    <%- uncapitalize(className) %>Class.setInterface(<%- checkIsInterface(eClass) %>);
+    this.getEClassifiers().push(<%- uncapitalize(className) %>Class);
+    <%- uncapitalize(className) %>Class.setEPackage(this);
+    <%- packageName %>Package.Literals.<%- upperName %> = <%- uncapitalize(className) %>Class;
+
+<% let featureIndex = 0;
+   for (const genFeature of genClass.genFeatures) {
+     const feature = genFeature.ecoreFeature;
+     const featureName = getName(feature);
+     const featureUpperName = featureName.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+     const isRef = typeMapper.isReference(feature);
+-%>
+    // Create <%- featureName %> feature
+<% if (isRef) { -%>
+    const <%- uncapitalize(className) %>_<%- featureName %> = new BasicEReference();
+    <%- uncapitalize(className) %>_<%- featureName %>.setContainment(<%- isContainment(feature) %>);
+<% } else { -%>
+    const <%- uncapitalize(className) %>_<%- featureName %> = new BasicEAttribute();
+<% } -%>
+    <%- uncapitalize(className) %>_<%- featureName %>.setName('<%- featureName %>');
+    <%- uncapitalize(className) %>_<%- featureName %>.setLowerBound(<%- getLowerBound(feature) %>);
+    <%- uncapitalize(className) %>_<%- featureName %>.setUpperBound(<%- getUpperBound(feature) %>);
+    <%- uncapitalize(className) %>Class.getEStructuralFeatures().push(<%- uncapitalize(className) %>_<%- featureName %>);
+    <%- packageName %>Package.Literals.<%- upperName %>__<%- featureUpperName %> = <%- uncapitalize(className) %>_<%- featureName %>;
+
+<% featureIndex++;
+   } -%>
+<% } -%>
+<%# TODO: Enum package metadata initialization - requires BasicEEnum implementation in emfts -%>
+
+    // ============================================
+    // Set ESuperTypes (must be done after all classes are created)
+    // ============================================
+<% for (const genClass of genClasses) {
+     const eClass = genClass.ecoreClass;
+     const className = getName(eClass);
+     const upperName = className.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+     const superTypes = getESuperTypes(eClass);
+     for (const superType of superTypes) {
+       const superTypeName = getName(superType);
+       if (superTypeName) {
+         const superTypeUpperName = superTypeName.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+-%>
+    (<%- packageName %>Package.Literals.<%- upperName %> as BasicEClass).getESuperTypes().push(<%- packageName %>Package.Literals.<%- superTypeUpperName %>);
+<%       }
+     }
+   } -%>
+
+    // ============================================
+    // Set ETypes for EReferences (must be done after all classes are created)
+    // ============================================
+<% for (const genClass of genClasses) {
+     const eClass = genClass.ecoreClass;
+     const className = getName(eClass);
+     const upperName = className.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+     for (const genFeature of genClass.genFeatures) {
+       const feature = genFeature.ecoreFeature;
+       const featureName = getName(feature);
+       const featureUpperName = featureName.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+       const isRef = typeMapper.isReference(feature);
+       if (isRef) {
+         const eType = getEType(feature);
+         if (eType) {
+           const typeName = getName(eType);
+           const typeUpperName = typeName.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+-%>
+    (<%- packageName %>Package.Literals.<%- upperName %>__<%- featureUpperName %> as BasicEReference).setEType(<%- packageName %>Package.Literals.<%- typeUpperName %>);
+<%       }
+       }
+     }
+   } -%>
+
+    // ============================================
+    // Register XML name mappings from ExtendedMetaData annotations
+    // ============================================
+<% for (const genClass of genClasses) {
+     const eClass = genClass.ecoreClass;
+     const className = getName(eClass);
+     const upperName = className.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+     for (const genFeature of genClass.genFeatures) {
+       const feature = genFeature.ecoreFeature;
+       const featureName = getName(feature);
+       const xmlName = getExtendedMetaDataName(feature);
+       if (xmlName && xmlName !== featureName) {
+         const featureUpperName = featureName.replace(/([A-Z])/g, '_$1').toUpperCase().replace(/^_/, '');
+-%>
+    (<%- packageName %>Package.Literals.<%- upperName %> as BasicEClass).registerXmlName('<%- xmlName %>', <%- packageName %>Package.Literals.<%- upperName %>__<%- featureUpperName %>);
+<%       }
+     }
+   } -%>
+  }
+}

package/dist/templates/partials/plain/class-file.ejs

@@ -0,0 +1,75 @@
+<%- header %>
+
+<%# Generate imports for referenced types -%>
+<%
+const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'plain');
+for (const imp of imports) {
+  if (imp.typeName !== className) {
+-%>
+import { <%- imp.typeName %> } from '<%- imp.importPath %>';
+<%
+  }
+}
+-%>
+
+/**
+ * <%- genClass.documentation || eClass.getName() %>
+ */
+export <% if (isAbstract) { %>abstract <% } %>class <%- className %><%
+if (typeParameters && typeParameters.length > 0) {
+  const params = [];
+  for (const tp of typeParameters) {
+    params.push(tp.getName());
+  }
+%><<%- params.join(', ') %>><%
+}
+if (superTypes && superTypes.length > 0) {
+  const superNames = [];
+  for (const st of superTypes) {
+    if (st.getName) {
+      superNames.push(st.getName());
+    }
+  }
+  if (superNames.length > 0) {
+%> extends <%- superNames[0] %><%
+  }
+}
+%> {
+<% for (const genFeature of features) {
+  const feature = genFeature.ecoreFeature;
+  const featureName = feature.getName();
+  const featureType = typeMapper.mapFeature(feature);
+  const defaultValue = typeMapper.getDefaultValue(feature);
+  const isMany = feature.isMany();
+-%>
+  <%- featureName %><% if (!isMany && defaultValue === null) { %>?<% } %>: <%- featureType %><% if (defaultValue !== null) { %> = <%- defaultValue %><% } %>;
+<% } -%>
+
+<% if (features.length > 0) { -%>
+  constructor(init?: Partial<<%- className %>>) {
+<% if (superTypes && superTypes.length > 0) { -%>
+    super(init);
+<% } -%>
+    if (init) {
+      Object.assign(this, init);
+    }
+  }
+<% } -%>
+
+<% for (const genOp of operations) {
+  const op = genOp.ecoreOperation;
+  const opName = op.getName();
+  const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
+  const params = [];
+  for (const param of op.getEParameters()) {
+    const paramName = param.getName();
+    const paramType = typeMapper.mapClassifier(param.getEType());
+    params.push(`${paramName}: ${paramType}`);
+  }
+-%>
+  <%- opName %>(<%- params.join(', ') %>): <%- returnType %> {
+    throw new Error('<%- opName %> not implemented');
+  }
+
+<% } -%>
+}

package/dist/templates/partials/plain/enum-file.ejs

@@ -0,0 +1,28 @@
+<%- header %>
+
+/**
+ * <%- genEnum.documentation || enumName %>
+ */
+<% if (generateAsConst) { -%>
+export const <%- enumName %> = {
+<% for (let i = 0; i < literals.length; i++) {
+  const literal = literals[i];
+  const literalName = literal.getLiteral() || literal.getName();
+  const value = useStringValues ? `'${literalName}'` : literal.getValue();
+-%>
+  <%- literal.getName() %>: <%- value %><% if (i < literals.length - 1) { %>,<% } %>
+<% } -%>
+} as const;
+
+export type <%- enumName %> = typeof <%- enumName %>[keyof typeof <%- enumName %>];
+<% } else { -%>
+export enum <%- enumName %> {
+<% for (let i = 0; i < literals.length; i++) {
+  const literal = literals[i];
+  const literalName = literal.getLiteral() || literal.getName();
+  const value = useStringValues ? `'${literalName}'` : literal.getValue();
+-%>
+  <%- literal.getName() %> = <%- value %><% if (i < literals.length - 1) { %>,<% } %>
+<% } -%>
+}
+<% } -%>

package/dist/templates/partials/plain/interface-file.ejs

@@ -0,0 +1,61 @@
+<%- header %>
+
+<%# Generate imports for referenced types -%>
+<%
+const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'plain');
+for (const imp of imports) {
+  if (imp.typeName !== interfaceName) {
+-%>
+import type { <%- imp.typeName %> } from '<%- imp.importPath %>';
+<%
+  }
+}
+-%>
+
+/**
+ * <%- genClass.documentation || eClass.getName() %>
+ */
+export interface <%- interfaceName %><%
+if (typeParameters && typeParameters.length > 0) {
+  const params = [];
+  for (const tp of typeParameters) {
+    params.push(tp.getName());
+  }
+%><<%- params.join(', ') %>><%
+}
+if (superTypes && superTypes.length > 0) {
+  const superNames = [];
+  for (const st of superTypes) {
+    if (st.getName) {
+      superNames.push(st.getName());
+    }
+  }
+  if (superNames.length > 0) {
+%> extends <%- superNames.join(', ') %><%
+  }
+}
+%> {
+<% for (const genFeature of features) {
+  const feature = genFeature.ecoreFeature;
+  const featureName = feature.getName();
+  const featureType = typeMapper.mapFeature(feature);
+  const isMany = feature.isMany();
+  const lowerBound = feature.getLowerBound();
+-%>
+  <%- featureName %><% if (lowerBound === 0 && !isMany) { %>?<% } %>: <%- featureType %>;
+<% } -%>
+
+<% for (const genOp of operations) {
+  const op = genOp.ecoreOperation;
+  const opName = op.getName();
+  const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
+  const params = [];
+  for (const param of op.getEParameters()) {
+    const paramName = param.getName();
+    const paramType = typeMapper.mapClassifier(param.getEType());
+    params.push(`${paramName}: ${paramType}`);
+  }
+-%>
+  <%- opName %>(<%- params.join(', ') %>): <%- returnType %>;
+<% } -%>
+}

package/dist/templates/partials/plain/package-file.ejs

@@ -0,0 +1,6 @@
+<%- header %>
+
+// Re-export all types from this package
+<% for (const exp of exports) { -%>
+export * from './<%- exp %>';
+<% } -%>

package/dist/templates/templates/partials/decorator/class-file.ejs

@@ -0,0 +1,98 @@
+<%- header %>
+
+<%# Generate imports for referenced types -%>
+<%
+const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'decorator');
+for (const imp of imports) {
+  if (imp.typeName !== className && !imp.typeName.includes(',')) {
+-%>
+import { <%- imp.typeName %> } from '<%- imp.importPath %>';
+<%
+  }
+}
+-%>
+import { Documentation, Attribute, ModelClass, Reference, Enum } from './ModelAnnotations';
+
+@ModelClass({ type: '<%- nsURI %>#//<%- className %>' })
+export <% if (isAbstract) { %>abstract <% } %>class <%- className %><%
+if (typeParameters && typeParameters.length > 0) {
+  const params = [];
+  for (const tp of typeParameters) {
+    params.push(tp.getName());
+  }
+%><<%- params.join(', ') %>><%
+}
+if (superTypes && superTypes.length > 0) {
+  const superNames = [];
+  for (const st of superTypes) {
+    if (st.getName) {
+      superNames.push(st.getName());
+    }
+  }
+  if (superNames.length > 0) {
+%> extends <%- superNames[0] %><%
+  }
+}
+%> {
+<% for (const genFeature of features) {
+  const feature = genFeature.ecoreFeature;
+  const featureName = feature.getName();
+  const featureType = typeMapper.mapFeatureBaseType(feature);
+  const fullType = typeMapper.mapFeature(feature);
+  const defaultValue = typeMapper.getDefaultValue(feature);
+  const isMany = feature.isMany();
+  const isRef = typeMapper.isReference(feature);
+  const isEnum = feature.getEType() && typeMapper.isEEnum(feature.getEType());
+
+  // Check for documentation annotation
+  let doc = null;
+  if (feature.getEAnnotations) {
+    for (const ann of feature.getEAnnotations()) {
+      const annSource = typeof ann.getSource === 'function' ? ann.getSource() : ann.source;
+      if (annSource === 'http://www.eclipse.org/emf/2002/GenModel') {
+        const details = typeof ann.getDetails === 'function' ? ann.getDetails() : ann.details;
+        if (details && details.get) {
+          doc = details.get('documentation');
+        }
+      }
+    }
+  }
+  if (doc) {
+-%>
+  @Documentation("<%- doc %>")
+<%
+  }
+  if (isEnum) {
+-%>
+  @Enum('<%- featureType %>')
+<%
+  } else if (isRef) {
+-%>
+  @Reference('<%- featureType %>')
+<%
+  } else {
+-%>
+  @Attribute()
+<%
+  }
+-%>
+  <%- featureName %><% if (!isMany && defaultValue === null) { %>?<% } %>: <%- fullType %><% if (defaultValue !== null) { %> = <%- defaultValue %><% } %>;
+
+<% } -%>
+<% for (const genOp of operations) {
+  const op = genOp.ecoreOperation;
+  const opName = op.getName();
+  const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
+  const params = [];
+  for (const param of op.getEParameters()) {
+    const paramName = param.getName();
+    const paramType = typeMapper.mapClassifier(param.getEType());
+    params.push(`${paramName}: ${paramType}`);
+  }
+-%>
+  <%- opName %>(<%- params.join(', ') %>): <%- returnType %> {
+    throw new Error('<%- opName %> not implemented');
+  }
+
+<% } -%>
+}

package/dist/templates/templates/partials/decorator/enum-file.ejs

@@ -0,0 +1,35 @@
+<%- header %>
+<%
+// Helper to get property from EEnumLiteral (handles both method calls and direct properties)
+function getLiteralProp(literal, prop) {
+  const getter = `get${prop.charAt(0).toUpperCase()}${prop.slice(1)}`;
+  if (typeof literal[getter] === 'function') {
+    return literal[getter]();
+  }
+  if (literal[prop] !== undefined) {
+    return literal[prop];
+  }
+  // Try eGet if available
+  if (typeof literal.eGet === 'function' && typeof literal.eClass === 'function') {
+    const eClass = literal.eClass();
+    const feature = eClass?.getEStructuralFeature?.(prop);
+    if (feature) {
+      return literal.eGet(feature);
+    }
+  }
+  return undefined;
+}
+-%>
+/**
+ * <%- genEnum.documentation || enumName %>
+ */
+export enum <%- enumName %> {
+<% for (let i = 0; i < literals.length; i++) {
+  const literal = literals[i];
+  const literalName = getLiteralProp(literal, 'literal') || getLiteralProp(literal, 'name');
+  const literalValue = getLiteralProp(literal, 'value');
+  const value = useStringValues ? `'${literalName}'` : literalValue;
+-%>
+  <%- getLiteralProp(literal, 'name') %> = <%- value %><% if (i < literals.length - 1) { %>,<% } %>
+<% } -%>
+}

package/dist/templates/templates/partials/decorator/interface-file.ejs

@@ -0,0 +1,61 @@
+<%- header %>
+
+<%# Generate imports for referenced types -%>
+<%
+const imports = importResolver.resolveImportsForClass(eClass, genPackage, 'decorator');
+for (const imp of imports) {
+  if (imp.typeName !== interfaceName && !imp.typeName.includes(',')) {
+-%>
+import type { <%- imp.typeName %> } from '<%- imp.importPath %>';
+<%
+  }
+}
+-%>
+
+/**
+ * <%- genClass.documentation || eClass.getName() %>
+ */
+export interface <%- interfaceName %><%
+if (typeParameters && typeParameters.length > 0) {
+  const params = [];
+  for (const tp of typeParameters) {
+    params.push(tp.getName());
+  }
+%><<%- params.join(', ') %>><%
+}
+if (superTypes && superTypes.length > 0) {
+  const superNames = [];
+  for (const st of superTypes) {
+    if (st.getName) {
+      superNames.push(st.getName());
+    }
+  }
+  if (superNames.length > 0) {
+%> extends <%- superNames.join(', ') %><%
+  }
+}
+%> {
+<% for (const genFeature of features) {
+  const feature = genFeature.ecoreFeature;
+  const featureName = feature.getName();
+  const featureType = typeMapper.mapFeature(feature);
+  const isMany = feature.isMany();
+  const lowerBound = feature.getLowerBound();
+-%>
+  <%- featureName %><% if (lowerBound === 0 && !isMany) { %>?<% } %>: <%- featureType %>;
+<% } -%>
+
+<% for (const genOp of operations) {
+  const op = genOp.ecoreOperation;
+  const opName = op.getName();
+  const returnType = op.getEType() ? typeMapper.mapClassifier(op.getEType()) : 'void';
+  const params = [];
+  for (const param of op.getEParameters()) {
+    const paramName = param.getName();
+    const paramType = typeMapper.mapClassifier(param.getEType());
+    params.push(`${paramName}: ${paramType}`);
+  }
+-%>
+  <%- opName %>(<%- params.join(', ') %>): <%- returnType %>;
+<% } -%>
+}

package/dist/templates/templates/partials/decorator/model-annotations.ejs

@@ -0,0 +1,91 @@
+<%- header %>
+
+import 'reflect-metadata';
+
+// Metadata keys
+const MODEL_CLASS_KEY = Symbol('modelClass');
+const ATTRIBUTE_KEY = Symbol('attribute');
+const REFERENCE_KEY = Symbol('reference');
+const ENUM_KEY = Symbol('enum');
+const DOCUMENTATION_KEY = Symbol('documentation');
+
+/**
+ * Decorator for model classes
+ */
+export function ModelClass(options: { type: string }) {
+  return function (target: Function) {
+    Reflect.defineMetadata(MODEL_CLASS_KEY, options, target);
+  };
+}
+
+/**
+ * Decorator for attributes (primitive properties)
+ */
+export function Attribute() {
+  return function (target: any, propertyKey: string) {
+    const existing = Reflect.getMetadata(ATTRIBUTE_KEY, target) || [];
+    existing.push(propertyKey);
+    Reflect.defineMetadata(ATTRIBUTE_KEY, existing, target);
+  };
+}
+
+/**
+ * Decorator for references (object properties)
+ */
+export function Reference(typeName: string) {
+  return function (target: any, propertyKey: string) {
+    const existing = Reflect.getMetadata(REFERENCE_KEY, target) || {};
+    existing[propertyKey] = typeName;
+    Reflect.defineMetadata(REFERENCE_KEY, existing, target);
+  };
+}
+
+/**
+ * Decorator for enum properties
+ */
+export function Enum(typeName: string) {
+  return function (target: any, propertyKey: string) {
+    const existing = Reflect.getMetadata(ENUM_KEY, target) || {};
+    existing[propertyKey] = typeName;
+    Reflect.defineMetadata(ENUM_KEY, existing, target);
+  };
+}
+
+/**
+ * Decorator for documentation
+ */
+export function Documentation(text: string) {
+  return function (target: any, propertyKey?: string) {
+    if (propertyKey) {
+      Reflect.defineMetadata(DOCUMENTATION_KEY, text, target, propertyKey);
+    } else {
+      Reflect.defineMetadata(DOCUMENTATION_KEY, text, target);
+    }
+  };
+}
+
+// Utility functions to read metadata
+
+export function getModelClassType(target: Function): string | undefined {
+  const meta = Reflect.getMetadata(MODEL_CLASS_KEY, target);
+  return meta?.type;
+}
+
+export function getAttributes(target: any): string[] {
+  return Reflect.getMetadata(ATTRIBUTE_KEY, target) || [];
+}
+
+export function getReferences(target: any): Record<string, string> {
+  return Reflect.getMetadata(REFERENCE_KEY, target) || {};
+}
+
+export function getEnums(target: any): Record<string, string> {
+  return Reflect.getMetadata(ENUM_KEY, target) || {};
+}
+
+export function getDocumentation(target: any, propertyKey?: string): string | undefined {
+  if (propertyKey) {
+    return Reflect.getMetadata(DOCUMENTATION_KEY, target, propertyKey);
+  }
+  return Reflect.getMetadata(DOCUMENTATION_KEY, target);
+}

package/dist/templates/templates/partials/decorator/package-file.ejs

@@ -0,0 +1,7 @@
+<%- header %>
+
+// Re-export all types from this package
+<% for (const exp of exports) { -%>
+export * from './<%- exp %>';
+<% } -%>
+export * from './ModelAnnotations';