@sohcah/openapi-generator 0.2.2 → 0.3.0

package/dist/generators/index.js

@@ -1,748 +0,0 @@
-import { __toESM } from "../chunk-DYFKRlHt.js";
-import { DocumentContext, NotImplementedError, ensureImport, ensureNamespaceImport, getKey, helpers_exports, notImplementedStatement, require_lib } from "../helpers-CqzmoMek.js";
-import { Context, Effect } from "effect";
-import escapeRegex from "regex-escape";
-
-//#region src/generators/requestFormats/json.ts
-var import_lib$8 = /* @__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$8.callExpression(import_lib$8.memberExpression(import_lib$8.identifier("JSON"), import_lib$8.identifier("stringify")), [import_lib$8.identifier("from")])
-	});
-});
-
-//#endregion
-//#region src/generators/requestFormats/formData.ts
-var import_lib$7 = /* @__PURE__ */ __toESM(require_lib(), 1);
-const maybeStringify = Effect.fn(function* (expression, schema) {
-	const resolved = yield* resolveSchema(schema);
-	if (resolved.type === "object" || resolved.type === "array") return import_lib$7.callExpression(import_lib$7.memberExpression(import_lib$7.identifier("JSON"), import_lib$7.identifier("stringify")), [expression]);
-	if (resolved.type === "string") return expression;
-	return import_lib$7.callExpression(import_lib$7.identifier("String"), [expression]);
-});
-const generateFormDataRequestCodec = Effect.fn(function* (options, schema, decoded) {
-	const encode = import_lib$7.blockStatement([import_lib$7.variableDeclaration("const", [import_lib$7.variableDeclarator(import_lib$7.identifier("formData"), import_lib$7.newExpression(import_lib$7.identifier("FormData"), []))])]);
-	const properties = schema.properties ?? {};
-	for (const [propertyKey, rawProperty] of Object.entries(properties)) {
-		const property = yield* resolveSchema(rawProperty);
-		const propertyExpression = import_lib$7.memberExpression(import_lib$7.identifier("from"), import_lib$7.stringLiteral(propertyKey), true);
-		if (property.type === "array") {
-			encode.body.push(import_lib$7.forOfStatement(import_lib$7.variableDeclaration("const", [import_lib$7.variableDeclarator(import_lib$7.identifier("propertyValue"))]), propertyExpression, import_lib$7.blockStatement([import_lib$7.expressionStatement(import_lib$7.callExpression(import_lib$7.memberExpression(import_lib$7.identifier("formData"), import_lib$7.identifier("append")), [import_lib$7.stringLiteral(propertyKey), yield* maybeStringify(import_lib$7.identifier("propertyValue"), property.items)]))])));
-			continue;
-		}
-		encode.body.push(import_lib$7.expressionStatement(import_lib$7.callExpression(import_lib$7.memberExpression(import_lib$7.identifier("formData"), import_lib$7.identifier("append")), [import_lib$7.stringLiteral(propertyKey), yield* maybeStringify(propertyExpression, property)])));
-	}
-	encode.body.push(import_lib$7.returnStatement(import_lib$7.identifier("formData")));
-	return options.transformer({
-		encoded: import_lib$7.callExpression(options.schema.instanceOf, [import_lib$7.identifier("FormData")]),
-		decoded,
-		decode: notImplementedStatement,
-		encode
-	});
-});
-
-//#endregion
-//#region src/generators/generatePathExpression.ts
-var import_lib$6 = /* @__PURE__ */ __toESM(require_lib(), 1);
-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$6.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$6.templateElement({
-			raw: "",
-			cooked: ""
-		}, false));
-	}
-	return import_lib$6.templateLiteral(quasis, expressions);
-}
-
-//#endregion
-//#region src/generators/responseFormats/json.ts
-var import_lib$5 = /* @__PURE__ */ __toESM(require_lib(), 1);
-const generateJsonResponseCodec = Effect.fn(function* (options, schema, decoded) {
-	return options.transformer({
-		encoded: import_lib$5.callExpression(options.schema.instanceOf, [import_lib$5.identifier("Response")]),
-		decoded,
-		decode: import_lib$5.blockStatement([import_lib$5.tryStatement(import_lib$5.blockStatement([import_lib$5.returnStatement(import_lib$5.tsAsExpression(import_lib$5.awaitExpression(import_lib$5.callExpression(import_lib$5.memberExpression(import_lib$5.identifier("from"), import_lib$5.identifier("json")), [])), import_lib$5.tsAnyKeyword()))]), import_lib$5.catchClause(Object.assign(import_lib$5.identifier("error"), { typeAnnotation: import_lib$5.tsTypeAnnotation(import_lib$5.tsUnknownKeyword()) }), options.transformerCatch(import_lib$5.identifier("error"))))]),
-		decodeAsync: true,
-		encode: notImplementedStatement
-	});
-});
-
-//#endregion
-//#region src/generators/responseFormats/blob.ts
-var import_lib$4 = /* @__PURE__ */ __toESM(require_lib(), 1);
-const generateBlobResponseCodec = Effect.fn(function* (options) {
-	return options.transformer({
-		encoded: import_lib$4.callExpression(options.schema.instanceOf, [import_lib$4.identifier("Response")]),
-		decoded: import_lib$4.callExpression(options.schema.instanceOf, [import_lib$4.identifier("Blob")]),
-		decode: import_lib$4.blockStatement([import_lib$4.tryStatement(import_lib$4.blockStatement([import_lib$4.returnStatement(import_lib$4.tsAsExpression(import_lib$4.awaitExpression(import_lib$4.callExpression(import_lib$4.memberExpression(import_lib$4.identifier("from"), import_lib$4.identifier("blob")), [])), import_lib$4.tsAnyKeyword()))]), import_lib$4.catchClause(Object.assign(import_lib$4.identifier("error"), { typeAnnotation: import_lib$4.tsTypeAnnotation(import_lib$4.tsUnknownKeyword()) }), options.transformerCatch(import_lib$4.identifier("error"))))]),
-		decodeAsync: true,
-		encode: notImplementedStatement
-	});
-});
-
-//#endregion
-//#region src/generators/schema.ts
-var import_lib$3 = /* @__PURE__ */ __toESM(require_lib(), 1);
-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$3.identifier(value);
-	return import_lib$3.stringLiteral(value);
-};
-const memberExpressionWithStringProperty = (object, property) => {
-	if (property.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) return import_lib$3.memberExpression(object, import_lib$3.identifier(property));
-	return import_lib$3.memberExpression(object, import_lib$3.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$3.exportNamedDeclaration(import_lib$3.variableDeclaration("const", [import_lib$3.variableDeclarator(import_lib$3.identifier("ParametersSchema"), import_lib$3.callExpression(options.schema.object, [import_lib$3.objectExpression([
-			import_lib$3.objectProperty(import_lib$3.identifier("path"), options.schema.string),
-			import_lib$3.objectProperty(import_lib$3.identifier("headers"), options.modifiers.optional(import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Headers")]))),
-			import_lib$3.objectProperty(import_lib$3.identifier("body"), options.modifiers.optional(options.schema.union([
-				options.schema.string,
-				import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")]),
-				import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("FormData")]),
-				import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("URLSearchParams")])
-			])))
-		])]))]))]);
-		return import_lib$3.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$3.arrowFunctionExpression([], import_lib$3.identifier(schemaKey.upper));
-				if (ctx.processingSchemaTypes.has(schemaName)) return {
-					expression: import_lib$3.nullLiteral(),
-					typeDecoded: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.identifier(schemaKey.upper))])),
-					typeEncoded: import_lib$3.tsTypeReference(options.types.typeEncoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.identifier(schemaKey.upper))])),
-					typeMeta
-				};
-				ctx.processingSchemaTypes.add(schemaName);
-				const typeSchema = yield* ensureSchema(resolvedSchema);
-				fn.returnType = import_lib$3.tsTypeAnnotation(import_lib$3.tsTypeReference(options.types.schema, import_lib$3.tsTypeParameterInstantiation([typeSchema.typeDecoded, typeSchema.typeEncoded])));
-				ctx.processingSchemaTypes.delete(schemaName);
-				return {
-					expression: options.modifiers.lazy(fn),
-					typeDecoded: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.identifier(schemaKey.upper))])),
-					typeEncoded: import_lib$3.tsTypeReference(options.types.typeEncoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.identifier(schemaKey.upper))])),
-					typeMeta
-				};
-			}
-			if (!ctx.schemas.has(schemaName)) {
-				ctx.processingSchemas.add(schemaName);
-				const schemaExpression = yield* ensureSchema(resolvedSchema);
-				const schemaKeyIdentifier = import_lib$3.identifier(schemaKey.upper);
-				if (options.experimental_includeTypes) schemaKeyIdentifier.typeAnnotation = import_lib$3.tsTypeAnnotation(import_lib$3.tsTypeReference(options.types.schema, import_lib$3.tsTypeParameterInstantiation([schemaExpression.typeDecoded, schemaExpression.typeEncoded])));
-				ctx.schemas.set(schemaName, [import_lib$3.exportNamedDeclaration(import_lib$3.variableDeclaration("const", [import_lib$3.variableDeclarator(schemaKeyIdentifier, schemaExpression.expression)])), import_lib$3.exportNamedDeclaration(import_lib$3.tsTypeAliasDeclaration(import_lib$3.identifier(schemaKey.upper), null, import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.identifier(schemaKey.upper))]))))]);
-				ctx.schemaTypeMeta.set(schemaName, schemaExpression.typeMeta);
-				ctx.processingSchemas.delete(schemaName);
-			}
-			return {
-				expression: import_lib$3.identifier(schemaKey.upper),
-				typeDecoded: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.identifier(schemaKey.upper))])),
-				typeEncoded: import_lib$3.tsTypeReference(options.types.typeEncoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(import_lib$3.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$3.tsUnionType([import_lib$3.tsUnknownKeyword(), import_lib$3.tsUndefinedKeyword()])),
-			typeMeta
-		};
-		const customResult = options.custom?.(schema);
-		if (customResult) {
-			const identifier = yield* ensureImport(customResult.name, customResult.from);
-			const returnType = import_lib$3.tsTypeReference(import_lib$3.identifier("ReturnType"), import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(identifier)]));
-			return {
-				expression: import_lib$3.callExpression(identifier, []),
-				typeDecoded: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([returnType])),
-				typeEncoded: import_lib$3.tsTypeReference(options.types.typeEncoded, import_lib$3.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$3.tsIntersectionType(results.map((result$1) => result$1.typeDecoded)),
-				typeEncoded: import_lib$3.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$3.tsUnionType([result.typeDecoded, import_lib$3.tsNullKeyword()]);
-				result.typeEncoded = import_lib$3.tsUnionType([result.typeEncoded, import_lib$3.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$3.numericLiteral(value);
-				if (typeof value === "boolean") return import_lib$3.booleanLiteral(value);
-				return import_lib$3.stringLiteral(value);
-			};
-			return {
-				expression: options.schema.enum(schema.enum.map((e) => e === null ? import_lib$3.nullLiteral() : getLiteral(e))),
-				...equivalentType(import_lib$3.tsUnionType(schema.enum.map((e) => e === null ? import_lib$3.tsNullKeyword() : import_lib$3.tsLiteralType(getLiteral(e))))),
-				typeMeta
-			};
-		}
-		switch (schema.type) {
-			case "boolean": return {
-				expression: options.schema.boolean,
-				...equivalentType(import_lib$3.tsBooleanKeyword()),
-				typeMeta
-			};
-			case "string": {
-				if (schema.format === "binary") return {
-					expression: import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")]),
-					...equivalentType(import_lib$3.tsTypeReference(import_lib$3.identifier("Blob"))),
-					typeMeta
-				};
-				let expression = {
-					expression: options.schema.string,
-					...equivalentType(import_lib$3.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$3.tsNumberKeyword()),
-				typeMeta
-			};
-			case "integer": return {
-				expression: options.schema.integer,
-				...equivalentType(import_lib$3.tsNumberKeyword()),
-				typeMeta
-			};
-			case "object": {
-				typeMeta.isObject = true;
-				const object = import_lib$3.objectExpression([]);
-				const objectTypeDecoded = import_lib$3.tsTypeLiteral([]);
-				const objectTypeEncoded = import_lib$3.tsTypeLiteral([]);
-				for (const [propertyKey, property] of Object.entries(schema.properties ?? {})) {
-					let propertySchema = yield* ensureSchema(property);
-					const decodedMember = import_lib$3.tsPropertySignature(import_lib$3.identifier(propertyKey), import_lib$3.tsTypeAnnotation(propertySchema.typeDecoded));
-					const encodedMember = import_lib$3.tsPropertySignature(import_lib$3.identifier(propertyKey), import_lib$3.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$3.objectProperty(stringLiteralOrIdentifier(propertyKey), propertySchema.expression);
-					if (property.description) import_lib$3.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$3.tsTypeReference(import_lib$3.identifier("Record"), import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsStringKeyword(), valueSchema.typeDecoded])),
-						typeEncoded: import_lib$3.tsTypeReference(import_lib$3.identifier("Record"), import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsStringKeyword(), valueSchema.typeEncoded])),
-						typeMeta
-					};
-					const expression = options.schema.catchall(import_lib$3.callExpression(options.schema.object, [object]), valueSchema.expression);
-					const keyParam = import_lib$3.identifier("key");
-					keyParam.typeAnnotation = import_lib$3.tsTypeAnnotation(import_lib$3.tsStringKeyword());
-					const indexSignatureDecoded = import_lib$3.tsIndexSignature([keyParam], import_lib$3.tsTypeAnnotation(valueSchema.typeDecoded));
-					const indexSignatureEncoded = import_lib$3.tsIndexSignature([keyParam], import_lib$3.tsTypeAnnotation(valueSchema.typeEncoded));
-					return {
-						expression,
-						typeDecoded: import_lib$3.tsTypeLiteral([...objectTypeDecoded.members, indexSignatureDecoded]),
-						typeEncoded: import_lib$3.tsTypeLiteral([...objectTypeEncoded.members, indexSignatureEncoded]),
-						typeMeta
-					};
-				}
-				return {
-					expression: import_lib$3.callExpression(options.schema.object, [object]),
-					typeDecoded: objectTypeDecoded,
-					typeEncoded: objectTypeEncoded,
-					typeMeta
-				};
-			}
-			case "array": {
-				const itemsSchema = yield* ensureSchema(schema.items);
-				let expression = import_lib$3.callExpression(options.schema.array, [itemsSchema.expression]);
-				let typeDecoded = import_lib$3.tsArrayType(itemsSchema.typeDecoded);
-				let typeEncoded = import_lib$3.tsArrayType(itemsSchema.typeEncoded);
-				if (options.supportsImmutability) if (itemsSchema.typeMeta?.readonly) {
-					expression = options.modifiers.immutable(expression);
-					typeDecoded = import_lib$3.tsTypeOperator(typeDecoded, "readonly");
-					typeEncoded = import_lib$3.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$3.tsNullKeyword()),
-					typeMeta
-				};
-			case void 0: return {
-				expression: options.schema.unknown,
-				...equivalentType(import_lib$3.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$3.tsUnionType(expressions.map((e) => e.typeDecoded)),
-			typeEncoded: import_lib$3.tsUnionType(expressions.map((e) => e.typeEncoded)),
-			typeMeta: {}
-		};
-		if (isNullable) {
-			result.expression = options.modifiers.nullable(result.expression);
-			result.typeDecoded = import_lib$3.tsUnionType([result.typeDecoded, import_lib$3.tsNullKeyword()]);
-			result.typeEncoded = import_lib$3.tsUnionType([result.typeEncoded, import_lib$3.tsNullKeyword()]);
-		}
-		return result;
-	});
-	const ensureParametersSchema = Effect.fn(function* (operationKey, method, path) {
-		const ctx = yield* DocumentContext;
-		const identifier = import_lib$3.identifier(`${operationKey.upper}_Parameters`);
-		const object = import_lib$3.objectExpression([]);
-		const queryArray = import_lib$3.arrayExpression([]);
-		const pathParameters = {};
-		const headerArray = import_lib$3.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$3.objectProperty(stringLiteralOrIdentifier(parameter.name), expression);
-			if (parameter.description) import_lib$3.addComment(objectProperty, "leading", `* ${parameter.description}`);
-			object.properties.push(objectProperty);
-			if (parameter.in === "query") {
-				const param = memberExpressionWithStringProperty(import_lib$3.identifier("from"), parameter.name);
-				if ("type" in parameter.schema && parameter.schema.type === "array") queryArray.elements.push(import_lib$3.spreadElement(import_lib$3.logicalExpression("??", Object.assign(import_lib$3.optionalCallExpression(import_lib$3.optionalMemberExpression(param, import_lib$3.identifier("map"), false, true), [import_lib$3.arrowFunctionExpression([import_lib$3.identifier("value")], import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [import_lib$3.identifier("value")])]))], false), { typeParameters: import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTupleType([import_lib$3.tsStringKeyword(), import_lib$3.tsStringKeyword()])]) }), import_lib$3.arrayExpression([]))));
-				else queryArray.elements.push(import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [param])]));
-			} else if (parameter.in === "path") pathParameters[parameter.name] = memberExpressionWithStringProperty(import_lib$3.identifier("from"), parameter.name);
-			else if (parameter.in === "header") headerArray.elements.push(import_lib$3.arrayExpression([import_lib$3.stringLiteral(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [memberExpressionWithStringProperty(import_lib$3.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$3.objectProperty(import_lib$3.identifier("data"), body.data));
-			headerArray.elements.push(...body.headers);
-		}
-		const decodedSchema = import_lib$3.callExpression(options.schema.object, [object]);
-		const transform = options.transformer({
-			encoded: yield* ensureStandardParametersSchema(),
-			decoded: decodedSchema,
-			decode: import_lib$3.blockStatement([import_lib$3.throwStatement(import_lib$3.newExpression(import_lib$3.identifier("Error"), [import_lib$3.stringLiteral("Not implemented")]))]),
-			encode: import_lib$3.objectExpression([
-				import_lib$3.objectProperty(import_lib$3.identifier("path"), generatePathExpression(path, pathParameters, queryArray.elements.length ? import_lib$3.newExpression(import_lib$3.identifier("URLSearchParams"), [queryArray]) : null)),
-				...headerArray.elements.length ? [import_lib$3.objectProperty(import_lib$3.identifier("headers"), import_lib$3.newExpression(import_lib$3.identifier("Headers"), [headerArray]))] : [],
-				...hasBody ? [import_lib$3.objectProperty(import_lib$3.identifier("body"), import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier("data")))] : []
-			])
-		});
-		ctx.schemas.set(identifier.name, [import_lib$3.exportNamedDeclaration(import_lib$3.variableDeclaration("const", [import_lib$3.variableDeclarator(identifier, transform)]))]);
-		return {
-			expression: identifier,
-			typeReference: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.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$3.arrayExpression([import_lib$3.stringLiteral("Content-Type"), import_lib$3.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$3.arrayExpression([import_lib$3.stringLiteral("Content-Type"), import_lib$3.stringLiteral(contentType)])],
-					data: import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.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$3.identifier(`${operationKey.upper}_Response`);
-		ctx.schemas.set(identifier.name, [import_lib$3.exportNamedDeclaration(import_lib$3.variableDeclaration("const", [import_lib$3.variableDeclarator(identifier, transform)]))]);
-		return {
-			expression: identifier,
-			typeReference: import_lib$3.tsTypeReference(options.types.typeDecoded, import_lib$3.tsTypeParameterInstantiation([import_lib$3.tsTypeQuery(identifier)]))
-		};
-	});
-	const processSchema = Effect.fn(function* (schema) {
-		if (options.includeSchemas) yield* ensureSchema(schema);
-	});
-	const processOperation = Effect.fn(function* (operationKey, path, _method, operation) {
-		if (options.includeOperations) {
-			yield* ensureParametersSchema(operationKey, operation, path);
-			yield* ensureResponseSchema(operationKey, operation);
-		}
-	});
-	const decodeResponse = Effect.fn(function* (schema, response) {
-		return options.methods.decode(schema, response);
-	});
-	const encodeParameters = Effect.fn(function* (schema, response) {
-		return options.methods.encode(schema, response);
-	});
-	return {
-		processSchema,
-		processOperation,
-		ensureParametersSchema,
-		ensureResponseSchema,
-		decodeResponse,
-		encodeParameters,
-		get schemaType() {
-			return options.types.schema;
-		}
-	};
-}
-
-//#endregion
-//#region src/generators/effect.ts
-var import_lib$2 = /* @__PURE__ */ __toESM(require_lib(), 1);
-const createEffectSchemaGenerator = (options) => ({
-	...createSchemaGenerator({
-		...options,
-		modifiers: {
-			lazy: (expression) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("suspend")), [expression]),
-			optional: (expression) => import_lib$2.callExpression(import_lib$2.memberExpression(expression, import_lib$2.identifier("pipe")), [import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("optional"))]),
-			regex: (expression, pattern) => import_lib$2.callExpression(import_lib$2.memberExpression(expression, import_lib$2.identifier("pipe")), [import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("pattern")), [import_lib$2.regExpLiteral(pattern)])]),
-			immutable: (expression) => expression,
-			mutable: (expression) => import_lib$2.callExpression(import_lib$2.memberExpression(expression, import_lib$2.identifier("pipe")), [import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("mutable"))]),
-			nullable: (expression) => import_lib$2.callExpression(import_lib$2.memberExpression(expression, import_lib$2.identifier("pipe")), [import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("NullOr"))])
-		},
-		types: {
-			schema: import_lib$2.tsQualifiedName(import_lib$2.identifier("Schema"), import_lib$2.identifier("Schema")),
-			typeDecoded: import_lib$2.tsQualifiedName(import_lib$2.tsQualifiedName(import_lib$2.identifier("Schema"), import_lib$2.identifier("Schema")), import_lib$2.identifier("Type")),
-			typeEncoded: import_lib$2.tsQualifiedName(import_lib$2.tsQualifiedName(import_lib$2.identifier("Schema"), import_lib$2.identifier("Schema")), import_lib$2.identifier("Encoded"))
-		},
-		schema: {
-			record: (key, value) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Record")), [import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("key"), key), import_lib$2.objectProperty(import_lib$2.identifier("value"), value)])]),
-			catchall: (object, value) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("extend")), [object, import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Record")), [import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("key"), import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("String"))), import_lib$2.objectProperty(import_lib$2.identifier("value"), value)])])]),
-			union: (expressions) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Union")), expressions),
-			intersection: (expressions) => expressions.reduce((a, b) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("extend")), [a, b])),
-			objectExtend: (expressions) => expressions.reduce((a, b) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("extend")), [a, b])),
-			enum: (expressions) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Literal")), expressions),
-			instanceOf: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("instanceOf")),
-			boolean: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Boolean")),
-			string: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("String")),
-			number: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Number")),
-			integer: import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Number")), import_lib$2.identifier("pipe")), [import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("int")), [])]),
-			array: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Array")),
-			object: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Struct")),
-			null: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Null")),
-			unknown: import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Unknown"))
-		},
-		transformer: ({ encoded, decoded, decode, decodeAsync, encode, encodeAsync }) => {
-			let decodeFn;
-			let encodeFn;
-			if (decodeAsync || encodeAsync) {
-				decodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Effect"), import_lib$2.identifier("promise")), [import_lib$2.arrowFunctionExpression([], decode, true)]));
-				encodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Effect"), import_lib$2.identifier("promise")), [import_lib$2.arrowFunctionExpression([], encode, true)]));
-			} else {
-				decodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], decode);
-				encodeFn = import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], encode);
-			}
-			return import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier(decodeAsync || encodeAsync ? "transformOrFail" : "transform")), [
-				encoded,
-				decoded,
-				import_lib$2.objectExpression([
-					import_lib$2.objectProperty(import_lib$2.identifier("strict"), import_lib$2.booleanLiteral(true)),
-					import_lib$2.objectProperty(import_lib$2.identifier("decode"), decodeFn),
-					import_lib$2.objectProperty(import_lib$2.identifier("encode"), encodeFn)
-				])
-			]);
-		},
-		transformerCatch: (expression) => import_lib$2.blockStatement([import_lib$2.throwStatement(expression)]),
-		methods: {
-			encode: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("encodePromise")), [schema]), [value]),
-			decode: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("decodePromise")), [schema]), [value]),
-			parse: (schema, value) => import_lib$2.callExpression(import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.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
-var import_lib$1 = /* @__PURE__ */ __toESM(require_lib(), 1);
-const z = import_lib$1.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$1.memberExpression(expression, import_lib$1.identifier("shape"));
-}
-const createZodSchemaGenerator = ({ mini = false,...options }) => {
-	const maybeExtension = (expression, extension, args) => mini ? import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier(extension)), [expression, ...args]) : import_lib$1.callExpression(import_lib$1.memberExpression(expression, import_lib$1.identifier(extension)), args);
-	return {
-		...createSchemaGenerator({
-			...options,
-			modifiers: {
-				lazy: (expression) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("lazy")), [expression]),
-				optional: (expression) => maybeExtension(expression, "optional", []),
-				regex: (expression, pattern) => maybeExtension(expression, "regex", [import_lib$1.regExpLiteral(pattern)]),
-				immutable: (expression) => expression,
-				mutable: (expression) => expression,
-				nullable: (expression) => maybeExtension(expression, "nullable", [])
-			},
-			types: {
-				schema: import_lib$1.tsQualifiedName(z, import_lib$1.identifier(mini ? "ZodMiniType" : "Schema")),
-				typeDecoded: import_lib$1.tsQualifiedName(z, import_lib$1.identifier("output")),
-				typeEncoded: import_lib$1.tsQualifiedName(z, import_lib$1.identifier("input"))
-			},
-			schema: {
-				record: (key, value) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("record")), [key, value]),
-				catchall: (object, value) => import_lib$1.callExpression(import_lib$1.memberExpression(mini ? z : object, import_lib$1.identifier("catchall")), [...mini ? [object] : [], value]),
-				union: (expressions) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("union")), [import_lib$1.arrayExpression(expressions)]),
-				intersection: (expressions) => expressions.reduce((a, b) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("intersection")), [a, b])),
-				objectExtend: (expressions) => expressions.reduce((a, b) => import_lib$1.callExpression(import_lib$1.memberExpression(mini ? z : a, import_lib$1.identifier("extend")), [...mini ? [a] : [], getObjectShape(b)])),
-				enum: (expressions) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("enum")), [import_lib$1.arrayExpression(expressions)]),
-				instanceOf: import_lib$1.memberExpression(z, import_lib$1.identifier("instanceof")),
-				boolean: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("boolean")), []),
-				string: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("string")), []),
-				number: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("number")), []),
-				integer: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("int")), []),
-				array: import_lib$1.memberExpression(z, import_lib$1.identifier("array")),
-				object: import_lib$1.memberExpression(z, import_lib$1.identifier("object")),
-				null: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("null")), []),
-				unknown: import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("unknown")), [])
-			},
-			transformer: ({ encoded, decoded, decode, decodeAsync, encode, encodeAsync }) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("codec")), [
-				encoded,
-				decoded,
-				import_lib$1.objectExpression([import_lib$1.objectProperty(import_lib$1.identifier("decode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], decode, decodeAsync)), import_lib$1.objectProperty(import_lib$1.identifier("encode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], encode, encodeAsync))])
-			]),
-			transformerCatch: (expression) => import_lib$1.blockStatement([import_lib$1.expressionStatement(import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.memberExpression(import_lib$1.identifier("ctx"), import_lib$1.identifier("issues")), import_lib$1.identifier("push")), [import_lib$1.objectExpression([
-				import_lib$1.objectProperty(import_lib$1.identifier("code"), import_lib$1.stringLiteral("custom")),
-				import_lib$1.objectProperty(import_lib$1.identifier("input"), import_lib$1.identifier("from")),
-				import_lib$1.objectProperty(import_lib$1.identifier("message"), import_lib$1.memberExpression(import_lib$1.tsAsExpression(expression, import_lib$1.tsTypeReference(import_lib$1.identifier("Error"))), import_lib$1.identifier("message")))
-			])])), import_lib$1.returnStatement(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("NEVER")))]),
-			methods: {
-				encode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("encodeAsync")), [schema, value]),
-				decode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("decodeAsync")), [schema, value]),
-				parse: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("parseAsync")), [schema, value])
-			},
-			supportsImmutability: false
-		}),
-		initialize: Effect.fn(function* () {
-			yield* ensureImport("z", mini ? "zod/mini" : "zod");
-		})
-	};
-};
-
-//#endregion
-//#region src/generators/client.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
-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.js.map