@aeriajs/compiler 0.0.4 → 0.0.7

package/dist/codegen/generateTSCollections.mjs

@@ -0,0 +1,99 @@
+"use strict";
+import { getProperties, stringify, makeASTImports, resizeFirstChar, getCollectionId, UnquotedSymbol, getExposedFunctions, PACKAGE_NAME, DEFAULT_FUNCTIONS } from "./utils.mjs";
+const initialImportedTypes = [
+  "Collection",
+  "SchemaWithId",
+  "ExtendCollection",
+  "Context"
+];
+export const generateTSCollections = (ast) => {
+  let code = "";
+  code += `import type { ${initialImportedTypes.join(", ")} } from '${PACKAGE_NAME}'
+`;
+  const importsResult = makeASTImports(ast);
+  code += importsResult.code + "\n\n";
+  code += makeTSCollections(ast, importsResult.modifiedSymbols) + "\n";
+  return code;
+};
+const makeTSCollections = (ast, modifiedSymbols) => {
+  const collectionCodes = {};
+  for (const collectionNode of ast) {
+    const id = getCollectionId(collectionNode.name);
+    const schemaName = resizeFirstChar(collectionNode.name, true);
+    const typeName = id + "Collection";
+    const collectionType = `export declare type ${typeName} = ${id in modifiedSymbols ? `ExtendCollection<typeof ${modifiedSymbols[id]}, ${makeTSCollectionSchema(collectionNode, id)}>` : makeTSCollectionSchema(collectionNode, id)}`;
+    const collectionDeclaration = `export declare const ${id}: ${typeName} & { item: SchemaWithId<${typeName}["description"]> }`;
+    const collectionSchema = `export declare type ${schemaName} = SchemaWithId<typeof ${id}.description>`;
+    const collectionExtend = `export declare const extend${schemaName}Collection: <
+            const TCollection extends {
+              [P in Exclude<keyof Collection, "functions">]?: Partial<Collection[P]>
+            } & {
+              functions?: {
+                [F: string]: (payload: any, context: Context<typeof ${id}["description"]>) => unknown
+              }
+            }>(collection: TCollection) => ExtendCollection<typeof ${id}, TCollection>`;
+    collectionCodes[collectionNode.name] = [
+      "//" + collectionNode.name,
+      collectionType,
+      collectionDeclaration,
+      collectionSchema,
+      collectionExtend
+    ].join("\n");
+  }
+  return Object.values(collectionCodes).join("\n\n");
+};
+const makeTSCollectionSchema = (collectionNode, collectionId) => {
+  const collectionSchema = {
+    description: {
+      $id: collectionId
+    }
+  };
+  for (const key of Object.keys(collectionNode)) {
+    if (collectionNode[key] === void 0) {
+      continue;
+    }
+    switch (key) {
+      case "properties":
+        collectionSchema.description.properties = getProperties(collectionNode[key]);
+        break;
+      case "owned":
+        collectionSchema.description.owned = collectionNode[key];
+        break;
+      case "functions":
+        collectionSchema.functions = makeTSFunctions(collectionNode[key]);
+        collectionSchema.exposedFunctions = getExposedFunctions(collectionNode[key]);
+        break;
+      case "table":
+      case "filters":
+      case "indexes":
+      case "form":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "actions":
+      case "individualActions":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "icon":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "presets":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "search":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "required":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+    }
+  }
+  return stringify(collectionSchema);
+};
+const makeTSFunctions = (functions) => {
+  return Object.keys(functions).reduce((acc, key) => {
+    acc[key] = {
+      [UnquotedSymbol]: DEFAULT_FUNCTIONS.includes(key) ? `typeof ${key}` : "() => never"
+    };
+    return acc;
+  }, {});
+};

package/dist/codegen/index.d.ts

@@ -0,0 +1,4 @@
+export * from './generateJSCollections.js';
+export * from './generateTSCollections.js';
+export * from './generateExports.js';
+export * from './generateContracts.js';

package/dist/codegen/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generateJSCollections.js"), exports);
+__exportStar(require("./generateTSCollections.js"), exports);
+__exportStar(require("./generateExports.js"), exports);
+__exportStar(require("./generateContracts.js"), exports);

package/dist/codegen/index.mjs

@@ -0,0 +1,5 @@
+"use strict";
+export * from "./generateJSCollections.mjs";
+export * from "./generateTSCollections.mjs";
+export * from "./generateExports.mjs";
+export * from "./generateContracts.mjs";

package/dist/codegen/utils.d.ts

