@sohcah/openapi-generator 0.2.2 → 0.3.0

package/dist/generators/index.mjs

@@ -0,0 +1,739 @@
+import { i as __toESM } from "../chunk-BcJDCUAU.mjs";
+import { c as NotImplementedError, i as helpers_exports, l as DocumentContext, n as ensureNamespaceImport, o as notImplementedStatement, r as getKey, t as ensureImport, u as require_lib } from "../helpers-BwQQbllq.mjs";
+import { Context, Effect } from "effect";
+import escapeRegex from "regex-escape";
+
+//#region src/generators/requestFormats/json.ts
+var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+const generateJsonRequestCodec = Effect.fn(function* (options, schema, decoded) {
+	return options.transformer({
+		encoded: options.schema.string,
+		decoded,
+		decode: notImplementedStatement,
+		encode: import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("JSON"), import_lib.identifier("stringify")), [import_lib.identifier("from")])
+	});
+});
+
+//#endregion
+//#region src/generators/requestFormats/formData.ts
+const maybeStringify = Effect.fn(function* (expression, schema) {
+	const resolved = yield* resolveSchema(schema);
+	if (resolved.type === "object" || resolved.type === "array") return import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("JSON"), import_lib.identifier("stringify")), [expression]);
+	if (resolved.type === "string") return expression;
+	return import_lib.callExpression(import_lib.identifier("String"), [expression]);
+});
+const generateFormDataRequestCodec = Effect.fn(function* (options, schema, decoded) {
+	const encode = import_lib.blockStatement([import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("formData"), import_lib.newExpression(import_lib.identifier("FormData"), []))])]);
+	const properties = schema.properties ?? {};
+	for (const [propertyKey, rawProperty] of Object.entries(properties)) {
+		const property = yield* resolveSchema(rawProperty);
+		const propertyExpression = import_lib.memberExpression(import_lib.identifier("from"), import_lib.stringLiteral(propertyKey), true);
+		if (property.type === "array") {
+			encode.body.push(import_lib.forOfStatement(import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("propertyValue"))]), propertyExpression, import_lib.blockStatement([import_lib.expressionStatement(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("formData"), import_lib.identifier("append")), [import_lib.stringLiteral(propertyKey), yield* maybeStringify(import_lib.identifier("propertyValue"), property.items)]))])));
+			continue;
+		}
+		encode.body.push(import_lib.expressionStatement(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("formData"), import_lib.identifier("append")), [import_lib.stringLiteral(propertyKey), yield* maybeStringify(propertyExpression, property)])));
+	}
+	encode.body.push(import_lib.returnStatement(import_lib.identifier("formData")));
+	return options.transformer({
+		encoded: import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("FormData")]),
+		decoded,
+		decode: notImplementedStatement,
+		encode
+	});
+});
+
+//#endregion
+//#region src/generators/generatePathExpression.ts
+function generatePathExpression(path, pathParameters, queryParameter) {
+	let modifiedPath = path;
+	if (queryParameter) modifiedPath += "?";
+	const split = modifiedPath.split(new RegExp(`\\{(${Object.keys(pathParameters).map((i) => escapeRegex(i)).join("|")})\\}`, "g"));
+	const quasis = [];
+	const expressions = [];
+	for (const [i, part] of split.entries()) if (i % 2 === 0) quasis.push(import_lib.templateElement({
+		raw: part,
+		cooked: part
+	}, false));
+	else {
+		const paramExpression = pathParameters[part];
+		if (!paramExpression) throw new Error(`Path parameter ${part} not found`);
+		expressions.push(paramExpression);
+	}
+	if (queryParameter) {
+		expressions.push(queryParameter);
+		quasis.push(import_lib.templateElement({
+			raw: "",
+			cooked: ""
+		}, false));
+	}
+	return import_lib.templateLiteral(quasis, expressions);
+}
+
+//#endregion
+//#region src/generators/responseFormats/json.ts
+const generateJsonResponseCodec = Effect.fn(function* (options, schema, decoded) {
+	return options.transformer({
+		encoded: import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Response")]),
+		decoded,
+		decode: import_lib.blockStatement([import_lib.tryStatement(import_lib.blockStatement([import_lib.returnStatement(import_lib.tsAsExpression(import_lib.awaitExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("from"), import_lib.identifier("json")), [])), import_lib.tsAnyKeyword()))]), import_lib.catchClause(Object.assign(import_lib.identifier("error"), { typeAnnotation: import_lib.tsTypeAnnotation(import_lib.tsUnknownKeyword()) }), options.transformerCatch(import_lib.identifier("error"))))]),
+		decodeAsync: true,
+		encode: notImplementedStatement
+	});
+});
+
+//#endregion
+//#region src/generators/responseFormats/blob.ts
+const generateBlobResponseCodec = Effect.fn(function* (options) {
+	return options.transformer({
+		encoded: import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Response")]),
+		decoded: import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Blob")]),
+		decode: import_lib.blockStatement([import_lib.tryStatement(import_lib.blockStatement([import_lib.returnStatement(import_lib.tsAsExpression(import_lib.awaitExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("from"), import_lib.identifier("blob")), [])), import_lib.tsAnyKeyword()))]), import_lib.catchClause(Object.assign(import_lib.identifier("error"), { typeAnnotation: import_lib.tsTypeAnnotation(import_lib.tsUnknownKeyword()) }), options.transformerCatch(import_lib.identifier("error"))))]),
+		decodeAsync: true,
+		encode: notImplementedStatement
+	});
+});
+
+//#endregion
+//#region src/generators/schema.ts
+const equivalentType = (type) => ({
+	typeDecoded: type,
+	typeEncoded: type
+});
+const resolveSchema = Effect.fn(function* (schema) {
+	const ctx = yield* DocumentContext;
+	let resolvedSchema = schema;
+	for (let i = 0; i < 10; i++) {
+		if (!("$ref" in resolvedSchema)) return resolvedSchema;
+		const ref = resolvedSchema.$ref;
+		if (!ref.startsWith("#/components/schemas/")) return yield* new NotImplementedError({ message: `$ref ${ref}` });
+		const schemaName = ref.slice(21);
+		const nextSchema = ctx.document.components?.schemas?.[schemaName];
+		if (!nextSchema) return yield* new NotImplementedError({ message: `Missing $ref ${ref}` });
+		resolvedSchema = nextSchema;
+	}
+	return yield* new NotImplementedError({ message: `Too many $ref in schema` });
+});
+const stringLiteralOrIdentifier = (value) => {
+	if (value.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) return import_lib.identifier(value);
+	return import_lib.stringLiteral(value);
+};
+const memberExpressionWithStringProperty = (object, property) => {
+	if (property.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) return import_lib.memberExpression(object, import_lib.identifier(property));
+	return import_lib.memberExpression(object, import_lib.stringLiteral(property), true);
+};
+function createSchemaGenerator(options) {
+	const ensureStandardParametersSchema = Effect.fn(function* () {
+		const ctx = yield* DocumentContext;
+		if (!ctx.schemas.has("ParametersSchema")) ctx.schemas.set("ParametersSchema", [import_lib.exportNamedDeclaration(import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("ParametersSchema"), import_lib.callExpression(options.schema.object, [import_lib.objectExpression([
+			import_lib.objectProperty(import_lib.identifier("path"), options.schema.string),
+			import_lib.objectProperty(import_lib.identifier("headers"), options.modifiers.optional(import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Headers")]))),
+			import_lib.objectProperty(import_lib.identifier("body"), options.modifiers.optional(options.schema.union([
+				options.schema.string,
+				import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Blob")]),
+				import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("FormData")]),
+				import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("URLSearchParams")])
+			])))
+		])]))]))]);
+		return import_lib.identifier("ParametersSchema");
+	});
+	const getBaseEffectSchema = Effect.fn(function* (schema) {
+		const ctx = yield* DocumentContext;
+		const typeMeta = {};
+		if ("$ref" in schema) {
+			const ref = schema.$ref;
+			if (!ref.startsWith("#/components/schemas/")) return yield* new NotImplementedError({ message: `$ref ${ref}` });
+			const schemaName = ref.slice(21);
+			const schemaKey = yield* getKey(schemaName);
+			const resolvedSchema = ctx.document.components?.schemas?.[schemaName];
+			if (!resolvedSchema) return yield* new NotImplementedError({ message: `Missing $ref ${ref}` });
+			if (ctx.processingSchemas.has(schemaName)) {
+				const fn = import_lib.arrowFunctionExpression([], import_lib.identifier(schemaKey.upper));
+				if (ctx.processingSchemaTypes.has(schemaName)) return {
+					expression: import_lib.nullLiteral(),
+					typeDecoded: import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))])),
+					typeEncoded: import_lib.tsTypeReference(options.types.typeEncoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))])),
+					typeMeta
+				};
+				ctx.processingSchemaTypes.add(schemaName);
+				const typeSchema = yield* ensureSchema(resolvedSchema);
+				fn.returnType = import_lib.tsTypeAnnotation(import_lib.tsTypeReference(options.types.schema, import_lib.tsTypeParameterInstantiation([typeSchema.typeDecoded, typeSchema.typeEncoded])));
+				ctx.processingSchemaTypes.delete(schemaName);
+				return {
+					expression: options.modifiers.lazy(fn),
+					typeDecoded: import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))])),
+					typeEncoded: import_lib.tsTypeReference(options.types.typeEncoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))])),
+					typeMeta
+				};
+			}
+			if (!ctx.schemas.has(schemaName)) {
+				ctx.processingSchemas.add(schemaName);
+				const schemaExpression = yield* ensureSchema(resolvedSchema);
+				const schemaKeyIdentifier = import_lib.identifier(schemaKey.upper);
+				if (options.experimental_includeTypes) schemaKeyIdentifier.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsTypeReference(options.types.schema, import_lib.tsTypeParameterInstantiation([schemaExpression.typeDecoded, schemaExpression.typeEncoded])));
+				ctx.schemas.set(schemaName, [import_lib.exportNamedDeclaration(import_lib.variableDeclaration("const", [import_lib.variableDeclarator(schemaKeyIdentifier, schemaExpression.expression)])), import_lib.exportNamedDeclaration(import_lib.tsTypeAliasDeclaration(import_lib.identifier(schemaKey.upper), null, import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))]))))]);
+				ctx.schemaTypeMeta.set(schemaName, schemaExpression.typeMeta);
+				ctx.processingSchemas.delete(schemaName);
+			}
+			return {
+				expression: import_lib.identifier(schemaKey.upper),
+				typeDecoded: import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))])),
+				typeEncoded: import_lib.tsTypeReference(options.types.typeEncoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(import_lib.identifier(schemaKey.upper))])),
+				typeMeta: ctx.schemaTypeMeta.get(schemaName)
+			};
+		}
+		if (schema.deprecated) if (options.deprecationHandling === "optional") typeMeta.optional = true;
+		else return {
+			expression: options.modifiers.optional(options.schema.unknown),
+			...equivalentType(import_lib.tsUnionType([import_lib.tsUnknownKeyword(), import_lib.tsUndefinedKeyword()])),
+			typeMeta
+		};
+		const customResult = options.custom?.(schema);
+		if (customResult) {
+			const identifier = yield* ensureImport(customResult.name, customResult.from);
+			const returnType = import_lib.tsTypeReference(import_lib.identifier("ReturnType"), import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(identifier)]));
+			return {
+				expression: import_lib.callExpression(identifier, []),
+				typeDecoded: import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([returnType])),
+				typeEncoded: import_lib.tsTypeReference(options.types.typeEncoded, import_lib.tsTypeParameterInstantiation([returnType])),
+				typeMeta
+			};
+		}
+		if (schema.allOf) {
+			const results = yield* Effect.forEach((schema$1) => ensureSchema(schema$1))(schema.allOf);
+			let result;
+			if (results.length === 1) result = results[0];
+			else result = {
+				expression: options.schema[results.every((i) => i.typeMeta.isObject) ? "objectExtend" : "intersection"](results.map((result$1) => result$1.expression)),
+				typeDecoded: import_lib.tsIntersectionType(results.map((result$1) => result$1.typeDecoded)),
+				typeEncoded: import_lib.tsIntersectionType(results.map((result$1) => result$1.typeEncoded)),
+				typeMeta
+			};
+			if ("nullable" in schema && schema.nullable) {
+				result.expression = options.modifiers.nullable(result.expression);
+				result.typeDecoded = import_lib.tsUnionType([result.typeDecoded, import_lib.tsNullKeyword()]);
+				result.typeEncoded = import_lib.tsUnionType([result.typeEncoded, import_lib.tsNullKeyword()]);
+			}
+			return result;
+		}
+		if (schema.enum) {
+			const unsupportedEnumValue = schema.enum.find((i) => typeof i !== "string" && typeof i !== "number" && typeof i !== "boolean" && i !== null);
+			if (unsupportedEnumValue !== void 0) return yield* new NotImplementedError({ message: `Unsupported 'enum' value: ${JSON.stringify(unsupportedEnumValue)}` });
+			const getLiteral = (value) => {
+				if (typeof value === "number") return import_lib.numericLiteral(value);
+				if (typeof value === "boolean") return import_lib.booleanLiteral(value);
+				return import_lib.stringLiteral(value);
+			};
+			return {
+				expression: options.schema.enum(schema.enum.map((e) => e === null ? import_lib.nullLiteral() : getLiteral(e))),
+				...equivalentType(import_lib.tsUnionType(schema.enum.map((e) => e === null ? import_lib.tsNullKeyword() : import_lib.tsLiteralType(getLiteral(e))))),
+				typeMeta
+			};
+		}
+		if (schema.contentMediaType) {
+			if (schema.contentEncoding) return yield* new NotImplementedError({ message: `Unsupported 'contentEncoding' value: ${schema.contentEncoding}` });
+			return {
+				expression: import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Blob")]),
+				...equivalentType(import_lib.tsTypeReference(import_lib.identifier("Blob"))),
+				typeMeta
+			};
+		}
+		switch (schema.type) {
+			case "boolean": return {
+				expression: options.schema.boolean,
+				...equivalentType(import_lib.tsBooleanKeyword()),
+				typeMeta
+			};
+			case "string": {
+				let expression = {
+					expression: options.schema.string,
+					...equivalentType(import_lib.tsStringKeyword()),
+					typeMeta
+				};
+				if (schema.pattern) expression.expression = options.modifiers.regex(expression.expression, schema.pattern);
+				return expression;
+			}
+			case "number": return {
+				expression: options.schema.number,
+				...equivalentType(import_lib.tsNumberKeyword()),
+				typeMeta
+			};
+			case "integer": return {
+				expression: options.schema.integer,
+				...equivalentType(import_lib.tsNumberKeyword()),
+				typeMeta
+			};
+			case "object": {
+				typeMeta.isObject = true;
+				const object = import_lib.objectExpression([]);
+				const objectTypeDecoded = import_lib.tsTypeLiteral([]);
+				const objectTypeEncoded = import_lib.tsTypeLiteral([]);
+				for (const [propertyKey, property] of Object.entries(schema.properties ?? {})) {
+					let propertySchema = yield* ensureSchema(property);
+					const decodedMember = import_lib.tsPropertySignature(import_lib.identifier(propertyKey), import_lib.tsTypeAnnotation(propertySchema.typeDecoded));
+					const encodedMember = import_lib.tsPropertySignature(import_lib.identifier(propertyKey), import_lib.tsTypeAnnotation(propertySchema.typeEncoded));
+					decodedMember.readonly = !!propertySchema.typeMeta?.readonly;
+					encodedMember.readonly = !!propertySchema.typeMeta?.readonly;
+					if (propertySchema.typeMeta?.optional || !schema.required?.includes(propertyKey)) {
+						propertySchema.expression = options.modifiers.optional(propertySchema.expression);
+						decodedMember.optional = true;
+						encodedMember.optional = true;
+					}
+					const objectProperty = import_lib.objectProperty(stringLiteralOrIdentifier(propertyKey), propertySchema.expression);
+					if (property.description) import_lib.addComment(objectProperty, "leading", `* ${property.description}`);
+					object.properties.push(objectProperty);
+					objectTypeDecoded.members.push(decodedMember);
+					objectTypeEncoded.members.push(encodedMember);
+				}
+				if (schema.additionalProperties) {
+					const valueSchema = yield* ensureSchema(schema.additionalProperties === true ? { type: void 0 } : schema.additionalProperties);
+					if (object.properties.length === 0) return {
+						expression: options.schema.record(options.schema.string, valueSchema.expression),
+						typeDecoded: import_lib.tsTypeReference(import_lib.identifier("Record"), import_lib.tsTypeParameterInstantiation([import_lib.tsStringKeyword(), valueSchema.typeDecoded])),
+						typeEncoded: import_lib.tsTypeReference(import_lib.identifier("Record"), import_lib.tsTypeParameterInstantiation([import_lib.tsStringKeyword(), valueSchema.typeEncoded])),
+						typeMeta
+					};
+					const expression = options.schema.catchall(import_lib.callExpression(options.schema.object, [object]), valueSchema.expression);
+					const keyParam = import_lib.identifier("key");
+					keyParam.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsStringKeyword());
+					const indexSignatureDecoded = import_lib.tsIndexSignature([keyParam], import_lib.tsTypeAnnotation(valueSchema.typeDecoded));
+					const indexSignatureEncoded = import_lib.tsIndexSignature([keyParam], import_lib.tsTypeAnnotation(valueSchema.typeEncoded));
+					return {
+						expression,
+						typeDecoded: import_lib.tsTypeLiteral([...objectTypeDecoded.members, indexSignatureDecoded]),
+						typeEncoded: import_lib.tsTypeLiteral([...objectTypeEncoded.members, indexSignatureEncoded]),
+						typeMeta
+					};
+				}
+				return {
+					expression: import_lib.callExpression(options.schema.object, [object]),
+					typeDecoded: objectTypeDecoded,
+					typeEncoded: objectTypeEncoded,
+					typeMeta
+				};
+			}
+			case "array": {
+				const itemsSchema = yield* ensureSchema(schema.items);
+				let expression = import_lib.callExpression(options.schema.array, [itemsSchema.expression]);
+				let typeDecoded = import_lib.tsArrayType(itemsSchema.typeDecoded);
+				let typeEncoded = import_lib.tsArrayType(itemsSchema.typeEncoded);
+				if (options.supportsImmutability) if (itemsSchema.typeMeta?.readonly) {
+					expression = options.modifiers.immutable(expression);
+					typeDecoded = import_lib.tsTypeOperator(typeDecoded, "readonly");
+					typeEncoded = import_lib.tsTypeOperator(typeEncoded, "readonly");
+				} else expression = options.modifiers.mutable(expression);
+				return {
+					expression,
+					typeDecoded,
+					typeEncoded,
+					typeMeta
+				};
+			}
+			case "null":
+				typeMeta.isNull = true;
+				return {
+					expression: options.schema.null,
+					...equivalentType(import_lib.tsNullKeyword()),
+					typeMeta
+				};
+			case void 0: return {
+				expression: options.schema.unknown,
+				...equivalentType(import_lib.tsUnknownKeyword()),
+				typeMeta
+			};
+			default:
+				console.info(schema);
+				return yield* new NotImplementedError({ message: `type ${schema.type}` });
+		}
+	});
+	const applyModifiers = Effect.fn(function* (expression, schema) {
+		if ("$ref" in schema) return expression;
+		const modified = { ...expression };
+		if (options.supportsImmutability) if (schema.readOnly) {
+			modified.expression = options.modifiers.immutable(modified.expression);
+			modified.typeMeta ??= {};
+			modified.typeMeta.readonly = true;
+		} else modified.expression = options.modifiers.mutable(modified.expression);
+		return modified;
+	});
+	const ensureSchema = Effect.fn(function* (schema) {
+		let schemas = [schema].flatMap((schema$1) => {
+			if ("$ref" in schema$1) return [schema$1];
+			if (schema$1.oneOf) return schema$1.oneOf;
+			return [schema$1];
+		}).flatMap((schema$1) => {
+			if (typeof schema$1 === "boolean") return [];
+			if ("$ref" in schema$1) return [schema$1];
+			if (Array.isArray(schema$1.type)) return schema$1.type.map((type) => ({
+				...schema$1,
+				type
+			}));
+			return [schema$1];
+		});
+		let expressions = [];
+		for (const schema$1 of schemas) expressions.push(yield* applyModifiers(yield* getBaseEffectSchema(schema$1), schema$1));
+		let isNullable = false;
+		if (expressions.some((e) => e.typeMeta?.isNull)) {
+			isNullable = true;
+			expressions = expressions.filter((e) => !e.typeMeta?.isNull);
+		}
+		let result;
+		if (expressions.length === 1) result = expressions[0];
+		else result = {
+			expression: options.schema.union(expressions.map((e) => e.expression)),
+			typeDecoded: import_lib.tsUnionType(expressions.map((e) => e.typeDecoded)),
+			typeEncoded: import_lib.tsUnionType(expressions.map((e) => e.typeEncoded)),
+			typeMeta: {}
+		};
+		if (isNullable) {
+			result.expression = options.modifiers.nullable(result.expression);
+			result.typeDecoded = import_lib.tsUnionType([result.typeDecoded, import_lib.tsNullKeyword()]);
+			result.typeEncoded = import_lib.tsUnionType([result.typeEncoded, import_lib.tsNullKeyword()]);
+		}
+		return result;
+	});
+	const ensureParametersSchema = Effect.fn(function* (operationKey, method, path) {
+		const ctx = yield* DocumentContext;
+		const identifier = import_lib.identifier(`${operationKey.upper}_Parameters`);
+		const object = import_lib.objectExpression([]);
+		const queryArray = import_lib.arrayExpression([]);
+		const pathParameters = {};
+		const headerArray = import_lib.arrayExpression([]);
+		let hasBody = false;
+		for (let parameter of method.parameters ?? []) {
+			if ("$ref" in parameter) {
+				const newParameter = ctx.document.components?.parameters?.[parameter.$ref.slice(24)];
+				if (newParameter) parameter = newParameter;
+				else return yield* new NotImplementedError({ message: "Unresolved $ref in parameter" });
+				if ("$ref" in parameter) return yield* new NotImplementedError({ message: "$ref in parameter" });
+			}
+			if (!parameter.schema) return yield* new NotImplementedError({ message: "parameter without schema" });
+			let expression = (yield* ensureSchema(parameter.schema)).expression;
+			if (!parameter.required) expression = options.modifiers.optional(expression);
+			const objectProperty = import_lib.objectProperty(stringLiteralOrIdentifier(parameter.name), expression);
+			if (parameter.description) import_lib.addComment(objectProperty, "leading", `* ${parameter.description}`);
+			object.properties.push(objectProperty);
+			if (parameter.in === "query") {
+				const param = memberExpressionWithStringProperty(import_lib.identifier("from"), parameter.name);
+				if ("type" in parameter.schema && parameter.schema.type === "array") queryArray.elements.push(import_lib.spreadElement(import_lib.logicalExpression("??", Object.assign(import_lib.optionalCallExpression(import_lib.optionalMemberExpression(param, import_lib.identifier("map"), false, true), [import_lib.arrowFunctionExpression([import_lib.identifier("value")], import_lib.arrayExpression([import_lib.stringLiteral(parameter.name), import_lib.callExpression(import_lib.identifier("String"), [import_lib.identifier("value")])]))], false), { typeParameters: import_lib.tsTypeParameterInstantiation([import_lib.tsTupleType([import_lib.tsStringKeyword(), import_lib.tsStringKeyword()])]) }), import_lib.arrayExpression([]))));
+				else queryArray.elements.push(import_lib.arrayExpression([import_lib.stringLiteral(parameter.name), import_lib.callExpression(import_lib.identifier("String"), [param])]));
+			} else if (parameter.in === "path") pathParameters[parameter.name] = memberExpressionWithStringProperty(import_lib.identifier("from"), parameter.name);
+			else if (parameter.in === "header") headerArray.elements.push(import_lib.arrayExpression([import_lib.stringLiteral(parameter.name), import_lib.callExpression(import_lib.identifier("String"), [memberExpressionWithStringProperty(import_lib.identifier("from"), parameter.name)])]));
+			else return yield* new NotImplementedError({ message: `parameter in ${parameter.in}` });
+		}
+		const body = yield* requestBodySchema(operationKey, method);
+		if (body) {
+			hasBody = true;
+			object.properties.push(import_lib.objectProperty(import_lib.identifier("data"), body.data));
+			headerArray.elements.push(...body.headers);
+		}
+		const decodedSchema = import_lib.callExpression(options.schema.object, [object]);
+		const transform = options.transformer({
+			encoded: yield* ensureStandardParametersSchema(),
+			decoded: decodedSchema,
+			decode: import_lib.blockStatement([import_lib.throwStatement(import_lib.newExpression(import_lib.identifier("Error"), [import_lib.stringLiteral("Not implemented")]))]),
+			encode: import_lib.objectExpression([
+				import_lib.objectProperty(import_lib.identifier("path"), generatePathExpression(path, pathParameters, queryArray.elements.length ? import_lib.newExpression(import_lib.identifier("URLSearchParams"), [queryArray]) : null)),
+				...headerArray.elements.length ? [import_lib.objectProperty(import_lib.identifier("headers"), import_lib.newExpression(import_lib.identifier("Headers"), [headerArray]))] : [],
+				...hasBody ? [import_lib.objectProperty(import_lib.identifier("body"), import_lib.memberExpression(import_lib.identifier("from"), import_lib.identifier("data")))] : []
+			])
+		});
+		ctx.schemas.set(identifier.name, [import_lib.exportNamedDeclaration(import_lib.variableDeclaration("const", [import_lib.variableDeclarator(identifier, transform)]))]);
+		return {
+			expression: identifier,
+			typeReference: import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(identifier)]))
+		};
+	});
+	const requestBodySchema = Effect.fn(function* (operationKey, method) {
+		if (!method.requestBody) return null;
+		if ("$ref" in method.requestBody) return yield* new NotImplementedError({ message: "$ref in requestBody" });
+		let hasBody = false;
+		for (const contentType in method.requestBody.content) {
+			hasBody = true;
+			const schema = method.requestBody.content[contentType]?.schema;
+			if (contentType === "application/json") {
+				if (!schema) continue;
+				return {
+					headers: [import_lib.arrayExpression([import_lib.stringLiteral("Content-Type"), import_lib.stringLiteral("application/json")])],
+					data: yield* generateJsonRequestCodec(options, yield* resolveSchema(schema), (yield* ensureSchema(schema)).expression)
+				};
+			} else if (contentType === "multipart/form-data") {
+				if (!schema) continue;
+				return {
+					headers: [],
+					data: yield* generateFormDataRequestCodec(options, yield* resolveSchema(schema), (yield* ensureSchema(schema)).expression)
+				};
+			} else {
+				if (schema && ("$ref" in schema || schema.type !== "string" && schema.format !== "binary")) continue;
+				return {
+					headers: [import_lib.arrayExpression([import_lib.stringLiteral("Content-Type"), import_lib.stringLiteral(contentType)])],
+					data: import_lib.callExpression(options.schema.instanceOf, [import_lib.identifier("Blob")])
+				};
+			}
+		}
+		if (!hasBody) return null;
+		return yield* new NotImplementedError({ message: `No supported requestBody type (${Object.keys(method.requestBody.content).join(", ")}) in ${operationKey.upper}` });
+	});
+	const responseSchema = Effect.fn(function* (content) {
+		if (content) {
+			for (const [format, formatContent] of Object.entries(content)) if (format === "application/json") {
+				if (!formatContent.schema) continue;
+				const schema = formatContent.schema;
+				const decodedSchema = (yield* ensureSchema(schema)).expression;
+				return yield* generateJsonResponseCodec(options, yield* resolveSchema(schema), decodedSchema);
+			}
+		}
+		return yield* generateBlobResponseCodec(options);
+	});
+	const ensureResponseSchema = Effect.fn(function* (operationKey, method) {
+		const ctx = yield* DocumentContext;
+		let transform;
+		if (!method.responses?.["200"]) transform = yield* responseSchema(void 0);
+		else {
+			let response;
+			if ("$ref" in method.responses["200"]) {
+				const ref = method.responses["200"].$ref;
+				if (!ref.startsWith("#/components/responses/")) return yield* new NotImplementedError({ message: `$ref ${ref} in response in ${operationKey.upper}` });
+				const responseName = ref.slice(23);
+				const newResponse = ctx.document.components?.responses?.[responseName];
+				if (!newResponse) return yield* new NotImplementedError({ message: `Missing $ref ${ref} in response in ${operationKey.upper}` });
+				if ("$ref" in newResponse) return yield* new NotImplementedError({ message: `$ref in $ref in response in ${operationKey.upper}` });
+				response = newResponse;
+			} else response = method.responses["200"];
+			transform = yield* responseSchema(response.content);
+		}
+		const identifier = import_lib.identifier(`${operationKey.upper}_Response`);
+		ctx.schemas.set(identifier.name, [import_lib.exportNamedDeclaration(import_lib.variableDeclaration("const", [import_lib.variableDeclarator(identifier, transform)]))]);
+		return {
+			expression: identifier,
+			typeReference: import_lib.tsTypeReference(options.types.typeDecoded, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeQuery(identifier)]))
+		};
+	});
+	return {
+		processSchema: Effect.fn(function* (schema) {
+			if (options.includeSchemas) yield* ensureSchema(schema);
+		}),
+		processOperation: Effect.fn(function* (operationKey, path, _method, operation) {
+			if (options.includeOperations) {
+				yield* ensureParametersSchema(operationKey, operation, path);
+				yield* ensureResponseSchema(operationKey, operation);
+			}
+		}),
+		ensureParametersSchema,
+		ensureResponseSchema,
+		decodeResponse: Effect.fn(function* (schema, response) {
+			return options.methods.decode(schema, response);
+		}),
+		encodeParameters: Effect.fn(function* (schema, response) {
+			return options.methods.encode(schema, response);
+		}),
+		get schemaType() {
+			return options.types.schema;
+		}
+	};
+}
+
+//#endregion
+//#region src/generators/effect.ts
+const createEffectSchemaGenerator = (options) => ({
+	...createSchemaGenerator({
+		...options,
+		modifiers: {
+			lazy: (expression) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("suspend")), [expression]),
+			optional: (expression) => import_lib.callExpression(import_lib.memberExpression(expression, import_lib.identifier("pipe")), [import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("optional"))]),
+			regex: (expression, pattern) => import_lib.callExpression(import_lib.memberExpression(expression, import_lib.identifier("pipe")), [import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("pattern")), [import_lib.regExpLiteral(pattern)])]),
+			immutable: (expression) => expression,
+			mutable: (expression) => import_lib.callExpression(import_lib.memberExpression(expression, import_lib.identifier("pipe")), [import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("mutable"))]),
+			nullable: (expression) => import_lib.callExpression(import_lib.memberExpression(expression, import_lib.identifier("pipe")), [import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("NullOr"))])
+		},
+		types: {
+			schema: import_lib.tsQualifiedName(import_lib.identifier("Schema"), import_lib.identifier("Schema")),
+			typeDecoded: import_lib.tsQualifiedName(import_lib.tsQualifiedName(import_lib.identifier("Schema"), import_lib.identifier("Schema")), import_lib.identifier("Type")),
+			typeEncoded: import_lib.tsQualifiedName(import_lib.tsQualifiedName(import_lib.identifier("Schema"), import_lib.identifier("Schema")), import_lib.identifier("Encoded"))
+		},
+		schema: {
+			record: (key, value) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Record")), [import_lib.objectExpression([import_lib.objectProperty(import_lib.identifier("key"), key), import_lib.objectProperty(import_lib.identifier("value"), value)])]),
+			catchall: (object, value) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("extend")), [object, import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Record")), [import_lib.objectExpression([import_lib.objectProperty(import_lib.identifier("key"), import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("String"))), import_lib.objectProperty(import_lib.identifier("value"), value)])])]),
+			union: (expressions) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Union")), expressions),
+			intersection: (expressions) => expressions.reduce((a, b) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("extend")), [a, b])),
+			objectExtend: (expressions) => expressions.reduce((a, b) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("extend")), [a, b])),
+			enum: (expressions) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Literal")), expressions),
+			instanceOf: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("instanceOf")),
+			boolean: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Boolean")),
+			string: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("String")),
+			number: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Number")),
+			integer: import_lib.callExpression(import_lib.memberExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Number")), import_lib.identifier("pipe")), [import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("int")), [])]),
+			array: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Array")),
+			object: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Struct")),
+			null: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Null")),
+			unknown: import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("Unknown"))
+		},
+		transformer: ({ encoded, decoded, decode, decodeAsync, encode, encodeAsync }) => {
+			let decodeFn;
+			let encodeFn;
+			if (decodeAsync || encodeAsync) {
+				decodeFn = import_lib.arrowFunctionExpression([import_lib.identifier("from"), import_lib.identifier("ctx")], import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Effect"), import_lib.identifier("promise")), [import_lib.arrowFunctionExpression([], decode, true)]));
+				encodeFn = import_lib.arrowFunctionExpression([import_lib.identifier("from"), import_lib.identifier("ctx")], import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Effect"), import_lib.identifier("promise")), [import_lib.arrowFunctionExpression([], encode, true)]));
+			} else {
+				decodeFn = import_lib.arrowFunctionExpression([import_lib.identifier("from"), import_lib.identifier("ctx")], decode);
+				encodeFn = import_lib.arrowFunctionExpression([import_lib.identifier("from"), import_lib.identifier("ctx")], encode);
+			}
+			return import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier(decodeAsync || encodeAsync ? "transformOrFail" : "transform")), [
+				encoded,
+				decoded,
+				import_lib.objectExpression([
+					import_lib.objectProperty(import_lib.identifier("strict"), import_lib.booleanLiteral(true)),
+					import_lib.objectProperty(import_lib.identifier("decode"), decodeFn),
+					import_lib.objectProperty(import_lib.identifier("encode"), encodeFn)
+				])
+			]);
+		},
+		transformerCatch: (expression) => import_lib.blockStatement([import_lib.throwStatement(expression)]),
+		methods: {
+			encode: (schema, value) => import_lib.callExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("encodePromise")), [schema]), [value]),
+			decode: (schema, value) => import_lib.callExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("decodePromise")), [schema]), [value]),
+			parse: (schema, value) => import_lib.callExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("Schema"), import_lib.identifier("decodeUnknownPromise")), [schema]), [value])
+		},
+		supportsImmutability: true
+	}),
+	initialize: Effect.fn(function* () {
+		yield* ensureNamespaceImport("Schema", "effect/Schema");
+		yield* ensureImport("Effect", "effect");
+	})
+});
+
+//#endregion
+//#region src/generators/zod.ts
+const z = import_lib.identifier("z");
+function getObjectShape(expression) {
+	if (expression.type === "CallExpression" && expression.callee.type === "MemberExpression" && expression.callee.object.type === "Identifier" && expression.callee.object.name === "z" && expression.callee.property.type === "Identifier" && expression.callee.property.name === "object" && expression.arguments.length === 1 && expression.arguments[0]?.type === "ObjectExpression") return expression.arguments[0];
+	return import_lib.memberExpression(expression, import_lib.identifier("shape"));
+}
+const createZodSchemaGenerator = ({ mini = false, ...options }) => {
+	const maybeExtension = (expression, extension, args) => mini ? import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier(extension)), [expression, ...args]) : import_lib.callExpression(import_lib.memberExpression(expression, import_lib.identifier(extension)), args);
+	return {
+		...createSchemaGenerator({
+			...options,
+			modifiers: {
+				lazy: (expression) => import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("lazy")), [expression]),
+				optional: (expression) => maybeExtension(expression, "optional", []),
+				regex: (expression, pattern) => maybeExtension(expression, "regex", [import_lib.regExpLiteral(pattern)]),
+				immutable: (expression) => expression,
+				mutable: (expression) => expression,
+				nullable: (expression) => maybeExtension(expression, "nullable", [])
+			},
+			types: {
+				schema: import_lib.tsQualifiedName(z, import_lib.identifier(mini ? "ZodMiniType" : "Schema")),
+				typeDecoded: import_lib.tsQualifiedName(z, import_lib.identifier("output")),
+				typeEncoded: import_lib.tsQualifiedName(z, import_lib.identifier("input"))
+			},
+			schema: {
+				record: (key, value) => import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("record")), [key, value]),
+				catchall: (object, value) => import_lib.callExpression(import_lib.memberExpression(mini ? z : object, import_lib.identifier("catchall")), [...mini ? [object] : [], value]),
+				union: (expressions) => import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("union")), [import_lib.arrayExpression(expressions)]),
+				intersection: (expressions) => expressions.reduce((a, b) => import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("intersection")), [a, b])),
+				objectExtend: (expressions) => expressions.reduce((a, b) => import_lib.callExpression(import_lib.memberExpression(mini ? z : a, import_lib.identifier("extend")), [...mini ? [a] : [], getObjectShape(b)])),
+				enum: (expressions) => import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("enum")), [import_lib.arrayExpression(expressions)]),
+				instanceOf: import_lib.memberExpression(z, import_lib.identifier("instanceof")),
+				boolean: import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("boolean")), []),
+				string: import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("string")), []),
+				number: import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("number")), []),
+				integer: import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("int")), []),
+				array: import_lib.memberExpression(z, import_lib.identifier("array")),
+				object: import_lib.memberExpression(z, import_lib.identifier("object")),
+				null: import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("null")), []),
+				unknown: import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("unknown")), [])
+			},
+			transformer: ({ encoded, decoded, decode, decodeAsync, encode, encodeAsync }) => import_lib.callExpression(import_lib.memberExpression(z, import_lib.identifier("codec")), [
+				encoded,
+				decoded,
+				import_lib.objectExpression([import_lib.objectProperty(import_lib.identifier("decode"), import_lib.arrowFunctionExpression([import_lib.identifier("from"), import_lib.identifier("ctx")], decode, decodeAsync)), import_lib.objectProperty(import_lib.identifier("encode"), import_lib.arrowFunctionExpression([import_lib.identifier("from"), import_lib.identifier("ctx")], encode, encodeAsync))])
+			]),
+			transformerCatch: (expression) => import_lib.blockStatement([import_lib.expressionStatement(import_lib.callExpression(import_lib.memberExpression(import_lib.memberExpression(import_lib.identifier("ctx"), import_lib.identifier("issues")), import_lib.identifier("push")), [import_lib.objectExpression([
+				import_lib.objectProperty(import_lib.identifier("code"), import_lib.stringLiteral("custom")),
+				import_lib.objectProperty(import_lib.identifier("input"), import_lib.identifier("from")),
+				import_lib.objectProperty(import_lib.identifier("message"), import_lib.memberExpression(import_lib.tsAsExpression(expression, import_lib.tsTypeReference(import_lib.identifier("Error"))), import_lib.identifier("message")))
+			])])), import_lib.returnStatement(import_lib.memberExpression(import_lib.identifier("z"), import_lib.identifier("NEVER")))]),
+			methods: {
+				encode: (schema, value) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("z"), import_lib.identifier("encodeAsync")), [schema, value]),
+				decode: (schema, value) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("z"), import_lib.identifier("decodeAsync")), [schema, value]),
+				parse: (schema, value) => import_lib.callExpression(import_lib.memberExpression(import_lib.identifier("z"), import_lib.identifier("parseAsync")), [schema, value])
+			},
+			supportsImmutability: false
+		}),
+		initialize: Effect.fn(function* () {
+			yield* ensureImport("z", mini ? "zod/mini" : "zod");
+		})
+	};
+};
+
+//#endregion
+//#region src/generators/client.ts
+function createReactQueryClientGenerator(options) {
+	const ensureApi = Effect.fn(function* () {
+		const ctx = yield* DocumentContext;
+		if (!ctx.schemas.has("Api")) {
+			const fetch = import_lib.identifier("fetch");
+			const fetchPath = import_lib.identifier("path");
+			fetchPath.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsStringKeyword());
+			const fetchOptions = import_lib.identifier("options");
+			fetchOptions.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsTypeLiteral([
+				import_lib.tsPropertySignature(import_lib.identifier("method"), import_lib.tsTypeAnnotation(import_lib.tsStringKeyword())),
+				Object.assign(import_lib.tsPropertySignature(import_lib.identifier("headers"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Headers")))), { optional: true }),
+				Object.assign(import_lib.tsPropertySignature(import_lib.identifier("body"), import_lib.tsTypeAnnotation(import_lib.tsUnionType([
+					import_lib.tsTypeReference(import_lib.identifier("string")),
+					import_lib.tsTypeReference(import_lib.identifier("Blob")),
+					import_lib.tsTypeReference(import_lib.identifier("FormData")),
+					import_lib.tsTypeReference(import_lib.identifier("URLSearchParams"))
+				]))), { optional: true })
+			]));
+			fetch.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsFunctionType(null, [fetchPath, fetchOptions], import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Promise"), import_lib.tsTypeParameterInstantiation([import_lib.tsTypeReference(import_lib.identifier("Response"))])))));
+			ctx.schemas.set("Api", [import_lib.exportNamedDeclaration(import_lib.classDeclaration(import_lib.identifier("Api"), null, import_lib.classBody([import_lib.classPrivateProperty(import_lib.privateName(fetch)), import_lib.classMethod("constructor", import_lib.identifier("constructor"), [fetch], import_lib.blockStatement([import_lib.expressionStatement(import_lib.assignmentExpression("=", import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(fetch)), fetch))]))])))]);
+		}
+		return ctx.schemas.get("Api")[0].declaration.body;
+	});
+	return {
+		initialize: Effect.fn(function* () {
+			yield* ensureApi();
+			if (options.schema.initialize) yield* options.schema.initialize();
+		}),
+		processSchema: Effect.fn(function* (schema) {
+			yield* ensureApi();
+			yield* options.schema.processSchema(schema);
+		}),
+		processOperation: Effect.fn(function* (operationKey, path, method, operation) {
+			const parametersSchema = yield* options.schema.ensureParametersSchema(operationKey, operation, path);
+			const responseSchema = yield* options.schema.ensureResponseSchema(operationKey, operation);
+			const parameters = import_lib.identifier("parameters");
+			parameters.typeAnnotation = import_lib.tsTypeAnnotation(parametersSchema.typeReference);
+			const parametersWithSkipToken = import_lib.identifier("parameters");
+			parametersWithSkipToken.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsUnionType([parametersSchema.typeReference, import_lib.tsTypeReference(yield* ensureImport("SkipToken", "@tanstack/react-query", true))]));
+			const isMutation = method !== "get" && method !== "head" && method !== "options" && !operation.tags?.some((i) => i.toLowerCase() === "query");
+			const fetchCall = import_lib.awaitExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(import_lib.identifier("fetch"))), [import_lib.memberExpression(import_lib.identifier("params"), import_lib.identifier("path")), import_lib.objectExpression([
+				import_lib.objectProperty(import_lib.identifier("method"), import_lib.stringLiteral(method.toUpperCase())),
+				import_lib.objectProperty(import_lib.identifier("headers"), import_lib.memberExpression(import_lib.identifier("params"), import_lib.identifier("headers"))),
+				import_lib.objectProperty(import_lib.identifier("body"), import_lib.memberExpression(import_lib.identifier("params"), import_lib.identifier("body")))
+			])]));
+			const doMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower), [parameters], import_lib.blockStatement([
+				import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("params"), import_lib.awaitExpression(yield* options.schema.encodeParameters(parametersSchema.expression, import_lib.identifier("parameters"))))]),
+				import_lib.variableDeclaration("const", [import_lib.variableDeclarator(import_lib.identifier("response"), fetchCall)]),
+				import_lib.returnStatement(import_lib.awaitExpression(yield* options.schema.decodeResponse(responseSchema.expression, import_lib.identifier("response"))))
+			]), false, false, false, true);
+			const queryMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower + (isMutation ? "Mutation" : "Query")), isMutation ? [] : [parametersWithSkipToken], import_lib.blockStatement([import_lib.returnStatement(import_lib.callExpression(yield* ensureImport(isMutation ? "mutationOptions" : "queryOptions", "@tanstack/react-query"), [import_lib.objectExpression([...isMutation ? [] : [import_lib.objectProperty(import_lib.identifier("queryKey"), import_lib.tsAsExpression(import_lib.arrayExpression([import_lib.stringLiteral(operationKey.upper), parametersWithSkipToken]), import_lib.tsTypeReference(yield* ensureImport("QueryKey", "@tanstack/react-query", true))))], isMutation ? import_lib.objectProperty(import_lib.identifier("mutationFn"), import_lib.arrowFunctionExpression([parameters], import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.identifier(operationKey.lower)), [parameters]), true)) : import_lib.objectProperty(import_lib.identifier("queryFn"), import_lib.conditionalExpression(import_lib.binaryExpression("===", parametersWithSkipToken, yield* ensureImport("skipToken", "@tanstack/react-query")), yield* ensureImport("skipToken", "@tanstack/react-query"), import_lib.arrowFunctionExpression([], import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.identifier(operationKey.lower)), [parametersWithSkipToken]), true)))])]))]));
+			const commentLines = [];
+			if (operation.summary) commentLines.push(`### ${operation.summary}`);
+			if (operation.description) commentLines.push(`${operation.description}`);
+			if (commentLines.length) {
+				import_lib.addComment(queryMethod, "leading", `*\n${commentLines.join("\n")}\n*`);
+				import_lib.addComment(doMethod, "leading", `*\n${commentLines.join("\n")}\n*`);
+			}
+			const api = yield* ensureApi();
+			api.body.push(doMethod);
+			api.body.push(queryMethod);
+		})
+	};
+}
+
+//#endregion
+export { createEffectSchemaGenerator, createReactQueryClientGenerator, createSchemaGenerator, createZodSchemaGenerator, helpers_exports as generatorHelpers };
+//# sourceMappingURL=index.mjs.map