@soda-gql/core 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,37 +1,6 @@
-import { a as unsafeOutputType, i as unsafeInputType, n as defineOperationRoots, o as wrapByKey, r as defineScalar, t as define } from "./schema-BiYcVVvm.js";
+import { i as wrapByKey, n as defineOperationRoots, r as defineScalar, t as defineEnum } from "./schema-builder-C9Qj5zQg.js";
 import { Kind, OperationTypeNode } from "graphql";
 
-//#region packages/core/src/types/type-foundation/directive-ref.ts
-/**
-* A reference to a directive that can be applied to fields.
-*
-* DirectiveRef carries type information about the directive via the TBrand
-* type parameter, but this information is only used for type inference,
-* not for runtime validation.
-*
-* @example
-* ```typescript
-* const skipDirective = new DirectiveRef({
-*   name: "skip",
-*   arguments: { if: true },
-*   locations: ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
-* });
-* ```
-*/
-var DirectiveRef = class {
-	constructor(inner) {
-		this.inner = inner;
-	}
-	/**
-	* Extracts the inner structure from a DirectiveRef.
-	* Used by build-document.ts to generate DirectiveNode.
-	*/
-	static getInner(ref) {
-		return ref.inner;
-	}
-};
-
-//#endregion
 //#region packages/core/src/types/type-foundation/var-ref.ts
 var VarRef = class {
 	constructor(inner) {
@@ -62,6 +31,37 @@ function createVarRefFromNestedValue(value) {
 	});
 }
 
+//#endregion
+//#region packages/core/src/types/type-foundation/directive-ref.ts
+/**
+* A reference to a directive that can be applied to fields.
+*
+* DirectiveRef carries type information about the directive via the TBrand
+* type parameter, but this information is only used for type inference,
+* not for runtime validation.
+*
+* @example
+* ```typescript
+* const skipDirective = new DirectiveRef({
+*   name: "skip",
+*   arguments: { if: true },
+*   locations: ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
+* });
+* ```
+*/
+var DirectiveRef = class {
+	constructor(inner) {
+		this.inner = inner;
+	}
+	/**
+	* Extracts the inner structure from a DirectiveRef.
+	* Used by build-document.ts to generate DirectiveNode.
+	*/
+	static getInner(ref) {
+		return ref.inner;
+	}
+};
+
 //#endregion
 //#region packages/core/src/composer/build-document.ts
 /**
@@ -667,7 +667,7 @@ const createFieldFactoriesInner = (schema, typeName) => {
 * @param createDepGenerator - Function to create evaluation generator for a dependency
 * @returns An executor generator function
 */
