@comet/admin-generator 8.17.1 → 9.0.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,4440 @@
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { loadSchema } from "@graphql-tools/load";
+import { exec } from "child_process";
+import { Command } from "commander";
+import fs, { existsSync, promises, readFileSync } from "fs";
+import { glob } from "glob";
+import { introspectionFromSchema } from "graphql";
+import * as path from "path";
+import { basename, dirname } from "path";
+import { promisify } from "util";
+import { createJiti } from "jiti";
+import * as ts$1 from "typescript";
+import ts from "typescript";
+import { camelCase, capitalCase } from "change-case";
+import { FormattedMessage } from "react-intl";
+import pluralize from "pluralize";
+import objectPath from "object-path";
+
+//#region rolldown:runtime
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+//#endregion
+//#region src/commands/generate/config/transformConfig.ts
+const supportedImportPaths = [
+	"[type=grid].columns.filterOperators",
+	"[type=grid].columns.block",
+	"[type=grid].columns.component",
+	...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.validate`),
+	...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.block`),
+	...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.component`)
+];
+const supportedInlineCodePaths = ["[type=grid].columns.renderCell", ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.validate`)];
+function transformConfigFile(fileName, sourceText) {
+	const sourceFile = ts$1.createSourceFile(fileName, sourceText, ts$1.ScriptTarget.ES2024, true);
+	const importedIdentifiers = collectImports(sourceFile);
+	function configTransformer() {
+		return (context) => {
+			const visit = (node, path$1) => {
+				if (ts$1.isCallExpression(node)) {
+					if (node.expression.getText() === "injectFormVariables") {
+						if (!path$1.startsWith("[type=form].fields")) throw new Error(`injectFormVariables can only be used in form field definitions: ${path$1}`);
+						if (node.arguments.length !== 1) throw new Error(`injectFormVariables expects exactly one argument`);
+						const injectFormVariablesArg = node.arguments[0];
+						if (!ts$1.isArrowFunction(injectFormVariablesArg)) throw new Error(`injectFormVariables expects an arrow function as its argument`);
+						node = injectFormVariablesArg.body;
+					}
+				}
+				if (ts$1.isArrowFunction(node)) if (supportedInlineCodePaths.includes(path$1)) {
+					let code = node.getText();
+					if (code.endsWith(",")) code = code.slice(0, -1);
+					const imports = findUsedImports(node.body, importedIdentifiers);
+					return ts$1.factory.createObjectLiteralExpression([ts$1.factory.createPropertyAssignment("code", ts$1.factory.createStringLiteral(code)), ts$1.factory.createPropertyAssignment("imports", ts$1.factory.createArrayLiteralExpression(imports.map((imprt) => {
+						return ts$1.factory.createObjectLiteralExpression([
+							ts$1.factory.createPropertyAssignment("name", ts$1.factory.createStringLiteral(imprt.name)),
+							ts$1.factory.createPropertyAssignment("import", ts$1.factory.createStringLiteral(imprt.import)),
+							...imprt.defaultImport ? [ts$1.factory.createPropertyAssignment("defaultImport", ts$1.factory.createTrue())] : []
+						]);
+					})))], true);
+				} else throw new Error(`Inline Function is not allowed here and calling the function is not supported: ${path$1}`);
+				else if (ts$1.isIdentifier(node)) {
+					const imported = importedIdentifiers.get(node.text);
+					if (imported) {
+						if (supportedImportPaths.includes(path$1)) return ts$1.factory.createObjectLiteralExpression([ts$1.factory.createPropertyAssignment("name", ts$1.factory.createStringLiteral(node.text)), ts$1.factory.createPropertyAssignment("import", ts$1.factory.createStringLiteral(imported.import))], true);
+					}
+				}
+				if (![
+					ts$1.SyntaxKind.Identifier,
+					ts$1.SyntaxKind.ArrayLiteralExpression,
+					ts$1.SyntaxKind.ObjectLiteralExpression,
+					ts$1.SyntaxKind.TaggedTemplateExpression,
+					ts$1.SyntaxKind.SpreadElement,
+					ts$1.SyntaxKind.PropertyAssignment,
+					ts$1.SyntaxKind.ShorthandPropertyAssignment
+				].includes(node.kind)) return node;
+				let newPath = path$1;
+				if (path$1 == "") {
+					if (ts$1.isObjectLiteralExpression(node)) {
+						const typeProperty = getTypePropertyFromObjectLiteral(node);
+						newPath = typeProperty ? `[type=${typeProperty}]` : "";
+					}
+				} else if (ts$1.isPropertyAssignment(node)) newPath = `${path$1}.${node.name.getText()}`;
+				return ts$1.visitEachChild(node, (child) => {
+					return visit(child, newPath);
+				}, context);
+			};
+			return (node) => ts$1.visitNode(node, (child) => visit(child, ""));
+		};
+	}
+	const configNode = findConfigNode(sourceFile);
+	const transformedConfigNode = ts$1.transform(configNode, [configTransformer()]).transformed[0];
+	const updatedSource = ts$1.transform(sourceFile, [(context) => {
+		const visitor = (node) => {
+			if (node === configNode) return transformedConfigNode;
+			return ts$1.visitEachChild(node, visitor, context);
+		};
+		return (node) => ts$1.visitNode(node, visitor);
+	}]).transformed[0];
+	return ts$1.createPrinter().printFile(updatedSource);
+}
+function findConfigNode(sourceFile) {
+	let ret;
+	sourceFile.forEachChild((node) => {
+		if (ts$1.isExportAssignment(node)) {
+			const exportedNode = node.expression;
+			if (ts$1.isCallExpression(exportedNode) && exportedNode.expression.getText() == "defineConfig") {
+				const args = exportedNode.arguments;
+				if (args.length != 1) throw new Error(`Expected exactly one argument for defineConfig`);
+				ret = args[0];
+				return false;
+			} else if (ts$1.isSatisfiesExpression(exportedNode)) {
+				if (ts$1.isObjectLiteralExpression(exportedNode.expression)) {
+					ret = exportedNode.expression;
+					return false;
+				}
+			} else if (ts$1.isObjectLiteralExpression(exportedNode)) {
+				ret = exportedNode;
+				return false;
+			}
+		}
+	});
+	if (!ret) throw new Error(`No default export found, please export the GeneratorConfig as default, preferrable using defineConfig helper.`);
+	return ret;
+}
+function getTypePropertyFromObjectLiteral(node) {
+	for (const property of node.properties) if (ts$1.isPropertyAssignment(property)) {
+		if (property.name.getText() == "type") {
+			const propertyAssignmentInitializer = property.initializer;
+			if (ts$1.isStringLiteral(propertyAssignmentInitializer)) return propertyAssignmentInitializer.text;
+		}
+	}
+	return null;
+}
+function collectImports(rootNode) {
+	const importedIdentifiers = /* @__PURE__ */ new Map();
+	function visit(node) {
+		if (ts$1.isImportDeclaration(node) && node.importClause) {
+			const moduleSpecifier = node.moduleSpecifier.text;
+			if (node.importClause.namedBindings && ts$1.isNamedImports(node.importClause.namedBindings)) for (const element of node.importClause.namedBindings.elements) {
+				const localName = element.name.text;
+				const originalName = element.propertyName ? element.propertyName.text : localName;
+				importedIdentifiers.set(localName, {
+					name: originalName,
+					import: moduleSpecifier
+				});
+			}
+			else if (node.importClause.name && ts$1.isIdentifier(node.importClause.name)) {
+				const localName = node.importClause.name.text;
+				importedIdentifiers.set(localName, {
+					defaultImport: true,
+					name: localName,
+					import: moduleSpecifier
+				});
+			}
+		}
+		ts$1.forEachChild(node, visit);
+	}
+	visit(rootNode);
+	return importedIdentifiers;
+}
+function findUsedImports(rootNode, importedIdentifiers) {
+	const imports = [];
+	const usedNames = /* @__PURE__ */ new Set();
+	function collectUsedIdentifiers(node) {
+		if (ts$1.isIdentifier(node)) usedNames.add(node.text);
+		ts$1.forEachChild(node, collectUsedIdentifiers);
+	}
+	collectUsedIdentifiers(rootNode);
+	for (const name of usedNames) {
+		const imported = importedIdentifiers.get(name);
+		if (imported) imports.push(imported);
+	}
+	return imports;
+}
+
+//#endregion
+//#region src/commands/generate/config/parseConfig.ts
+let alias;
+try {
+	const tsConfigJson = readFileSync("tsconfig.json", "utf-8");
+	const tsConfig = JSON.parse(tsConfigJson);
+	if (tsConfig.compilerOptions?.paths) {
+		alias = {};
+		for (const [key, value] of Object.entries(tsConfig.compilerOptions.paths)) {
+			const cleanedKey = key.replace("/*", "");
+			const cleanedValue = value[0].replace("/*", "");
+			alias[cleanedKey] = `${process.cwd()}/${cleanedValue}`;
+		}
+	}
+} catch (error) {
+	console.warn("Failed to parse TSConfig paths, import aliases might not work. See original error below");
+	console.warn(error);
+}
+const jiti = createJiti(import.meta.url, {
+	alias,
+	fsCache: false,
+	jsx: { runtime: "automatic" }
+});
+async function parseConfig(file) {
+	const transformedConfig = transformConfigFile(file, await promises.readFile(file, "utf-8"));
+	const tempFileName = `${dirname(file)}/.temp-${basename(file)}`;
+	await promises.writeFile(tempFileName, transformedConfig, "utf-8");
+	let executedConfig;
+	try {
+		executedConfig = await jiti.import(tempFileName.replace(/\.tsx?$/, ""), { default: true });
+	} catch (e) {
+		console.error(e);
+		throw new Error(`Error executing config file ${file}: ${e}`);
+	}
+	await promises.rm(tempFileName);
+	return executedConfig;
+}
+
+//#endregion
+//#region src/commands/generate/utils/convertConfigImport.ts
+function convertConfigImport(imprt) {
+	let importPath = imprt.import;
+	if (importPath.startsWith("../")) importPath = `../${importPath}`;
+	else if (importPath.startsWith("./")) importPath = `.${importPath}`;
+	return {
+		name: imprt.name,
+		importPath,
+		defaultImport: imprt.defaultImport
+	};
+}
+
+//#endregion
+//#region src/commands/generate/utils/findMutationType.ts
+function findMutationType(mutationName, schema) {
+	if (!schema.__schema.mutationType) throw new Error("Schema has no Mutation type");
+	const queryType = schema.__schema.types.find((type) => type.name === schema.__schema.mutationType?.name);
+	if (!queryType) throw new Error("Can't find Mutation type in gql schema");
+	return queryType.fields.find((field) => field.name === mutationName);
+}
+function findMutationTypeOrThrow(mutationName, schema) {
+	const ret = findMutationType(mutationName, schema);
+	if (!ret) throw new Error(`Can't find Mutation ${mutationName} in gql schema`);
+	return ret;
+}
+
+//#endregion
+//#region src/commands/generate/utils/generateGqlOperation.ts
+function generateGqlQueryTreeFromFields(fields) {
+	function getOrCreateNode(root$1, path$1) {
+		let node = root$1;
+		for (const part of path$1) {
+			if (!node.children[part]) node.children[part] = {
+				children: {},
+				fragments: []
+			};
+			node = node.children[part];
+		}
+		return node;
+	}
+	const root = {
+		children: {},
+		fragments: []
+	};
+	for (const field of fields) {
+		const fragmentMatch = field.match(/(.*)(\.{3}.*)/);
+		if (fragmentMatch) {
+			const key = fragmentMatch[1].trim();
+			const fragment = fragmentMatch[2].trim();
+			if (key === "") root.fragments.push(fragment);
+			else getOrCreateNode(root, key.split(".").filter(Boolean)).fragments.push(fragment);
+		} else {
+			const path$1 = field.split(".").filter(Boolean);
+			if (path$1.length === 0) continue;
+			getOrCreateNode(root, path$1);
+		}
+	}
+	function recursiveStringify$1(node) {
+		const parts = [];
+		for (const key of Object.keys(node.children)) {
+			const child = node.children[key];
+			const childStr = recursiveStringify$1(child);
+			if (childStr) parts.push(`${key} { ${childStr} }`);
+			else parts.push(key);
+		}
+		if (node.fragments.length > 0) parts.push(...node.fragments);
+		return parts.join(" ");
+	}
+	return recursiveStringify$1(root);
+}
+function generateGqlOperation(options) {
+	let queryArgs = "";
+	if (options.variables && options.variables.length > 0) {
+		queryArgs += `(`;
+		queryArgs += options.variables.map((v) => `$${v.name}: ${v.type}`).join(", ");
+		queryArgs += `)`;
+	}
+	let rootQueryArgs = "";
+	if (options.variables && options.variables.length > 0) {
+		rootQueryArgs += `(`;
+		rootQueryArgs += options.variables.map((v) => `${v.name}: $${v.name}`).join(", ");
+		rootQueryArgs += `)`;
+	}
+	return `
+    ${options.type} ${options.operationName}${queryArgs} {
+        ${options.rootOperation}${rootQueryArgs} {
+            ${generateGqlQueryTreeFromFields(options.fields)}
+        }
+    }
+    ${(options.fragmentVariables ?? []).join("\n")}
+    `;
+}
+
+//#endregion
+//#region src/commands/generate/utils/generateImportsCode.ts
+function generateImportsCode(imports) {
+	const importsNameToPath = /* @__PURE__ */ new Map();
+	return imports.filter((imp) => {
+		if (importsNameToPath.has(imp.name)) if (importsNameToPath.get(imp.name) !== imp.importPath) throw new Error(`Duplicate import name ${imp.name}`);
+		else return false;
+		importsNameToPath.set(imp.name, imp.importPath);
+		return true;
+	}).map((imp) => {
+		if (imp.defaultImport) return `import ${imp.name} from "${imp.importPath}";`;
+		else return `import { ${imp.name} } from "${imp.importPath}";`;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/commands/generate/utils/runtimeTypeGuards.ts
+/**
+* Type Guard used by generator runtime for places where runtime vs. configtime types mismatch
+*/
+function isGeneratorConfigImport(value) {
+	if (value && typeof value === "object" && "import" in value && "name" in value) return true;
+	return false;
+}
+/**
+* Type Guard used by generator runtime for places where runtime vs. configtime types mismatch
+*/
+function isGeneratorConfigCode(value) {
+	if (value && typeof value === "object" && "code" in value && "imports" in value) return true;
+	return false;
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/extractErrorEnums.ts
+/**
+* Extracts error enum type names from create and update mutations.
+* Navigates: Mutation → return type → payload object → errors field → LIST → error object → code field → ENUM
+*/
+function extractErrorEnumsFromMutations({ createMutationType, updateMutationType, gqlIntrospection }) {
+	const createErrorEnum = createMutationType ? extractErrorEnumFromMutation(createMutationType, gqlIntrospection) : void 0;
+	const updateErrorEnum = updateMutationType ? extractErrorEnumFromMutation(updateMutationType, gqlIntrospection) : void 0;
+	return {
+		createErrorEnum,
+		updateErrorEnum,
+		useDifferentEnums: Boolean(createErrorEnum && updateErrorEnum && createErrorEnum !== updateErrorEnum)
+	};
+}
+/**
+* Extracts error enum type name from a single mutation field.
+* Returns undefined if mutation doesn't have error enum.
+*/
+function extractErrorEnumFromMutation(mutationType, gqlIntrospection) {
+	try {
+		let returnType = mutationType.type;
+		if (returnType.kind === "NON_NULL") returnType = returnType.ofType;
+		if (returnType.kind !== "OBJECT") return;
+		const payloadType = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === returnType.name);
+		if (!payloadType) return;
+		const errorsField = payloadType.fields.find((field) => field.name === "errors");
+		if (!errorsField) return;
+		return extractEnumFromErrorsField(errorsField, gqlIntrospection);
+	} catch {
+		return;
+	}
+}
+/**
+* Extracts enum type name from the errors field.
+* Traverses: errors field → unwrap NON_NULL → unwrap LIST → unwrap NON_NULL → error OBJECT → code field → ENUM
+*/
+function extractEnumFromErrorsField(errorsField, gqlIntrospection) {
+	try {
+		let errorsType = errorsField.type;
+		if (errorsType.kind === "NON_NULL") errorsType = errorsType.ofType;
+		if (errorsType.kind !== "LIST") return;
+		let errorItemType = errorsType.ofType;
+		if (errorItemType.kind === "NON_NULL") errorItemType = errorItemType.ofType;
+		if (errorItemType.kind !== "OBJECT") return;
+		const errorObjectType = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === errorItemType.name);
+		if (!errorObjectType) return;
+		const codeField = errorObjectType.fields.find((field) => field.name === "code");
+		if (!codeField) return;
+		let codeType = codeField.type;
+		if (codeType.kind === "NON_NULL") codeType = codeType.ofType;
+		if (codeType.kind !== "ENUM") return;
+		return codeType.name;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/flatFormFieldsFromFormConfig.ts
+function flatFormFieldsFromFormConfig(config) {
+	return config.fields.reduce((acc, field) => {
+		if (isFormLayoutConfig(field)) field.fields.forEach((nestedFieldConfig) => {
+			if (isFormFieldConfig(nestedFieldConfig)) acc.push(nestedFieldConfig);
+		});
+		else if (isFormFieldConfig(field)) acc.push(field);
+		return acc;
+	}, []);
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateErrorHandling.ts
+/**
+* Generates error handling code for form submissions.
+* Creates errors.reduce() implementation that maps GraphQL errors to Final Form submission errors.
+*/
+function generateErrorHandlingCode({ mutationResponsePath, errorMessagesVariable }) {
+	return `
+    if (${mutationResponsePath}.errors.length) {
+        return ${mutationResponsePath}.errors.reduce(
+            (submissionErrors, error) => {
+                const errorMessage = ${errorMessagesVariable}[error.code];
+                if (error.field) {
+                    submissionErrors[error.field] = errorMessage;
+                } else {
+                    submissionErrors[FORM_ERROR] = errorMessage;
+                }
+                return submissionErrors;
+            },
+            {} as Record<string, ReactNode>,
+        );
+    }`;
+}
+
+//#endregion
+//#region src/commands/generate/utils/camelCaseToHumanReadable.ts
+function camelCaseToHumanReadable(s) {
+	return capitalCase(s);
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateErrorMessages.ts
+/**
+* Generates TypeScript code for submissionErrorMessages object(s).
+* Creates a mapped type object with FormattedMessage components for each error code.
+*/
+function generateErrorMessagesCode({ enumName, gqlType, variableName, gqlIntrospection }) {
+	const enumType = gqlIntrospection.__schema.types.find((type) => type.kind === "ENUM" && type.name === enumName);
+	if (!enumType || enumType.enumValues.length === 0) return "";
+	return `const ${variableName}: Record<GQL${enumName}, ReactNode> = {
+${enumType.enumValues.map((enumValue) => {
+		const errorCode = enumValue.name;
+		const defaultMessage = enumValue.description || camelCaseToHumanReadable(errorCode);
+		return `${errorCode}: <FormattedMessage id="${`${gqlType.toLowerCase()}.form.error.${errorCode}`}" defaultMessage="${defaultMessage}" />`;
+	}).join(",\n")},
+};`;
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateComponentFormField.ts
+function generateComponentFormField({ config }) {
+	if (!isGeneratorConfigImport(config.component)) throw new Error("config.component must be a GeneratorConfigImport");
+	return {
+		imports: [convertConfigImport(config.component)],
+		formProps: [],
+		hooksCode: "",
+		formFragmentFields: [],
+		formValuesConfig: [],
+		finalFormConfig: void 0,
+		code: `<${config.component.name} />`,
+		gqlDocuments: {}
+	};
+}
+
+//#endregion
+//#region ../../../node_modules/.pnpm/react@19.2.4/node_modules/react/cjs/react.production.js
+/**
+* @license React
+* react.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+	var ReactNoopUpdateQueue = {
+		isMounted: function() {
+			return !1;
+		},
+		enqueueForceUpdate: function() {},
+		enqueueReplaceState: function() {},
+		enqueueSetState: function() {}
+	}, assign = Object.assign, emptyObject = {};
+	function Component(props, context, updater) {
+		this.props = props;
+		this.context = context;
+		this.refs = emptyObject;
+		this.updater = updater || ReactNoopUpdateQueue;
+	}
+	Component.prototype.isReactComponent = {};
+	Component.prototype.setState = function(partialState, callback) {
+		if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
+		this.updater.enqueueSetState(this, partialState, callback, "setState");
+	};
+	Component.prototype.forceUpdate = function(callback) {
+		this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+	};
+	function ComponentDummy() {}
+	ComponentDummy.prototype = Component.prototype;
+	function PureComponent(props, context, updater) {
+		this.props = props;
+		this.context = context;
+		this.refs = emptyObject;
+		this.updater = updater || ReactNoopUpdateQueue;
+	}
+	var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+	pureComponentPrototype.constructor = PureComponent;
+	assign(pureComponentPrototype, Component.prototype);
+	pureComponentPrototype.isPureReactComponent = !0;
+	var isArrayImpl = Array.isArray;
+	function isValidElement(object) {
+		return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+	}
+	exports.isValidElement = isValidElement;
+}));
+
+//#endregion
+//#region ../../../node_modules/.pnpm/react@19.2.4/node_modules/react/cjs/react.development.js
+/**
+* @license React
+* react.development.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	"production" !== process.env.NODE_ENV && (function() {
+		function defineDeprecationWarning(methodName, info) {
+			Object.defineProperty(Component.prototype, methodName, { get: function() {
+				console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+			} });
+		}
+		function getIteratorFn(maybeIterable) {
+			if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+			maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+			return "function" === typeof maybeIterable ? maybeIterable : null;
+		}
+		function warnNoop(publicInstance, callerName) {
+			publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+			var warningKey = publicInstance + "." + callerName;
+			didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = !0);
+		}
+		function Component(props, context, updater) {
+			this.props = props;
+			this.context = context;
+			this.refs = emptyObject;
+			this.updater = updater || ReactNoopUpdateQueue;
+		}
+		function ComponentDummy() {}
+		function PureComponent(props, context, updater) {
+			this.props = props;
+			this.context = context;
+			this.refs = emptyObject;
+			this.updater = updater || ReactNoopUpdateQueue;
+		}
+		function noop() {}
+		function testStringCoercion(value) {
+			return "" + value;
+		}
+		function checkKeyStringCoercion(value) {
+			try {
+				testStringCoercion(value);
+				var JSCompiler_inline_result = !1;
+			} catch (e) {
+				JSCompiler_inline_result = !0;
+			}
+			if (JSCompiler_inline_result) {
+				JSCompiler_inline_result = console;
+				var JSCompiler_temp_const = JSCompiler_inline_result.error;
+				var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+				JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+				return testStringCoercion(value);
+			}
+		}
+		function getComponentNameFromType(type) {
+			if (null == type) return null;
+			if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+			if ("string" === typeof type) return type;
+			switch (type) {
+				case REACT_FRAGMENT_TYPE: return "Fragment";
+				case REACT_PROFILER_TYPE: return "Profiler";
+				case REACT_STRICT_MODE_TYPE: return "StrictMode";
+				case REACT_SUSPENSE_TYPE: return "Suspense";
+				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
+				case REACT_ACTIVITY_TYPE: return "Activity";
+			}
+			if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+				case REACT_PORTAL_TYPE: return "Portal";
+				case REACT_CONTEXT_TYPE: return type.displayName || "Context";
+				case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer";
+				case REACT_FORWARD_REF_TYPE:
+					var innerType = type.render;
+					type = type.displayName;
+					type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+					return type;
+				case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+				case REACT_LAZY_TYPE:
+					innerType = type._payload;
+					type = type._init;
+					try {
+						return getComponentNameFromType(type(innerType));
+					} catch (x) {}
+			}
+			return null;
+		}
+		function getTaskName(type) {
+			if (type === REACT_FRAGMENT_TYPE) return "<>";
+			if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+			try {
+				var name = getComponentNameFromType(type);
+				return name ? "<" + name + ">" : "<...>";
+			} catch (x) {
+				return "<...>";
+			}
+		}
+		function getOwner() {
+			var dispatcher = ReactSharedInternals.A;
+			return null === dispatcher ? null : dispatcher.getOwner();
+		}
+		function UnknownOwner() {
+			return Error("react-stack-top-frame");
+		}
+		function hasValidKey(config) {
+			if (hasOwnProperty.call(config, "key")) {
+				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+				if (getter && getter.isReactWarning) return !1;
+			}
+			return void 0 !== config.key;
+		}
+		function defineKeyPropWarningGetter(props, displayName) {
+			function warnAboutAccessingKey() {
+				specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+			}
+			warnAboutAccessingKey.isReactWarning = !0;
+			Object.defineProperty(props, "key", {
+				get: warnAboutAccessingKey,
+				configurable: !0
+			});
+		}
+		function elementRefGetterWithDeprecationWarning() {
+			var componentName = getComponentNameFromType(this.type);
+			didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+			componentName = this.props.ref;
+			return void 0 !== componentName ? componentName : null;
+		}
+		function ReactElement(type, key, props, owner, debugStack, debugTask) {
+			var refProp = props.ref;
+			type = {
+				$$typeof: REACT_ELEMENT_TYPE,
+				type,
+				key,
+				props,
+				_owner: owner
+			};
+			null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				get: elementRefGetterWithDeprecationWarning
+			}) : Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				value: null
+			});
+			type._store = {};
+			Object.defineProperty(type._store, "validated", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: 0
+			});
+			Object.defineProperty(type, "_debugInfo", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: null
+			});
+			Object.defineProperty(type, "_debugStack", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugStack
+			});
+			Object.defineProperty(type, "_debugTask", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugTask
+			});
+			Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+			return type;
+		}
+		function cloneAndReplaceKey(oldElement, newKey) {
+			newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
+			oldElement._store && (newKey._store.validated = oldElement._store.validated);
+			return newKey;
+		}
+		function validateChildKeys(node) {
+			isValidElement$1(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement$1(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+		}
+		function isValidElement$1(object) {
+			return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		function escape(key) {
+			var escaperLookup = {
+				"=": "=0",
+				":": "=2"
+			};
+			return "$" + key.replace(/[=:]/g, function(match) {
+				return escaperLookup[match];
+			});
+		}
+		function getElementKey(element, index) {
+			return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+		}
+		function resolveThenable(thenable) {
+			switch (thenable.status) {
+				case "fulfilled": return thenable.value;
+				case "rejected": throw thenable.reason;
+				default: switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
+					"pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+				}, function(error) {
+					"pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+				})), thenable.status) {
+					case "fulfilled": return thenable.value;
+					case "rejected": throw thenable.reason;
+				}
+			}
+			throw thenable;
+		}
+		function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+			var type = typeof children;
+			if ("undefined" === type || "boolean" === type) children = null;
+			var invokeCallback = !1;
+			if (null === children) invokeCallback = !0;
+			else switch (type) {
+				case "bigint":
+				case "string":
+				case "number":
+					invokeCallback = !0;
+					break;
+				case "object": switch (children.$$typeof) {
+					case REACT_ELEMENT_TYPE:
+					case REACT_PORTAL_TYPE:
+						invokeCallback = !0;
+						break;
+					case REACT_LAZY_TYPE: return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+				}
+			}
+			if (invokeCallback) {
+				invokeCallback = children;
+				callback = callback(invokeCallback);
+				var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+				isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+					return c;
+				})) : null != callback && (isValidElement$1(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), "" !== nameSoFar && null != invokeCallback && isValidElement$1(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+				return 1;
+			}
+			invokeCallback = 0;
+			childKey = "" === nameSoFar ? "." : nameSoFar + ":";
+			if (isArrayImpl(children)) for (var i = 0; i < children.length; i++) nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+			else if (i = getIteratorFn(children), "function" === typeof i) for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0), children = i.call(children), i = 0; !(nameSoFar = children.next()).done;) nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+			else if ("object" === type) {
+				if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+				array = String(children);
+				throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+			}
+			return invokeCallback;
+		}
+		function mapChildren(children, func, context) {
+			if (null == children) return children;
+			var result = [], count = 0;
+			mapIntoArray(children, result, "", "", function(child) {
+				return func.call(context, child, count++);
+			});
+			return result;
+		}
+		function lazyInitializer(payload) {
+			if (-1 === payload._status) {
+				var ioInfo = payload._ioInfo;
+				null != ioInfo && (ioInfo.start = ioInfo.end = performance.now());
+				ioInfo = payload._result;
+				var thenable = ioInfo();
+				thenable.then(function(moduleObject) {
+					if (0 === payload._status || -1 === payload._status) {
+						payload._status = 1;
+						payload._result = moduleObject;
+						var _ioInfo = payload._ioInfo;
+						null != _ioInfo && (_ioInfo.end = performance.now());
+						void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
+					}
+				}, function(error) {
+					if (0 === payload._status || -1 === payload._status) {
+						payload._status = 2;
+						payload._result = error;
+						var _ioInfo2 = payload._ioInfo;
+						null != _ioInfo2 && (_ioInfo2.end = performance.now());
+						void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+					}
+				});
+				ioInfo = payload._ioInfo;
+				if (null != ioInfo) {
+					ioInfo.value = thenable;
+					var displayName = thenable.displayName;
+					"string" === typeof displayName && (ioInfo.name = displayName);
+				}
+				-1 === payload._status && (payload._status = 0, payload._result = thenable);
+			}
+			if (1 === payload._status) return ioInfo = payload._result, void 0 === ioInfo && console.error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?", ioInfo), "default" in ioInfo || console.error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))", ioInfo), ioInfo.default;
+			throw payload._result;
+		}
+		function resolveDispatcher() {
+			var dispatcher = ReactSharedInternals.H;
+			null === dispatcher && console.error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+			return dispatcher;
+		}
+		function releaseAsyncTransition() {
+			ReactSharedInternals.asyncTransitions--;
+		}
+		function enqueueTask(task) {
+			if (null === enqueueTaskImpl) try {
+				var requireString = ("require" + Math.random()).slice(0, 7);
+				enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
+			} catch (_err) {
+				enqueueTaskImpl = function(callback) {
+					!1 === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = !0, "undefined" === typeof MessageChannel && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+					var channel = new MessageChannel();
+					channel.port1.onmessage = callback;
+					channel.port2.postMessage(void 0);
+				};
+			}
+			return enqueueTaskImpl(task);
+		}
+		function aggregateErrors(errors) {
+			return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
+		}
+		function popActScope(prevActQueue, prevActScopeDepth) {
+			prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
+			actScopeDepth = prevActScopeDepth;
+		}
+		function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+			var queue = ReactSharedInternals.actQueue;
+			if (null !== queue) if (0 !== queue.length) try {
+				flushActQueue(queue);
+				enqueueTask(function() {
+					return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+				});
+				return;
+			} catch (error) {
+				ReactSharedInternals.thrownErrors.push(error);
+			}
+			else ReactSharedInternals.actQueue = null;
+			0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+		}
+		function flushActQueue(queue) {
+			if (!isFlushing) {
+				isFlushing = !0;
+				var i = 0;
+				try {
+					for (; i < queue.length; i++) {
+						var callback = queue[i];
+						do {
+							ReactSharedInternals.didUsePromise = !1;
+							var continuation = callback(!1);
+							if (null !== continuation) {
+								if (ReactSharedInternals.didUsePromise) {
+									queue[i] = callback;
+									queue.splice(0, i);
+									return;
+								}
+								callback = continuation;
+							} else break;
+						} while (1);
+					}
+					queue.length = 0;
+				} catch (error) {
+					queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+				} finally {
+					isFlushing = !1;
+				}
+			}
+		}
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+		var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+			isMounted: function() {
+				return !1;
+			},
+			enqueueForceUpdate: function(publicInstance) {
+				warnNoop(publicInstance, "forceUpdate");
+			},
+			enqueueReplaceState: function(publicInstance) {
+				warnNoop(publicInstance, "replaceState");
+			},
+			enqueueSetState: function(publicInstance) {
+				warnNoop(publicInstance, "setState");
+			}
+		}, assign = Object.assign, emptyObject = {};
+		Object.freeze(emptyObject);
+		Component.prototype.isReactComponent = {};
+		Component.prototype.setState = function(partialState, callback) {
+			if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
+			this.updater.enqueueSetState(this, partialState, callback, "setState");
+		};
+		Component.prototype.forceUpdate = function(callback) {
+			this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+		};
+		var deprecatedAPIs = {
+			isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
+			replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
+		};
+		for (fnName in deprecatedAPIs) deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+		ComponentDummy.prototype = Component.prototype;
+		deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
+		deprecatedAPIs.constructor = PureComponent;
+		assign(deprecatedAPIs, Component.prototype);
+		deprecatedAPIs.isPureReactComponent = !0;
+		var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
+			H: null,
+			A: null,
+			T: null,
+			S: null,
+			actQueue: null,
+			asyncTransitions: 0,
+			isBatchingLegacy: !1,
+			didScheduleLegacyUpdate: !1,
+			didUsePromise: !1,
+			thrownErrors: [],
+			getCurrentStack: null,
+			recentlyCreatedOwnerStacks: 0
+		}, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+			return null;
+		};
+		deprecatedAPIs = { react_stack_bottom_frame: function(callStackForError) {
+			return callStackForError();
+		} };
+		var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+		var didWarnAboutElementRef = {};
+		var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
+		var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+		var didWarnAboutMaps = !1, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
+			if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+				var event = new window.ErrorEvent("error", {
+					bubbles: !0,
+					cancelable: !0,
+					message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+					error
+				});
+				if (!window.dispatchEvent(event)) return;
+			} else if ("object" === typeof process && "function" === typeof process.emit) {
+				process.emit("uncaughtException", error);
+				return;
+			}
+			console.error(error);
+		}, didWarnAboutMessageChannel = !1, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = !1, isFlushing = !1, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
+			queueMicrotask(function() {
+				return queueMicrotask(callback);
+			});
+		} : enqueueTask;
+		deprecatedAPIs = Object.freeze({
+			__proto__: null,
+			c: function(size) {
+				return resolveDispatcher().useMemoCache(size);
+			}
+		});
+		var fnName = {
+			map: mapChildren,
+			forEach: function(children, forEachFunc, forEachContext) {
+				mapChildren(children, function() {
+					forEachFunc.apply(this, arguments);
+				}, forEachContext);
+			},
+			count: function(children) {
+				var n = 0;
+				mapChildren(children, function() {
+					n++;
+				});
+				return n;
+			},
+			toArray: function(children) {
+				return mapChildren(children, function(child) {
+					return child;
+				}) || [];
+			},
+			only: function(children) {
+				if (!isValidElement$1(children)) throw Error("React.Children.only expected to receive a single React element child.");
+				return children;
+			}
+		};
+		exports.Activity = REACT_ACTIVITY_TYPE;
+		exports.Children = fnName;
+		exports.Component = Component;
+		exports.Fragment = REACT_FRAGMENT_TYPE;
+		exports.Profiler = REACT_PROFILER_TYPE;
+		exports.PureComponent = PureComponent;
+		exports.StrictMode = REACT_STRICT_MODE_TYPE;
+		exports.Suspense = REACT_SUSPENSE_TYPE;
+		exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+		exports.__COMPILER_RUNTIME = deprecatedAPIs;
+		exports.act = function(callback) {
+			var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+			actScopeDepth++;
+			var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = !1;
+			try {
+				var result = callback();
+			} catch (error) {
+				ReactSharedInternals.thrownErrors.push(error);
+			}
+			if (0 < ReactSharedInternals.thrownErrors.length) throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+			if (null !== result && "object" === typeof result && "function" === typeof result.then) {
+				var thenable = result;
+				queueSeveralMicrotasks(function() {
+					didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+				});
+				return { then: function(resolve, reject) {
+					didAwaitActCall = !0;
+					thenable.then(function(returnValue) {
+						popActScope(prevActQueue, prevActScopeDepth);
+						if (0 === prevActScopeDepth) {
+							try {
+								flushActQueue(queue), enqueueTask(function() {
+									return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+								});
+							} catch (error$0) {
+								ReactSharedInternals.thrownErrors.push(error$0);
+							}
+							if (0 < ReactSharedInternals.thrownErrors.length) {
+								var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+								ReactSharedInternals.thrownErrors.length = 0;
+								reject(_thrownError);
+							}
+						} else resolve(returnValue);
+					}, function(error) {
+						popActScope(prevActQueue, prevActScopeDepth);
+						0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+					});
+				} };
+			}
+			var returnValue$jscomp$0 = result;
+			popActScope(prevActQueue, prevActScopeDepth);
+			0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
+				didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
+			}), ReactSharedInternals.actQueue = null);
+			if (0 < ReactSharedInternals.thrownErrors.length) throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+			return { then: function(resolve, reject) {
+				didAwaitActCall = !0;
+				0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+					return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
+				})) : resolve(returnValue$jscomp$0);
+			} };
+		};
+		exports.cache = function(fn) {
+			return function() {
+				return fn.apply(null, arguments);
+			};
+		};
+		exports.cacheSignal = function() {
+			return null;
+		};
+		exports.captureOwnerStack = function() {
+			var getCurrentStack = ReactSharedInternals.getCurrentStack;
+			return null === getCurrentStack ? null : getCurrentStack();
+		};
+		exports.cloneElement = function(element, config, children) {
+			if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + ".");
+			var props = assign({}, element.props), key = element.key, owner = element._owner;
+			if (null != config) {
+				var JSCompiler_inline_result;
+				a: {
+					if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
+						JSCompiler_inline_result = !1;
+						break a;
+					}
+					JSCompiler_inline_result = void 0 !== config.ref;
+				}
+				JSCompiler_inline_result && (owner = getOwner());
+				hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+				for (propName in config) !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+			}
+			var propName = arguments.length - 2;
+			if (1 === propName) props.children = children;
+			else if (1 < propName) {
+				JSCompiler_inline_result = Array(propName);
+				for (var i = 0; i < propName; i++) JSCompiler_inline_result[i] = arguments[i + 2];
+				props.children = JSCompiler_inline_result;
+			}
+			props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
+			for (key = 2; key < arguments.length; key++) validateChildKeys(arguments[key]);
+			return props;
+		};
+		exports.createContext = function(defaultValue) {
+			defaultValue = {
+				$$typeof: REACT_CONTEXT_TYPE,
+				_currentValue: defaultValue,
+				_currentValue2: defaultValue,
+				_threadCount: 0,
+				Provider: null,
+				Consumer: null
+			};
+			defaultValue.Provider = defaultValue;
+			defaultValue.Consumer = {
+				$$typeof: REACT_CONSUMER_TYPE,
+				_context: defaultValue
+			};
+			defaultValue._currentRenderer = null;
+			defaultValue._currentRenderer2 = null;
+			return defaultValue;
+		};
+		exports.createElement = function(type, config, children) {
+			for (var i = 2; i < arguments.length; i++) validateChildKeys(arguments[i]);
+			i = {};
+			var key = null;
+			if (null != config) for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = !0, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config) hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
+			var childrenLength = arguments.length - 2;
+			if (1 === childrenLength) i.children = children;
+			else if (1 < childrenLength) {
+				for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++) childArray[_i] = arguments[_i + 2];
+				Object.freeze && Object.freeze(childArray);
+				i.children = childArray;
+			}
+			if (type && type.defaultProps) for (propName in childrenLength = type.defaultProps, childrenLength) void 0 === i[propName] && (i[propName] = childrenLength[propName]);
+			key && defineKeyPropWarningGetter(i, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+			var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+		exports.createRef = function() {
+			var refObject = { current: null };
+			Object.seal(refObject);
+			return refObject;
+		};
+		exports.forwardRef = function(render) {
+			null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : "function" !== typeof render ? console.error("forwardRef requires a render function but was given %s.", null === render ? "null" : typeof render) : 0 !== render.length && 2 !== render.length && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", 1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+			null != render && null != render.defaultProps && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
+			var elementType = {
+				$$typeof: REACT_FORWARD_REF_TYPE,
+				render
+			}, ownName;
+			Object.defineProperty(elementType, "displayName", {
+				enumerable: !1,
+				configurable: !0,
+				get: function() {
+					return ownName;
+				},
+				set: function(name) {
+					ownName = name;
+					render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+				}
+			});
+			return elementType;
+		};
+		exports.isValidElement = isValidElement$1;
+		exports.lazy = function(ctor) {
+			ctor = {
+				_status: -1,
+				_result: ctor
+			};
+			var lazyType = {
+				$$typeof: REACT_LAZY_TYPE,
+				_payload: ctor,
+				_init: lazyInitializer
+			}, ioInfo = {
+				name: "lazy",
+				start: -1,
+				end: -1,
+				value: null,
+				owner: null,
+				debugStack: Error("react-stack-top-frame"),
+				debugTask: console.createTask ? console.createTask("lazy()") : null
+			};
+			ctor._ioInfo = ioInfo;
+			lazyType._debugInfo = [{ awaited: ioInfo }];
+			return lazyType;
+		};
+		exports.memo = function(type, compare) {
+			type ?? console.error("memo: The first argument must be a component. Instead received: %s", null === type ? "null" : typeof type);
+			compare = {
+				$$typeof: REACT_MEMO_TYPE,
+				type,
+				compare: void 0 === compare ? null : compare
+			};
+			var ownName;
+			Object.defineProperty(compare, "displayName", {
+				enumerable: !1,
+				configurable: !0,
+				get: function() {
+					return ownName;
+				},
+				set: function(name) {
+					ownName = name;
+					type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+				}
+			});
+			return compare;
+		};
+		exports.startTransition = function(scope) {
+			var prevTransition = ReactSharedInternals.T, currentTransition = {};
+			currentTransition._updatedFibers = /* @__PURE__ */ new Set();
+			ReactSharedInternals.T = currentTransition;
+			try {
+				var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+				null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+				"object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+			} catch (error) {
+				reportGlobalError(error);
+			} finally {
+				null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+			}
+		};
+		exports.unstable_useCacheRefresh = function() {
+			return resolveDispatcher().useCacheRefresh();
+		};
+		exports.use = function(usable) {
+			return resolveDispatcher().use(usable);
+		};
+		exports.useActionState = function(action, initialState, permalink) {
+			return resolveDispatcher().useActionState(action, initialState, permalink);
+		};
+		exports.useCallback = function(callback, deps) {
+			return resolveDispatcher().useCallback(callback, deps);
+		};
+		exports.useContext = function(Context) {
+			var dispatcher = resolveDispatcher();
+			Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
+			return dispatcher.useContext(Context);
+		};
+		exports.useDebugValue = function(value, formatterFn) {
+			return resolveDispatcher().useDebugValue(value, formatterFn);
+		};
+		exports.useDeferredValue = function(value, initialValue) {
+			return resolveDispatcher().useDeferredValue(value, initialValue);
+		};
+		exports.useEffect = function(create, deps) {
+			create ?? console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+			return resolveDispatcher().useEffect(create, deps);
+		};
+		exports.useEffectEvent = function(callback) {
+			return resolveDispatcher().useEffectEvent(callback);
+		};
+		exports.useId = function() {
+			return resolveDispatcher().useId();
+		};
+		exports.useImperativeHandle = function(ref, create, deps) {
+			return resolveDispatcher().useImperativeHandle(ref, create, deps);
+		};
+		exports.useInsertionEffect = function(create, deps) {
+			create ?? console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+			return resolveDispatcher().useInsertionEffect(create, deps);
+		};
+		exports.useLayoutEffect = function(create, deps) {
+			create ?? console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+			return resolveDispatcher().useLayoutEffect(create, deps);
+		};
+		exports.useMemo = function(create, deps) {
+			return resolveDispatcher().useMemo(create, deps);
+		};
+		exports.useOptimistic = function(passthrough, reducer) {
+			return resolveDispatcher().useOptimistic(passthrough, reducer);
+		};
+		exports.useReducer = function(reducer, initialArg, init) {
+			return resolveDispatcher().useReducer(reducer, initialArg, init);
+		};
+		exports.useRef = function(initialValue) {
+			return resolveDispatcher().useRef(initialValue);
+		};
+		exports.useState = function(initialState) {
+			return resolveDispatcher().useState(initialState);
+		};
+		exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+			return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+		};
+		exports.useTransition = function() {
+			return resolveDispatcher().useTransition();
+		};
+		exports.version = "19.2.4";
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	})();
+}));
+
+//#endregion
+//#region ../../../node_modules/.pnpm/react@19.2.4/node_modules/react/index.js
+var require_react = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_react_production();
+	else module.exports = require_react_development();
+}));
+
+//#endregion
+//#region src/commands/generate/utils/intl.ts
+var import_react = require_react();
+function isFormattedMessageElement(node) {
+	return (0, import_react.isValidElement)(node) && node.type === FormattedMessage;
+}
+/**
+* Generates a <FormattedMessage> JSX element or an intl.formatMessage call string supporting <FormattedMessage> config objects.
+*
+* either config or defaultMessage is required
+*/
+const generateFormattedMessage = (options) => {
+	let id = options.id;
+	let defaultMessage = "";
+	if ("defaultMessage" in options) defaultMessage = options.defaultMessage;
+	if (isFormattedMessageElement(options.config)) {
+		if (!options.config.props.id) throw new Error("FormattedMessage requires an id");
+		id = options.config.props.id;
+		if (!options.config.props.defaultMessage) throw new Error("FormattedMessage requires an defaultMessage");
+		if (typeof options.config.props.defaultMessage !== "string") throw new Error("FormattedMessage requires a string defaultMessage");
+		defaultMessage = options.config.props.defaultMessage;
+	} else if (typeof options.config === "string") defaultMessage = options.config;
+	if (options.type === "jsx") return `<FormattedMessage id=${JSON.stringify(id)} defaultMessage=${JSON.stringify(defaultMessage)} />`;
+	else return `intl.formatMessage({ id: ${JSON.stringify(id)}, defaultMessage: ${JSON.stringify(defaultMessage)} })`;
+};
+
+//#endregion
+//#region src/commands/generate/utils/isFieldOptional.ts
+const isFieldOptional = ({ config, gqlIntrospection, gqlType }) => {
+	if (config.required !== void 0) return !config.required;
+	if (config.readOnly) return true;
+	const schemaEntity = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+	if (!schemaEntity) throw new Error(`didn't find entity ${gqlType} in schema types`);
+	if (schemaEntity.kind !== "OBJECT") throw new Error(`kind of ${gqlType} is not object, but should be.`);
+	const fieldDef = schemaEntity.fields.find((field) => field.name === String(config.name));
+	if (!fieldDef) return false;
+	return fieldDef.type.kind !== "NON_NULL";
+};
+
+//#endregion
+//#region src/commands/generate/utils/findQueryType.ts
+function findQueryType(queryName, schema) {
+	const queryType = schema.__schema.types.find((type) => type.name === schema.__schema.queryType.name);
+	if (!queryType) throw new Error("Can't find Query type in gql schema");
+	const ret = queryType.fields.find((field) => field.name === queryName);
+	if (!ret) throw new Error(`Can't find query ${queryName} in gql schema`);
+	return ret;
+}
+function findQueryTypeOrThrow(queryName, schema) {
+	const ret = findQueryType(queryName, schema);
+	if (!ret) throw new Error(`Can't find query ${queryName} in gql schema`);
+	return ret;
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/formField/options.ts
+const buildAdornmentData = ({ adornmentData }) => {
+	let adornmentString = "";
+	let adornmentImport = {
+		name: "",
+		importPath: ""
+	};
+	if (typeof adornmentData === "string") return { adornmentString: adornmentData };
+	if (typeof adornmentData.icon === "string") {
+		adornmentString = `<${adornmentData.icon}Icon />`;
+		adornmentImport = {
+			name: `${adornmentData.icon} as ${adornmentData.icon}Icon`,
+			importPath: "@comet/admin-icons"
+		};
+	} else if (typeof adornmentData.icon === "object") if (isGeneratorConfigImport(adornmentData.icon)) {
+		adornmentString = `<${adornmentData.icon.name} />`;
+		adornmentImport = convertConfigImport(adornmentData.icon);
+	} else {
+		const { name, ...iconProps } = adornmentData.icon;
+		adornmentString = `<${name}Icon
+                ${Object.entries(iconProps).map(([key, value]) => `${key}="${value}"`).join("\n")}
+            />`;
+		adornmentImport = {
+			name: `${adornmentData.icon.name} as ${adornmentData.icon.name}Icon`,
+			importPath: "@comet/admin-icons"
+		};
+	}
+	return {
+		adornmentString,
+		adornmentImport
+	};
+};
+/**
+* Helper function that builds various options needed for generating form fields.
+*/
+function buildFormFieldOptions({ config, formConfig }) {
+	const rootGqlType = formConfig.gqlType;
+	const name = String(config.name);
+	const formattedMessageRootId = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
+	const fieldLabel = generateFormattedMessage({
+		config: config.label,
+		id: `${formattedMessageRootId}.${name}`,
+		defaultMessage: camelCaseToHumanReadable(name),
+		type: "jsx"
+	});
+	const imports = [];
+	let startAdornment = { adornmentString: "" };
+	let endAdornment = { adornmentString: "" };
+	if ("startAdornment" in config && config.startAdornment) {
+		startAdornment = buildAdornmentData({ adornmentData: config.startAdornment });
+		if (startAdornment.adornmentImport) imports.push(startAdornment.adornmentImport);
+	}
+	if ("endAdornment" in config && config.endAdornment) {
+		endAdornment = buildAdornmentData({ adornmentData: config.endAdornment });
+		if (endAdornment.adornmentImport) imports.push(endAdornment.adornmentImport);
+	}
+	return {
+		name,
+		formattedMessageRootId,
+		fieldLabel,
+		startAdornment,
+		endAdornment,
+		imports
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/asyncSelect/generateAsyncSelect.ts
+function gqlScalarToTypescriptType(scalarName) {
+	if (scalarName === "String" || scalarName === "ID" || scalarName === "DateTime" || scalarName === "LocalDate" || scalarName === "Date") return "string";
+	else if (scalarName === "Boolean") return "boolean";
+	else if (scalarName === "Int" || scalarName === "Float") return "number";
+	else if (scalarName === "JSONObject") return "unknown";
+	else return "unknown";
+}
+function buildTypeInfo(arg, gqlIntrospection) {
+	let typeKind = void 0;
+	let typeClass = "unknown";
+	let required = false;
+	let type = arg.type;
+	let inputType = void 0;
+	if (type.kind === "NON_NULL") {
+		required = true;
+		type = type.ofType;
+	}
+	if (type.kind === "INPUT_OBJECT") {
+		typeClass = type.name;
+		typeKind = type.kind;
+		inputType = gqlIntrospection.__schema.types.find((type$1) => type$1.name === typeClass);
+	} else if (type.kind === "ENUM") {
+		typeClass = type.name;
+		typeKind = type.kind;
+	} else if (type.kind === "SCALAR") {
+		typeClass = type.name;
+		typeKind = type.kind;
+	} else throw new Error(`getTypeInfo: Resolving kind ${type.kind} currently not supported.`);
+	return {
+		required,
+		typeKind,
+		typeClass,
+		inputType
+	};
+}
+/**
+* Helper that returns the introspection object type for a given form field config, supporting the special case for asyncSelectFilter
+*/
+function findIntrospectionObjectType({ config, gqlIntrospection, gqlType }) {
+	const name = String(config.name);
+	const introspectionObject = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+	if (!introspectionObject) throw new Error(`didn't find object ${gqlType} in gql introspection`);
+	function findIntrospectionField(introspectionObject$1, name$1) {
+		const introspectionField = introspectionObject$1.fields.find((field) => field.name === name$1);
+		if (!introspectionField) throw new Error(`didn't find field ${name$1} in gql introspection type ${gqlType}`);
+		let introspectionFieldType = introspectionField.type.kind === "NON_NULL" ? introspectionField.type.ofType : introspectionField.type;
+		const multiple = introspectionFieldType?.kind === "LIST";
+		if (introspectionFieldType?.kind === "LIST") introspectionFieldType = introspectionFieldType.ofType.kind === "NON_NULL" ? introspectionFieldType.ofType.ofType : introspectionFieldType.ofType;
+		if (introspectionFieldType.kind !== "OBJECT") throw new Error(`asyncSelect only supports OBJECT types`);
+		const objectType = gqlIntrospection.__schema.types.find((t) => t.kind === "OBJECT" && t.name === introspectionFieldType.name);
+		if (!objectType) throw new Error(`Object type ${introspectionFieldType.name} not found for field ${name$1}`);
+		return {
+			multiple,
+			objectType
+		};
+	}
+	if (config.type === "asyncSelectFilter") return {
+		multiple: false,
+		objectType: config.loadValueQueryField.split(".").reduce((acc, fieldName) => {
+			const introspectionField = findIntrospectionField(acc, fieldName);
+			if (introspectionField.multiple) throw new Error(`asyncSelectFilter does not support list fields in loadValueQueryField`);
+			return introspectionField.objectType;
+		}, introspectionObject)
+	};
+	else return findIntrospectionField(introspectionObject, name);
+}
+function generateAsyncSelect({ gqlIntrospection, baseOutputFilename, config, formConfig, gqlType, namePrefix }) {
+	const imports = [];
+	const formProps = [];
+	const { name, fieldLabel, startAdornment, imports: optionsImports } = buildFormFieldOptions({
+		config,
+		formConfig
+	});
+	imports.push(...optionsImports);
+	const nameWithPrefix = `${namePrefix ? `${namePrefix}.` : ``}${name}`;
+	const required = !isFieldOptional({
+		config,
+		gqlIntrospection,
+		gqlType
+	});
+	const formValueConfig = {
+		fieldName: name,
+		destructFromFormValues: config.type == "asyncSelectFilter"
+	};
+	let finalFormConfig;
+	let code = "";
+	const { objectType, multiple } = findIntrospectionObjectType({
+		config,
+		gqlIntrospection,
+		gqlType
+	});
+	let labelField = config.labelField;
+	if (!labelField) labelField = objectType.fields.find((field) => {
+		let type = field.type;
+		if (type.kind == "NON_NULL") type = type.ofType;
+		if ((field.name == "name" || field.name == "title") && type.kind == "SCALAR" && type.name == "String") return true;
+	})?.name;
+	if (!labelField) labelField = objectType.fields.find((field) => {
+		let type = field.type;
+		if (type.kind == "NON_NULL") type = type.ofType;
+		if (field.type.kind == "SCALAR" && field.type.name == "String") return true;
+	})?.name;
+	const rootQuery = config.rootQuery;
+	const queryName = `${rootQuery[0].toUpperCase() + rootQuery.substring(1)}Select`;
+	const rootQueryType = findQueryTypeOrThrow(rootQuery, gqlIntrospection);
+	let formFragmentFields;
+	if (config.type == "asyncSelectFilter") formFragmentFields = [`${config.loadValueQueryField}.id`, `${config.loadValueQueryField}.${labelField}`];
+	else formFragmentFields = [`${name}.id`, `${name}.${labelField}`];
+	const rootQueryHasSearchArg = rootQueryType.args.find((arg) => arg.name === "search");
+	const useAutocomplete = config.autocomplete ?? !!rootQueryHasSearchArg;
+	if (useAutocomplete) {
+		if (!rootQueryHasSearchArg) throw new Error(`Field ${String(config.name)}: Autocomplete is enabled but root query "${rootQuery}" has no search argument.`);
+		if (rootQueryHasSearchArg.type.kind !== "SCALAR" || rootQueryHasSearchArg.type.name !== "String") throw new Error(`Field ${String(config.name)}: Autocomplete is enabled but root query "${rootQuery}" has search argument that is not a string.`);
+	}
+	const filterConfig = config.filter ? (() => {
+		let filterField;
+		let rootQueryArg = config.filter.rootQueryArg;
+		let filterVar = "";
+		if (config.filter.type === "field") {
+			filterField = findFieldByName(config.filter.formFieldName, formConfig.fields);
+			if (!filterField) throw new Error(`Field ${String(config.name)}: No field with name "${config.filter.formFieldName}" referenced as filter.formFieldName found in form-config.`);
+			if (!isFormFieldConfig(filterField)) throw new Error(`Field ${String(config.name)}: Field with name "${config.filter.formFieldName}" referenced as filter.formFieldName is no FormField.`);
+			filterVar = `values.${filterField.type === "asyncSelect" || filterField.type === "asyncSelectFilter" ? `${String(filterField.name)}?.id` : String(filterField.name)}`;
+			if (!rootQueryArg) rootQueryArg = config.filter.formFieldName;
+		} else if (config.filter.type === "formProp") {
+			filterVar = config.filter.propName;
+			if (!rootQueryArg) rootQueryArg = config.filter.propName;
+		} else throw new Error("unsupported filter type");
+		const rootArgForName = rootQueryType.args.find((arg) => arg.name === rootQueryArg);
+		let filterType = rootArgForName ? buildTypeInfo(rootArgForName, gqlIntrospection) : void 0;
+		let filterVarName = void 0;
+		let filterVarValue = void 0;
+		let filterVarType = "unknown";
+		if (filterType) {
+			filterVarName = rootQueryArg;
+			filterVarValue = filterVar;
+			if (filterType.typeKind === "INPUT_OBJECT" || filterType.typeKind === "ENUM") {
+				filterVarType = `GQL${filterType.typeClass}`;
+				imports.push({
+					name: filterVarType,
+					importPath: "@src/graphql.generated"
+				});
+			} else if (filterType.typeKind === "SCALAR") filterVarType = gqlScalarToTypescriptType(filterType.typeClass);
+		} else {
+			const rootArgFilter = rootQueryType.args.find((arg) => arg.name === "filter");
+			filterType = rootArgFilter ? buildTypeInfo(rootArgFilter, gqlIntrospection) : void 0;
+			if (filterType) {
+				filterVarName = "filter";
+				filterVarValue = `{ ${rootQueryArg}: { equal: ${filterVar} } }`;
+				if (filterType.inputType?.kind !== "INPUT_OBJECT") throw new Error(`Field ${String(config.name)}: Type of filter is no object-type.`);
+				const nestedFilterInput = filterType.inputType.inputFields.find((inputField) => inputField.name === rootQueryArg);
+				if (!nestedFilterInput) throw new Error(`Field ${String(config.name)}: Field filter.${rootQueryArg} does not exist`);
+				const gqlFilterInputType = buildTypeInfo(nestedFilterInput, gqlIntrospection);
+				if (!gqlFilterInputType?.inputType || gqlFilterInputType.inputType.kind !== "INPUT_OBJECT") throw new Error(`Field ${String(config.name)}: Type of filter.${rootQueryArg} is no object-type, but needs to be e.g. StringFilter-type.`);
+				const gqlFilterEqualInputType = gqlFilterInputType.inputType.inputFields.find((inputField) => inputField.name === "equal");
+				if (!gqlFilterEqualInputType) throw new Error(`Field ${String(config.name)}: Field filter.${rootQueryArg}.equal does not exist`);
+				const equalFieldType = buildTypeInfo(gqlFilterEqualInputType, gqlIntrospection);
+				if (!equalFieldType) throw new Error(`Field ${String(config.name)}: Field filter.${rootQueryArg}.equal does not exist but is required for filtering.`);
+				if (equalFieldType.typeKind === "INPUT_OBJECT" || equalFieldType.typeKind === "ENUM") {
+					filterVarType = `GQL${equalFieldType.typeClass}`;
+					imports.push({
+						name: filterVarType,
+						importPath: "@src/graphql.generated"
+					});
+				} else if (equalFieldType.typeKind === "SCALAR") filterVarType = gqlScalarToTypescriptType(equalFieldType.typeClass);
+			} else throw new Error(`Neither filter-prop nor root-prop with name: ${rootQueryArg} for asyncSelect-query not found. Consider setting filterField.gqlVarName explicitly.`);
+		}
+		if (config.filter.type === "formProp") formProps.push({
+			name: config.filter.propName,
+			optional: false,
+			type: filterVarType
+		});
+		return {
+			filterField,
+			filterType,
+			filterVarName,
+			filterVarValue
+		};
+	})() : void 0;
+	if (filterConfig) {
+		imports.push({
+			name: "OnChangeField",
+			importPath: "@comet/admin"
+		});
+		finalFormConfig = {
+			subscription: { values: true },
+			renderProps: {
+				values: true,
+				form: true
+			}
+		};
+	}
+	if (config.type != "asyncSelectFilter") if (!multiple) if (!required) formValueConfig.formValueToGqlInputCode = `$fieldName ? $fieldName.id : null`;
+	else formValueConfig.formValueToGqlInputCode = `$fieldName?.id`;
+	else formValueConfig.formValueToGqlInputCode = `$fieldName.map((item) => item.id)`;
+	imports.push({
+		name: `GQL${queryName}Query`,
+		importPath: `./${baseOutputFilename}.generated`
+	});
+	imports.push({
+		name: `GQL${queryName}QueryVariables`,
+		importPath: `./${baseOutputFilename}.generated`
+	});
+	if (useAutocomplete) imports.push({
+		name: "AsyncAutocompleteField",
+		importPath: "@comet/admin"
+	});
+	else imports.push({
+		name: "AsyncSelectField",
+		importPath: "@comet/admin"
+	});
+	const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
+	if (config.type == "asyncSelectFilter") {
+		formValueConfig.typeCode = {
+			nullable: true,
+			type: `{ id: string; ${labelField}: string }`
+		};
+		formValueConfig.initializationCode = `data.${instanceGqlType}.${config.loadValueQueryField.replace(/\./g, "?.")}`;
+	}
+	code = `<${useAutocomplete ? "AsyncAutocompleteField" : "AsyncSelectField"}
+                ${required ? "required" : ""}
+                variant="horizontal"
+                fullWidth
+                ${config.readOnly ? "readOnly disabled" : ""}
+                ${multiple ? "multiple" : ""}
+                name="${nameWithPrefix}"
+                label={${fieldLabel}}
+                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+                loadOptions={async (${useAutocomplete ? `search?: string` : ""}) => {
+                    const { data } = await client.query<GQL${queryName}Query, GQL${queryName}QueryVariables>({
+                        query: gql\`${generateGqlOperation({
+		type: "query",
+		operationName: queryName,
+		rootOperation: rootQuery,
+		fields: ["nodes.id", `nodes.${labelField}`],
+		variables: [useAutocomplete ? {
+			name: "search",
+			type: "String"
+		} : void 0, filterConfig ? {
+			name: filterConfig.filterVarName,
+			type: filterConfig.filterType.typeClass + (filterConfig.filterType.required ? `!` : ``)
+		} : void 0].filter((v) => v !== void 0)
+	})}\`${filterConfig || useAutocomplete ? ", variables: { " : ""}
+                            ${filterConfig ? `${filterConfig.filterVarName}: ${filterConfig.filterVarValue},` : ``}
+                            ${useAutocomplete ? `search,` : ``}
+                        ${filterConfig || useAutocomplete ? " }" : ""}
+                    });
+                    return data.${rootQuery}.nodes;
+                }}
+                getOptionLabel={(option) => option.${labelField}}
+                ${filterConfig?.filterField ? `disabled={!values?.${String(filterConfig.filterField.name)}}` : ``}
+            />${filterConfig?.filterField ? `<OnChangeField name="${String(filterConfig.filterField.name)}">
+                            {(value, previousValue) => {
+                                if (value.id !== previousValue.id) {
+                                    form.change("${String(config.name)}", undefined);
+                                }
+                            }}
+                        </OnChangeField>` : ``}`;
+	return {
+		code,
+		hooksCode: "",
+		formFragmentFields,
+		gqlDocuments: {},
+		imports,
+		formProps,
+		formValuesConfig: [formValueConfig],
+		finalFormConfig
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/formField/findIntrospectionFieldType.ts
+function findIntrospectionFieldType({ name, gqlType, gqlIntrospection }) {
+	let introspectionFieldType;
+	for (const namePart of name.split(".")) {
+		const introspectionObject = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+		if (!introspectionObject) throw new Error(`didn't find object ${gqlType} in gql introspection`);
+		const introspectionField = introspectionObject.fields.find((field) => field.name === namePart);
+		introspectionFieldType = introspectionField ? introspectionField.type.kind === "NON_NULL" ? introspectionField.type.ofType : introspectionField.type : void 0;
+		if (introspectionFieldType?.kind === "OBJECT") gqlType = introspectionFieldType.name;
+	}
+	return introspectionFieldType;
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateFormField.ts
+function generateFormField({ gqlIntrospection, baseOutputFilename, config, formConfig, gqlType, namePrefix }) {
+	if (config.type == "asyncSelect" || config.type == "asyncSelectFilter") return generateAsyncSelect({
+		gqlIntrospection,
+		baseOutputFilename,
+		config,
+		formConfig,
+		gqlType,
+		namePrefix
+	});
+	const imports = [];
+	const formProps = [];
+	const { name, formattedMessageRootId, fieldLabel, startAdornment, endAdornment, imports: optionsImports } = buildFormFieldOptions({
+		config,
+		formConfig
+	});
+	imports.push(...optionsImports);
+	let introspectionFieldType = findIntrospectionFieldType({
+		name,
+		gqlIntrospection,
+		gqlType
+	});
+	const nameWithPrefix = `${namePrefix ? `${namePrefix}.` : ``}${name}`;
+	const rootGqlType = formConfig.gqlType;
+	const dataRootName = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
+	const required = !isFieldOptional({
+		config,
+		gqlIntrospection,
+		gqlType
+	});
+	const endAdornmentWithLockIconProp = `endAdornment={<InputAdornment position="end"><Lock /></InputAdornment>}`;
+	const readOnlyProps = `readOnly disabled`;
+	const readOnlyPropsWithLock = `${readOnlyProps} ${endAdornmentWithLockIconProp}`;
+	const formValueConfig = { fieldName: nameWithPrefix };
+	const gqlDocuments = {};
+	const hooksCode = "";
+	let finalFormConfig;
+	let validateCode = "";
+	if (config.validate) {
+		if (isGeneratorConfigImport(config.validate)) {
+			imports.push(convertConfigImport(config.validate));
+			validateCode = `validate={${config.validate.name}}`;
+		} else if (isGeneratorConfigCode(config.validate)) {
+			validateCode = `validate={${config.validate.code}}`;
+			imports.push(...config.validate.imports.map((imprt) => convertConfigImport(imprt)));
+		}
+	}
+	let code = "";
+	let formFragmentFields = [name];
+	if (config.type == "text") {
+		code = `
+        <${config.multiline ? "TextAreaField" : "TextField"}
+            ${required ? "required" : ""}
+            ${config.readOnly ? readOnlyPropsWithLock : ""}
+            variant="horizontal"
+            fullWidth
+            name="${nameWithPrefix}"
+            label={${fieldLabel}}
+            ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+            ${config.endAdornment ? `endAdornment={<InputAdornment position="end">${endAdornment.adornmentString}</InputAdornment>}` : ""}
+            ${config.helperText ? `helperText={${generateFormattedMessage({
+			config: config.helperText,
+			id: `${formattedMessageRootId}.${name}.helperText`,
+			type: "jsx"
+		})}}` : ""}
+            ${validateCode}
+        />`;
+		if (!required && !config.readOnly) formValueConfig.formValueToGqlInputCode = `$fieldName ?? null`;
+		if (config.initialValue !== void 0) formValueConfig.defaultInitializationCode = JSON.stringify(config.initialValue);
+	} else if (config.type == "number") {
+		code = `
+            <NumberField
+                ${required ? "required" : ""}
+                ${config.readOnly ? readOnlyPropsWithLock : ""}
+                variant="horizontal"
+                fullWidth
+                name="${nameWithPrefix}"
+                label={${fieldLabel}}
+                ${config.decimals ? `decimals={${config.decimals}}` : ""}
+                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.endAdornment ? `endAdornment={<InputAdornment position="end">${endAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.helperText ? `helperText={<FormattedMessage id="${formattedMessageRootId}.${name}.helperText" defaultMessage="${config.helperText}" />}` : ""}
+                ${validateCode}
+            />`;
+		if (!required && !config.readOnly) formValueConfig.formValueToGqlInputCode = `$fieldName ?? null`;
+		if (config.initialValue !== void 0) formValueConfig.defaultInitializationCode = JSON.stringify(config.initialValue);
+	} else if (config.type === "numberRange") {
+		code = `
+            <Field
+                ${required ? "required" : ""}
+                ${config.readOnly ? readOnlyPropsWithLock : ""}
+                variant="horizontal"
+                fullWidth
+                name="${nameWithPrefix}"
+                component={FinalFormRangeInput}
+                label={${fieldLabel}}
+                min={${config.minValue}}
+                max={${config.maxValue}}
+                ${config.disableSlider ? "disableSlider" : ""}
+                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.endAdornment ? `endAdornment={<InputAdornment position="end">${endAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.helperText ? `helperText={<FormattedMessage id="${formattedMessageRootId}.${name}.helperText" defaultMessage="${config.helperText}" />}` : ""}
+                ${validateCode}
+            />`;
+		formFragmentFields = [`${name}.min`, `${name}.max`];
+		if (config.initialValue !== void 0) formValueConfig.defaultInitializationCode = JSON.stringify(config.initialValue);
+	} else if (config.type == "boolean") {
+		const checkboxLabel = config.checkboxLabel ? generateFormattedMessage({
+			config: config.checkboxLabel,
+			id: `${formattedMessageRootId}.${name}.checkboxLabel`,
+			type: "jsx"
+		}) : "";
+		code = `<CheckboxField
+                        fieldLabel={${fieldLabel}}
+                        ${config.checkboxLabel ? `label={${checkboxLabel}}` : ""}
+                        name="${nameWithPrefix}"
+                        fullWidth
+                        variant="horizontal"
+                        ${config.readOnly ? readOnlyProps : ""}
+                        ${config.helperText ? `helperText={<FormattedMessage id="${formattedMessageRootId}.${name}.helperText" defaultMessage="${config.helperText}" />}` : ""}
+                        ${validateCode}
+                    />`;
+		formValueConfig.defaultInitializationCode = config.initialValue ? "true" : "false";
+	} else if (config.type == "date") {
+		imports.push({
+			name: "DatePickerField",
+			importPath: "@comet/admin"
+		});
+		code = `
+            <DatePickerField
+                ${required ? "required" : ""}
+                ${config.readOnly ? readOnlyPropsWithLock : ""}
+                variant="horizontal"
+                fullWidth
+                name="${nameWithPrefix}"
+                label={${fieldLabel}}
+                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.endAdornment ? `endAdornment={<InputAdornment position="end">${endAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.helperText ? `helperText={<FormattedMessage id="${formattedMessageRootId}.${name}.helperText" defaultMessage="${config.helperText}" />}` : ""}
+                ${validateCode}
+            />`;
+		if (!required && !config.readOnly) formValueConfig.formValueToGqlInputCode = `$fieldName ?? null`;
+		if (config.initialValue !== void 0) formValueConfig.defaultInitializationCode = JSON.stringify(config.initialValue);
+	} else if (config.type == "dateTime") {
+		imports.push({
+			name: "DateTimePickerField",
+			importPath: "@comet/admin"
+		});
+		code = `<DateTimePickerField
+                ${required ? "required" : ""}
+                ${config.readOnly ? readOnlyPropsWithLock : ""}
+                variant="horizontal"
+                fullWidth
+                name="${nameWithPrefix}"
+                label={${fieldLabel}}
+                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.endAdornment ? `endAdornment={<InputAdornment position="end">${endAdornment.adornmentString}</InputAdornment>}` : ""}
+                ${config.helperText ? `helperText={<FormattedMessage id="${formattedMessageRootId}.${name}.helperText" defaultMessage="${config.helperText}" />}` : ""}
+                ${validateCode}
+            />`;
+		formValueConfig.initializationCode = `data.${dataRootName}.${nameWithPrefix} ? new Date(data.${dataRootName}.${nameWithPrefix}) : undefined`;
+		formValueConfig.omitFromFragmentType = true;
+		formValueConfig.typeCode = {
+			nullable: !required,
+			type: `Date${!required ? " | null" : ""}`
+		};
+		if (!config.readOnly) formValueConfig.formValueToGqlInputCode = required ? `$fieldName.toISOString()` : `$fieldName ? $fieldName.toISOString() : null`;
+		if (config.initialValue !== void 0) formValueConfig.defaultInitializationCode = `new Date("${config.initialValue.toISOString()}")`;
+	} else if (config.type == "block") {
+		code = `<Field name="${nameWithPrefix}" isEqual={isEqual} label={${fieldLabel}} variant="horizontal" fullWidth>
+            {createFinalFormBlock(rootBlocks.${String(config.name)})}
+        </Field>`;
+		formValueConfig.formValueToGqlInputCode = `rootBlocks.${name}.state2Output($fieldName)`;
+		formValueConfig.omitFromFragmentType = true;
+		formValueConfig.typeCode = {
+			nullable: false,
+			type: `BlockState<typeof rootBlocks.${name}>`
+		};
+		formValueConfig.initializationCode = `rootBlocks.${name}.input2State(data.${dataRootName}.${nameWithPrefix})`;
+		formValueConfig.defaultInitializationCode = `rootBlocks.${name}.defaultValues()`;
+	} else if (config.type === "fileUpload") {
+		const multiple = config.multiple || typeof config.maxFiles === "number" && config.maxFiles > 1;
+		code = `<FileUploadField name="${name}" label={${fieldLabel}}
+            variant="horizontal"
+            ${config.multiple ? "multiple" : ""}
+            ${config.maxFiles ? `maxFiles={${config.maxFiles}}` : ""}
+            ${config.maxFileSize ? `maxFileSize={${config.maxFileSize}}` : ""}
+            ${config.readOnly ? `readOnly` : ""}
+            ${config.layout ? `layout="${config.layout}"` : ""}
+            ${config.accept ? `accept="${config.accept}"` : ""}
+        />`;
+		if (multiple) formValueConfig.formValueToGqlInputCode = `$fieldName?.map(({ id }) => id)`;
+		else formValueConfig.formValueToGqlInputCode = `$fieldName ? $fieldName.id : null`;
+		formFragmentFields = [`${name}...${config.download ? "FinalFormFileUploadDownloadable" : "FinalFormFileUpload"}`];
+	} else if (config.type == "staticSelect") {
+		const multiple = introspectionFieldType?.kind === "LIST";
+		if (introspectionFieldType?.kind === "LIST") introspectionFieldType = introspectionFieldType.ofType.kind === "NON_NULL" ? introspectionFieldType.ofType.ofType : introspectionFieldType.ofType;
+		const enumType = gqlIntrospection.__schema.types.find((t) => t.kind === "ENUM" && t.name === introspectionFieldType.name);
+		if (!enumType) throw new Error(`Enum type ${introspectionFieldType.name} not found for field ${name}`);
+		const values = (config.values ? config.values : enumType.enumValues.map((i) => i.name)).map((value) => {
+			if (typeof value === "string") {
+				const messageId = `${formattedMessageRootId}.${name}.${value.charAt(0).toLowerCase() + value.slice(1)}`;
+				return {
+					value,
+					labelCode: generateFormattedMessage({
+						config: void 0,
+						defaultMessage: camelCaseToHumanReadable(value),
+						id: messageId,
+						type: "jsx"
+					})
+				};
+			} else {
+				const messageId = `${formattedMessageRootId}.${name}.${value.value.charAt(0).toLowerCase() + value.value.slice(1)}`;
+				const valueLabel = generateFormattedMessage({
+					config: value.label,
+					id: messageId,
+					type: "jsx"
+				});
+				return {
+					value: value.value,
+					labelCode: valueLabel
+				};
+			}
+		});
+		let inputType = config.inputType;
+		if (!inputType) if (!required || multiple) inputType = "select";
+		else if (values.length <= 5) inputType = "radio";
+		else inputType = "select";
+		if (inputType === "radio" && multiple) throw new Error(`${name}: inputType=radio doesn't support multiple`);
+		if (inputType === "radio" && !required) throw new Error(`${name}: inputType=radio must be required as it doesn't support clearable`);
+		if (inputType === "radio") code = `<RadioGroupField
+             ${required ? "required" : ""}
+              variant="horizontal"
+             fullWidth
+             name="${nameWithPrefix}"
+             label={${fieldLabel}}
+             options={[
+                  ${values.map((value) => {
+			return `{
+                                label: ${value.labelCode},
+                                value: "${value.value}",
+                            }`;
+		}).join(",")}
+            ]}/>`;
+		else {
+			imports.push({
+				name: "SelectField",
+				importPath: "@comet/admin"
+			});
+			code = `<SelectField
+                            ${required ? "required" : ""}
+                             fullWidth
+                                variant={"horizontal"}
+                                name="${nameWithPrefix}"
+                                label={${fieldLabel}}
+                                ${config.startAdornment ? `startAdornment={<InputAdornment position="start">${startAdornment.adornmentString}</InputAdornment>}` : ""}
+                                ${config.helperText ? `helperText={<FormattedMessage id="${formattedMessageRootId}.${name}.helperText" defaultMessage="${config.helperText}" />}` : ""}
+                                ${validateCode}
+                                ${config.readOnly ? readOnlyPropsWithLock : ""}
+                                ${multiple ? "multiple" : ""}
+                                options={[${values.map((value) => {
+				return `{
+                                        value: "${value.value}",
+                                        label: ${value.labelCode}
+                                    }`;
+			})}]}
+                            />`;
+		}
+		if (config.initialValue !== void 0) formValueConfig.defaultInitializationCode = JSON.stringify(config.initialValue);
+	} else throw new Error(`Unsupported type`);
+	return {
+		code,
+		hooksCode,
+		formFragmentFields,
+		gqlDocuments,
+		imports,
+		formProps,
+		formValuesConfig: [formValueConfig],
+		finalFormConfig
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateFormLayout.ts
+function generateFormLayout({ gqlIntrospection, baseOutputFilename, config, formFragmentName, formConfig, gqlType, namePrefix }) {
+	const rootGqlType = formConfig.gqlType;
+	const formattedMessageRootId = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
+	const dataRootName = rootGqlType[0].toLowerCase() + rootGqlType.substring(1);
+	let code = "";
+	let hooksCode = "";
+	const formFragmentFields = [];
+	const gqlDocuments = {};
+	const imports = [];
+	const formProps = [];
+	const formValuesConfig = [];
+	const finalFormConfig = {
+		subscription: {},
+		renderProps: {}
+	};
+	if (config.type === "fieldSet") {
+		const generatedFields = generateFields({
+			gqlIntrospection,
+			baseOutputFilename,
+			fields: config.fields,
+			formFragmentName,
+			formConfig,
+			gqlType,
+			namePrefix
+		});
+		hooksCode += generatedFields.hooksCode;
+		formFragmentFields.push(...generatedFields.formFragmentFields);
+		for (const name in generatedFields.gqlDocuments) gqlDocuments[name] = generatedFields.gqlDocuments[name];
+		imports.push(...generatedFields.imports);
+		formProps.push(...generatedFields.formProps);
+		formValuesConfig.push(...generatedFields.formValuesConfig);
+		finalFormConfig.subscription = {
+			...finalFormConfig.subscription,
+			...generatedFields.finalFormConfig?.subscription
+		};
+		finalFormConfig.renderProps = {
+			...finalFormConfig.renderProps,
+			...generatedFields.finalFormConfig?.renderProps
+		};
+		imports.push({
+			name: "FieldSet",
+			importPath: "@comet/admin"
+		});
+		const supportPlaceholder = config.supportText?.includes("{");
+		if (supportPlaceholder) imports.push({
+			name: "FormSpy",
+			importPath: "react-final-form"
+		});
+		code = `
+        <FieldSet
+            ${config.collapsible === void 0 || config.collapsible ? `collapsible` : ``}
+            ${config.initiallyExpanded != null ? `initiallyExpanded={${config.initiallyExpanded}}` : ``}
+            title={${generateFormattedMessage({
+			config: config.title,
+			id: `${formattedMessageRootId}.${config.name}.title`,
+			defaultMessage: camelCaseToHumanReadable(config.name),
+			type: "jsx"
+		})}}
+            ${config.supportText ? `supportText={
+                        ${supportPlaceholder ? `mode === "edit" && (<FormSpy subscription={{ values: true }}>{({ values }) => (` : ``}
+                        <FormattedMessage
+                            id="${formattedMessageRootId}.${config.name}.supportText"
+                            defaultMessage="${config.supportText}"
+                            ${supportPlaceholder ? `values={{ ...values }}` : ``}
+                        />
+                        ${supportPlaceholder ? `)}</FormSpy>)` : ``}
+                    }` : ``}
+        >
+            ${generatedFields.code}
+        </FieldSet>`;
+	} else if (config.type === "optionalNestedFields") {
+		const name = String(config.name);
+		const introspectionFieldType = findIntrospectionFieldType({
+			name,
+			gqlType,
+			gqlIntrospection
+		});
+		if (!introspectionFieldType) throw new Error(`field ${name} in gql introspection type ${gqlType} not found`);
+		if (introspectionFieldType.kind !== "OBJECT") throw new Error(`field ${name} in gql introspection type ${gqlType} has to be OBJECT`);
+		const generatedFields = generateFields({
+			gqlIntrospection,
+			baseOutputFilename,
+			fields: config.fields,
+			formFragmentName,
+			formConfig,
+			gqlType: introspectionFieldType.name,
+			namePrefix: name
+		});
+		hooksCode += generatedFields.hooksCode;
+		formFragmentFields.push(...generatedFields.formFragmentFields.map((field) => `${name}.${field}`));
+		for (const name$1 in generatedFields.gqlDocuments) gqlDocuments[name$1] = generatedFields.gqlDocuments[name$1];
+		imports.push(...generatedFields.imports);
+		formValuesConfig.push(...generatedFields.formValuesConfig);
+		formValuesConfig.push({
+			fieldName: `${name}Enabled`,
+			omitFromFragmentType: false,
+			destructFromFormValues: true,
+			typeCode: {
+				nullable: false,
+				type: "boolean"
+			},
+			initializationCode: `!!data.${dataRootName}.${name}`
+		});
+		formValuesConfig.push({
+			fieldName: `${name}`,
+			wrapFormValueToGqlInputCode: `${name.split(".").pop()}Enabled && $fieldName ? $inner : null`
+		});
+		imports.push({
+			name: "FinalFormSwitch",
+			importPath: "@comet/admin"
+		});
+		imports.push({
+			name: "messages",
+			importPath: "@comet/admin"
+		});
+		imports.push({
+			name: "FormControlLabel",
+			importPath: "@mui/material"
+		});
+		code = `<Field
+                    fullWidth
+                    name="${String(config.name)}Enabled"
+                    type="checkbox"
+                    label={${generateFormattedMessage({
+			config: config.checkboxLabel,
+			id: `${formattedMessageRootId}.${String(config.name)}.${String(config.name)}Enabled`,
+			defaultMessage: `Enable ${camelCaseToHumanReadable(String(config.name))}`,
+			type: "jsx"
+		})}}
+                >
+                    {(props) => (
+                        <FormControlLabel
+                            control={<FinalFormSwitch {...props} />}
+                            label={props.input.checked ? <FormattedMessage {...messages.yes} /> : <FormattedMessage {...messages.no} />}
+                        />
+                    )}
+                </Field>
+                 <Field name="${String(config.name)}Enabled" fullWidth subscription={{ value: true }}>
+                    {({ input: { value } }) =>
+                        value ? (
+                            <>
+                                ${generatedFields.code}
+                            </>
+                            ) : null
+                    }
+                </Field>`;
+	} else throw new Error(`Unsupported type`);
+	return {
+		code,
+		hooksCode,
+		formFragmentFields,
+		gqlDocuments,
+		imports,
+		formProps,
+		formValuesConfig,
+		finalFormConfig
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateFields.ts
+function findFieldByName(name, fields) {
+	return fields.reduce((acc, field) => {
+		return acc ? acc : "name" in field && field.name === name ? field : isFormLayoutConfig(field) ? findFieldByName(name, field.fields) : void 0;
+	}, void 0);
+}
+function generateFields({ gqlIntrospection, baseOutputFilename, fields, formFragmentName, formConfig, gqlType, namePrefix }) {
+	const gqlDocuments = {};
+	let hooksCode = "";
+	const formFragmentFields = [];
+	const imports = [];
+	const formProps = [];
+	const formValuesConfig = [];
+	const finalFormConfig = {
+		subscription: {},
+		renderProps: {}
+	};
+	return {
+		code: fields.map((field) => {
+			let generated;
+			if (field.type === "component") generated = generateComponentFormField({ config: field });
+			else if (isFormFieldConfig(field)) generated = generateFormField({
+				gqlIntrospection,
+				baseOutputFilename,
+				formFragmentName,
+				config: field,
+				formConfig,
+				gqlType,
+				namePrefix
+			});
+			else if (isFormLayoutConfig(field)) generated = generateFormLayout({
+				gqlIntrospection,
+				baseOutputFilename,
+				formFragmentName,
+				config: field,
+				formConfig,
+				gqlType,
+				namePrefix
+			});
+			else throw new Error("Not supported config");
+			for (const name in generated.gqlDocuments) gqlDocuments[name] = generated.gqlDocuments[name];
+			imports.push(...generated.imports);
+			formProps.push(...generated.formProps);
+			hooksCode += generated.hooksCode;
+			formFragmentFields.push(...generated.formFragmentFields);
+			formValuesConfig.push(...generated.formValuesConfig);
+			finalFormConfig.subscription = {
+				...finalFormConfig.subscription,
+				...generated.finalFormConfig?.subscription
+			};
+			finalFormConfig.renderProps = {
+				...finalFormConfig.renderProps,
+				...generated.finalFormConfig?.renderProps
+			};
+			return generated.code;
+		}).join("\n"),
+		hooksCode,
+		formFragmentFields,
+		gqlDocuments,
+		imports,
+		formProps,
+		formValuesConfig,
+		finalFormConfig
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateFormValues.ts
+function formValuesConfigToTree({ formValuesConfig, gqlIntrospection, gqlType }) {
+	const treeRoot = { children: {} };
+	for (const formValueConfig of formValuesConfig) {
+		const fieldName = formValueConfig.fieldName;
+		let currentTreeNode = treeRoot;
+		let currentGqlType = gqlType;
+		for (const part of fieldName.split(".")) {
+			const introspectionObject = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === currentGqlType);
+			if (!introspectionObject) throw new Error(`didn't find object ${gqlType} in gql introspection`);
+			const introspectionField = introspectionObject.fields.find((field) => field.name === part);
+			const introspectionFieldType = introspectionField ? introspectionField.type.kind === "NON_NULL" ? introspectionField.type.ofType : introspectionField.type : void 0;
+			if (introspectionFieldType?.kind === "OBJECT") currentGqlType = introspectionFieldType.name;
+			if (!currentTreeNode.children[part]) currentTreeNode.children[part] = { children: {} };
+			currentTreeNode.children[part].nullable = introspectionField?.type.kind !== "NON_NULL";
+			currentTreeNode = currentTreeNode.children[part];
+		}
+		currentTreeNode.config = formValueConfig;
+	}
+	return treeRoot.children;
+}
+function generateFormValuesTypeFromTree(tree, currentTypeName, currentIsNullable) {
+	const omitKeys = [];
+	let appendCode = "";
+	for (const [key, value] of Object.entries(tree)) if (Object.keys(value.children).length > 0) {
+		let childRootType = `${currentTypeName}["${key}"]`;
+		if (currentIsNullable) childRootType = `NonNullable<${currentTypeName}>["${key}"]`;
+		const childOmit = generateFormValuesTypeFromTree(value.children, childRootType, value.nullable ?? false);
+		if (childOmit !== childRootType) {
+			appendCode += `${key}: ${childOmit}`;
+			omitKeys.push(key);
+		}
+		if (value.config?.typeCode) throw new Error("Field has both subfields and direct typeCode, which is not supported.");
+		if (value.config?.omitFromFragmentType) throw new Error("Field has both subfields and direct omitFromFragmentType, which is not supported.");
+	} else if (value.config) {
+		if (value.config.typeCode) appendCode += `${key}${value.config.typeCode.nullable ? "?" : ""}: ${value.config.typeCode.type}; `;
+		if (value.config.omitFromFragmentType) omitKeys.push(key);
+	}
+	let code = omitKeys.length ? `Omit<${currentIsNullable ? `NonNullable<` : ""}${currentTypeName}${currentIsNullable ? `>` : ""}, ${omitKeys.map((k) => `"${k}"`).join(" | ")}>` : currentTypeName;
+	if (appendCode.length) code += ` & { ${appendCode} }`;
+	return code;
+}
+function generateFormValuesType({ formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType }) {
+	return `type FormValues = ${generateFormValuesTypeFromTree(formValuesConfigToTree({
+		formValuesConfig,
+		gqlIntrospection,
+		gqlType
+	}), filterByFragmentType, false)};`;
+}
+function generateInitialValuesFromTree(tree, dataObject, generationType) {
+	let code = "";
+	for (const [key, value] of Object.entries(tree)) if (Object.keys(value.children).length > 0) {
+		let childCode = generateInitialValuesFromTree(value.children, dataObject ? `${dataObject}.${key}` : null, generationType);
+		if (childCode.length) if (dataObject) {
+			childCode = `{ ...${dataObject}.${key}, ${childCode} }`;
+			if (value.nullable) code += `${key}: ${dataObject}.${key} ? ${childCode} : undefined, `;
+			else code += `${key}: ${childCode}, `;
+		} else code += `${key}: { ${childCode} }, `;
+		if (value.config?.[generationType]) throw new Error("Field has both subfields and direct initialization code, which is not supported.");
+	} else if (value.config) {
+		if (value.config[generationType]) code += `${key}: ${value.config[generationType]}, `;
+	}
+	return code;
+}
+function generateInitialValues({ mode, formValuesConfig, filterByFragmentType, gqlIntrospection, gqlType, initialValuesAsProp }) {
+	const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
+	const editMode = mode === "edit" || mode == "all";
+	const tree = formValuesConfigToTree({
+		formValuesConfig,
+		gqlIntrospection,
+		gqlType
+	});
+	if (editMode) return `const initialValues = useMemo<Partial<FormValues>>(() => data?.${instanceGqlType}
+            ? {
+                ...filterByFragment<${filterByFragmentType}>(${instanceGqlType}FormFragment, data.${instanceGqlType}),
+                ${generateInitialValuesFromTree(tree, `data.${instanceGqlType}`, "initializationCode")}
+            }
+            : {
+                ${generateInitialValuesFromTree(tree, initialValuesAsProp ? `passedInitialValues` : null, "defaultInitializationCode")}
+                ${initialValuesAsProp ? `...passedInitialValues,` : ""}
+            }
+        , [data]);`;
+	else return `const initialValues = {
+            ${generateInitialValuesFromTree(tree, initialValuesAsProp ? `passedInitialValues` : null, "defaultInitializationCode")}
+            ${initialValuesAsProp ? `...passedInitialValues,` : ""}
+        };`;
+}
+function generateDestructFormValueForInputFromTree(tree, restObject) {
+	let code = "";
+	for (const [key, value] of Object.entries(tree)) if (Object.keys(value.children).length > 0) {
+		const childCode = generateDestructFormValueForInputFromTree(value.children, `${restObject}${key.substring(0, 1).toUpperCase()}${key.substring(1)}`);
+		if (childCode.length) code += `${key}: { ${childCode} }, `;
+	} else if (value.config) {
+		if (value.config.destructFromFormValues) code += `${key}, `;
+	}
+	if (code.length) {
+		code += `...${restObject}Rest`;
+		return code;
+	} else return "";
+}
+function generateDestructFormValueForInput({ formValuesConfig, gqlIntrospection, gqlType }) {
+	const code = generateDestructFormValueForInputFromTree(formValuesConfigToTree({
+		formValuesConfig,
+		gqlIntrospection,
+		gqlType
+	}), "formValues");
+	return code.length ? `{ ${code} }` : "formValues";
+}
+function generateFormValuesToGqlInputFromTree(tree, dataObject, restObject) {
+	let code = "";
+	for (const [key, value] of Object.entries(tree)) if (Object.keys(value.children).length > 0) {
+		const childRestObject = `${restObject.replace(/Rest$/, "")}${key.substring(0, 1).toUpperCase()}${key.substring(1)}Rest`;
+		const hasChildDestruct = hasChildDestructTree(value.children);
+		let childCode = generateFormValuesToGqlInputFromTree(value.children, hasChildDestruct ? childRestObject : `${dataObject}.${key}`, childRestObject);
+		if (childCode.length || hasChildDestruct) {
+			childCode = `{ ...${hasChildDestruct ? childRestObject : `${dataObject}.${key}`}, ${childCode} }`;
+			if (value.config?.wrapFormValueToGqlInputCode) childCode = value.config.wrapFormValueToGqlInputCode.replaceAll("$fieldName", `${dataObject}.${key}`).replaceAll("$inner", childCode);
+			code += `${key}: ${childCode}, `;
+		}
+		if (value.config?.formValueToGqlInputCode) throw new Error("Field has both subfields and direct formValueToGqlInputCode, which is not supported.");
+	} else if (value.config) {
+		if (value.config.formValueToGqlInputCode) code += `${key}: ${value.config.formValueToGqlInputCode.replaceAll("$fieldName", `${dataObject}.${key}`)}, `;
+	}
+	return code;
+}
+function hasChildDestructTree(tree) {
+	return Object.values(tree).some((childValue) => {
+		if (childValue.config?.destructFromFormValues) return true;
+		if (Object.keys(childValue.children).length > 0) return hasChildDestructTree(childValue.children);
+		return false;
+	});
+}
+function generateFormValuesToGqlInput({ formValuesConfig, gqlIntrospection, gqlType }) {
+	const tree = formValuesConfigToTree({
+		formValuesConfig,
+		gqlIntrospection,
+		gqlType
+	});
+	const hasChildDestruct = hasChildDestructTree(tree);
+	const code = generateFormValuesToGqlInputFromTree(tree, hasChildDestruct ? "formValuesRest" : "formValues", hasChildDestruct ? "formValuesRest" : "formValues");
+	if (code.length) return `const output = { ...${hasChildDestruct ? "formValuesRest" : "formValues"}, ${code} };`;
+	else if (hasChildDestruct) return `const output = formValuesRest;`;
+	else return `const output = formValues;`;
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateFragmentByFormFragmentFields.ts
+/**
+* Helper function that generates a GraphQL fragment from form fragment fields (array of dot.separated.fields).
+*
+* - Fragments are supported as "foo...FragmentName"
+* - for FinalFormFileUpload and FinalFormFileUploadDownloadable the needed variable is added automatically
+*/
+function generateFragmentByFormFragmentFields({ formFragmentName, gqlType, formFragmentFields }) {
+	let fragmentCode = `
+        fragment ${formFragmentName} on ${gqlType} {
+            ${generateGqlQueryTreeFromFields(formFragmentFields)}
+        }
+    `;
+	for (const [fragmentName, fragmentVar] of Object.entries({
+		"...FinalFormFileUpload": "${finalFormFileUploadFragment}",
+		"...FinalFormFileUploadDownloadable": "${finalFormFileUploadDownloadableFragment}"
+	})) if (fragmentCode.match(`${fragmentName.replace(".", "\\.")}\\b`) && !fragmentCode.includes(fragmentVar)) fragmentCode += `\n${fragmentVar}`;
+	return fragmentCode;
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/getForwardedGqlArgs.ts
+function getForwardedGqlArgs$1({ fields, gqlOperation, gqlIntrospection }) {
+	const ret = [];
+	getArgsIncludingInputArgSubfields(gqlOperation, gqlIntrospection).forEach((arg) => {
+		if (arg.isInputArgSubfield) {
+			if (fields.some((field) => {
+				return field.name === arg.name || field.name.startsWith(`${arg.name}.`);
+			})) return;
+		}
+		let prop;
+		const imports = [];
+		if (arg.type === "ID" || arg.type === "String" || arg.type === "DateTime") prop = {
+			name: arg.name,
+			optional: false,
+			type: "string"
+		};
+		else if (arg.type === "Boolean") prop = {
+			name: arg.name,
+			optional: false,
+			type: "boolean"
+		};
+		else if (arg.type === "Int" || arg.type === "Float") prop = {
+			name: arg.name,
+			optional: false,
+			type: "number"
+		};
+		else if (arg.type === "JSONObject") prop = {
+			name: arg.name,
+			optional: false,
+			type: "unknown"
+		};
+		else {
+			prop = {
+				name: arg.name,
+				optional: false,
+				type: `GQL${arg.type}`
+			};
+			imports.push({
+				name: `GQL${arg.type}`,
+				importPath: "@src/graphql.generated"
+			});
+		}
+		ret.push({
+			gqlArg: arg,
+			prop,
+			imports
+		});
+	});
+	return ret;
+}
+function getArgsIncludingInputArgSubfields(gqlOperation, gqlIntrospection) {
+	const nativeScalars = [
+		"ID",
+		"String",
+		"Boolean",
+		"Int",
+		"Float",
+		"DateTime",
+		"JSONObject"
+	];
+	function reducer(acc, inputField) {
+		if (inputField.type.kind !== "NON_NULL" || inputField.defaultValue) return acc;
+		const gqlType = inputField.type.ofType;
+		if (gqlType.kind === "INPUT_OBJECT") if (inputField.name === "input") {
+			const typeDef = gqlIntrospection.__schema.types.find((type) => type.kind === "INPUT_OBJECT" && type.name === gqlType.name);
+			if (typeDef && typeDef.kind === "INPUT_OBJECT") {
+				const inputArgSubfields = typeDef.inputFields.reduce(reducer, []).map((inputArgSubfield) => {
+					return {
+						...inputArgSubfield,
+						isInputArgSubfield: true
+					};
+				});
+				acc.push(...inputArgSubfields);
+			} else console.warn(`IntrospectionType for ${gqlType.name} not found or no INPUT_OBJECT`);
+		} else acc.push({
+			name: inputField.name,
+			type: gqlType.name,
+			isInputArgSubfield: false
+		});
+		else if (gqlType.kind === "SCALAR") if (!nativeScalars.includes(gqlType.name)) console.warn(`Currently not supported special SCALAR of type ${gqlType.name} in arg/field ${inputField.name}`);
+		else acc.push({
+			name: inputField.name,
+			type: gqlType.name,
+			isInputArgSubfield: false
+		});
+		else if (gqlType.kind === "ENUM") acc.push({
+			name: inputField.name,
+			type: gqlType.name,
+			isInputArgSubfield: false
+		});
+		else if (gqlType.kind === "LIST") throw new Error(`Not supported kind ${gqlType.kind}, arg: input.${inputField.name}`);
+		return acc;
+	}
+	return gqlOperation.args.reduce(reducer, []);
+}
+
+//#endregion
+//#region src/commands/generate/generateForm/generateForm.ts
+/**
+* Detects if a mutation has a wrapped payload response type (e.g., CreateProductPayload with product and errors fields)
+* vs returning the entity directly.
+*/
+function hasPayloadResponseType(mutationField, gqlType) {
+	let returnType = mutationField.type;
+	if (returnType.kind === "NON_NULL") returnType = returnType.ofType;
+	if (returnType.kind === "OBJECT" && returnType.name === gqlType) return false;
+	else return true;
+}
+function generateFormPropsCode(props) {
+	if (!props.length) return {
+		formPropsTypeCode: "",
+		formPropsParamsCode: ""
+	};
+	const uniqueProps = props.reduce((acc, item) => {
+		const propWithSameName = acc.find((prop) => prop.name == item.name);
+		if (!propWithSameName) return [item, ...acc];
+		if (propWithSameName.type != item.type || propWithSameName.optional != item.optional) return [item, ...acc];
+		return acc;
+	}, []);
+	return {
+		formPropsTypeCode: `interface FormProps {
+            ${uniqueProps.map((prop) => `${prop.name}${prop.optional ? `?` : ``}: ${prop.type};`).join("\n")}
+        }`,
+		formPropsParamsCode: `{${uniqueProps.map((prop) => prop.name + (prop.localAliasName ? `: ${prop.localAliasName}` : "")).join(", ")}}: FormProps`
+	};
+}
+function generateForm({ exportName, baseOutputFilename, targetDirectory, gqlIntrospection }, config) {
+	assertValidConfig(config);
+	const gqlType = config.gqlType;
+	const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
+	const formFragmentName = config.fragmentName ?? `${gqlType}Form`;
+	const gqlDocuments = {};
+	const imports = [
+		{
+			name: "FormattedMessage",
+			importPath: "react-intl"
+		},
+		{
+			name: "useApolloClient",
+			importPath: "@apollo/client"
+		},
+		{
+			name: "useQuery",
+			importPath: "@apollo/client"
+		},
+		{
+			name: "gql",
+			importPath: "@apollo/client"
+		},
+		{
+			name: "CheckboxField",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "Field",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "filterByFragment",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "FinalForm",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "FinalFormInput",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "FinalFormRangeInput",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "FinalFormSelect",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "FinalFormSubmitEvent",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "Loading",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "NumberField",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "RadioGroupField",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "TextAreaField",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "TextField",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "useFormApiRef",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "useStackSwitchApi",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "ArrowLeft",
+			importPath: "@comet/admin-icons"
+		},
+		{
+			name: "Lock",
+			importPath: "@comet/admin-icons"
+		},
+		{
+			name: "DateTimeField",
+			importPath: "@comet/admin-date-time"
+		},
+		{
+			name: "FinalFormDatePicker",
+			importPath: "@comet/admin-date-time"
+		},
+		{
+			name: "BlockState",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "createFinalFormBlock",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "queryUpdatedAt",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "resolveHasSaveConflict",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "useFormSaveConflict",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "FileUploadField",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "IconButton",
+			importPath: "@mui/material"
+		},
+		{
+			name: "MenuItem",
+			importPath: "@mui/material"
+		},
+		{
+			name: "InputAdornment",
+			importPath: "@mui/material"
+		},
+		{
+			name: "FormApi",
+			importPath: "final-form"
+		},
+		{
+			name: "useMemo",
+			importPath: "react"
+		}
+	];
+	const formProps = [];
+	const mode = config.mode ?? "all";
+	const editMode = mode === "edit" || mode == "all";
+	const addMode = mode === "add" || mode == "all";
+	const createMutationType = addMode && findMutationTypeOrThrow(config.createMutation ?? `create${gqlType}`, gqlIntrospection);
+	const updateMutationType = editMode && findMutationTypeOrThrow(`update${gqlType}`, gqlIntrospection);
+	const createMutationHasPayloadResponse = createMutationType && hasPayloadResponseType(createMutationType, gqlType);
+	const updateMutationHasPayloadResponse = updateMutationType && hasPayloadResponseType(updateMutationType, gqlType);
+	const errorEnums = extractErrorEnumsFromMutations({
+		createMutationType: createMutationHasPayloadResponse ? createMutationType : null,
+		updateMutationType: updateMutationHasPayloadResponse ? updateMutationType : null,
+		gqlIntrospection
+	});
+	if (errorEnums.createErrorEnum || errorEnums.updateErrorEnum) {
+		imports.push({
+			name: "ReactNode",
+			importPath: "react"
+		});
+		imports.push({
+			name: "FORM_ERROR",
+			importPath: "final-form"
+		});
+		imports.push({
+			name: "FormattedMessage",
+			importPath: "react-intl"
+		});
+	}
+	const formFields = flatFormFieldsFromFormConfig(config);
+	let useScopeFromContext = false;
+	const gqlArgs = [];
+	if (createMutationType) {
+		const forwardedArgs = getForwardedGqlArgs$1({
+			fields: formFields,
+			gqlOperation: createMutationType,
+			gqlIntrospection
+		});
+		for (const forwardedArg of forwardedArgs) {
+			imports.push(...forwardedArg.imports);
+			if (forwardedArg.gqlArg.name === "scope" && !forwardedArg.gqlArg.isInputArgSubfield && !config.scopeAsProp) {
+				useScopeFromContext = true;
+				gqlArgs.push(forwardedArg.gqlArg);
+			} else {
+				formProps.push(forwardedArg.prop);
+				gqlArgs.push(forwardedArg.gqlArg);
+			}
+		}
+	}
+	if (useScopeFromContext) imports.push({
+		name: "useContentScope",
+		importPath: "@comet/cms-admin"
+	});
+	if (editMode) {
+		if (mode === "all") formProps.push({
+			name: "id",
+			optional: true,
+			type: "string"
+		});
+		else if (mode === "edit") formProps.push({
+			name: "id",
+			optional: false,
+			type: "string"
+		});
+	}
+	const rootBlockFields = formFields.filter((field) => field.type == "block").map((field) => {
+		if (field.type !== "block") throw new Error("Field is not a block field");
+		return field;
+	});
+	rootBlockFields.forEach((field) => {
+		if (isGeneratorConfigImport(field.block)) imports.push(convertConfigImport(field.block));
+	});
+	const readOnlyFields = formFields.filter((field) => field.readOnly);
+	const fileFields = formFields.filter((field) => field.type == "fileUpload");
+	if (fileFields.length > 0) {
+		imports.push({
+			name: "GQLFinalFormFileUploadFragment",
+			importPath: "@comet/cms-admin"
+		});
+		imports.push({
+			name: "GQLFinalFormFileUploadDownloadableFragment",
+			importPath: "@comet/cms-admin"
+		});
+	}
+	let hooksCode = "";
+	const formFragmentFields = [];
+	const formValuesConfig = [];
+	const generatedFields = generateFields({
+		gqlIntrospection,
+		baseOutputFilename,
+		fields: config.fields,
+		formFragmentName,
+		formConfig: config,
+		gqlType: config.gqlType
+	});
+	const fieldsCode = generatedFields.code;
+	for (const name in generatedFields.gqlDocuments) gqlDocuments[name] = {
+		document: generatedFields.gqlDocuments[name].document,
+		export: true
+	};
+	imports.push(...generatedFields.imports);
+	formProps.push(...generatedFields.formProps);
+	hooksCode += generatedFields.hooksCode;
+	formFragmentFields.push(...generatedFields.formFragmentFields);
+	formValuesConfig.push(...generatedFields.formValuesConfig);
+	formProps.push({
+		name: "onCreate",
+		optional: true,
+		type: `(id: string) => void`
+	});
+	if (config.initialValuesAsProp) formProps.push({
+		name: "initialValues",
+		localAliasName: "passedInitialValues",
+		optional: true,
+		type: `Partial<FormValues>`
+	});
+	const { formPropsTypeCode, formPropsParamsCode } = generateFormPropsCode(formProps);
+	gqlDocuments[`${instanceGqlType}FormFragment`] = {
+		document: generateFragmentByFormFragmentFields({
+			formFragmentName,
+			gqlType,
+			formFragmentFields
+		}),
+		export: editMode
+	};
+	if (editMode) gqlDocuments[`${instanceGqlType}Query`] = {
+		document: generateGqlOperation({
+			type: "query",
+			operationName: gqlType,
+			rootOperation: instanceGqlType,
+			fields: [
+				"id",
+				"updatedAt",
+				`...${formFragmentName}`
+			],
+			variables: [{
+				name: "id",
+				type: "ID!"
+			}],
+			fragmentVariables: [`\${${`${instanceGqlType}FormFragment`}}`]
+		}),
+		export: true
+	};
+	if (addMode && createMutationType) gqlDocuments[`create${gqlType}Mutation`] = {
+		document: generateGqlOperation({
+			type: "mutation",
+			operationName: `Create${gqlType}`,
+			rootOperation: createMutationType.name,
+			fields: createMutationHasPayloadResponse ? [
+				`${instanceGqlType}.id`,
+				`${instanceGqlType}.updatedAt`,
+				`${instanceGqlType}...${formFragmentName}`,
+				"errors.code",
+				"errors.field"
+			] : [
+				"id",
+				"updatedAt",
+				`...${formFragmentName}`
+			],
+			fragmentVariables: [`\${${`${instanceGqlType}FormFragment`}}`],
+			variables: [...gqlArgs.filter((gqlArg) => !gqlArg.isInputArgSubfield).map((gqlArg) => ({
+				name: gqlArg.name,
+				type: `${gqlArg.type}!`
+			})), {
+				name: "input",
+				type: `${gqlType}Input!`
+			}]
+		}),
+		export: true
+	};
+	if (editMode) gqlDocuments[`update${gqlType}Mutation`] = {
+		document: generateGqlOperation({
+			type: "mutation",
+			operationName: `Update${gqlType}`,
+			rootOperation: `update${gqlType}`,
+			fields: updateMutationHasPayloadResponse ? [
+				`${instanceGqlType}.id`,
+				`${instanceGqlType}.updatedAt`,
+				`${instanceGqlType}...${formFragmentName}`,
+				"errors.code",
+				"errors.field"
+			] : [
+				"id",
+				"updatedAt",
+				`...${formFragmentName}`
+			],
+			fragmentVariables: [`\${${`${instanceGqlType}FormFragment`}}`],
+			variables: [{
+				name: "id",
+				type: "ID!"
+			}, {
+				name: "input",
+				type: `${gqlType}UpdateInput!`
+			}]
+		}),
+		export: true
+	};
+	for (const name in gqlDocuments) {
+		const gqlDocument = gqlDocuments[name];
+		imports.push({
+			name,
+			importPath: `./${baseOutputFilename}.gql`
+		});
+		const match = gqlDocument.document.match(/^\s*(query|mutation|fragment)\s+(\w+)/);
+		if (!match) throw new Error(`Could not find query or mutation name in ${gqlDocument}`);
+		const type = match[1];
+		const documentName = match[2];
+		imports.push({
+			name: `GQL${documentName}${type[0].toUpperCase() + type.substring(1)}`,
+			importPath: `./${baseOutputFilename}.gql.generated`
+		});
+		if (type !== "fragment") imports.push({
+			name: `GQL${documentName}${type[0].toUpperCase() + type.substring(1)}Variables`,
+			importPath: `./${baseOutputFilename}.gql.generated`
+		});
+	}
+	const finalFormSubscription = Object.keys(generatedFields.finalFormConfig?.subscription ?? {});
+	const finalFormRenderProps = Object.keys(generatedFields.finalFormConfig?.renderProps ?? {});
+	let filterByFragmentType = `GQL${formFragmentName}Fragment`;
+	let customFilterByFragment = "";
+	if (fileFields.length > 0) {
+		const keysToOverride = fileFields.map((field) => field.name);
+		customFilterByFragment = `type ${formFragmentName}Fragment = Omit<${filterByFragmentType}, ${keysToOverride.map((key) => `"${String(key)}"`).join(" | ")}> & {
+            ${fileFields.map((field) => {
+			if (field.type !== "fileUpload") throw new Error("Field is not a file upload field");
+			if ("multiple" in field && field.multiple || "maxFiles" in field && typeof field.maxFiles === "number" && field.maxFiles > 1) return `${String(field.name)}: ${field.download ? "GQLFinalFormFileUploadDownloadableFragment" : "GQLFinalFormFileUploadFragment"}[];`;
+			return `${String(field.name)}: ${field.download ? "GQLFinalFormFileUploadDownloadableFragment" : "GQLFinalFormFileUploadFragment"} | null;`;
+		}).join("\n")}
+        }`;
+		filterByFragmentType = `${formFragmentName}Fragment`;
+	}
+	if (errorEnums.createErrorEnum) {
+		const typeName = `GQL${errorEnums.createErrorEnum}`;
+		imports.push({
+			name: typeName,
+			importPath: `@src/graphql.generated`
+		});
+	}
+	if (errorEnums.useDifferentEnums && errorEnums.updateErrorEnum) {
+		const typeName = `GQL${errorEnums.updateErrorEnum}`;
+		imports.push({
+			name: typeName,
+			importPath: `@src/graphql.generated`
+		});
+	}
+	let errorMessagesCode = "";
+	if (errorEnums.useDifferentEnums) {
+		if (errorEnums.createErrorEnum) {
+			errorMessagesCode += generateErrorMessagesCode({
+				enumName: errorEnums.createErrorEnum,
+				gqlType,
+				variableName: "createErrorMessages",
+				gqlIntrospection
+			});
+			errorMessagesCode += "\n\n";
+		}
+		if (errorEnums.updateErrorEnum) errorMessagesCode += generateErrorMessagesCode({
+			enumName: errorEnums.updateErrorEnum,
+			gqlType,
+			variableName: "updateErrorMessages",
+			gqlIntrospection
+		});
+	} else if (errorEnums.createErrorEnum || errorEnums.updateErrorEnum) errorMessagesCode = generateErrorMessagesCode({
+		enumName: errorEnums.createErrorEnum || errorEnums.updateErrorEnum,
+		gqlType,
+		variableName: "submissionErrorMessages",
+		gqlIntrospection
+	});
+	return {
+		code: `
+    ${generateImportsCode(imports)}
+    import isEqual from "lodash.isequal";
+
+    ${rootBlockFields.length > 0 ? `const rootBlocks = {
+                ${rootBlockFields.map((field) => `${String(field.name)}: ${field.block.name}`)}
+                };` : ""}
+
+    ${customFilterByFragment}
+
+    ${generateFormValuesType({
+			formValuesConfig,
+			filterByFragmentType,
+			gqlIntrospection,
+			gqlType
+		})}
+
+    ${formPropsTypeCode}
+
+    ${errorMessagesCode}
+
+    export function ${exportName}(${formPropsParamsCode}) {
+        const client = useApolloClient();
+        ${mode == "all" ? `const mode = id ? "edit" : "add";` : ""}
+        const formApiRef = useFormApiRef<FormValues>();
+        ${addMode ? `const stackSwitchApi = useStackSwitchApi();` : ""}
+        ${useScopeFromContext ? `const { scope } = useContentScope();` : ""}
+
+        ${editMode ? `
+        const { data, error, loading, refetch } = useQuery<GQL${gqlType}Query, GQL${gqlType}QueryVariables>(
+            ${instanceGqlType}Query,
+            ${mode == "edit" ? `{ variables: { id } }` : `id ? { variables: { id } } : { skip: true }`},
+        );
+        ` : ""}
+
+        ${generateInitialValues({
+			mode,
+			formValuesConfig,
+			filterByFragmentType,
+			gqlIntrospection,
+			gqlType,
+			initialValuesAsProp: !!config.initialValuesAsProp
+		})}
+
+
+        ${editMode ? `
+        const saveConflict = useFormSaveConflict({
+            checkConflict: async () => {
+                const updatedAt = await queryUpdatedAt(client, "${instanceGqlType}", id);
+                return resolveHasSaveConflict(data?.${instanceGqlType}.updatedAt, updatedAt);
+            },
+            formApiRef,
+            loadLatestVersion: async () => {
+                await refetch();
+            },
+        });
+        ` : ""}
+
+        const handleSubmit = async (${generateDestructFormValueForInput({
+			formValuesConfig,
+			gqlIntrospection,
+			gqlType
+		})}: FormValues, form: FormApi<FormValues>${addMode ? `, event: FinalFormSubmitEvent` : ""}) => {
+            ${editMode ? `if (await saveConflict.checkForConflicts()) throw new Error("Conflicts detected");` : ""}
+            ${generateFormValuesToGqlInput({
+			formValuesConfig,
+			gqlIntrospection,
+			gqlType
+		})}
+
+            ${mode == "all" ? `if (mode === "edit") {` : ""}
+                ${editMode ? `
+                ${readOnlyFields.some((field) => field.name === "id") ? "" : "if (!id) throw new Error();"}
+                const { ${readOnlyFields.map((field) => `${String(field.name)},`).join("")} ...updateInput } = output;
+                ${updateMutationHasPayloadResponse ? `const { data: mutationResponse } = ` : ""}await client.mutate<GQLUpdate${gqlType}Mutation, GQLUpdate${gqlType}MutationVariables>({
+                    mutation: update${gqlType}Mutation,
+                    variables: { id, input: updateInput },
+                });
+                ${updateMutationHasPayloadResponse && updateMutationType && errorEnums.updateErrorEnum ? `
+                    ${generateErrorHandlingCode({
+			mutationResponsePath: `mutationResponse?.${updateMutationType.name}`,
+			errorMessagesVariable: errorEnums.useDifferentEnums ? "updateErrorMessages" : "submissionErrorMessages"
+		})}
+                ` : ""}
+                ` : ""}
+            ${mode == "all" ? `} else {` : ""}
+                ${addMode && createMutationType ? `
+                const { data: mutationResponse } = await client.mutate<GQLCreate${gqlType}Mutation, GQLCreate${gqlType}MutationVariables>({
+                    mutation: create${gqlType}Mutation,
+                    variables: {
+                        input: ${gqlArgs.filter((prop) => prop.isInputArgSubfield).length ? `{ ...output, ${gqlArgs.filter((prop) => prop.isInputArgSubfield).map((prop) => prop.name).join(",")} }` : "output"}${gqlArgs.filter((prop) => !prop.isInputArgSubfield).length ? `, ${gqlArgs.filter((prop) => !prop.isInputArgSubfield).map((arg) => arg.name).join(",")}` : ""} },
+                });
+                ${createMutationHasPayloadResponse && errorEnums.createErrorEnum ? `
+                    ${generateErrorHandlingCode({
+			mutationResponsePath: `mutationResponse?.${createMutationType.name}`,
+			errorMessagesVariable: errorEnums.useDifferentEnums ? "createErrorMessages" : "submissionErrorMessages"
+		})}
+                ` : ""}
+                
+                const id = mutationResponse?.${createMutationType.name}${createMutationHasPayloadResponse ? `.${instanceGqlType}?` : ""}.id;
+                if (id) {
+                    setTimeout(() => {
+                        onCreate?.(id);
+                        ${config.navigateOnCreate === true || config.navigateOnCreate === void 0 ? `if (!event.navigatingBack) { stackSwitchApi.activatePage(\`edit\`, id);` : ``}
+                    });
+                }
+                ` : ""}
+            ${mode == "all" ? `}` : ""}
+        };
+
+        ${hooksCode}
+
+        ${editMode ? ` if (error) throw error;
+
+                    if (loading) {
+                        return <Loading behavior="fillPageHeight" />;
+                    }` : ``}
+
+        return (
+            <FinalForm<FormValues>
+                apiRef={formApiRef}
+                onSubmit={handleSubmit}
+                mode=${mode == "all" ? `{mode}` : editMode ? `"edit"` : `"add"`}
+                initialValues={initialValues}
+                initialValuesEqual={isEqual} //required to compare block data correctly
+                subscription={{ ${finalFormSubscription.length ? finalFormSubscription.map((field) => `${field}: true`).join(", ") : ``} }}
+            >
+                {(${finalFormRenderProps.length ? `{${finalFormRenderProps.join(", ")}}` : ``}) => (
+                    ${editMode ? `<>` : ``}
+                        ${editMode ? `{saveConflict.dialogs}` : ``}
+                        <>
+                            ${fieldsCode}
+                        </>
+                    ${editMode ? `</>` : ``}
+                )}
+            </FinalForm>
+        );
+    }
+
+    `,
+		gqlDocuments
+	};
+}
+/**
+* Checks if the provided form config is valid.
+*
+* Examples of invalid configs:
+* - The "id" field is not read-only
+*
+* @param config The form config to check.
+* @throws Will throw an error if the provided config is invalid.
+*/
+function assertValidConfig(config) {
+	function validateFields(fields) {
+		for (const field of fields) if (isFormFieldConfig(field)) {
+			if (field.name === "id" && !field.readOnly) throw new Error(`Invalid form config: the "id" field must be read-only`);
+		} else if (isFormLayoutConfig(field)) validateFields(field.fields);
+	}
+	validateFields(config.fields);
+}
+
+//#endregion
+//#region src/commands/generate/utils/findRootBlocks.ts
+const fallbackLibraryBlocks = {
+	AnchorBlock: "@comet/cms-admin",
+	DamImageBlock: "@comet/cms-admin",
+	DamVideoBlock: "@comet/cms-admin",
+	ExternalLinkBlock: "@comet/cms-admin",
+	InternalLinkBlock: "@comet/cms-admin",
+	PixelImageBlock: "@comet/cms-admin",
+	SpaceBlock: "@comet/cms-admin",
+	SvgImageBlock: "@comet/cms-admin",
+	YouTubeVideoBlock: "@comet/cms-admin"
+};
+function findRootBlocks({ gqlType, targetDirectory }, schema) {
+	const ret = {};
+	const schemaEntity = schema.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+	if (!schemaEntity) throw new Error("didn't find entity in schema types");
+	schemaEntity.fields.forEach((field) => {
+		if (ret[field.name]) return;
+		let type = field.type;
+		if (type.kind == "NON_NULL") type = type.ofType;
+		if (type.kind == "SCALAR" && type.name.endsWith("BlockData")) {
+			let match = false;
+			const blockName = `${type.name.replace(/BlockData$/, "")}Block`;
+			const checkNames = [{
+				folderName: `${targetDirectory.replace(/\/generated$/, "")}/blocks`,
+				import: `../blocks/${blockName}`
+			}, {
+				folderName: `src/common/blocks`,
+				import: `@src/common/blocks/${blockName}`
+			}];
+			for (const checkName of checkNames) if (existsSync(`${checkName.folderName}/${blockName}.tsx`)) {
+				match = true;
+				ret[field.name] = {
+					import: checkName.import,
+					name: blockName
+				};
+				break;
+			}
+			if (!match) {
+				const fallback = fallbackLibraryBlocks[blockName];
+				if (fallback) {
+					ret[field.name] = {
+						import: fallback,
+						name: blockName
+					};
+					match = true;
+				}
+			}
+			if (!match) throw new Error(`Didn't find admin block for ${blockName} in ${checkNames.map((c) => c.folderName).join(" or ")}`);
+		}
+	});
+	return ret;
+}
+
+//#endregion
+//#region src/commands/generate/generateGrid/detectMuiXVersion.ts
+function detectMuiXGridVariant() {
+	const packageJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+	const packages = Object.keys(packageJson.dependencies);
+	if (packages.includes("@mui/x-data-grid-premium")) return {
+		variant: "premium",
+		package: "@mui/x-data-grid-premium",
+		gridComponent: "DataGridPremium"
+	};
+	else if (packages.includes("@mui/x-data-grid-pro")) return {
+		variant: "pro",
+		package: "@mui/x-data-grid-pro",
+		gridComponent: "DataGridPro"
+	};
+	else return {
+		variant: "community",
+		package: "@mui/x-data-grid",
+		gridComponent: "DataGrid"
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateGrid/findInputObjectType.ts
+function findInputObjectType(input, schema) {
+	let type = input.type;
+	if (type.kind == "NON_NULL") type = type.ofType;
+	if (type.kind !== "INPUT_OBJECT") throw new Error("must be INPUT_OBJECT");
+	const typeName = type.name;
+	return schema.__schema.types.find((type$1) => type$1.kind === "INPUT_OBJECT" && type$1.name === typeName);
+}
+
+//#endregion
+//#region src/commands/generate/generateGrid/generateGqlFieldList.ts
+const recursiveStringify = (obj) => {
+	let ret = "";
+	let prefixField = "";
+	for (const key in obj) {
+		const valueForKey = obj[key];
+		if (typeof valueForKey === "boolean") ret += `${prefixField}${key}`;
+		else if (typeof valueForKey === "string") ret += `${prefixField}${key}${valueForKey}`;
+		else ret += `${prefixField}${key} { ${recursiveStringify(valueForKey)} }`;
+		prefixField = " ";
+	}
+	return ret;
+};
+function generateGqlFieldList({ columns }) {
+	return recursiveStringify(columns.reduce((acc, field) => {
+		if (field.type === "actions") field.queryFields?.forEach((queryField) => {
+			objectPath.set(acc, queryField, true);
+		});
+		else if (field.name === "id") {} else {
+			let hasCustomFields = false;
+			if ("labelField" in field && field.labelField) {
+				objectPath.set(acc, `${field.name}.${field.labelField}`, true);
+				hasCustomFields = true;
+			}
+			if ("queryFields" in field) {
+				field.queryFields?.forEach((queryField) => {
+					objectPath.set(acc, queryField, true);
+				});
+				hasCustomFields = true;
+			}
+			if (!hasCustomFields) objectPath.set(acc, field.name, true);
+		}
+		return acc;
+	}, {}));
+}
+
+//#endregion
+//#region src/commands/generate/generateGrid/generateGridToolbar.ts
+const generateGridToolbar = ({ componentName, forwardToolbarAction, hasSearch, hasFilter, excelExport, allowAdding, instanceGqlType, gqlType, newEntryText, fragmentName }) => {
+	return `${renderToolbarProps(componentName, !!forwardToolbarAction, !!excelExport)}
+    function ${componentName}(${getGridToolbarProps(componentName, !!forwardToolbarAction, !!excelExport)}) {
+        return (
+            <DataGridToolbar>
+                ${hasSearch ? "<GridToolbarQuickFilter />" : ""}
+                ${hasFilter ? "<GridFilterButton />" : ""}
+                <FillSpace />
+                ${renderToolbarActions({
+		forwardToolbarAction,
+		addItemText: generateFormattedMessage({
+			config: newEntryText,
+			id: `${instanceGqlType}.${camelCase(fragmentName)}.newEntry`,
+			defaultMessage: `New ${camelCaseToHumanReadable(gqlType)}`,
+			type: "jsx"
+		}),
+		excelExport,
+		allowAdding
+	})}
+            </DataGridToolbar>
+        );
+    }`.replace(/^\s+\n/gm, "");
+};
+const getGridToolbarProps = (componentName, toolbarAction, exportApi) => {
+	const props = [];
+	if (toolbarAction) props.push({
+		destructured: "toolbarAction",
+		typeDefinition: "toolbarAction?: ReactNode"
+	});
+	if (exportApi) props.push({
+		destructured: "exportApi",
+		typeDefinition: "exportApi: ExportApi"
+	});
+	if (!props.length) return "";
+	return `{
+        ${props.map((prop) => `${prop.destructured}`).join(",")}
+    }: ${componentName}ToolbarProps`;
+};
+const renderToolbarActions = ({ forwardToolbarAction, addItemText, excelExport, allowAdding }) => {
+	const showMoreActionsMenu = excelExport;
+	if (!showMoreActionsMenu && !allowAdding) return "";
+	const moreActionsMenu = `<CrudMoreActionsMenu
+        slotProps={{
+            button: {
+                responsive: true
+            }
+        }}
+        overallActions={[
+            ${excelExport ? `{
+                        label: <FormattedMessage {...messages.downloadAsExcel} />,
+                        icon: exportApi.loading ? <CircularProgress size={20} /> : <ExcelIcon />,
+                        onClick: () => exportApi.exportGrid(),
+                        disabled: exportApi.loading,
+                    }` : ""}
+        ]}
+    />`;
+	const defaultAddItemButton = `<Button responsive startIcon={<AddIcon />} component={StackLink} pageName="add" payload="add">
+        ${addItemText}
+    </Button>`;
+	return `
+        ${showMoreActionsMenu ? moreActionsMenu : ""}
+        ${allowAdding ? forwardToolbarAction ? "{toolbarAction}" : defaultAddItemButton : ""}`;
+};
+const renderToolbarProps = (componentName, forwardToolbarAction, exportApi) => {
+	if (forwardToolbarAction || exportApi) return `interface ${componentName}ToolbarProps extends GridToolbarProps {
+         ${forwardToolbarAction ? "toolbarAction: ReactNode;" : ""}
+         ${exportApi ? "exportApi: ExportApi;" : ""}
+}`;
+	return "";
+};
+
+//#endregion
+//#region src/commands/generate/generateGrid/getForwardedGqlArgs.ts
+function getForwardedGqlArgs(gqlFields) {
+	const ret = [];
+	getArgs(gqlFields, [
+		"offset",
+		"limit",
+		"sort",
+		"search",
+		"filter",
+		"input"
+	]).forEach((arg) => {
+		let prop;
+		const imports = [];
+		if (arg.type === "ID" || arg.type === "String" || arg.type === "DateTime") prop = {
+			name: arg.name,
+			optional: false,
+			type: "string"
+		};
+		else if (arg.type === "Boolean") prop = {
+			name: arg.name,
+			optional: false,
+			type: "boolean"
+		};
+		else if (arg.type === "Int" || arg.type === "Float") prop = {
+			name: arg.name,
+			optional: false,
+			type: "number"
+		};
+		else if (arg.type === "JSONObject") prop = {
+			name: arg.name,
+			optional: false,
+			type: "unknown"
+		};
+		else {
+			prop = {
+				name: arg.name,
+				optional: false,
+				type: `GQL${arg.type}`
+			};
+			imports.push({
+				name: `GQL${arg.type}`,
+				importPath: "@src/graphql.generated"
+			});
+		}
+		ret.push({
+			gqlArg: {
+				name: arg.name,
+				type: arg.type,
+				queryOrMutationName: arg.gqlField.name
+			},
+			prop,
+			imports
+		});
+	});
+	return ret;
+}
+function getArgs(gqlFields, skipGqlArgs) {
+	return gqlFields.reduce((acc, gqlField) => {
+		gqlField.args.forEach((gqlArg) => {
+			if (skipGqlArgs.includes(gqlArg.name)) return acc;
+			if (gqlArg.type.kind !== "NON_NULL" || gqlArg.defaultValue) return acc;
+			const gqlType = gqlArg.type.ofType;
+			let type = "unknown";
+			if (gqlType.kind === "SCALAR") if (![
+				"ID",
+				"String",
+				"Boolean",
+				"Int",
+				"Float",
+				"DateTime",
+				"JSONObject"
+			].includes(gqlType.name)) console.warn(`Currently not supported special SCALAR of type ${gqlType.name} in param ${gqlArg.name} of ${gqlField.name}`);
+			else type = gqlType.name;
+			else if (gqlType.kind === "INPUT_OBJECT") type = gqlType.name;
+			else throw new Error(`Not supported kind ${gqlType.kind}, arg: ${gqlArg.name}`);
+			acc.push({
+				name: gqlArg.name,
+				type,
+				gqlArg,
+				gqlField
+			});
+		});
+		return acc;
+	}, []);
+}
+
+//#endregion
+//#region src/commands/generate/generateGrid/getPropsForFilterProp.ts
+function getPropsForFilterProp({ config, filterType }) {
+	if (!config.filterProp) return {
+		hasFilterProp: false,
+		imports: [],
+		props: []
+	};
+	const filterTypeName = `GQL${filterType.name}`;
+	return {
+		hasFilterProp: true,
+		imports: [{
+			name: filterTypeName,
+			importPath: "@src/graphql.generated"
+		}],
+		props: [{
+			name: "filter",
+			optional: true,
+			type: filterTypeName
+		}]
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generateGrid/generateGrid.ts
+const { plural, singular } = pluralize;
+function tsCodeRecordToString(object, spreadAbove) {
+	return `{${spreadAbove ? `${spreadAbove}` : ""}${Object.entries(object).filter(([key, value]) => value !== void 0).map(([key, value]) => `${key}: ${value},`).join("\n")}}`;
+}
+function generateGridPropsCode(props) {
+	if (!props.length) return {
+		gridPropsTypeCode: "",
+		gridPropsParamsCode: ""
+	};
+	const uniqueProps = props.reduce((acc, prop) => {
+		const propWithSameName = acc.find((filteredProps) => filteredProps.name === prop.name);
+		if (propWithSameName) if (propWithSameName.type === prop.type) {} else throw new Error(`Prop ${prop.name} with same name but different types (${propWithSameName.type} and ${prop.type}) detected.`);
+		else acc.push(prop);
+		return acc;
+	}, []);
+	return {
+		gridPropsTypeCode: `type Props = {
+            ${uniqueProps.map((prop) => `${prop.type.includes("any") ? `// eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                ` : ``}${prop.name}${prop.optional ? `?` : ``}: ${prop.type};`).join("\n")}
+        };`,
+		gridPropsParamsCode: `{${uniqueProps.map((prop) => `${prop.name} ${prop.defaultValue ? `= ${prop.defaultValue}` : ""}`).join(", ")}}: Props`
+	};
+}
+const getSortByValue = (sortBy) => {
+	if (Array.isArray(sortBy)) return `[${sortBy.map((i) => `"${i}"`).join(", ")}]`;
+	if (typeof sortBy === "string") return `"${sortBy}"`;
+	return sortBy;
+};
+const getValueOptionsLabelData = (messageId, label) => {
+	if (typeof label === "string" || isFormattedMessageElement(label)) return { textLabel: generateFormattedMessage({
+		config: label,
+		id: messageId,
+		type: "intlCall"
+	}) };
+	const textLabelParts = [];
+	const gridCellContentProps = {};
+	if ("primaryText" in label && label.primaryText) {
+		const primaryMessageId = `${messageId}.primary`;
+		textLabelParts.push(generateFormattedMessage({
+			config: label.primaryText,
+			id: primaryMessageId,
+			type: "intlCall"
+		}));
+		gridCellContentProps.primaryText = generateFormattedMessage({
+			config: label.primaryText,
+			id: primaryMessageId,
+			type: "jsx"
+		});
+	}
+	if ("secondaryText" in label && label.secondaryText) {
+		const secondaryMessageId = `${messageId}.secondary`;
+		textLabelParts.push(generateFormattedMessage({
+			config: label.secondaryText,
+			id: secondaryMessageId,
+			type: "intlCall"
+		}));
+		gridCellContentProps.secondaryText = generateFormattedMessage({
+			config: label.secondaryText,
+			id: secondaryMessageId,
+			type: "jsx"
+		});
+	}
+	if ("icon" in label) {
+		if (typeof label.icon === "string") gridCellContentProps.icon = `<${label.icon}Icon />`;
+		else if (typeof label.icon === "object") if ("import" in label.icon) gridCellContentProps.icon = `<${label.icon.name} />`;
+		else {
+			const { name, ...iconProps } = label.icon;
+			gridCellContentProps.icon = `<${name}Icon
+                ${Object.entries(iconProps).map(([key, value]) => `${key}="${value}"`).join("\n")}
+            />`;
+		}
+	}
+	const gridCellContent = `<GridCellContent
+        ${Object.entries(gridCellContentProps).map(([key, value]) => `${key}={${value}}`).join("\n")}
+    />`;
+	return {
+		textLabel: textLabelParts.join(" + ' ' + "),
+		gridCellContent
+	};
+};
+function queryHasPaging(gridQueryType, gqlIntrospection) {
+	let returnType = gridQueryType.type;
+	if (returnType.kind === "NON_NULL") returnType = returnType.ofType;
+	if (returnType.kind === "LIST") return false;
+	if (returnType.kind === "OBJECT") {
+		const typeName = returnType.name;
+		const objectType = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === typeName);
+		if (objectType) {
+			const hasNodes = objectType.fields.some((f) => f.name === "nodes");
+			const hasTotalCount = objectType.fields.some((f) => f.name === "totalCount");
+			return hasNodes && hasTotalCount;
+		}
+	}
+	return false;
+}
+function generateGrid({ exportName, baseOutputFilename, targetDirectory, gqlIntrospection }, config) {
+	const gqlType = config.gqlType;
+	if (!gqlType) throw new Error("gqlType is required in grid config");
+	const muiXGridVariant = detectMuiXGridVariant();
+	const gqlTypePlural = plural(gqlType);
+	const instanceGqlType = gqlType[0].toLowerCase() + gqlType.substring(1);
+	const instanceGqlTypePlural = gqlTypePlural[0].toLowerCase() + gqlTypePlural.substring(1);
+	const gridQuery = config.query ? config.query : instanceGqlType != instanceGqlTypePlural ? instanceGqlTypePlural : `${instanceGqlTypePlural}List`;
+	const gqlDocuments = {};
+	const imports = [
+		{
+			name: "FormattedMessage",
+			importPath: "react-intl"
+		},
+		{
+			name: "FormattedNumber",
+			importPath: "react-intl"
+		},
+		{
+			name: "useIntl",
+			importPath: "react-intl"
+		},
+		{
+			name: "ReactNode",
+			importPath: "react"
+		},
+		{
+			name: "gql",
+			importPath: "@apollo/client"
+		},
+		{
+			name: "useApolloClient",
+			importPath: "@apollo/client"
+		},
+		{
+			name: "useQuery",
+			importPath: "@apollo/client"
+		},
+		{
+			name: "Button",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "CrudContextMenu",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "CrudMoreActionsMenu",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "DataGridToolbar",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "ExportApi",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "filterByFragment",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "GridFilterButton",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "GridCellContent",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "GridColDef",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "dataGridDateTimeColumn",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "dataGridDateColumn",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "dataGridIdColumn",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "dataGridManyToManyColumn",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "dataGridOneToManyColumn",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "renderStaticSelectCell",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "messages",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "muiGridFilterToGql",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "StackLink",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "useStackSwitchApi",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "FillSpace",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "Tooltip",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "useBufferedRowCount",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "useDataGridExcelExport",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "usePersistentColumnState",
+			importPath: "@comet/admin"
+		},
+		{
+			name: "BlockPreviewContent",
+			importPath: "@comet/cms-admin"
+		},
+		{
+			name: "Alert",
+			importPath: "@mui/material"
+		},
+		{
+			name: "Box",
+			importPath: "@mui/material"
+		},
+		{
+			name: "IconButton",
+			importPath: "@mui/material"
+		},
+		{
+			name: "Typography",
+			importPath: "@mui/material"
+		},
+		{
+			name: "useTheme",
+			importPath: "@mui/material"
+		},
+		{
+			name: "Menu",
+			importPath: "@mui/material"
+		},
+		{
+			name: "MenuItem",
+			importPath: "@mui/material"
+		},
+		{
+			name: "ListItemIcon",
+			importPath: "@mui/material"
+		},
+		{
+			name: "ListItemText",
+			importPath: "@mui/material"
+		},
+		{
+			name: "CircularProgress",
+			importPath: "@mui/material"
+		},
+		{
+			name: muiXGridVariant.gridComponent,
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: `${muiXGridVariant.gridComponent}Props`,
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridLogicOperator",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridRenderCellParams",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridSlotsComponent",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridToolbarProps",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridColumnHeaderTitle",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridToolbarQuickFilter",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "GridRowOrderChangeParams",
+			importPath: muiXGridVariant.package
+		},
+		{
+			name: "useMemo",
+			importPath: "react"
+		}
+	];
+	const iconsToImport = [
+		"Add",
+		"Edit",
+		"Info",
+		"Excel"
+	];
+	const props = [];
+	const fieldList = generateGqlFieldList({ columns: config.columns });
+	const rootBlocks = findRootBlocks({
+		gqlType,
+		targetDirectory
+	}, gqlIntrospection);
+	config.columns.filter((column) => column.type == "block").forEach((field) => {
+		if (rootBlocks[String(field.name)]) {
+			const block = field.block;
+			if (isGeneratorConfigImport(block)) {
+				rootBlocks[String(field.name)].import = block.import;
+				rootBlocks[String(field.name)].name = block.name;
+			}
+		}
+	});
+	Object.values(rootBlocks).forEach((block) => {
+		if (isGeneratorConfigImport(block)) imports.push(convertConfigImport(block));
+	});
+	const gridQueryType = findQueryTypeOrThrow(gridQuery, gqlIntrospection);
+	const hasPaging = queryHasPaging(gridQueryType, gqlIntrospection);
+	if (hasPaging) imports.push({
+		name: "useDataGridRemote",
+		importPath: "@comet/admin"
+	});
+	else imports.push({
+		name: "useDataGridUrlState",
+		importPath: "@comet/admin"
+	});
+	const updateMutationType = findMutationType(`update${gqlType}`, gqlIntrospection);
+	const hasDeleteMutation = !!findMutationType(`delete${gqlType}`, gqlIntrospection);
+	const hasUpdateMutation = !!updateMutationType;
+	const allowAdding = (typeof config.add === "undefined" || config.add === true) && !config.readOnly;
+	const allowEditing = (typeof config.edit === "undefined" || config.edit === true) && !config.readOnly;
+	const allowDeleting = (typeof config.delete === "undefined" || config.delete === true) && !config.readOnly && hasDeleteMutation;
+	const allowRowReordering = typeof config.rowReordering?.enabled !== "undefined" && config.rowReordering?.enabled && hasUpdateMutation;
+	const updateInputArg = updateMutationType?.args.find((arg) => arg.name === "input");
+	if (allowRowReordering && updateInputArg) {
+		const inputType = findInputObjectType(updateInputArg, gqlIntrospection);
+		if (!inputType) throw new Error("Can't find update input type");
+		if (!inputType.inputFields?.find((field) => field.name === "position")) throw new Error("Position field is needed when using 'rowReordering'");
+	}
+	if (allowRowReordering && typeof config.rowReordering?.dragPreviewField !== "undefined" && !config.columns.find((column) => column.type !== "actions" && column?.name === config.rowReordering?.dragPreviewField)) throw new Error(`rowReorderingOnDragField '${config.rowReordering?.dragPreviewField}' must exist in columns`);
+	const forwardRowAction = allowEditing && config.rowActionProp;
+	const showActionsColumn = allowEditing || allowDeleting;
+	const showCrudContextMenuInActionsColumn = allowDeleting;
+	const showEditInActionsColumn = allowEditing && !forwardRowAction;
+	const defaultActionsColumnWidth = getDefaultActionsColumnWidth(showCrudContextMenuInActionsColumn, showEditInActionsColumn);
+	let useScopeFromContext = false;
+	const gqlArgs = [];
+	{
+		const forwardedArgs = getForwardedGqlArgs([gridQueryType]);
+		for (const forwardedArg of forwardedArgs) {
+			imports.push(...forwardedArg.imports);
+			if (forwardedArg.gqlArg.name === "scope" && !config.scopeAsProp) {
+				useScopeFromContext = true;
+				gqlArgs.push(forwardedArg.gqlArg);
+			} else {
+				props.push(forwardedArg.prop);
+				gqlArgs.push(forwardedArg.gqlArg);
+			}
+		}
+	}
+	if (useScopeFromContext) imports.push({
+		name: "useContentScope",
+		importPath: "@comet/cms-admin"
+	});
+	const renderToolbar = config.toolbar ?? true;
+	const filterArg = gridQueryType.args.find((arg) => arg.name === "filter");
+	const hasFilter = !!filterArg && renderToolbar && !allowRowReordering;
+	let hasFilterProp = false;
+	let filterFields = [];
+	if (filterArg) {
+		const filterType = findInputObjectType(filterArg, gqlIntrospection);
+		if (!filterType) throw new Error("Can't find filter type");
+		filterFields = filterType.inputFields.map((f) => f.name.replace(/_/g, "."));
+		const { hasFilterProp: tempHasFilterProp, imports: filterPropImports, props: filterPropProps } = getPropsForFilterProp({
+			config,
+			filterType
+		});
+		hasFilterProp = tempHasFilterProp;
+		imports.push(...filterPropImports);
+		props.push(...filterPropProps);
+	}
+	const forwardToolbarAction = allowAdding && renderToolbar && config.toolbarActionProp;
+	if (forwardToolbarAction) props.push({
+		name: "toolbarAction",
+		type: "ReactNode",
+		optional: true
+	});
+	const sortArg = gridQueryType.args.find((arg) => arg.name === "sort");
+	const hasSort = !!sortArg;
+	let sortFields = [];
+	if (sortArg) {
+		imports.push({
+			name: "muiGridSortToGql",
+			importPath: "@comet/admin"
+		});
+		let sortArgType = sortArg.type;
+		if (sortArgType.kind === "NON_NULL") sortArgType = sortArgType.ofType;
+		if (sortArgType.kind !== "LIST") throw new Error("Sort argument must be LIST");
+		if (sortArgType.ofType.kind !== "NON_NULL") throw new Error("Sort argument must be LIST->NON_NULL");
+		if (sortArgType.ofType.ofType.kind !== "INPUT_OBJECT") throw new Error("Sort argument must be LIST->NON_NULL->INPUT_OBJECT");
+		const sortTypeName = sortArgType.ofType.ofType.name;
+		const sortType = gqlIntrospection.__schema.types.find((type) => type.kind === "INPUT_OBJECT" && type.name === sortTypeName);
+		if (!sortType) throw new Error("Can't find sort type");
+		const sortField = sortType.inputFields.find((i) => i.name == "field");
+		if (!sortField) throw new Error("Can't find sortFieldName");
+		if (sortField.type.kind !== "NON_NULL") throw new Error("sortField must be NON_NULL");
+		if (sortField.type.ofType.kind != "ENUM") throw new Error("sortField must be NON_NULL->ENUM");
+		const sortFieldEnumName = sortField.type.ofType.name;
+		const sortInputEnum = gqlIntrospection.__schema.types.find((type) => type.kind === "ENUM" && type.name === sortFieldEnumName);
+		if (!sortInputEnum) throw new Error("Can't find sortInputEnum");
+		sortFields = sortInputEnum.enumValues.map((v) => v.name.replace(/_/g, "."));
+		if (allowRowReordering && !sortFields.includes("position")) throw new Error("Sort argument must include 'position' field for row reordering");
+	}
+	const hasSearch = gridQueryType.args.some((arg) => arg.name === "search") && !allowRowReordering;
+	const schemaEntity = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
+	if (!schemaEntity) throw new Error("didn't find entity in schema types");
+	const { component: actionsColumnComponent, type: actionsColumnType, headerName: actionsColumnHeaderName, pinned: actionsColumnPinned = "right", width: actionsColumnWidth = defaultActionsColumnWidth, visible: actionsColumnVisible = void 0, queryFields: actionsColumnQueryFields = [], ...restActionsColumnConfig } = config.columns.find((column) => column.type === "actions") ?? {};
+	if (actionsColumnComponent) {
+		if (!isGeneratorConfigImport(actionsColumnComponent)) throw new Error("Unsupported actionsColumnComponent, only imports are supported");
+		imports.push(convertConfigImport(actionsColumnComponent));
+	}
+	const gridNeedsTheme = config.columns.some((column) => typeof column.visible === "string");
+	const gridColumnFields = config.columns.filter((column) => column.type !== "actions").map((column) => {
+		const type = column.type;
+		const name = String(column.name);
+		let gridColumnType = void 0;
+		let renderCell = void 0;
+		let valueFormatter = void 0;
+		let valueGetter = name.includes(".") ? `(params, row) => row.${name.replace(/\./g, "?.")}` : void 0;
+		let gridType;
+		let filterOperators;
+		if (column.type != "virtual" && column.filterOperators) if (isGeneratorConfigImport(column.filterOperators)) {
+			imports.push(convertConfigImport(column.filterOperators));
+			filterOperators = column.filterOperators.name;
+		} else throw new Error("Unsupported filterOperators, only imports are supported for now");
+		if (type == "dateTime") {
+			gridColumnType = "...dataGridDateTimeColumn,";
+			valueGetter = name.includes(".") ? `(params, row) => row.${name.replace(/\./g, "?.")} && new Date(row.${name.replace(/\./g, "?.")})` : void 0;
+		} else if (type == "date") {
+			gridColumnType = "...dataGridDateColumn,";
+			valueGetter = name.includes(".") ? `(params, row) => row.${name.replace(/\./g, "?.")} && new Date(row.${name.replace(/\./g, "?.")})` : void 0;
+		} else if (type == "number") {
+			gridType = "number";
+			const defaultDecimals = column.currency ? 2 : 0;
+			const decimals = typeof column.decimals === "number" ? column.decimals : defaultDecimals;
+			renderCell = `({ value }) => {
+                return (typeof value === "number") ? <FormattedNumber value={value} ${column.currency ? `style="currency" currency="${column.currency}"` : ""} minimumFractionDigits={${decimals}} maximumFractionDigits={${decimals}} /> : "";
+            }`;
+		} else if (type == "boolean") gridType = "boolean";
+		else if (column.type == "block") renderCell = `(params) => {
+                    return <BlockPreviewContent block={${column.block.name}} input={params.row.${name}} />;
+                }`;
+		else if (type == "staticSelect") {
+			valueFormatter = `(value, row) => row.${name}?.toString()`;
+			const introspectionField = schemaEntity.fields.find((field) => field.name === name);
+			if (!introspectionField) throw new Error(`didn't find field ${name} in gql introspection type ${gqlType}`);
+			const introspectionFieldType = introspectionField.type.kind === "NON_NULL" ? introspectionField.type.ofType : introspectionField.type;
+			const enumType = gqlIntrospection.__schema.types.find((t) => t.kind === "ENUM" && t.name === introspectionFieldType.name);
+			column.values?.forEach((value) => {
+				if (typeof value === "object" && typeof value.label === "object" && "icon" in value.label) {
+					if (typeof value.label.icon === "string") iconsToImport.push(value.label.icon);
+					else if (typeof value.label.icon?.name === "string") if (isGeneratorConfigImport(value.label.icon)) imports.push(convertConfigImport(value.label.icon));
+					else iconsToImport.push(value.label.icon.name);
+				}
+			});
+			let columnValues = [];
+			if (column.values) columnValues = column.values;
+			else if (enumType) columnValues = enumType.enumValues.map((i) => i.name);
+			else throw new Error(`Enum type not found`);
+			const valueOptions = `[${columnValues.map((value) => {
+				if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return {
+					value,
+					label: camelCaseToHumanReadable(value.toString())
+				};
+				else return value;
+			}).map(({ value, label }) => {
+				const labelData = getValueOptionsLabelData(`${instanceGqlType}.${name}.${value.toString().charAt(0).toLowerCase() + value.toString().slice(1)}`, label);
+				return `{
+                        value: ${JSON.stringify(value)},
+                        label: ${labelData.textLabel},
+                        ${labelData.gridCellContent !== void 0 ? `cellContent: ${labelData.gridCellContent},` : ""}
+                    },`;
+			}).join(" ")}]`;
+			renderCell = `renderStaticSelectCell`;
+			return {
+				name,
+				headerName: column.headerName,
+				type,
+				gridType: "singleSelect",
+				columnType: gridColumnType,
+				valueOptions,
+				renderCell,
+				valueFormatter,
+				width: column.width,
+				minWidth: column.minWidth,
+				maxWidth: column.maxWidth,
+				flex: column.flex,
+				headerInfoTooltip: column.headerInfoTooltip,
+				visible: column.visible !== void 0 ? typeof column.visible == "string" ? `theme.breakpoints.${column.visible}` : "false" : void 0,
+				pinned: column.pinned,
+				disableExport: column.disableExport
+			};
+		} else if (type == "id") gridColumnType = "...dataGridIdColumn,";
+		else if (type == "manyToMany") gridColumnType = "...dataGridManyToManyColumn,";
+		else if (type == "oneToMany") gridColumnType = "...dataGridOneToManyColumn,";
+		if ((column.type == "text" || column.type == "number" || column.type == "boolean" || column.type == "date" || column.type == "dateTime" || column.type == "virtual" || column.type == "id" || column.type == "manyToMany" || column.type == "oneToMany") && column.renderCell) if (isGeneratorConfigCode(column.renderCell)) {
+			renderCell = column.renderCell.code;
+			imports.push(...column.renderCell.imports.map((imprt) => convertConfigImport(imprt)));
+		} else throw new Error(`Unsupported renderCell for column '${name}', only arrow functions are supported`);
+		if ((column.type === "manyToMany" || column.type === "oneToMany") && !column.renderCell) {
+			if (!column.labelField) throw new Error(`labelField is required for ${column.type} column '${name}' if no custom renderCell is provided`);
+			renderCell = `({ row }) => <>{row.${column.name}.map((${singular(column.name)}) => ${singular(column.name)}.${column.labelField}).join(", ")}</>`;
+		}
+		return {
+			name,
+			fieldName: column.fieldName,
+			headerName: column.headerName,
+			type,
+			gridType,
+			columnType: gridColumnType,
+			renderCell,
+			valueGetter,
+			filterOperators,
+			valueFormatter,
+			width: column.width,
+			minWidth: column.minWidth,
+			maxWidth: column.maxWidth,
+			flex: column.flex,
+			headerInfoTooltip: column.headerInfoTooltip,
+			visible: column.visible !== void 0 ? typeof column.visible == "string" ? `theme.breakpoints.${column.visible}` : "false" : void 0,
+			pinned: column.pinned,
+			disableExport: column.disableExport,
+			sortBy: "sortBy" in column ? column.sortBy : void 0
+		};
+	});
+	iconsToImport.forEach((icon) => {
+		imports.push({
+			name: `${icon} as ${icon}Icon`,
+			importPath: "@comet/admin-icons"
+		});
+	});
+	const fragmentName = config.fragmentName ?? `${gqlTypePlural}Form`;
+	if (forwardRowAction) {
+		props.push({
+			name: "rowAction",
+			type: `(params: GridRenderCellParams<GQL${fragmentName}Fragment>) => ReactNode`,
+			optional: true
+		});
+		props.push({
+			name: "actionsColumnWidth",
+			type: `number`,
+			optional: true,
+			defaultValue: defaultActionsColumnWidth
+		});
+		props.push({
+			name: "onRowClick",
+			type: `${muiXGridVariant.gridComponent}Props["onRowClick"]`,
+			optional: true
+		});
+	}
+	if (config.selectionProps) {
+		props.push({
+			name: "rowSelectionModel",
+			type: `${muiXGridVariant.gridComponent}Props["rowSelectionModel"]`,
+			optional: true
+		});
+		props.push({
+			name: "onRowSelectionModelChange",
+			type: `${muiXGridVariant.gridComponent}Props["onRowSelectionModelChange"]`,
+			optional: true
+		});
+	}
+	const { gridPropsTypeCode, gridPropsParamsCode } = generateGridPropsCode(props);
+	const gridToolbarComponentName = `${gqlTypePlural}GridToolbar`;
+	const dataGridRemoteParameters = config.initialSort || config.queryParamsPrefix || config.initialFilter ? `{${config.initialSort ? ` initialSort: [${config.initialSort.map((item) => {
+		return `{field: "${item.field}", sort: "${item.sort}"}`;
+	}).join(",\n")} ], ` : ""}
+              ${config.initialFilter ? `initialFilter:{ ${config.initialFilter.linkOperator ? `linkOperator: GridLogicOperator.${config.initialFilter.linkOperator === "or" ? "Or" : "And"},` : ""}
+                      items: [${config.initialFilter.items.map((item) => {
+		return `{ field: "${item.field}", operator: "${item.operator}", value: "${item.value}" }`;
+	}).join(",\n")} ],},` : ""}
+              ${config.queryParamsPrefix ? `queryParamsPrefix: "${config.queryParamsPrefix}",` : ""}
+              }` : "";
+	return {
+		code: `import {
+        GQL${gqlTypePlural}GridQuery,
+        GQL${gqlTypePlural}GridQueryVariables,
+        GQL${fragmentName}Fragment,
+        GQLCreate${gqlType}Mutation,
+        GQLCreate${gqlType}MutationVariables,
+        GQLUpdate${gqlType}PositionMutation,
+        GQLUpdate${gqlType}PositionMutationVariables,
+        GQLDelete${gqlType}Mutation,
+        GQLDelete${gqlType}MutationVariables
+    } from "./${baseOutputFilename}.generated";
+    ${generateImportsCode(imports)}
+
+    const ${instanceGqlTypePlural}Fragment = gql\`
+        fragment ${fragmentName} on ${gqlType} {
+            id
+            ${fieldList}
+        }
+    \`;
+
+    const ${instanceGqlTypePlural}Query = gql\`${generateGqlOperation({
+			type: "query",
+			operationName: `${gqlTypePlural}Grid`,
+			rootOperation: gridQuery,
+			fields: hasPaging ? [`nodes...${fragmentName}`, "totalCount"] : [`...${fragmentName}`],
+			fragmentVariables: [`\${${instanceGqlTypePlural}Fragment}`],
+			variables: [
+				...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name).map((gqlArg) => ({
+					name: gqlArg.name,
+					type: `${gqlArg.type}!`
+				})),
+				...hasPaging ? [{
+					name: "offset",
+					type: "Int!"
+				}, {
+					name: "limit",
+					type: "Int!"
+				}] : [],
+				...hasSort ? [{
+					name: "sort",
+					type: `[${gqlType}Sort!]`
+				}] : [],
+				...hasSearch ? [{
+					name: "search",
+					type: "String"
+				}] : [],
+				...filterArg && (hasFilter || hasFilterProp) ? [{
+					name: "filter",
+					type: `${gqlType}Filter`
+				}] : []
+			]
+		})}\`;
+
+    ${allowRowReordering ? `const update${gqlType}PositionMutation = gql\`
+                mutation Update${gqlType}Position($id: ID!, $input: ${gqlType}UpdateInput!) {
+                    update${gqlType}(id: $id, input: $input) {
+                        id
+                        position
+                        updatedAt
+                    }
+                }
+            \`;` : ""}
+
+    ${allowDeleting ? `const delete${gqlType}Mutation = gql\`
+                mutation Delete${gqlType}($id: ID!) {
+                    delete${gqlType}(id: $id)
+                }
+            \`;` : ""}
+
+
+    ${renderToolbar ? generateGridToolbar({
+			componentName: gridToolbarComponentName,
+			forwardToolbarAction,
+			hasSearch,
+			hasFilter,
+			allowAdding,
+			instanceGqlType,
+			gqlType,
+			excelExport: config.excelExport,
+			newEntryText: config.newEntryText,
+			fragmentName
+		}) : ""}
+
+    ${gridPropsTypeCode}
+
+    export function ${gqlTypePlural}Grid(${gridPropsParamsCode}) {
+        ${showCrudContextMenuInActionsColumn ? "const client = useApolloClient();" : ""}
+        const intl = useIntl();
+        const dataGridProps = { ...${hasPaging ? "useDataGridRemote" : "useDataGridUrlState"}(${dataGridRemoteParameters}), ...usePersistentColumnState("${gqlTypePlural}Grid")${config.selectionProps === "multiSelect" ? `, rowSelectionModel, onRowSelectionModelChange, checkboxSelection: true, keepNonExistentRowsSelected: true` : config.selectionProps === "singleSelect" ? `, rowSelectionModel, onRowSelectionModelChange, checkboxSelection: false, keepNonExistentRowsSelected: false, disableRowSelectionOnClick: false` : ``} };
+        ${useScopeFromContext ? `const { scope } = useContentScope();` : ""}
+        ${gridNeedsTheme ? `const theme = useTheme();` : ""}
+        ${showEditInActionsColumn ? `const stackSwitchApi = useStackSwitchApi();` : ""}
+
+        ${generateHandleRowOrderChange(allowRowReordering, gqlType, instanceGqlTypePlural)}
+
+        ${showEditInActionsColumn ? `const handleRowClick: ${muiXGridVariant.gridComponent}Props["onRowClick"] = (params) => {
+            stackSwitchApi.activatePage("edit", params.row.id);
+        };` : ""}
+
+        const columns: GridColDef<GQL${fragmentName}Fragment>[] = useMemo(()=>[
+            ${gridColumnFields.map((column) => {
+			const defaultMinWidth = 150;
+			const defaultColumnFlex = 1;
+			let minWidth;
+			let maxWidth;
+			let tooltipColumnWidth = column.width;
+			if (typeof column.width === "undefined") {
+				maxWidth = column.maxWidth;
+				if (typeof column.minWidth === "undefined" && (typeof column.maxWidth === "undefined" || column.maxWidth >= defaultMinWidth)) {
+					minWidth = defaultMinWidth;
+					tooltipColumnWidth = defaultMinWidth;
+				} else if (typeof column.minWidth !== "undefined") {
+					minWidth = column.minWidth;
+					tooltipColumnWidth = column.minWidth;
+				}
+			}
+			let isColumnFilterable = !hasPaging ? true : filterFields.includes(column.name) || !!column.filterOperators;
+			if (allowRowReordering) isColumnFilterable = false;
+			if (column.type == "block" && !hasPaging) isColumnFilterable = false;
+			let isColumnSortable = !hasPaging ? true : sortFields.includes(column.name) || !!column.sortBy;
+			if (allowRowReordering) isColumnSortable = false;
+			if (column.type == "block" && !hasPaging) isColumnSortable = false;
+			const columnDefinition = {
+				field: column.fieldName ? `"${column.fieldName}"` : `"${column.name.replace(/\./g, "_")}"`,
+				renderHeader: column.headerInfoTooltip ? `() => (
+                                    <>
+                                        <GridColumnHeaderTitle label={${generateFormattedMessage({
+					config: column.headerName,
+					id: `${instanceGqlType}.${column.name}`,
+					defaultMessage: camelCaseToHumanReadable(column.name),
+					type: "intlCall"
+				})}} columnWidth= {${tooltipColumnWidth}}
+                              />
+                                        <Tooltip
+                                            title={${generateFormattedMessage({
+					config: column.headerInfoTooltip,
+					id: `${instanceGqlType}.${column.name}.tooltip`,
+					type: "jsx"
+				})}}
+                                        >
+                                            <InfoIcon sx={{ marginLeft: 1 }} />
+                                        </Tooltip>
+                                    </>
+                                )` : void 0,
+				headerName: column.headerName === "" ? `""` : generateFormattedMessage({
+					config: column.headerName,
+					id: `${instanceGqlType}.${column.name}`,
+					defaultMessage: camelCaseToHumanReadable(column.name),
+					type: "intlCall"
+				}),
+				type: column.gridType ? `"${column.gridType}"` : void 0,
+				filterable: isColumnFilterable ? void 0 : `false`,
+				sortable: isColumnSortable ? void 0 : `false`,
+				valueGetter: column.valueGetter,
+				valueFormatter: column.valueFormatter,
+				valueOptions: column.valueOptions,
+				renderCell: column.renderCell,
+				filterOperators: column.filterOperators,
+				width: column.width,
+				flex: column.flex,
+				pinned: column.pinned && `"${column.pinned}"`,
+				visible: column.visible,
+				disableExport: column.disableExport ? "true" : void 0
+			};
+			if ("sortBy" in column && column.sortBy) columnDefinition["sortBy"] = getSortByValue(column.sortBy);
+			if (typeof column.width === "undefined") {
+				columnDefinition.flex = defaultColumnFlex;
+				columnDefinition.minWidth = minWidth;
+				columnDefinition.maxWidth = maxWidth;
+			}
+			return tsCodeRecordToString(columnDefinition, column.columnType);
+		}).join(",\n")},
+                ${showActionsColumn ? tsCodeRecordToString({
+			field: "\"actions\"",
+			headerName: actionsColumnHeaderName ? generateFormattedMessage({
+				config: actionsColumnHeaderName,
+				id: `${instanceGqlType}.actions`,
+				type: "intlCall"
+			}) : `""`,
+			sortable: "false",
+			filterable: "false",
+			type: "\"actions\"",
+			align: "\"right\"",
+			pinned: `"${actionsColumnPinned}"`,
+			width: forwardRowAction ? "actionsColumnWidth" : actionsColumnWidth,
+			visible: actionsColumnVisible !== void 0 ? typeof actionsColumnVisible == "string" ? `theme.breakpoints.${actionsColumnVisible}` : "false" : void 0,
+			...restActionsColumnConfig,
+			headerInfoTooltip: restActionsColumnConfig.headerInfoTooltip ? generateFormattedMessage({
+				config: restActionsColumnConfig.headerInfoTooltip,
+				id: `${instanceGqlType}.actions`,
+				type: "intlCall"
+			}) : void 0,
+			disableExport: config.excelExport ? "true" : void 0,
+			renderCell: `(params) => {
+                            return (
+                                <>
+                                ${actionsColumnComponent?.name ? `<${actionsColumnComponent.name} {...params} />` : ""}${allowEditing ? forwardRowAction ? `{rowAction && rowAction(params)}` : `
+                                        <IconButton color="primary" component={StackLink} pageName="edit" payload={params.row.id}>
+                                            <EditIcon />
+                                        </IconButton>` : ""}${showCrudContextMenuInActionsColumn ? `
+                                        <CrudContextMenu
+                                            ${allowDeleting ? `
+                                            onDelete={async () => {
+                                                await client.mutate<GQLDelete${gqlType}Mutation, GQLDelete${gqlType}MutationVariables>({
+                                                    mutation: delete${gqlType}Mutation,
+                                                    variables: { id: params.row.id },
+                                                });
+                                            }}
+                                            ` : ""}
+                                            refetchQueries={[${instanceGqlTypePlural}Query]}
+                                            ${config.crudContextMenu?.deleteType ? `deleteType="${config.crudContextMenu.deleteType}"` : ""}
+                                            ${config.crudContextMenu?.deleteText ? `messagesMapping={{ delete: <FormattedMessage id="${instanceGqlType}.crudContextMenu.delete" defaultMessage="${config.crudContextMenu.deleteText}" /> }}` : ""}
+                                        />
+                                    ` : ""}
+                                </>
+                            );
+                                }`
+		}) : ""}
+        ],[intl${gridNeedsTheme ? ", theme" : ""}${showCrudContextMenuInActionsColumn ? ", client" : ""}${forwardRowAction ? ", rowAction, actionsColumnWidth" : ""}]);
+
+        ${hasFilter || hasSearch ? `const { ${hasFilter ? `filter: gqlFilter, ` : ""}${hasSearch ? `search: gqlSearch, ` : ""} } = muiGridFilterToGql(columns, dataGridProps.filterModel);` : ""}
+
+        const { data, loading, error } = useQuery<GQL${gqlTypePlural}GridQuery, GQL${gqlTypePlural}GridQueryVariables>(${instanceGqlTypePlural}Query, {
+            variables: {
+                ${[
+			...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQueryType.name).map((arg) => arg.name),
+			...filterArg ? hasFilter && hasFilterProp ? ["filter: filter ? { and: [gqlFilter, filter] } : gqlFilter"] : hasFilter ? ["filter: gqlFilter"] : hasFilterProp ? ["filter"] : [] : [],
+			...hasSearch ? ["search: gqlSearch"] : [],
+			...hasSort ? !allowRowReordering ? ["sort: muiGridSortToGql(dataGridProps.sortModel, columns)"] : [`sort: { field: "position", direction: "ASC" }`] : [],
+			...hasPaging ? !allowRowReordering ? [`offset: dataGridProps.paginationModel.page * dataGridProps.paginationModel.pageSize`, `limit: dataGridProps.paginationModel.pageSize`] : [`offset: 0`, `limit: 100`] : []
+		].join(", ")}
+            },
+        });
+        ${hasPaging ? `const rowCount = useBufferedRowCount(data?.${gridQuery}.totalCount);` : ""}
+        if (error) throw error;
+        const rows = ${!allowRowReordering ? hasPaging ? `data?.${gridQuery}.nodes` : `data?.${gridQuery}` : generateRowReorderingRows(gridQuery, fieldList, config.rowReordering?.dragPreviewField)} ?? [];
+
+        ${generateGridExportApi(config.excelExport, gqlTypePlural, instanceGqlTypePlural, gridQuery, gqlArgs, hasPaging)}
+
+        return (
+            <${muiXGridVariant.gridComponent}
+                {...dataGridProps}
+                rows={rows}
+                ${hasPaging ? `rowCount={rowCount}` : ""}
+                columns={columns}
+                loading={loading}
+                ${renderToolbar ? `slots={{
+                                toolbar: ${gridToolbarComponentName} as GridSlotsComponent["toolbar"],
+                            }}
+                            ${getDataGridSlotProps(gridToolbarComponentName, forwardToolbarAction, config.excelExport)}` : ""}
+                ${allowRowReordering ? `rowReordering
+                           onRowOrderChange={handleRowOrderChange}
+                           hideFooterPagination` : ""}
+                ${config.density ? `density="${config.density}"` : ""}
+                ${showEditInActionsColumn ? `onRowClick={handleRowClick}` : forwardRowAction ? `onRowClick={onRowClick}` : ""}
+            />
+        );
+    }
+    `,
+		gqlDocuments
+	};
+}
+const generateRowReorderingRows = (gridQuery, fieldList, dragPreviewField) => {
+	const fields = fieldList.split(" ");
+	return `data?.${gridQuery}.nodes.map((node) => ({
+        ...node,
+        __reorder__: node.${dragPreviewField || fields.find((field) => field === "title" || field === "name") || "id"}
+    }))`;
+};
+const getDefaultActionsColumnWidth = (showCrudContextMenu, showEdit) => {
+	let numberOfActions = 0;
+	if (showCrudContextMenu) numberOfActions += 1;
+	if (showEdit) numberOfActions += 1;
+	return numberOfActions * 32 + 20;
+};
+const getDataGridSlotProps = (componentName, forwardToolbarAction, excelExport) => {
+	if (!forwardToolbarAction && !excelExport) return "";
+	return `slotProps={{
+        toolbar: ${`{
+        ${forwardToolbarAction ? `toolbarAction,` : ""}
+        ${excelExport ? `exportApi,` : ""}
+    } as ${componentName}ToolbarProps`.replace(/\n/g, "")}  
+    }}`;
+};
+const generateGridExportApi = (excelExport, gqlTypePlural, instanceGqlTypePlural, gridQuery, gqlArgs, hasPaging) => {
+	if (!excelExport) return "";
+	const queryNodeType = hasPaging ? `GQL${gqlTypePlural}GridQuery["${gridQuery}"]["nodes"][0]` : `GQL${gqlTypePlural}GridQuery["${gridQuery}"][0]`;
+	const variablesType = hasPaging ? `Omit<GQL${gqlTypePlural}GridQueryVariables, "offset" | "limit">` : `GQL${gqlTypePlural}GridQueryVariables`;
+	const resolveQueryNodes = hasPaging ? `(data) => data.${gridQuery}.nodes` : `(data) => data.${gridQuery}`;
+	const totalCount = hasPaging ? `data?.${gridQuery}.totalCount ?? 0` : `data?.${gridQuery}.length ?? 0`;
+	return `const exportApi = useDataGridExcelExport<${queryNodeType}, GQL${gqlTypePlural}GridQuery, ${variablesType}>({
+        columns,
+        variables: {
+            ${[...gqlArgs.filter((gqlArg) => gqlArg.queryOrMutationName === gridQuery).map((arg) => arg.name), `...muiGridFilterToGql(columns, dataGridProps.filterModel)`].join(", ")}
+        },
+        query: ${instanceGqlTypePlural}Query,
+        resolveQueryNodes: ${resolveQueryNodes},
+        totalCount: ${totalCount},
+        ${!hasPaging ? `hasPaging: false,` : ""}
+        exportOptions: {
+            fileName: "${gqlTypePlural}",
+        },
+    });`;
+};
+const generateHandleRowOrderChange = (allowRowReordering, gqlType, instanceGqlTypePlural) => {
+	if (!allowRowReordering) return "";
+	return `const handleRowOrderChange = async ({ row: { id }, targetIndex }: GridRowOrderChangeParams) => {
+        await client.mutate<GQLUpdate${gqlType}PositionMutation, GQLUpdate${gqlType}PositionMutationVariables>({
+            mutation: update${gqlType}PositionMutation,
+            variables: { id, input: { position: targetIndex + 1 } },
+            awaitRefetchQueries: true,
+            refetchQueries: [${instanceGqlTypePlural}Query]
+        });
+    };`;
+};
+
+//#endregion
+//#region src/commands/generate/utils/writeGenerated.ts
+async function writeGenerated(filePath, contents) {
+	const header = `// This file has been generated by comet admin-generator.
+    // You may choose to use this file as scaffold by moving this file out of generated folder and removing this comment.
+    `;
+	await promises.mkdir(path.dirname(filePath), { recursive: true });
+	const sourceFile = ts.createSourceFile(filePath, header + contents, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+	const result = ts.transform(sourceFile, [removeUnusedImports()]);
+	const prettyCode = ts.createPrinter({
+		newLine: ts.NewLineKind.LineFeed,
+		removeComments: false
+	}).printFile(result.transformed[0]).replace(/gql `/g, "gql`");
+	await promises.writeFile(filePath, prettyCode);
+	console.log(`generated ${filePath}`);
+}
+function removeUnusedImports() {
+	return (context) => {
+		function visit(sourceFile) {
+			const usedIdentifiers = /* @__PURE__ */ new Set();
+			function collectUsage(node) {
+				if (ts.isIdentifier(node)) usedIdentifiers.add(node.text);
+				else if (ts.isImportDeclaration(node)) return;
+				ts.forEachChild(node, collectUsage);
+			}
+			ts.forEachChild(sourceFile, collectUsage);
+			function visitor(node) {
+				if (ts.isImportDeclaration(node) && node.importClause) {
+					const { name, namedBindings } = node.importClause;
+					const updatedBindings = [];
+					if (name && usedIdentifiers.has(name.text)) {} else if (name) return;
+					if (namedBindings && ts.isNamedImports(namedBindings)) {
+						for (const specifier of namedBindings.elements) {
+							const importName = specifier.name.text;
+							if (usedIdentifiers.has(importName)) updatedBindings.push(specifier);
+						}
+						if (updatedBindings.length === 0 && !name) return;
+						return ts.factory.updateImportDeclaration(node, node.modifiers, ts.factory.updateImportClause(node.importClause, node.importClause.isTypeOnly, name, updatedBindings.length > 0 ? ts.factory.updateNamedImports(namedBindings, updatedBindings) : void 0), node.moduleSpecifier, node.assertClause);
+					}
+					if (!namedBindings && !name) return node;
+					return node;
+				}
+				return ts.visitEachChild(node, visitor, context);
+			}
+			return ts.visitNode(sourceFile, visitor);
+		}
+		return (sourceFile) => visit(sourceFile);
+	};
+}
+
+//#endregion
+//#region src/commands/generate/generate-command.ts
+const exec$1 = promisify(exec);
+function isComponentFormFieldConfig(arg) {
+	return arg && arg.type === "component";
+}
+function isFormFieldConfig(arg) {
+	return !isFormLayoutConfig(arg) && !isComponentFormFieldConfig(arg);
+}
+function isFormLayoutConfig(arg) {
+	return arg.type !== void 0 && ["fieldSet", "optionalNestedFields"].includes(arg.type);
+}
+function injectFormVariables(fn) {
+	return fn({});
+}
+function defineConfig(config) {
+	return config;
+}
+/**
+* @experimental
+*/
+async function runGenerate(filePattern = "src/**/*.cometGen.{ts,tsx}") {
+	const gqlIntrospection = introspectionFromSchema(await loadSchema("./schema.gql", { loaders: [new GraphQLFileLoader()] }));
+	const writtenFiles = [];
+	const files = await glob(filePattern);
+	for (const file of files) {
+		let outputCode = "";
+		let gqlDocumentsOutputCode = "";
+		const targetDirectory = `${dirname(file)}/generated`;
+		const baseOutputFilename = basename(file).replace(/\.cometGen\.tsx?$/, "");
+		console.log(`generating ${file}`);
+		const config = await parseConfig(`${process.cwd()}/${file}`);
+		const codeOuputFilename = `${targetDirectory}/${basename(file.replace(/\.cometGen\.tsx?$/, ""))}.tsx`;
+		await promises.rm(codeOuputFilename, { force: true });
+		const exportName = file.match(/([^/]+)\.cometGen\.tsx?$/)?.[1];
+		if (!exportName) throw new Error("Can not determine exportName");
+		let generated;
+		if (config.type == "form") generated = generateForm({
+			exportName,
+			gqlIntrospection,
+			baseOutputFilename,
+			targetDirectory
+		}, config);
+		else if (config.type == "grid") generated = generateGrid({
+			exportName,
+			gqlIntrospection,
+			baseOutputFilename,
+			targetDirectory
+		}, config);
+		else throw new Error(`Unknown config type`);
+		outputCode += generated.code;
+		for (const queryName in generated.gqlDocuments) {
+			const exportStatement = generated.gqlDocuments[queryName].export ? "export " : "";
+			gqlDocumentsOutputCode += `${exportStatement} const ${queryName} = gql\`${generated.gqlDocuments[queryName].document}\`\n`;
+		}
+		await writeGenerated(codeOuputFilename, outputCode);
+		writtenFiles.push(codeOuputFilename);
+		if (gqlDocumentsOutputCode != "") {
+			const gqlDocumentsOuputFilename = `${targetDirectory}/${basename(file.replace(/\.cometGen\.tsx?$/, ""))}.gql.tsx`;
+			await promises.rm(gqlDocumentsOuputFilename, { force: true });
+			gqlDocumentsOutputCode = `import { gql } from "@apollo/client";
+                import { finalFormFileUploadFragment, finalFormFileUploadDownloadableFragment } from "@comet/cms-admin";
+
+                ${gqlDocumentsOutputCode}
+            `;
+			await writeGenerated(gqlDocumentsOuputFilename, gqlDocumentsOutputCode);
+			writtenFiles.push(gqlDocumentsOuputFilename);
+		}
+		console.log("");
+	}
+	if (writtenFiles.length > 0) {
+		console.log("Formatting generated files...");
+		await exec$1(`./node_modules/.bin/prettier --write ${writtenFiles.join(" ")}`);
+	}
+}
+const generateCommand = new Command("generate").option("-f, --file <file>", "path to config file or glob pattern to generate specific files").action(async ({ file: filePattern }) => {
+	console.log("️️️⚠️️️⚠️️️⚠️️️  Admin Generator is still experimental and in beta phase.  ⚠️️️⚠️️️⚠️️️\n\n");
+	await runGenerate(filePattern);
+});
+
+//#endregion
+export { defineConfig, injectFormVariables };