@sohcah/openapi-generator 0.0.1

package/dist/generators/index.js

@@ -0,0 +1,495 @@
+import { __toESM } from "../chunk-51aI8Tpl.js";
+import { DocumentContext, NotImplementedError, ensureImport, ensureNamespaceImport, getKey, helpers_exports, require_lib } from "../helpers-ChEkrLHV.js";
+import { Effect } from "effect";
+
+//#region src/generators/schema.ts
+var import_lib$3 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const equivalentType = (type) => ({
+	typeDecoded: type,
+	typeEncoded: type
+});
+function defaultParseJson(options) {
+	return (expression) => options.transformer({
+		encoded: options.schema.string,
+		decoded: expression,
+		decode: import_lib$3.blockStatement([import_lib$3.tryStatement(import_lib$3.blockStatement([import_lib$3.returnStatement(import_lib$3.callExpression(import_lib$3.memberExpression(import_lib$3.identifier("JSON"), import_lib$3.identifier("parse")), [import_lib$3.identifier("from")]))]), import_lib$3.catchClause(Object.assign(import_lib$3.identifier("error"), { typeAnnotation: import_lib$3.tsTypeAnnotation(import_lib$3.tsUnknownKeyword()) }), options.transformerCatch(import_lib$3.identifier("error"))))]),
+		encode: import_lib$3.callExpression(import_lib$3.memberExpression(import_lib$3.identifier("JSON"), import_lib$3.identifier("stringify")), [import_lib$3.identifier("from")])
+	});
+}
+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("query"), options.modifiers.optional(import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("URLSearchParams")]))),
+			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("path"), options.modifiers.optional(options.schema.record(options.schema.string, options.schema.string))),
+			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")])])))
+		])]))]))]);
+		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.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
+			};
+		}
+		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.enum) {
+			const unsupportedEnumValue = schema.enum.find((i) => typeof i !== "string");
+			if (unsupportedEnumValue !== void 0) return yield* new NotImplementedError({ message: `Unsupported 'enum' value: ${JSON.stringify(unsupportedEnumValue)}` });
+			return {
+				expression: options.schema.enum(schema.enum.map((e) => import_lib$3.stringLiteral(e))),
+				...equivalentType(import_lib$3.tsUnionType(schema.enum.map((e) => import_lib$3.tsLiteralType(import_lib$3.stringLiteral(e))))),
+				typeMeta
+			};
+		}
+		switch (schema.type) {
+			case "boolean": return {
+				expression: options.schema.boolean,
+				...equivalentType(import_lib$3.tsBooleanKeyword()),
+				typeMeta
+			};
+			case "string": {
+				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": {
+				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(import_lib$3.identifier(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);
+				}
+				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": 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 ("nullable" in schema && schema.nullable) {
+			modified.expression = options.modifiers.nullable(modified.expression);
+			modified.typeDecoded = import_lib$3.tsUnionType([modified.typeDecoded, import_lib$3.tsNullKeyword()]);
+			modified.typeEncoded = import_lib$3.tsUnionType([modified.typeEncoded, import_lib$3.tsNullKeyword()]);
+		}
+		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 ("$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];
+		});
+		const expressions = [];
+		for (const schema$1 of schemas) expressions.push(yield* applyModifiers(yield* getBaseEffectSchema(schema$1), schema$1));
+		if (expressions.length !== 1) return {
+			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: {}
+		};
+		return expressions[0];
+	});
+	const ensureParametersSchema = Effect.fn(function* (operationKey, method) {
+		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 pathObject = import_lib$3.objectExpression([]);
+		const headerArray = import_lib$3.arrayExpression([]);
+		let hasBody = false;
+		for (const parameter of method.parameters ?? []) {
+			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(import_lib$3.identifier(parameter.name), expression);
+			if (parameter.description) import_lib$3.addComment(objectProperty, "leading", `* ${parameter.description}`);
+			object.properties.push(objectProperty);
+			if (parameter.in === "query") {
+				const param = import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier(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.tsTypeReference(import_lib$3.identifier("[string, string]"))]) }), 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") pathObject.properties.push(import_lib$3.objectProperty(import_lib$3.identifier(parameter.name), import_lib$3.callExpression(import_lib$3.identifier("String"), [import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier(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"), [import_lib$3.memberExpression(import_lib$3.identifier("from"), import_lib$3.identifier(parameter.name))])]));
+			else return yield* new NotImplementedError({ message: `parameter in ${parameter.in}` });
+		}
+		body: if (method.requestBody) {
+			if ("$ref" in method.requestBody) return yield* new NotImplementedError({ message: "$ref in requestBody" });
+			for (const contentKey in method.requestBody.content) {
+				hasBody = true;
+				const schema = method.requestBody.content[contentKey]?.schema;
+				if (!!schema && contentKey === "application/json") {
+					object.properties.push(import_lib$3.objectProperty(import_lib$3.identifier("data"), (options.builtins.parseJson ?? defaultParseJson(options))((yield* ensureSchema(schema)).expression)));
+					break body;
+				} else if (contentKey === "application/octet-stream") {
+					object.properties.push(import_lib$3.objectProperty(import_lib$3.identifier("data"), import_lib$3.callExpression(options.schema.instanceOf, [import_lib$3.identifier("Blob")])));
+					break body;
+				}
+			}
+			return yield* new NotImplementedError({ message: `No supported requestBody type (${Object.keys(method.requestBody.content).join(", ")})` });
+		}
+		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([
+				...queryArray.elements.length ? [import_lib$3.objectProperty(import_lib$3.identifier("query"), import_lib$3.newExpression(import_lib$3.identifier("URLSearchParams"), [queryArray]))] : [],
+				...pathObject.properties.length ? [import_lib$3.objectProperty(import_lib$3.identifier("path"), pathObject)] : [],
+				...headerArray.elements.length ? [import_lib$3.objectProperty(import_lib$3.identifier("header"), 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 ensureResponseSchema = Effect.fn(function* (operationKey, method) {
+		const ctx = yield* DocumentContext;
+		if (!method.responses?.["200"]) return null;
+		if ("$ref" in method.responses["200"]) return yield* new NotImplementedError({ message: "$ref in response" });
+		if (!method.responses["200"].content) return null;
+		if (!method.responses["200"].content["application/json"]?.schema) return yield* new NotImplementedError({ message: `response without 'application/json' content schema in ${operationKey.upper}` });
+		const schema = method.responses["200"].content["application/json"].schema;
+		const identifier = import_lib$3.identifier(`${operationKey.upper}_Response`);
+		const decodedSchema = (yield* ensureSchema(schema)).expression;
+		const transform = (options.builtins.parseJson ?? defaultParseJson(options))(decodedSchema);
+		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 ?? true) yield* ensureSchema(schema);
+	});
+	const processOperation = Effect.fn(function* (operationKey, _path, _method, operation) {
+		if (options.includeOperations) {
+			yield* ensureParametersSchema(operationKey, operation);
+			yield* ensureResponseSchema(operationKey, operation);
+		}
+	});
+	return {
+		processSchema,
+		processOperation,
+		ensureParametersSchema,
+		ensureResponseSchema,
+		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)])]),
+			union: (expressions) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("Union")), expressions),
+			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, encode }) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("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"), import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], decode)),
+				import_lib$2.objectProperty(import_lib$2.identifier("encode"), import_lib$2.arrowFunctionExpression([import_lib$2.identifier("from"), import_lib$2.identifier("ctx")], encode))
+			])
+		]),
+		transformerCatch: (expression) => import_lib$2.blockStatement([import_lib$2.throwStatement(expression)]),
+		builtins: { parseJson: (expression) => import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("Schema"), import_lib$2.identifier("parseJson")), [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("encodeSync")), [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("decodeSync")), [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("decodeUnknownSync")), [schema]), [value])
+		},
+		supportsImmutability: true
+	}),
+	initialize: Effect.fn(function* () {
+		yield* ensureNamespaceImport("Schema", "effect/Schema");
+	})
+});
+
+//#endregion
+//#region src/generators/zod.ts
+var import_lib$1 = /* @__PURE__ */ __toESM(require_lib(), 1);
+const createZodSchemaGenerator = ({ mini = false,...options }) => {
+	const z = import_lib$1.identifier("z");
+	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]),
+				union: (expressions) => import_lib$1.callExpression(import_lib$1.memberExpression(z, import_lib$1.identifier("union")), [import_lib$1.arrayExpression(expressions)]),
+				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, encode }) => 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)), import_lib$1.objectProperty(import_lib$1.identifier("encode"), import_lib$1.arrowFunctionExpression([import_lib$1.identifier("from"), import_lib$1.identifier("ctx")], encode))])
+			]),
+			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")))]),
+			builtins: {},
+			methods: {
+				encode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("encode")), [schema, value]),
+				decode: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("decode")), [schema, value]),
+				parse: (schema, value) => import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("z"), import_lib$1.identifier("parse")), [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 makeRequest = import_lib.identifier("makeRequest");
+			const makeRequestOptions = import_lib.identifier("options");
+			makeRequestOptions.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsTypeLiteral([
+				import_lib.tsPropertySignature(import_lib.identifier("method"), import_lib.tsTypeAnnotation(import_lib.tsStringKeyword())),
+				import_lib.tsPropertySignature(import_lib.identifier("path"), import_lib.tsTypeAnnotation(import_lib.tsStringKeyword())),
+				import_lib.tsPropertySignature(import_lib.identifier("parametersSchema"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(options.schema.schemaType, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeReference(import_lib.identifier("TParams")), import_lib.tsTypeLiteral([
+					Object.assign(import_lib.tsPropertySignature(import_lib.identifier("query"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("URLSearchParams")))), { optional: true }),
+					Object.assign(import_lib.tsPropertySignature(import_lib.identifier("body"), import_lib.tsTypeAnnotation(import_lib.tsUnionType([import_lib.tsStringKeyword(), import_lib.tsTypeReference(import_lib.identifier("Blob"))]))), { optional: true }),
+					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("path"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("Record<string, string>")))), { optional: true })
+				])])))),
+				import_lib.tsPropertySignature(import_lib.identifier("parameters"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier("TParams")))),
+				Object.assign(import_lib.tsPropertySignature(import_lib.identifier("responseSchema"), import_lib.tsTypeAnnotation(import_lib.tsTypeReference(options.schema.schemaType, import_lib.tsTypeParameterInstantiation([import_lib.tsTypeReference(import_lib.identifier("TResponse")), import_lib.tsStringKeyword()])))), { optional: true })
+			]));
+			makeRequest.typeAnnotation = import_lib.tsTypeAnnotation(import_lib.tsFunctionType(import_lib.tsTypeParameterDeclaration([import_lib.tsTypeParameter(null, null, "TParams"), import_lib.tsTypeParameter(null, null, "TResponse")]), [makeRequestOptions], import_lib.tsTypeAnnotation(import_lib.tsTypeReference(import_lib.identifier(options.responseGeneric ? `Promise<${(yield* ensureImport(options.responseGeneric.name, options.responseGeneric.from)).name}<TResponse>>` : "Promise<TResponse>")))));
+			ctx.schemas.set("Api", [import_lib.exportNamedDeclaration(import_lib.classDeclaration(import_lib.identifier("Api"), null, import_lib.classBody([import_lib.classPrivateProperty(import_lib.privateName(makeRequest)), import_lib.classMethod("constructor", import_lib.identifier("constructor"), [makeRequest], import_lib.blockStatement([import_lib.expressionStatement(import_lib.assignmentExpression("=", import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(makeRequest)), makeRequest))]))])))]);
+		}
+		return ctx.schemas.get("Api")[0].declaration.body;
+	});
+	return {
+		initialize: Effect.fn(function* () {
+			yield* ensureApi();
+			if (options.schema.initialize) yield* options.schema.initialize();
+		}),
+		processOperation: Effect.fn(function* (operationKey, path, method, operation) {
+			yield* DocumentContext;
+			const parametersSchema = yield* options.schema.ensureParametersSchema(operationKey, operation);
+			const responseSchema = yield* options.schema.ensureResponseSchema(operationKey, operation);
+			const parameters = import_lib.identifier("parameters");
+			parameters.typeAnnotation = import_lib.tsTypeAnnotation(parametersSchema.typeReference);
+			const isMutation = method !== "get";
+			const fnBody = import_lib.awaitExpression(import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.privateName(import_lib.identifier("makeRequest"))), [import_lib.objectExpression([
+				import_lib.objectProperty(import_lib.identifier("method"), import_lib.stringLiteral(method)),
+				import_lib.objectProperty(import_lib.identifier("path"), import_lib.stringLiteral(path)),
+				import_lib.objectProperty(import_lib.identifier("parametersSchema"), parametersSchema.expression, false, true),
+				import_lib.objectProperty(import_lib.identifier("parameters"), parameters),
+				...responseSchema ? [import_lib.objectProperty(import_lib.identifier("responseSchema"), responseSchema.expression)] : []
+			])]));
+			const doMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower), [parameters], import_lib.blockStatement([import_lib.returnStatement(fnBody)]), false, false, false, true);
+			const queryMethod = import_lib.classMethod("method", import_lib.identifier(operationKey.lower + (isMutation ? "Mutation" : "Query")), isMutation ? [] : [parameters], 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.arrayExpression([import_lib.stringLiteral(operationKey.upper), parameters]))], import_lib.objectProperty(import_lib.identifier(isMutation ? "mutationFn" : "queryFn"), import_lib.arrowFunctionExpression(isMutation ? [parameters] : [], import_lib.callExpression(import_lib.memberExpression(import_lib.thisExpression(), import_lib.identifier(operationKey.lower)), [parameters]), 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