@@ -0,0 +1,29 @@
+import type * as AST from '../ast.js';
+import type { Property } from '@aeriajs/types';
+export declare const PACKAGE_NAME = "aeria";
+export declare const DEFAULT_FUNCTIONS: string[];
+export declare const ArraySymbol: unique symbol;
+export declare const getExposedFunctions: (astFunctions: NonNullable<AST.CollectionNode["functions"]>) => {
+    [k: string]: import("@aeriajs/types").AccessCondition;
+};
+/**
+ * Obs: It will save and return any modified symbols to avoid name duplication later
+*/
+export declare const makeASTImports: (ast: AST.Node[], initialImports?: Record<string, Set<string>>) => {
+    code: string[];
+    modifiedSymbols: Record<string, string>;
+};
+export declare const propertyToSchema: (propertyNode: AST.PropertyNode) => Property;
+/** Transforms the AST properties to the format of aeria schema properties */
+export declare const getProperties: <TProperties extends Record<string, AST.PropertyNode | AST.PropertyNode[]>, TReturnType = TProperties[keyof TProperties] extends unknown[] ? Record<string, Property[]> : Record<string, Property>>(properties: TProperties) => TReturnType;
+export declare const UnquotedSymbol: unique symbol;
+/** Serves to know if the value must be unquoted on strinfigy function */
+export type StringifyProperty = unknown | {
+    [UnquotedSymbol]: string;
+};
+/** Assure if specific fields needs to be between quotes or not */
+export declare const stringify: (value: StringifyProperty, parents?: (symbol | string)[]) => string;
+/** Used to make the id and the schema name of the collection */
+export declare const resizeFirstChar: (text: string, capitalize: boolean) => string;
+export declare const getCollectionId: (name: string) => string;
+export declare const getExtendName: (name: string) => string;

