@zenstackhq/sdk 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/index.cjs

@@ -318,9 +318,9 @@ var Model = class extends ContainerDeclaration {
   }
   name;
   isView;
-  fields;
+  fields = [];
   constructor(name, isView, documentations = []) {
-    super(documentations), this.name = name, this.isView = isView, this.fields = [];
+    super(documentations), this.name = name, this.isView = isView;
   }
   addField(name, type, attributes = [], documentations = [], addToFront = false) {
     const field = new ModelField(name, type, attributes, documentations);
@@ -540,9 +540,9 @@ var Enum = class extends ContainerDeclaration {
     __name(this, "Enum");
   }
   name;
-  fields;
+  fields = [];
   constructor(name, documentations = []) {
-    super(documentations), this.name = name, this.fields = [];
+    super(documentations), this.name = name;
   }
   addField(name, attributes = [], documentations = []) {
     const field = new EnumField(name, attributes, documentations);
@@ -591,15 +591,14 @@ var PrismaSchemaGenerator = class {
     __name(this, "PrismaSchemaGenerator");
   }
   zmodel;
-  PRELUDE;
-  constructor(zmodel) {
-    this.zmodel = zmodel;
-    this.PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
+  PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
 // DO NOT MODIFY THIS FILE                                                                  //
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 `;
+  constructor(zmodel) {
+    this.zmodel = zmodel;
   }
   async generate() {
     const prisma = new PrismaModel();
@@ -810,37 +809,39 @@ var PrismaSchemaGenerator = class {
 };
 
 // src/ts-schema-generator.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_language = require("@zenstackhq/language");
 var import_ast3 = require("@zenstackhq/language/ast");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_tiny_invariant = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern2 = require("ts-pattern");
 var ts = __toESM(require("typescript"), 1);
 var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
-  async generate(schemaFile, pluginModelFiles, outputFile) {
+  async generate(schemaFile, pluginModelFiles, outputDir) {
     const loaded = await (0, import_language.loadDocument)(schemaFile, pluginModelFiles);
     if (!loaded.success) {
       throw new Error(`Error loading schema:${loaded.errors.join("\n")}`);
     }
-    const { model, warnings } = loaded;
+    const { model } = loaded;
+    import_node_fs.default.mkdirSync(outputDir, {
+      recursive: true
+    });
+    this.generateSchema(model, outputDir);
+    this.generateModels(model, outputDir);
+    this.generateInputTypes(model, outputDir);
+  }
+  generateSchema(model, outputDir) {
     const statements = [];
     this.generateSchemaStatements(model, statements);
     this.generateBannerComments(statements);
-    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    const schemaOutputFile = import_node_path.default.join(outputDir, "schema.ts");
+    const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
     const printer = ts.createPrinter();
     const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
-    import_node_fs.default.mkdirSync(import_node_path.default.dirname(outputFile), {
-      recursive: true
-    });
-    import_node_fs.default.writeFileSync(outputFile, result);
-    return {
-      model,
-      warnings
-    };
+    import_node_fs.default.writeFileSync(schemaOutputFile, result);
   }
   generateSchemaStatements(model, statements) {
     const hasComputedFields = model.declarations.some((d) => (0, import_ast3.isDataModel)(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
@@ -852,27 +853,6 @@ var TsSchemaGenerator = class {
       ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
     ])), ts.factory.createStringLiteral("@zenstackhq/runtime/schema"));
     statements.push(runtimeImportDecl);
-    const { type: providerType } = this.getDataSourceProvider(model);
-    switch (providerType) {
-      case "sqlite": {
-        const pathImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("path"), void 0), ts.factory.createStringLiteral("node:path"));
-        statements.push(pathImportDecl);
-        const urlImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("url"), void 0), ts.factory.createStringLiteral("node:url"));
-        statements.push(urlImportDecl);
-        const dialectConfigImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
-          ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("toDialectConfig"))
-        ])), ts.factory.createStringLiteral("@zenstackhq/runtime/utils/sqlite-utils"));
-        statements.push(dialectConfigImportDecl);
-        break;
-      }
-      case "postgresql": {
-        const dialectConfigImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
-          ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("toDialectConfig"))
-        ])), ts.factory.createStringLiteral("@zenstackhq/runtime/utils/pg-utils"));
-        statements.push(dialectConfigImportDecl);
-        break;
-      }
-    }
     const declaration = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
@@ -909,8 +889,7 @@ var TsSchemaGenerator = class {
   createProviderObject(model) {
     const dsProvider = this.getDataSourceProvider(model);
     return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type)),
-      ts.factory.createPropertyAssignment("dialectConfigProvider", this.createDialectConfigProvider(dsProvider))
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type))
     ], true);
   }
   createModelsObject(model) {
@@ -937,19 +916,26 @@ var TsSchemaGenerator = class {
   }
   createComputedFieldsObject(fields) {
     return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [], ts.factory.createTypeReferenceNode("OperandExpression", [
-      ts.factory.createKeywordTypeNode(this.mapTypeToTSSyntaxKeyword(field.type.type))
+      ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type))
     ]), ts.factory.createBlock([
       ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [
         ts.factory.createStringLiteral("This is a stub for computed field")
       ]))
     ], true))), true);
   }
-  mapTypeToTSSyntaxKeyword(type) {
-    return (0, import_ts_pattern2.match)(type).with("String", () => ts.SyntaxKind.StringKeyword).with("Boolean", () => ts.SyntaxKind.BooleanKeyword).with("Int", () => ts.SyntaxKind.NumberKeyword).with("Float", () => ts.SyntaxKind.NumberKeyword).with("BigInt", () => ts.SyntaxKind.BigIntKeyword).with("Decimal", () => ts.SyntaxKind.NumberKeyword).otherwise(() => ts.SyntaxKind.UnknownKeyword);
+  mapFieldTypeToTSType(type) {
+    let result = (0, import_ts_pattern2.match)(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
+    if (type.array) {
+      result = `${result}[]`;
+    }
+    if (type.optional) {
+      result = `${result} | null`;
+    }
+    return result;
   }
   createDataModelFieldObject(field) {
     const objectFields = [
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type ?? field.type.reference.$refText))
+      ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
     ];
     if (isIdField(field)) {
       objectFields.push(ts.factory.createPropertyAssignment("id", ts.factory.createTrue()));
@@ -969,9 +955,9 @@ var TsSchemaGenerator = class {
     if (field.attributes.length > 0) {
       objectFields.push(ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr)))));
     }
-    const defaultValue = this.getMappedDefault(field);
+    const defaultValue = this.getFieldMappedDefault(field);
     if (defaultValue !== void 0) {
-      if (typeof defaultValue === "object") {
+      if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
         if ("call" in defaultValue) {
           objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
             ts.factory.createStringLiteral(defaultValue.call),
@@ -990,7 +976,11 @@ var TsSchemaGenerator = class {
           throw new Error(`Unsupported default value type for field ${field.name}`);
         }
       } else {
-        objectFields.push(ts.factory.createPropertyAssignment("default", typeof defaultValue === "string" ? ts.factory.createStringLiteral(defaultValue) : typeof defaultValue === "number" ? ts.factory.createNumericLiteral(defaultValue) : defaultValue === true ? ts.factory.createTrue() : ts.factory.createFalse()));
+        if (Array.isArray(defaultValue)) {
+          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)))));
+        } else {
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createLiteralNode(defaultValue)));
+        }
       }
     }
     if (hasAttribute(field, "@computed")) {
@@ -1007,12 +997,12 @@ var TsSchemaGenerator = class {
   }
   getDataSourceProvider(model) {
     const dataSource = model.declarations.find(import_ast3.isDataSource);
-    (0, import_tiny_invariant.default)(dataSource, "No data source found in the model");
+    (0, import_common_helpers.invariant)(dataSource, "No data source found in the model");
     const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    (0, import_tiny_invariant.default)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
+    (0, import_common_helpers.invariant)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
     const type = providerExpr.value;
     const urlExpr = dataSource.fields.find((f) => f.name === "url")?.value;
-    (0, import_tiny_invariant.default)((0, import_ast3.isLiteralExpr)(urlExpr) || (0, import_ast3.isInvocationExpr)(urlExpr), "URL must be a literal or env function");
+    (0, import_common_helpers.invariant)((0, import_ast3.isLiteralExpr)(urlExpr) || (0, import_ast3.isInvocationExpr)(urlExpr), "URL must be a literal or env function");
     if ((0, import_ast3.isLiteralExpr)(urlExpr)) {
       return {
         type,
@@ -1020,8 +1010,8 @@ var TsSchemaGenerator = class {
         env: void 0
       };
     } else if ((0, import_ast3.isInvocationExpr)(urlExpr)) {
-      (0, import_tiny_invariant.default)(urlExpr.function.$refText === "env", 'only "env" function is supported');
-      (0, import_tiny_invariant.default)(urlExpr.args.length === 1, "env function must have one argument");
+      (0, import_common_helpers.invariant)(urlExpr.function.$refText === "env", 'only "env" function is supported');
+      (0, import_common_helpers.invariant)(urlExpr.args.length === 1, "env function must have one argument");
       return {
         type,
         env: urlExpr.args[0].value.value,
@@ -1031,34 +1021,39 @@ var TsSchemaGenerator = class {
       throw new Error("Unsupported URL type");
     }
   }
-  getMappedDefault(field) {
+  getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
     if (!defaultAttr) {
       return void 0;
     }
     const defaultValue = defaultAttr.args[0]?.value;
-    (0, import_tiny_invariant.default)(defaultValue, "Expected a default value");
-    if ((0, import_ast3.isLiteralExpr)(defaultValue)) {
-      const lit = defaultValue.value;
-      return field.type.type === "Boolean" ? lit : [
+    (0, import_common_helpers.invariant)(defaultValue, "Expected a default value");
+    return this.getMappedValue(defaultValue, field.type);
+  }
+  getMappedValue(expr, fieldType) {
+    if ((0, import_ast3.isLiteralExpr)(expr)) {
+      const lit = expr.value;
+      return fieldType.type === "Boolean" ? lit : [
         "Int",
         "Float",
         "Decimal",
         "BigInt"
-      ].includes(field.type.type) ? Number(lit) : lit;
-    } else if ((0, import_ast3.isReferenceExpr)(defaultValue) && (0, import_ast3.isEnumField)(defaultValue.target.ref)) {
-      return defaultValue.target.ref.name;
-    } else if ((0, import_ast3.isInvocationExpr)(defaultValue)) {
+      ].includes(fieldType.type) ? Number(lit) : lit;
+    } else if ((0, import_ast3.isArrayExpr)(expr)) {
+      return expr.items.map((item) => this.getMappedValue(item, fieldType));
+    } else if ((0, import_ast3.isReferenceExpr)(expr) && (0, import_ast3.isEnumField)(expr.target.ref)) {
+      return expr.target.ref.name;
+    } else if ((0, import_ast3.isInvocationExpr)(expr)) {
       return {
-        call: defaultValue.function.$refText,
-        args: defaultValue.args.map((arg) => this.getLiteral(arg.value))
+        call: expr.function.$refText,
+        args: expr.args.map((arg) => this.getLiteral(arg.value))
       };
-    } else if (this.isAuthMemberAccess(defaultValue)) {
+    } else if (this.isAuthMemberAccess(expr)) {
       return {
-        authMember: this.getMemberAccessChain(defaultValue)
+        authMember: this.getMemberAccessChain(expr)
       };
     } else {
-      throw new Error(`Unsupported default value type for field ${field.name}`);
+      throw new Error(`Unsupported default value type for ${expr.$type}`);
     }
   }
   getMemberAccessChain(expr) {
@@ -1157,7 +1152,7 @@ var TsSchemaGenerator = class {
     if (relation) {
       const nameArg = relation.args.find((arg) => arg.$resolvedParam.name === "name");
       if (nameArg) {
-        (0, import_tiny_invariant.default)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
+        (0, import_common_helpers.invariant)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
         return nameArg.value.value;
       }
     }
@@ -1171,10 +1166,11 @@ var TsSchemaGenerator = class {
     for (const field of dm.fields) {
       if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) {
         properties.push(ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type))
+          ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
         ])));
       }
     }
+    const seenKeys = /* @__PURE__ */ new Set();
     for (const attr of dm.attributes) {
       if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
         const fieldNames = this.getReferenceNames(attr.args[0].value);
@@ -1184,13 +1180,18 @@ var TsSchemaGenerator = class {
         if (fieldNames.length === 1) {
           const fieldDef = dm.fields.find((f) => f.name === fieldNames[0]);
           properties.push(ts.factory.createPropertyAssignment(fieldNames[0], ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+            ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
           ])));
         } else {
+          const key = fieldNames.join("_");
+          if (seenKeys.has(key)) {
+            continue;
+          }
+          seenKeys.add(key);
           properties.push(ts.factory.createPropertyAssignment(fieldNames.join("_"), ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
             const fieldDef = dm.fields.find((f) => f.name === field);
             return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([
-              ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+              ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
             ]));
           }))));
         }
@@ -1198,6 +1199,10 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(properties, true);
   }
+  generateFieldTypeLiteral(field) {
+    (0, import_common_helpers.invariant)(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
+    return field.type.type ? ts.factory.createStringLiteral(field.type.type) : field.type.reference ? ts.factory.createStringLiteral(field.type.reference.$refText) : ts.factory.createStringLiteral("Unsupported");
+  }
   createEnumObject(e) {
     return ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createStringLiteral(field.name))), true);
   }
@@ -1218,44 +1223,6 @@ var TsSchemaGenerator = class {
   createLiteralNode(arg) {
     return arg === null ? ts.factory.createNull() : typeof arg === "string" ? ts.factory.createStringLiteral(arg) : typeof arg === "number" ? ts.factory.createNumericLiteral(arg) : arg === true ? ts.factory.createTrue() : arg === false ? ts.factory.createFalse() : void 0;
   }
-  createDialectConfigProvider(dsProvider) {
-    const type = dsProvider.type;
-    let urlExpr;
-    if (dsProvider.env !== void 0) {
-      urlExpr = ts.factory.createIdentifier(`process.env['${dsProvider.env}']`);
-    } else {
-      urlExpr = ts.factory.createStringLiteral(dsProvider.url);
-      if (type === "sqlite") {
-        let parsedUrl;
-        try {
-          parsedUrl = new URL(dsProvider.url);
-        } catch {
-        }
-        if (parsedUrl) {
-          if (parsedUrl.protocol !== "file:") {
-            throw new Error("Invalid SQLite URL: only file protocol is supported");
-          }
-          urlExpr = ts.factory.createStringLiteral(dsProvider.url.replace(/^file:/, ""));
-        }
-      }
-    }
-    return (0, import_ts_pattern2.match)(type).with("sqlite", () => {
-      return ts.factory.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, ts.factory.createBlock([
-        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("toDialectConfig"), void 0, [
-          urlExpr,
-          ts.factory.createIdentifier(`typeof __dirname !== 'undefined' ? __dirname : path.dirname(url.fileURLToPath(import.meta.url))`)
-        ]))
-      ], true));
-    }).with("postgresql", () => {
-      return ts.factory.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, ts.factory.createBlock([
-        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("toDialectConfig"), void 0, [
-          urlExpr
-        ]))
-      ], true));
-    }).otherwise(() => {
-      throw new Error(`Unsupported provider: ${type}`);
-    });
-  }
   createProceduresObject(procedures) {
     return ts.factory.createObjectLiteralExpression(procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
   }
@@ -1290,6 +1257,8 @@ var TsSchemaGenerator = class {
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
+/* eslint-disable */
+
 `;
     ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.SingleLineCommentTrivia, banner);
   }
@@ -1384,6 +1353,132 @@ var TsSchemaGenerator = class {
       throw new Error(`Unsupported literal type: ${type}`);
     });
   }