-const createLazyEvaluator = (define$1, getDeps, createDepGenerator) => {
+const createLazyEvaluator = (define, getDeps, createDepGenerator) => {
 	let cache = null;
 	let promise = null;
 	return function* execute(context) {
@@ -677,7 +677,7 @@ const createLazyEvaluator = (define$1, getDeps, createDepGenerator) => {
 			return cache.value;
 		}
 		if (getDeps) for (const dep of getDeps()) yield* createDepGenerator(dep);
-		const defined = define$1(context);
+		const defined = define(context);
 		if (!(defined instanceof Promise)) return (cache = { value: defined }).value;
 		promise = defined.then((value) => {
 			cache = { value };
@@ -720,8 +720,8 @@ const GQL_ELEMENT_CONTEXT = Symbol("GQL_ELEMENT_CONTEXT");
 var GqlElement = class GqlElement {
 	[GQL_ELEMENT_FACTORY];
 	[GQL_ELEMENT_CONTEXT] = null;
-	constructor(define$1, getDeps) {
-		this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define$1, getDeps, GqlElement.createEvaluationGenerator);
+	constructor(define, getDeps) {
+		this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define, getDeps, GqlElement.createEvaluationGenerator);
 		Object.defineProperty(this, "$infer", { get() {
 			throw new Error("This property is only for type meta. Do not access this property directly.");
 		} });
@@ -792,15 +792,28 @@ var GqlElement = class GqlElement {
 * @template TVariables - Variables required when spreading
 * @template TFields - The selected fields structure
 * @template TOutput - Inferred output type from selected fields
+* @template TKey - Optional unique key for prebuilt type lookup
 */
 var Fragment = class Fragment extends GqlElement {
-	constructor(define$1) {
-		super(define$1);
+	constructor(define) {
+		super(define);
 	}
 	/** The GraphQL type name this fragment selects from. */
 	get typename() {
 		return GqlElement.get(this).typename;
 	}
+	/** Optional unique key for prebuilt type lookup. */
+	get key() {
+		return GqlElement.get(this).key;
+	}
+	/** The schema label this fragment belongs to. */
+	get schemaLabel() {
+		return GqlElement.get(this).schemaLabel;
+	}
+	/** Variable definitions for this fragment. */
+	get variableDefinitions() {
+		return GqlElement.get(this).variableDefinitions;
+	}
 	/**
 	* Spreads this fragment's fields into a parent selection.
 	* Pass variables if the fragment defines any.
@@ -813,8 +826,8 @@ var Fragment = class Fragment extends GqlElement {
 	* Prefer using the `gql(({ fragment }) => ...)` API instead.
 	* @internal
 	*/
-	static create(define$1) {
-		return new Fragment(define$1);
+	static create(define) {
+		return new Fragment(define);
 	}
 };
 
@@ -834,8 +847,8 @@ var Fragment = class Fragment extends GqlElement {
 * @template TData - Inferred response data type
 */
 var Operation = class Operation extends GqlElement {
-	constructor(define$1) {
-		super(define$1);
+	constructor(define) {
+		super(define);
 	}
 	/** The operation type: 'query', 'mutation', or 'subscription'. */
 	get operationType() {
@@ -845,6 +858,10 @@ var Operation = class Operation extends GqlElement {
 	get operationName() {
 		return GqlElement.get(this).operationName;
 	}
+	/** The schema label this operation belongs to. */
+	get schemaLabel() {
+		return GqlElement.get(this).schemaLabel;
+	}
 	/** List of variable names defined for this operation. */
 	get variableNames() {
 		return GqlElement.get(this).variableNames;
@@ -869,8 +886,8 @@ var Operation = class Operation extends GqlElement {
 	* Prefer using the `gql(({ query }) => ...)` API instead.
 	* @internal
 	*/
-	static create(define$1) {
-		return new Operation(define$1);
+	static create(define) {
+		return new Operation(define);
 	}
 };
 
@@ -968,9 +985,12 @@ const createGqlFragmentComposers = (schema, _adapter) => {
 	const createFragmentComposer = (typename) => {
 		return (options) => {
 			const varDefinitions = options.variables ?? {};
-			const { metadata, fields } = options;
+			const { key, metadata, fields } = options;
 			return Fragment.create(() => ({
 				typename,
+				key,
+				schemaLabel: schema.label,
+				variableDefinitions: varDefinitions,
 				spread: (variables) => {
 					const f = createFieldFactories(schema, typename);
 					const $ = createVarAssignments(varDefinitions, variables);
@@ -1018,11 +1038,12 @@ const defaultMetadataAdapter = createDefaultAdapter();
 *
 * @param schema - The GraphQL schema definition
 * @param adapter - Optional metadata adapter for custom metadata handling
+* @param transformDocument - Optional document transformer called after building
 * @returns Operation type selector function
 *
 * @internal Used by `createGqlElementComposer`
 */
-const createOperationComposerFactory = (schema, adapter) => {
+const createOperationComposerFactory = (schema, adapter, transformDocument) => {
 	const resolvedAdapter = adapter ?? defaultMetadataAdapter;
 	return (operationType) => {
 		const operationTypeName = schema.operations[operationType];
@@ -1043,23 +1064,26 @@ const createOperationComposerFactory = (schema, adapter) => {
 					variables,
 					fields
 				});
-				const createDefinition = (metadata) => ({
+				const variableNames = Object.keys(variables);
+				if (!fragmentUsages.some((u) => u.metadataBuilder) && !options.metadata && !transformDocument && !options.transformDocument) return {
 					operationType,
 					operationName,
-					variableNames: Object.keys(variables),
+					schemaLabel: schema.label,
+					variableNames,
 					documentSource: () => fields,
 					document,
-					metadata
-				});
-				if (!fragmentUsages.some((u) => u.metadataBuilder) && !options.metadata) return createDefinition(void 0);
-				const fragmentMetadataResults = fragmentUsages.map((usage) => usage.metadataBuilder ? usage.metadataBuilder() : void 0);
-				const hasAsyncFragmentMetadata = fragmentMetadataResults.some((r) => r instanceof Promise);
-				const buildOperationMetadata = (resolvedFragmentMetadata) => {
+					metadata: void 0
+				};
+				const aggregateFragmentMetadata = (resolvedFragmentMetadata) => {
 					const fragmentMetaInfos = fragmentUsages.map((usage, index) => ({
 						metadata: resolvedFragmentMetadata[index],
 						fieldPath: usage.path
 					}));
-					const aggregatedFragmentMetadata = resolvedAdapter.aggregateFragmentMetadata(fragmentMetaInfos);
+					return resolvedAdapter.aggregateFragmentMetadata(fragmentMetaInfos);
+				};
+				const fragmentMetadataResults = fragmentUsages.map((usage) => usage.metadataBuilder ? usage.metadataBuilder() : void 0);
+				const hasAsyncFragmentMetadata = fragmentMetadataResults.some((r) => r instanceof Promise);
+				const buildOperationMetadata = (aggregatedFragmentMetadata) => {
 					const schemaLevel = resolvedAdapter.schemaLevel;
 					return options.metadata?.({
 						$,
@@ -1068,12 +1092,41 @@ const createOperationComposerFactory = (schema, adapter) => {
 						schemaLevel
 					});
 				};
+				const makeCreateDefinition = (aggregated$1) => {
+					return ({ metadata }) => {
+						let finalDocument = options.transformDocument ? options.transformDocument({
+							document,
+							metadata
+						}) : document;
+						if (transformDocument) finalDocument = transformDocument({
+							document: finalDocument,
+							operationName,
+							operationType,
+							variableNames,
+							schemaLevel: resolvedAdapter.schemaLevel,
+							fragmentMetadata: aggregated$1
+						});
+						return {
+							operationType,
+							operationName,
+							schemaLabel: schema.label,
+							variableNames,
+							documentSource: () => fields,
+							document: finalDocument,
+							metadata
+						};
+					};
+				};
 				if (hasAsyncFragmentMetadata) return Promise.all(fragmentMetadataResults).then(async (resolvedFragmentMetadata) => {
-					return createDefinition(await buildOperationMetadata(resolvedFragmentMetadata));
+					const aggregated$1 = aggregateFragmentMetadata(resolvedFragmentMetadata);
+					const operationMetadata = await buildOperationMetadata(aggregated$1);
+					return makeCreateDefinition(aggregated$1)({ metadata: operationMetadata });
 				});
-				const operationMetadataResult = buildOperationMetadata(fragmentMetadataResults);
-				if (operationMetadataResult instanceof Promise) return operationMetadataResult.then(createDefinition);
-				return createDefinition(operationMetadataResult);
+				const aggregated = aggregateFragmentMetadata(fragmentMetadataResults);
+				const createDefinition = makeCreateDefinition(aggregated);
+				const operationMetadataResult = buildOperationMetadata(aggregated);
+				if (operationMetadataResult instanceof Promise) return operationMetadataResult.then((metadata) => createDefinition({ metadata }));
+				return createDefinition({ metadata: operationMetadataResult });
 			});
 		};
 	};
@@ -1329,8 +1382,9 @@ const createGqlElementComposer = (schema, options) => {
 	const { adapter, inputTypeMethods, directiveMethods } = options;
 	const helpers = adapter?.helpers;
 	const metadataAdapter = adapter?.metadata;
+	const transformDocument = adapter?.transformDocument;
 	const fragment = createGqlFragmentComposers(schema, metadataAdapter);
-	const createOperationComposer = createOperationComposerFactory(schema, metadataAdapter);
+	const createOperationComposer = createOperationComposerFactory(schema, metadataAdapter, transformDocument);
 	const context = {
 		fragment,
 		query: { operation: createOperationComposer("query") },
@@ -1346,5 +1400,298 @@ const createGqlElementComposer = (schema, options) => {
 };
 
 //#endregion
-export { Fragment, GqlElement, Operation, appendToPath, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, createColocateHelper, createDefaultAdapter, createDirectiveBuilder, createDirectiveMethod, createFieldFactories, createGqlElementComposer, createGqlFragmentComposers, createOperationComposerFactory, createStandardDirectives, createVarAssignments, createVarBuilder, createVarMethod, createVarMethodFactory, createVarRefs, defaultMetadataAdapter, define, defineOperationRoots, defineScalar, getCurrentFieldPath, isDirectiveRef, isListType, recordFragmentUsage, unsafeInputType, unsafeOutputType, withFieldPath, withFragmentUsageCollection };
+//#region packages/core/src/composer/prebuilt-composer.ts
+/**
+* Creates a prebuilt GQL element composer for a given schema.
+*
+* This composer has the same runtime behavior as `createGqlElementComposer`,
+* but the returned elements have their types resolved from the PrebuiltTypeRegistry
+* instead of using complex type inference.
+*
+* Use this when bundling with tools like tsdown that may lose type information.
+*
+* @param schema - The GraphQL schema definition
+* @param options - Configuration including input type methods and optional adapter
+* @returns Prebuilt element composer function
+*
+* @example
+* ```typescript
+* // Generated by codegen in prebuilt/index.ts
+* import type { PrebuiltTypes } from "./types";
+*
+* const gql = createPrebuiltGqlElementComposer<
+*   Schema,
+*   PrebuiltTypes,
+*   FragmentBuilders,
+*   DirectiveMethods,
+*   Context
+* >(schema, { inputTypeMethods });
+*
+* // Types are resolved from PrebuiltTypes registry
+* const GetUser = gql(({ query }) =>
+*   query.operation({
+*     name: "GetUser",
+*     fields: ({ f }) => ({ ...f.user({ id: "1" })(({ f }) => ({ ...f.id() })) }),
+*   })
+* );
+* // GetUser.$infer.output is PrebuiltTypes["operations"]["GetUser"]["output"]
+* ```
+*/
+const createPrebuiltGqlElementComposer = (schema, options) => {
+	return createGqlElementComposer(schema, options);
+};
+
+//#endregion
+//#region packages/core/src/prebuilt/type-calculator.ts
+/**
+* Type calculator for generating TypeScript type strings from field selections.
+*
+* This is a runtime reimplementation of the InferFields type-level computation,
+* used for generating prebuilt types that can be bundled without losing type information.
+*
+* @module
+*/
+/**
+* Apply a type modifier to a base type string.
+*
+* Modifier format:
+* - "!" = required (T)
+* - "?" = optional (T | null | undefined)
+* - "![]!" = required array of required items (T[])
+* - "![]?" = optional array of required items (T[] | null | undefined)
+* - "?[]!" = required array of optional items ((T | null | undefined)[])
+* - "?[]?" = optional array of optional items ((T | null | undefined)[] | null | undefined)
+* - Deeper nesting follows the same pattern
+*/
+const applyTypeModifier = (baseType, modifier) => {
+	if (modifier === "!") return baseType;
+	if (modifier === "?") return `(${baseType} | null | undefined)`;
+	const parts = modifier.split("[]");
+	if (parts.length < 2) return baseType;
+	let result = baseType;
+	if (parts[0] === "?") result = `(${result} | null | undefined)`;
+	for (let i = 1; i < parts.length; i++) {
+		const arrayNullability = parts[i];
+		result = `(${result})[]`;
+		if (arrayNullability === "?") result = `(${result} | null | undefined)`;
+	}
+	return result;
+};
+/**
+* Get the TypeScript type string for a scalar output type from the schema.
+*
+* Returns a `ScalarOutput<"Name">` reference for all scalars in the schema.
+* The actual type is resolved at compile time from the inject file's scalar definitions.
+* This allows users to customize even built-in scalars (ID, String, etc.).
+*/
+const getScalarOutputType = (schema, scalarName) => {
+	if (schema.scalar[scalarName]) return `ScalarOutput<"${scalarName}">`;
+	return "unknown";
+};
+/**
+* Get the TypeScript type string for a scalar input type from the schema.
+*
+* Returns a `ScalarInput<"Name">` reference for all scalars in the schema.
+* Used for input/variable types in operations.
+*/
+const getScalarInputType = (schema, scalarName) => {
+	if (schema.scalar[scalarName]) return `ScalarInput<"${scalarName}">`;
+	return "unknown";
+};
+/**
+* Get the TypeScript type string for an enum type from the schema.
+*/
+const getEnumType = (schema, enumName) => {
+	const enumDef = schema.enum[enumName];
+	if (!enumDef) return "string";
+	const values = Object.keys(enumDef.values);
+	if (values.length === 0) return "never";
+	return values.map((v) => `"${v}"`).join(" | ");
+};
+/**
+* Default depth limit for input object type generation.
+*/
+const DEFAULT_INPUT_DEPTH = 3;
+/**
+* Generate a TypeScript type string for an input object type.
+*
+* Recursively expands fields using ScalarInput for scalars.
+* Returns `unknown` if depth is exhausted or circular reference is detected.
+*
+* @param schema - The GraphQL schema
+* @param inputName - The input object type name
+* @param options - Generation options including depth limits
+* @param seen - Set of already visited input names (for circular reference detection)
+* @param currentDepth - Current recursion depth
+*/
+const generateInputObjectType = (schema, inputName, options = {}, seen = /* @__PURE__ */ new Set(), currentDepth) => {
+	const inputDef = schema.input[inputName];
+	if (!inputDef) return "unknown";
+	const depthOverrides = options.depthOverrides ?? {};
+	const defaultDepth = options.defaultDepth ?? DEFAULT_INPUT_DEPTH;
+	const maxDepth = depthOverrides[inputName] ?? defaultDepth;
+	const depth = currentDepth ?? maxDepth;
+	if (depth <= 0) return "unknown";
+	if (seen.has(inputName)) return "unknown";
+	const newSeen = new Set(seen);
+	newSeen.add(inputName);
+	const fields = inputDef.fields;
+	const fieldEntries = Object.entries(fields);
+	if (fieldEntries.length === 0) return "{}";
+	return `{ ${fieldEntries.map(([fieldName, specifier]) => {
+		const fieldType = generateInputFieldType(schema, specifier, options, newSeen, depth - 1);
+		const isOptional = specifier.modifier === "?" || specifier.modifier.endsWith("?");
+		if (specifier.defaultValue != null || isOptional) return `readonly ${fieldName}?: ${fieldType}`;
+		return `readonly ${fieldName}: ${fieldType}`;
+	}).join("; ")} }`;
+};
+/**
+* Generate a TypeScript type string for an input field based on its specifier.
+*/
+const generateInputFieldType = (schema, specifier, options, seen, depth) => {
+	let baseType;
+	const { formatters } = options;
+	switch (specifier.kind) {
+		case "scalar":
+			baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);
+			break;
+		case "enum":
+			baseType = getEnumType(schema, specifier.name);
+			break;
+		case "input":
+			baseType = formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options, seen, depth);
+			break;
+		default: baseType = "unknown";
+	}
+	return applyTypeModifier(baseType, specifier.modifier);
+};
+/**
+* Calculate the TypeScript type string for a single field selection.
+*
+* @param schema - The GraphQL schema
+* @param selection - The field selection to calculate type for
+* @param formatters - Optional formatters for customizing type names
+*/
+const calculateFieldType = (schema, selection, formatters) => {
+	const { type } = selection;
+	if (type.kind === "object" && selection.object) return applyTypeModifier(calculateFieldsType(schema, selection.object, formatters), type.modifier);
+	if (type.kind === "union" && selection.union) return applyTypeModifier(calculateUnionType(schema, selection.union, formatters), type.modifier);
+	if (type.kind === "typename") return applyTypeModifier(`"${type.name}"`, type.modifier);
+	if (type.kind === "scalar") return applyTypeModifier(formatters?.scalarOutput?.(type.name) ?? getScalarOutputType(schema, type.name), type.modifier);
+	if (type.kind === "enum") return applyTypeModifier(getEnumType(schema, type.name), type.modifier);
+	return "unknown";
+};
+/**
+* Calculate the TypeScript type string for a union type selection.
+*/
+const calculateUnionType = (schema, union, formatters) => {
+	const memberTypes = [];
+	for (const [_typeName, fields] of Object.entries(union)) if (fields) {
+		const memberType = calculateFieldsType(schema, fields, formatters);
+		memberTypes.push(memberType);
+	}
+	if (memberTypes.length === 0) return "never";
+	return memberTypes.join(" | ");
+};
+/**
+* Calculate the TypeScript type string for a set of field selections.
+* This is the main entry point for type calculation.
+*
+* @param schema - The GraphQL schema
+* @param fields - The field selections to calculate types for
+* @param formatters - Optional formatters for customizing type names
+*/
+const calculateFieldsType = (schema, fields, formatters) => {
+	const entries = Object.entries(fields);
+	if (entries.length === 0) return "{}";
+	return `{ ${entries.map(([alias, selection]) => {
+		return `readonly ${alias}: ${calculateFieldType(schema, selection, formatters)}`;
+	}).join("; ")} }`;
+};
+/**
+* Convert a GraphQL TypeNode to a TypeScript type string for input types.
+*
+* Handles NonNullType, ListType, and NamedType recursively.
+* Uses ScalarInput for scalar types since this is used for input/variable types.
+*
+* @param schema - The GraphQL schema
+* @param typeNode - The GraphQL type node to convert
+* @param formatters - Optional formatters for customizing type names
+*/
+const graphqlTypeToTypeScript = (schema, typeNode, formatters) => {
+	switch (typeNode.kind) {
+		case Kind.NON_NULL_TYPE: return graphqlTypeToTypeScript(schema, typeNode.type, formatters);
+		case Kind.LIST_TYPE: return `(${graphqlTypeToTypeScript(schema, typeNode.type, formatters)})[]`;
+		case Kind.NAMED_TYPE: {
+			const name = typeNode.name.value;
+			if (schema.scalar[name]) return formatters?.scalarInput?.(name) ?? getScalarInputType(schema, name);
+			if (schema.enum[name]) return getEnumType(schema, name);
+			return formatters?.inputObject?.(name) ?? name;
+		}
+	}
+};
+/**
+* Generate a TypeScript type string for operation input variables.
+*
+* Extracts variable types from GraphQL VariableDefinitionNode AST.
+*
+* @param schema - The GraphQL schema
+* @param variableDefinitions - Variable definition nodes from the operation
+* @param formatters - Optional formatters for customizing type names
+*/
+const generateInputType = (schema, variableDefinitions, formatters) => {
+	if (variableDefinitions.length === 0) return "{}";
+	return `{ ${variableDefinitions.map((varDef) => {
+		const name = varDef.variable.name.value;
+		const isRequired = varDef.type.kind === Kind.NON_NULL_TYPE;
+		const tsType = graphqlTypeToTypeScript(schema, varDef.type, formatters);
+		const finalType = isRequired ? tsType : `(${tsType} | null | undefined)`;
+		return `readonly ${name}${isRequired ? "" : "?"}: ${finalType}`;
+	}).join("; ")} }`;
+};
+/**
+* Generate TypeScript type for a single input field from its specifier.
+* Used by generateInputTypeFromSpecifiers.
+*/
+const generateInputFieldTypeFromSpecifier = (schema, specifier, options) => {
+	let baseType;
+	const { formatters } = options;
+	switch (specifier.kind) {
+		case "scalar":
+			baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);
+			break;
+		case "enum":
+			baseType = getEnumType(schema, specifier.name);
+			break;
+		case "input":
+			baseType = formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options);
+			break;
+		default: baseType = "unknown";
+	}
+	return applyTypeModifier(baseType, specifier.modifier);
+};
+/**
+* Generate a TypeScript type string for input variables from InputTypeSpecifiers.
+*
+* Unlike generateInputType which works with GraphQL AST VariableDefinitionNode[],
+* this function works with soda-gql's internal InputTypeSpecifiers format.
+* Used for generating Fragment input types in prebuilt mode.
+*
+* @param schema - The GraphQL schema
+* @param specifiers - Input type specifiers (variable definitions)
+* @param options - Generation options including depth limits
+*/
+const generateInputTypeFromSpecifiers = (schema, specifiers, options = {}) => {
+	const entries = Object.entries(specifiers);
+	if (entries.length === 0) return "void";
+	return `{ ${entries.map(([name, specifier]) => {
+		const isOuterRequired = specifier.modifier.endsWith("!");
+		const hasDefault = specifier.defaultValue != null;
+		const baseType = generateInputFieldTypeFromSpecifier(schema, specifier, options);
+		return `readonly ${name}${!isOuterRequired || hasDefault ? "?" : ""}: ${baseType}`;
+	}).join("; ")} }`;
+};
+
+//#endregion
+export { Fragment, GqlElement, Operation, VarRef, appendToPath, applyTypeModifier, buildArgumentValue, buildConstValueNode, buildDocument, buildOperationTypeNode, buildWithTypeModifier, calculateFieldType, calculateFieldsType, createColocateHelper, createDefaultAdapter, createDirectiveBuilder, createDirectiveMethod, createFieldFactories, createGqlElementComposer, createGqlFragmentComposers, createOperationComposerFactory, createPrebuiltGqlElementComposer, createStandardDirectives, createVarAssignments, createVarBuilder, createVarMethod, createVarMethodFactory, createVarRefFromVariable, createVarRefs, defaultMetadataAdapter, defineEnum, defineOperationRoots, defineScalar, generateInputObjectType, generateInputType, generateInputTypeFromSpecifiers, getCurrentFieldPath, getEnumType, getScalarInputType, getScalarOutputType, graphqlTypeToTypeScript, isDirectiveRef, isListType, recordFragmentUsage, withFieldPath, withFragmentUsageCollection };
 //# sourceMappingURL=index.js.map