package/dist/codegen/utils.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtendName = exports.getCollectionId = exports.resizeFirstChar = exports.stringify = exports.UnquotedSymbol = exports.getProperties = exports.propertyToSchema = exports.makeASTImports = exports.getExposedFunctions = exports.ArraySymbol = exports.DEFAULT_FUNCTIONS = exports.PACKAGE_NAME = void 0;
+exports.PACKAGE_NAME = 'aeria';
+exports.DEFAULT_FUNCTIONS = [
+    'count',
+    'get',
+    'getAll',
+    'insert',
+    'upload',
+    'remove',
+    'removeAll',
+    'removeFile',
+];
+exports.ArraySymbol = Symbol('array');
+const getExposedFunctions = (astFunctions) => {
+    return Object.fromEntries(Object.entries(astFunctions)
+        .map(([key, value]) => [
+        key,
+        value.accessCondition,
+    ]));
+};
+exports.getExposedFunctions = getExposedFunctions;
+/**
+ * Obs: It will save and return any modified symbols to avoid name duplication later
+*/
+const makeASTImports = (ast, initialImports) => {
+    const modifiedSymbols = {};
+    const toImport = ast.reduce((imports, node) => {
+        if (node.kind === 'collection') {
+            if (node.extends?.packageName) {
+                if (!(node.extends.packageName in imports)) {
+                    imports[node.extends.packageName] = new Set();
+                }
+                const modifiedSymbol = `original${(0, exports.resizeFirstChar)(node.extends.symbolName, true)}`;
+                modifiedSymbols[node.extends.symbolName] = modifiedSymbol;
+                imports[node.extends.packageName].add(`${node.extends.symbolName} as ${modifiedSymbol}`);
+            }
+            if (node.functions) {
+                const functionsToImport = Object.keys(node.functions).filter((key) => exports.DEFAULT_FUNCTIONS.includes(key));
+                if (functionsToImport.length > 0) {
+                    if (!(exports.PACKAGE_NAME in imports)) {
+                        imports[exports.PACKAGE_NAME] = new Set();
+                    }
+                    for (const key of functionsToImport) {
+                        imports[exports.PACKAGE_NAME].add(key);
+                    }
+                }
+            }
+        }
+        return imports;
+    }, initialImports ?? {});
+    return {
+        code: Object.keys(toImport).map((key) => `import { ${Array.from(toImport[key]).join(', ')} } from '${key}'`),
+        modifiedSymbols,
+    };
+};
+exports.makeASTImports = makeASTImports;
+const propertyToSchema = (propertyNode) => {
+    const propertySchema = propertyNode.property;
+    if ('$ref' in propertySchema) {
+        propertySchema.$ref = (0, exports.getCollectionId)(propertySchema.$ref);
+    }
+    else if ('items' in propertySchema && '$ref' in propertySchema.items) {
+        propertySchema.items.$ref = (0, exports.getCollectionId)(propertySchema.items.$ref);
+    }
+    if (propertyNode.nestedProperties && 'type' in propertySchema) {
+        if (propertySchema.type === 'object' && 'properties' in propertySchema) {
+            propertySchema.properties = (0, exports.getProperties)(propertyNode.nestedProperties);
+        }
+        else if (propertySchema.type === 'array') {
+            propertySchema.items = {
+                type: 'object',
+                properties: (0, exports.getProperties)(propertyNode.nestedProperties),
+            };
+        }
+    }
+    return propertySchema;
+};
+exports.propertyToSchema = propertyToSchema;
+/** Transforms the AST properties to the format of aeria schema properties */
+const getProperties = (properties) => {
+    return Object.entries(properties).reduce((acc, [key, value]) => {
+        if (Array.isArray(value)) {
+            acc[key] = value.map((propertyNode) => (0, exports.propertyToSchema)(propertyNode));
+        }
+        else {
+            acc[key] = (0, exports.propertyToSchema)(value);
+        }
+        return acc;
+    }, {});
+};
+exports.getProperties = getProperties;
+exports.UnquotedSymbol = Symbol('unquoted');
+const isRecord = (value) => typeof value === 'object';
+/** Assure if specific fields needs to be between quotes or not */
+const stringify = (value, parents = []) => {
+    if (Array.isArray(value)) {
+        let arrayString = '[\n';
+        value.map((element) => {
+            const currentParents = [
+                ...parents,
+                exports.ArraySymbol,
+            ];
+            arrayString += '\t'.repeat(currentParents.length) +
+                checkQuotes(currentParents, element) + ',\n';
+        });
+        return arrayString + `${'\t'.repeat(parents.length)}]`;
+    }
+    if (!isRecord(value)) {
+        return typeof value === 'number' || typeof value === 'boolean' || !value
+            ? String(value)
+            : `"${String(value)}"`;
+    }
+    const objectString = Object.keys(value).map((key) => {
+        const currentParents = [
+            ...parents,
+            key,
+        ];
+        const prefix = '\t'.repeat(currentParents.length);
+        return `${prefix}${key}: ${checkQuotes(currentParents, value[key])}`;
+    }).join(',\n');
+    return `{\n${objectString}\n${'\t'.repeat(parents.length)}}`;
+};
+exports.stringify = stringify;
+const checkQuotes = (parents, value) => {
+    if (value && typeof value === 'object' && exports.UnquotedSymbol in value) {
+        return value[exports.UnquotedSymbol];
+    }
+    return (0, exports.stringify)(value, parents);
+};
+/** Used to make the id and the schema name of the collection */
+const resizeFirstChar = (text, capitalize) => {
+    if (capitalize === true) {
+        return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+    return text.charAt(0).toLowerCase() + text.slice(1);
+};
+exports.resizeFirstChar = resizeFirstChar;
+const getCollectionId = (name) => (0, exports.resizeFirstChar)(name, false);
+exports.getCollectionId = getCollectionId;
+const getExtendName = (name) => `extend${(0, exports.resizeFirstChar)(name, true)}Collection`;
+exports.getExtendName = getExtendName;

package/dist/codegen/utils.mjs

@@ -0,0 +1,122 @@
+"use strict";
+export const PACKAGE_NAME = "aeria";
+export const DEFAULT_FUNCTIONS = [
+  "count",
+  "get",
+  "getAll",
+  "insert",
+  "upload",
+  "remove",
+  "removeAll",
+  "removeFile"
+];
+export const ArraySymbol = Symbol("array");
+export const getExposedFunctions = (astFunctions) => {
+  return Object.fromEntries(Object.entries(astFunctions).map(([key, value]) => [
+    key,
+    value.accessCondition
+  ]));
+};
+export const makeASTImports = (ast, initialImports) => {
+  const modifiedSymbols = {};
+  const toImport = ast.reduce((imports, node) => {
+    if (node.kind === "collection") {
+      if (node.extends?.packageName) {
+        if (!(node.extends.packageName in imports)) {
+          imports[node.extends.packageName] = /* @__PURE__ */ new Set();
+        }
+        const modifiedSymbol = `original${resizeFirstChar(node.extends.symbolName, true)}`;
+        modifiedSymbols[node.extends.symbolName] = modifiedSymbol;
+        imports[node.extends.packageName].add(`${node.extends.symbolName} as ${modifiedSymbol}`);
+      }
+      if (node.functions) {
+        const functionsToImport = Object.keys(node.functions).filter((key) => DEFAULT_FUNCTIONS.includes(key));
+        if (functionsToImport.length > 0) {
+          if (!(PACKAGE_NAME in imports)) {
+            imports[PACKAGE_NAME] = /* @__PURE__ */ new Set();
+          }
+          for (const key of functionsToImport) {
+            imports[PACKAGE_NAME].add(key);
+          }
+        }
+      }
+    }
+    return imports;
+  }, initialImports ?? {});
+  return {
+    code: Object.keys(toImport).map((key) => `import { ${Array.from(toImport[key]).join(", ")} } from '${key}'`),
+    modifiedSymbols
+  };
+};
+export const propertyToSchema = (propertyNode) => {
+  const propertySchema = propertyNode.property;
+  if ("$ref" in propertySchema) {
+    propertySchema.$ref = getCollectionId(propertySchema.$ref);
+  } else if ("items" in propertySchema && "$ref" in propertySchema.items) {
+    propertySchema.items.$ref = getCollectionId(propertySchema.items.$ref);
+  }
+  if (propertyNode.nestedProperties && "type" in propertySchema) {
+    if (propertySchema.type === "object" && "properties" in propertySchema) {
+      propertySchema.properties = getProperties(propertyNode.nestedProperties);
+    } else if (propertySchema.type === "array") {
+      propertySchema.items = {
+        type: "object",
+        properties: getProperties(propertyNode.nestedProperties)
+      };
+    }
+  }
+  return propertySchema;
+};
+export const getProperties = (properties) => {
+  return Object.entries(properties).reduce((acc, [key, value]) => {
+    if (Array.isArray(value)) {
+      acc[key] = value.map((propertyNode) => propertyToSchema(propertyNode));
+    } else {
+      acc[key] = propertyToSchema(value);
+    }
+    return acc;
+  }, {});
+};
+export const UnquotedSymbol = Symbol("unquoted");
+const isRecord = (value) => typeof value === "object";
+export const stringify = (value, parents = []) => {
+  if (Array.isArray(value)) {
+    let arrayString = "[\n";
+    value.map((element) => {
+      const currentParents = [
+        ...parents,
+        ArraySymbol
+      ];
+      arrayString += "	".repeat(currentParents.length) + checkQuotes(currentParents, element) + ",\n";
+    });
+    return arrayString + `${"	".repeat(parents.length)}]`;
+  }
+  if (!isRecord(value)) {
+    return typeof value === "number" || typeof value === "boolean" || !value ? String(value) : `"${String(value)}"`;
+  }
+  const objectString = Object.keys(value).map((key) => {
+    const currentParents = [
+      ...parents,
+      key
+    ];
+    const prefix = "	".repeat(currentParents.length);
+    return `${prefix}${key}: ${checkQuotes(currentParents, value[key])}`;
+  }).join(",\n");
+  return `{
+${objectString}
+${"	".repeat(parents.length)}}`;
+};
+const checkQuotes = (parents, value) => {
+  if (value && typeof value === "object" && UnquotedSymbol in value) {
+    return value[UnquotedSymbol];
+  }
+  return stringify(value, parents);
+};
+export const resizeFirstChar = (text, capitalize) => {
+  if (capitalize === true) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+  }
+  return text.charAt(0).toLowerCase() + text.slice(1);
+};
+export const getCollectionId = (name) => resizeFirstChar(name, false);
+export const getExtendName = (name) => `extend${resizeFirstChar(name, true)}Collection`;