+  generateModels(model, outputDir) {
+    const statements = [];
+    statements.push(this.generateSchemaTypeImport(true, true));
+    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
+      ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`))
+    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    const dataModels = model.declarations.filter(import_ast3.isDataModel);
+    for (const dm of dataModels) {
+      let modelType = ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], dm.name, void 0, ts.factory.createTypeReferenceNode("$ModelResult", [
+        ts.factory.createTypeReferenceNode("$Schema"),
+        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))
+      ]));
+      if (dm.comments.length > 0) {
+        modelType = this.generateDocs(modelType, dm);
+      }
+      statements.push(modelType);
+    }
+    const enums = model.declarations.filter(import_ast3.isEnum);
+    for (const e of enums) {
+      let enumDecl = ts.factory.createVariableStatement([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)))
+      ], ts.NodeFlags.Const));
+      if (e.comments.length > 0) {
+        enumDecl = this.generateDocs(enumDecl, e);
+      }
+      statements.push(enumDecl);
+      let typeAlias = ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], e.name, void 0, ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)), ts.factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)))));
+      if (e.comments.length > 0) {
+        typeAlias = this.generateDocs(typeAlias, e);
+      }
+      statements.push(typeAlias);
+    }
+    this.generateBannerComments(statements);
+    const outputFile = import_node_path.default.join(outputDir, "models.ts");
+    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    const printer = ts.createPrinter();
+    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+    import_node_fs.default.writeFileSync(outputFile, result);
+  }
+  generateSchemaTypeImport(schemaObject, schemaType) {
+    const importSpecifiers = [];
+    if (schemaObject) {
+      importSpecifiers.push(ts.factory.createImportSpecifier(false, ts.factory.createIdentifier("schema"), ts.factory.createIdentifier("$schema")));
+    }
+    if (schemaType) {
+      importSpecifiers.push(ts.factory.createImportSpecifier(true, ts.factory.createIdentifier("SchemaType"), ts.factory.createIdentifier("$Schema")));
+    }
+    return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral("./schema"));
+  }
+  generateDocs(tsDecl, decl) {
+    return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*
+ * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}
+ `, true);
+  }
+  generateInputTypes(model, outputDir) {
+    const dataModels = model.declarations.filter(import_ast3.isDataModel);
+    const statements = [];
+    statements.push(this.generateSchemaTypeImport(false, true));
+    const inputTypes = [
+      "FindManyArgs",
+      "FindUniqueArgs",
+      "FindFirstArgs",
+      "CreateArgs",
+      "CreateManyArgs",
+      "CreateManyAndReturnArgs",
+      "UpdateArgs",
+      "UpdateManyArgs",
+      "UpdateManyAndReturnArgs",
+      "UpsertArgs",
+      "DeleteArgs",
+      "DeleteManyArgs",
+      "CountArgs",
+      "AggregateArgs",
+      "GroupByArgs",
+      "WhereInput",
+      "SelectInput",
+      "IncludeInput",
+      "OmitInput"
+    ];
+    const inputTypeNameFixes = {
+      SelectInput: "Select",
+      IncludeInput: "Include",
+      OmitInput: "Omit"
+    };
+    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports(inputTypes.map((inputType) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`${inputType} as $${inputType}`))))), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([
+      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SimplifiedModelResult as $SimplifiedModelResult")),
+      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))
+    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    for (const dm of dataModels) {
+      for (const inputType of inputTypes) {
+        const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
+        statements.push(ts.factory.createTypeAliasDeclaration([
+          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+        ], exportName, void 0, ts.factory.createTypeReferenceNode(`$${inputType}`, [
+          ts.factory.createTypeReferenceNode("$Schema"),
+          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))
+        ])));
+      }
+      statements.push(ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], `${dm.name}GetPayload`, [
+        ts.factory.createTypeParameterDeclaration(void 0, "Args", ts.factory.createTypeReferenceNode("$SelectIncludeOmit", [
+          ts.factory.createTypeReferenceNode("$Schema"),
+          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+          ts.factory.createLiteralTypeNode(ts.factory.createTrue())
+        ]))
+      ], ts.factory.createTypeReferenceNode("$SimplifiedModelResult", [
+        ts.factory.createTypeReferenceNode("$Schema"),
+        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+        ts.factory.createTypeReferenceNode("Args")
+      ])));
+    }
+    this.generateBannerComments(statements);
+    const outputFile = import_node_path.default.join(outputDir, "input.ts");
+    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    const printer = ts.createPrinter();
+    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+    import_node_fs.default.writeFileSync(outputFile, result);
+  }
 };
 
 // src/zmodel-code-generator.ts