package/dist/codegen.d.ts

@@ -0,0 +1,3 @@
+import type { CompilationOptions } from './compile.js';
+import type * as AST from './ast';
+export declare const generateCode: (ast: AST.ProgramNode, options: CompilationOptions) => Promise<Record<string, string>>;

package/dist/codegen.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCode = void 0;
+const index_js_1 = require("./codegen/index.js");
+const fsPromises = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+/**
+ * Maps the path tree into a object with the full paths
+ * {
+ *  folderX: {
+ *    folderY: {
+ *      file: ...
+ *    }
+ *  }
+ * }
+ * turns into
+ * {
+ *  ['outDir/folderX/folderY/file']: ...
+ * }
+ */
+const generateFileMap = async (fileTree, outDir) => {
+    const mappedPaths = {};
+    const mapPathTree = async (tree, previousPath) => {
+        for (const treePath in tree) {
+            const currentPath = path.join(previousPath, treePath);
+            if (typeof tree[treePath] === 'object') {
+                await mapPathTree(tree[treePath], currentPath);
+                continue;
+            }
+            await fsPromises.mkdir(previousPath, {
+                recursive: true,
+            });
+            mappedPaths[currentPath] = tree[treePath];
+        }
+        return;
+    };
+    await mapPathTree(fileTree, outDir);
+    return mappedPaths;
+};
+const generateCode = async (ast, options) => {
+    const contracts = (0, index_js_1.generateContracts)(ast.contracts);
+    const exports = (0, index_js_1.generateExports)(ast, Boolean(contracts));
+    const fileTree = {
+        ['collections']: {
+            ['collections.d.ts']: (0, index_js_1.generateTSCollections)(ast.collections),
+            ['collections.js']: (0, index_js_1.generateJSCollections)(ast.collections),
+            ['index.d.ts']: exports.collections.dTs,
+            ['index.js']: exports.collections.js,
+        },
+        ['index.d.ts']: exports.main.dTs,
+        ['index.js']: exports.main.js,
+    };
+    if (contracts) {
+        fileTree.contracts = {
+            ['contracts.js']: contracts.js,
+            ['contracts.d.ts']: contracts.dTs,
+            ['index.d.ts']: exports.contracts.dTs,
+            ['index.js']: exports.contracts.js,
+        };
+    }
+    const fileStructure = await generateFileMap(fileTree, options.outDir);
+    if (!options.dryRun) {
+        for (const path in fileStructure) {
+            await fsPromises.writeFile(path, fileStructure[path]);
+        }
+    }
+    return fileStructure;
+};
+exports.generateCode = generateCode;

package/dist/codegen.mjs

@@ -0,0 +1,52 @@
+"use strict";
+import { generateContracts, generateExports, generateJSCollections, generateTSCollections } from "./codegen/index.mjs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+const generateFileMap = async (fileTree, outDir) => {
+  const mappedPaths = {};
+  const mapPathTree = async (tree, previousPath) => {
+    for (const treePath in tree) {
+      const currentPath = path.join(previousPath, treePath);
+      if (typeof tree[treePath] === "object") {
+        await mapPathTree(tree[treePath], currentPath);
+        continue;
+      }
+      await fsPromises.mkdir(previousPath, {
+        recursive: true
+      });
+      mappedPaths[currentPath] = tree[treePath];
+    }
+    return;
+  };
+  await mapPathTree(fileTree, outDir);
+  return mappedPaths;
+};
+export const generateCode = async (ast, options) => {
+  const contracts = generateContracts(ast.contracts);
+  const exports = generateExports(ast, Boolean(contracts));
+  const fileTree = {
+    ["collections"]: {
+      ["collections.d.ts"]: generateTSCollections(ast.collections),
+      ["collections.mjs"]: generateJSCollections(ast.collections),
+      ["index.d.ts"]: exports.collections.dTs,
+      ["index.mjs"]: exports.collections.js
+    },
+    ["index.d.ts"]: exports.main.dTs,
+    ["index.mjs"]: exports.main.js
+  };
+  if (contracts) {
+    fileTree.contracts = {
+      ["contracts.mjs"]: contracts.js,
+      ["contracts.d.ts"]: contracts.dTs,
+      ["index.d.ts"]: exports.contracts.dTs,
+      ["index.mjs"]: exports.contracts.js
+    };
+  }
+  const fileStructure = await generateFileMap(fileTree, options.outDir);
+  if (!options.dryRun) {
+    for (const path2 in fileStructure) {
+      await fsPromises.writeFile(path2, fileStructure[path2]);
+    }
+  }
+  return fileStructure;
+};

package/dist/compile.d.ts

@@ -0,0 +1,21 @@
+import type * as AST from './ast.js';
+import { Diagnostic } from './diagnostic.js';
+export type CompilationResult = {
+    success: boolean;
+    ast: AST.ProgramNode;
+    errors: Diagnostic[];
+    errorCount: number;
+};
+export type CompilationOptions = {
+    outDir: string;
+    dryRun?: true;
+};
+export declare const parseAndCheck: (sources: Record<string, string>) => Promise<CompilationResult>;
+export declare const generateScaffolding: (options: CompilationOptions) => Promise<string[]>;
+export declare const compileFromFiles: (schemaDir: string, options: CompilationOptions) => Promise<{
+    emittedFiles: Record<string, string>;
+    success: boolean;
+    ast: AST.ProgramNode;
+    errors: Diagnostic[];
+    errorCount: number;
+}>;