@workos/oagen-emitters 0.12.0 → 0.12.1

package/dist/{plugin-C408Wh-o.mjs → plugin-CmfzawTp.mjs}

@@ -2450,17 +2450,9 @@ function dump$1(input, options) {
 	return "";
 }
 var dumper = { dump: dump$1 };
-function renamed(from, to) {
-	return function() {
-		throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
-	};
-}
 var load = loader.load;
 loader.loadAll;
 dumper.dump;
-renamed("safeLoad", "load");
-renamed("safeLoadAll", "loadAll");
-renamed("safeDump", "dump");
 //#endregion
 //#region src/shared/model-utils.ts
 /**
@@ -6356,7 +6348,7 @@ function renderVoidTest(lines, op, plan, method, serviceProp, modelMap) {
 	lines.push("    });");
 }
 function renderErrorTest(lines, op, plan, method, serviceProp, modelMap) {
-	const args = buildCallArgs(op, plan, modelMap);
+	const args = buildCallArgs$1(op, plan, modelMap);
 	lines.push("");
 	lines.push(`    testUnauthorized(() => workos.${serviceProp}.${method}(${args}));`);
 	const errorStatuses = new Set(op.errors.map((e) => e.statusCode));
@@ -6379,7 +6371,7 @@ function renderErrorTest(lines, op, plan, method, serviceProp, modelMap) {
 * Build the argument string for a method call in tests.
 * Shared by renderErrorTest and other test renderers.
 */
-function buildCallArgs(op, plan, modelMap) {
+function buildCallArgs$1(op, plan, modelMap) {
 	const pathArgs = buildTestPathArgs(op);
 	const isPaginated = plan.isPaginated;
 	const hasBody = plan.hasBody;
@@ -23562,7 +23554,12 @@ function resolveFieldNames(fields) {
 }
 function renderField(field, rustField, modelName, registry) {
 	const lines = [];
-	if (field.description) for (const c of docComment$1(field.description)) lines.push(`    ${c}`);
+	const hasDescription = !!field.description;
+	if (hasDescription) for (const c of docComment$1(field.description)) lines.push(`    ${c}`);
+	if (field.default != null) {
+		if (hasDescription) lines.push("    ///");
+		lines.push(`    /// Defaults to \`${formatDefault$1(field.default)}\`.`);
+	}
 	const rename = rustField !== field.name ? field.name : null;
 	let baseType = mapTypeRef$1(field.type, {
 		hint: `${typeName(modelName)}${typeName(field.name)}`,
@@ -23587,6 +23584,15 @@ function renderModelsBarrel(modules) {
 function docComment$1(text) {
 	return text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).map((l) => `/// ${l}`);
 }
+/**
+* Render a spec-level default value for inclusion in a doc comment. Strings
+* render bare (e.g. `desc`) so they nest naturally inside the surrounding
+* backticks; numbers/booleans use JSON encoding.
+*/
+function formatDefault$1(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
 //#endregion
 //#region src/rust/enums.ts
 /**
@@ -23807,6 +23813,7 @@ function renderMountGroup(mountName, resolvedOps, ctx, registry, _lookup) {
 	lines.push("    pub(crate) client: &'a Client,");
 	lines.push("}");
 	lines.push("");
+	const groupEmitter = new GroupEmitter();
 	const paramsStructs = [];
 	const methods = [];
 	const seenMethods = /* @__PURE__ */ new Set();
@@ -23819,7 +23826,7 @@ function renderMountGroup(mountName, resolvedOps, ctx, registry, _lookup) {
 				seenMethods.add(wrapperMethodName);
 				const paramsType = `${typeName(wrapper.name)}Params`;
 				const params = resolveWrapperParams(wrapper, ctx);
-				paramsStructs.push(renderWrapperParamsStruct(paramsType, op, wrapper, params, registry));
+				paramsStructs.push(renderWrapperParamsStruct(paramsType, op, wrapper, params, registry, ctx));
 				methods.push(renderWrapperMethod(op, wrapper, params, paramsType, wrapperMethodName));
 			}
 			continue;
@@ -23827,13 +23834,25 @@ function renderMountGroup(mountName, resolvedOps, ctx, registry, _lookup) {
 		const m = methodName(resolved.methodName);
 		if (seenMethods.has(m)) continue;
 		seenMethods.add(m);
+		if (resolved.urlBuilder) {
+			const paramsType = `${typeName(resolved.methodName)}Params`;
+			const emptyParams = isEmptyParams(op, resolved);
+			if (!emptyParams) paramsStructs.push(renderParamsStruct(paramsType, op, resolved, registry, ctx, groupEmitter));
+			methods.push(renderUrlBuilderMethod(op, resolved, paramsType, m, emptyParams));
+			continue;
+		}
 		const paramsType = `${typeName(resolved.methodName)}Params`;
 		const emptyParams = isEmptyParams(op, resolved);
-		if (!emptyParams) paramsStructs.push(renderParamsStruct(paramsType, op, resolved, registry));
+		if (!emptyParams) paramsStructs.push(renderParamsStruct(paramsType, op, resolved, registry, ctx, groupEmitter));
 		methods.push(renderMethod(op, resolved, paramsType, m, emptyParams));
 		const autoPaging = renderAutoPagingMethod(op, resolved, paramsType, m, ctx);
 		if (autoPaging) methods.push(autoPaging);
 	}
+	const groupBlock = groupEmitter.render();
+	if (groupBlock.length > 0) {
+		lines.push(groupBlock);
+		lines.push("");
+	}
 	for (const s of paramsStructs) {
 		lines.push(s);
 		lines.push("");
@@ -23846,14 +23865,158 @@ function renderMountGroup(mountName, resolvedOps, ctx, registry, _lookup) {
 	lines.push("}");
 	return lines.join("\n").replace(/\n+$/g, "\n");
 }
-function renderParamsStruct(name, op, resolved, registry) {
+var GroupEmitter = class {
+	enums = [];
+	bodies = [];
+	seenEnums = /* @__PURE__ */ new Set();
+	seenBodies = /* @__PURE__ */ new Set();
+	/** Register a parameter-group enum, returning the PascalCase Rust name. */
+	registerEnum(group) {
+		const name = typeName(group.name);
+		const variants = group.variants.map((v) => ({
+			name: typeName(v.name),
+			fields: v.parameters.map((p) => ({
+				rustName: fieldName(p.name),
+				wireName: p.name,
+				rustType: rustTypeForGroupParam(p.type)
+			}))
+		}));
+		if (!this.seenEnums.has(name)) {
+			this.seenEnums.add(name);
+			this.enums.push({
+				name,
+				variants
+			});
+		}
+		return name;
+	}
+	/** Register a synthetic body struct, returning its PascalCase Rust name. */
+	registerBody(spec) {
+		if (!this.seenBodies.has(spec.name)) {
+			this.seenBodies.add(spec.name);
+			this.bodies.push(spec);
+		}
+		return spec.name;
+	}
+	render() {
+		const blocks = [];
+		for (const e of this.enums) {
+			const lines = [];
+			lines.push("#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]");
+			lines.push("#[serde(untagged)]");
+			lines.push(`pub enum ${e.name} {`);
+			for (const v of e.variants) {
+				if (v.fields.length === 0) {
+					lines.push(`    ${v.name},`);
+					continue;
+				}
+				lines.push(`    ${v.name} {`);
+				for (const f of v.fields) {
+					if (f.rustName !== f.wireName) lines.push(`        #[serde(rename = ${JSON.stringify(f.wireName)})]`);
+					lines.push(`        ${f.rustName}: ${f.rustType},`);
+				}
+				lines.push("    },");
+			}
+			lines.push("}");
+			blocks.push(lines.join("\n"));
+		}
+		for (const b of this.bodies) {
+			const lines = [];
+			const everythingOptional = b.flatFields.every((f) => !f.required) && b.flattenEnums.every((f) => !f.required);
+			const baseDerives = "Debug, Clone, serde::Serialize, serde::Deserialize";
+			const derives = everythingOptional ? `${baseDerives}, Default` : baseDerives;
+			lines.push(`#[derive(${derives})]`);
+			lines.push(`pub struct ${b.name} {`);
+			for (const f of b.flatFields) {
+				if (f.doc) for (const c of paramDocComment(f.doc)) lines.push(`    ${c}`);
+				if (f.required) {
+					if (f.doc) lines.push("    ///");
+					lines.push("    /// Required.");
+				}
+				if (!f.required) lines.push("    #[serde(skip_serializing_if = \"Option::is_none\")]");
+				if (f.rustName !== f.wireName) lines.push(`    #[serde(rename = ${JSON.stringify(f.wireName)})]`);
+				lines.push(`    pub ${f.rustName}: ${f.rustType},`);
+			}
+			for (const f of b.flattenEnums) {
+				if (f.doc) for (const c of paramDocComment(f.doc)) lines.push(`    ${c}`);
+				lines.push("    #[serde(flatten)]");
+				if (!f.required) lines.push("    #[serde(skip_serializing_if = \"Option::is_none\")]");
+				lines.push(`    pub ${f.rustName}: ${f.rustType},`);
+			}
+			lines.push("}");
+			const required = [...b.flatFields.filter((f) => f.required), ...b.flattenEnums.filter((f) => f.required)];
+			if (required.length > 0 || b.flatFields.length + b.flattenEnums.length > 0) {
+				const ctorArgs = required.map((f) => `${f.rustName}: ${ctorParamType(f.rustType)}`).join(", ");
+				const init = [];
+				for (const f of b.flatFields) if (f.required) {
+					const value = ctorParamConvert(f.rustType, f.rustName);
+					init.push(value === f.rustName ? `            ${f.rustName},` : `            ${f.rustName}: ${value},`);
+				} else init.push(`            ${f.rustName}: Default::default(),`);
+				for (const f of b.flattenEnums) if (f.required) {
+					const value = ctorParamConvert(f.rustType, f.rustName);
+					init.push(value === f.rustName ? `            ${f.rustName},` : `            ${f.rustName}: ${value},`);
+				} else init.push(`            ${f.rustName}: Default::default(),`);
+				lines.push("");
+				lines.push(`impl ${b.name} {`);
+				lines.push(`    /// Construct a new \`${b.name}\` with the required fields set.`);
+				lines.push(`    pub fn new(${ctorArgs}) -> Self {`);
+				lines.push("        Self {");
+				for (const l of init) lines.push(l);
+				lines.push("        }");
+				lines.push("    }");
+				lines.push("}");
+			}
+			blocks.push(lines.join("\n"));
+		}
+		return blocks.join("\n\n");
+	}
+};
+/**
+* Render the Rust type for a parameter-group variant field. Variants commit
+* the caller to supplying their full payload, so optional individual params
+* still flow as `String` (not `Option<String>`); the enum-level choice is the
+* one source of truth for "did the caller pick this variant or not."
+*/
+function rustTypeForGroupParam(type) {
+	const rust = mapTypeRef$1(type);
+	if (rust.startsWith("Option<")) return rust.slice(7, -1);
+	return rust;
+}
+/** Classify each parameter group on an op as "query" or "body". */
+function classifyGroup(group, op) {
+	const queryNames = new Set(op.queryParams.map((qp) => qp.name));
+	return group.variants.every((v) => v.parameters.every((p) => queryNames.has(p.name))) ? "query" : "body";
+}
+function renderParamsStruct(name, op, resolved, registry, ctx, groupEmitter) {
 	const bodyRequired = isBodyRequired(op);
 	const hidden = new Set([...Object.keys(resolved.defaults ?? {}), ...resolved.inferFromClient ?? []]);
+	const queryGroupParamNames = /* @__PURE__ */ new Set();
+	const bodyGroupParamNames = /* @__PURE__ */ new Set();
+	const queryGroupFields = [];
+	const bodyGroupFields = [];
+	for (const group of op.parameterGroups ?? []) {
+		const enumName = groupEmitter.registerEnum(group);
+		const rustType = group.optional ? `Option<${enumName}>` : enumName;
+		const groupField = {
+			name: fieldName(group.name),
+			rustType,
+			required: !group.optional,
+			doc: void 0
+		};
+		if (classifyGroup(group, op) === "query") {
+			for (const v of group.variants) for (const p of v.parameters) queryGroupParamNames.add(p.name);
+			queryGroupFields.push(groupField);
+		} else {
+			for (const v of group.variants) for (const p of v.parameters) bodyGroupParamNames.add(p.name);
+			bodyGroupFields.push(groupField);
+		}
+	}
 	const fields = [];
 	const fieldLines = [];
 	const seen = /* @__PURE__ */ new Set();
-	const emitField = (p) => {
+	const emitField = (p, opts = {}) => {
 		if (hidden.has(p.name)) return;
+		if (queryGroupParamNames.has(p.name)) return;
 		const fname = fieldName(p.name);
 		if (seen.has(fname)) return;
 		seen.add(fname);
@@ -23863,26 +24026,47 @@ function renderParamsStruct(name, op, resolved, registry) {
 		});
 		if (!p.required && !rust.startsWith("Option<")) rust = makeOptional(rust);
 		rust = applySecretRedaction(rust, p.name);
+		const defaultExpr = p.default != null ? rustDefaultExpr(p.default, p.type, rust.startsWith("Option<"), ctx) : null;
 		const desc = p.description?.trim();
 		if (desc) for (const c of paramDocComment(desc)) fieldLines.push(`    ${c}`);
-		if (p.required && !rust.startsWith("Option<")) {
+		if (p.default != null) {
 			if (desc) fieldLines.push("    ///");
+			fieldLines.push(`    /// Defaults to \`${formatDefault(p.default)}\`.`);
+		}
+		if (p.required && !rust.startsWith("Option<")) {
+			if (desc || p.default != null) fieldLines.push("    ///");
 			fieldLines.push("    /// Required.");
 		}
 		if (rust.startsWith("Option<")) fieldLines.push("    #[serde(skip_serializing_if = \"Option::is_none\")]");
+		if (opts.isQuery && p.explode === false && isVecType(rust)) fieldLines.push(rust.startsWith("Option<") ? "    #[serde(serialize_with = \"crate::query::serialize_comma_separated_opt\")]" : "    #[serde(serialize_with = \"crate::query::serialize_comma_separated\")]");
 		if (fname !== p.name) fieldLines.push(`    #[serde(rename = ${JSON.stringify(p.name)})]`);
 		if (p.deprecated) fieldLines.push("    #[deprecated]");
 		fieldLines.push(`    pub ${fname}: ${rust},`);
 		fields.push({
 			fname,
 			rust,
-			required: !!p.required && !rust.startsWith("Option<")
+			required: !!p.required && !rust.startsWith("Option<"),
+			defaultExpr
 		});
 	};
-	for (const p of op.queryParams) emitField(p);
+	for (const p of op.queryParams) emitField(p, { isQuery: true });
 	for (const p of op.headerParams) emitField(p);
+	for (const p of op.cookieParams ?? []) emitField(p);
+	for (const g of queryGroupFields) {
+		fieldLines.push("    #[serde(flatten)]");
+		if (!g.required) fieldLines.push("    #[serde(skip_serializing_if = \"Option::is_none\")]");
+		fieldLines.push(`    pub ${g.name}: ${g.rustType},`);
+		fields.push({
+			fname: g.name,
+			rust: g.rustType,
+			required: g.required,
+			defaultExpr: null
+		});
+	}
 	if (op.requestBody) {
-		let bodyType = mapTypeRef$1(op.requestBody, {
+		let bodyType;
+		if (bodyGroupFields.length > 0) bodyType = registerSyntheticBody(op, name, bodyGroupParamNames, bodyGroupFields, ctx, registry, groupEmitter);
+		else bodyType = mapTypeRef$1(op.requestBody, {
 			hint: `${name}Body`,
 			registry
 		});
@@ -23895,21 +24079,36 @@ function renderParamsStruct(name, op, resolved, registry) {
 		fields.push({
 			fname: "body",
 			rust: bodyType,
-			required: bodyRequired
+			required: bodyRequired,
+			defaultExpr: null
 		});
 	}
 	const requiredFields = fields.filter((f) => f.required);
-	const derives = fields.length === 0 || requiredFields.length === 0 ? "Debug, Clone, Default, Serialize" : "Debug, Clone, Serialize";
+	const allOptional = fields.length === 0 || requiredFields.length === 0;
+	const hasSpecDefault = fields.some((f) => f.defaultExpr !== null);
+	const derives = allOptional && !hasSpecDefault ? "Debug, Clone, Default, Serialize" : "Debug, Clone, Serialize";
 	const out = [];
 	if (fieldLines.length === 0) out.push(`#[derive(${derives})]`, `pub struct ${name} {}`);
 	else out.push(`#[derive(${derives})]`, `pub struct ${name} {`, ...fieldLines, "}");
+	if (allOptional && hasSpecDefault) {
+		const defaultInitLines = fields.map((f) => `            ${f.fname}: ${f.defaultExpr ?? "Default::default()"},`);
+		out.push("");
+		out.push(`impl Default for ${name} {`);
+		out.push("    #[allow(deprecated)]");
+		out.push("    fn default() -> Self {");
+		out.push("        Self {");
+		out.push(...defaultInitLines);
+		out.push("        }");
+		out.push("    }");
+		out.push("}");
+	}
 	if (requiredFields.length > 0) {
 		const ctorArgs = requiredFields.map((f) => `${f.fname}: ${ctorParamType(f.rust)}`).join(", ");
 		const initLines = [];
 		for (const f of fields) if (f.required) {
 			const value = ctorParamConvert(f.rust, f.fname);
 			initLines.push(value === f.fname ? `            ${f.fname},` : `            ${f.fname}: ${value},`);
-		} else initLines.push(`            ${f.fname}: Default::default(),`);
+		} else initLines.push(`            ${f.fname}: ${f.defaultExpr ?? "Default::default()"},`);
 		out.push("");
 		out.push(`impl ${name} {`);
 		out.push(`    /// Construct a new \`${name}\` with the required fields set.`);
@@ -23923,6 +24122,52 @@ function renderParamsStruct(name, op, resolved, registry) {
 	}
 	return out.join("\n");
 }
+/** True when a Rust type expression is a `Vec<…>` (or `Option<Vec<…>>`). */
+function isVecType(rust) {
+	return (rust.startsWith("Option<") ? rust.slice(7, -1) : rust).startsWith("Vec<");
+}
+/**
+* Build a synthetic body struct for an op that has body-side parameter
+* groups. The original body model can't be reused as-is because its grouped
+* fields are still flat optionals; the synthetic type swaps them for a
+* flattened enum so callers commit to one variant at construction time.
+*/
+function registerSyntheticBody(op, paramsName, bodyGroupParamNames, bodyGroupFields, ctx, registry, groupEmitter) {
+	const bodyRef = op.requestBody;
+	if (!bodyRef || bodyRef.kind !== "model") return mapTypeRef$1(bodyRef, {
+		hint: `${paramsName}Body`,
+		registry
+	});
+	const model = ctx.spec.models.find((m) => m.name === bodyRef.name);
+	if (!model) return typeName(bodyRef.name);
+	const name = `${paramsName}Body`;
+	const flatFields = model.fields.filter((f) => !bodyGroupParamNames.has(f.name)).map((f) => {
+		let rust = mapTypeRef$1(f.type, {
+			hint: `${name}${typeName(f.name)}`,
+			registry
+		});
+		if (!f.required && !rust.startsWith("Option<")) rust = makeOptional(rust);
+		rust = applySecretRedaction(rust, f.name);
+		return {
+			rustName: fieldName(f.name),
+			wireName: f.name,
+			rustType: rust,
+			required: !!f.required && !rust.startsWith("Option<"),
+			doc: f.description
+		};
+	});
+	const flattenEnums = bodyGroupFields.map((g) => ({
+		rustName: g.name,
+		rustType: g.rustType,
+		required: g.required,
+		doc: g.doc
+	}));
+	return groupEmitter.registerBody({
+		name,
+		flatFields,
+		flattenEnums
+	});
+}
 /** Constructor parameter type — accept `impl Into<String>` for ergonomic strings. */
 function ctorParamType(rust) {
 	if (rust === "String") return "impl Into<String>";
@@ -23934,6 +24179,16 @@ function ctorParamConvert(rust, name) {
 	if (rust === "crate::SecretString") return `${name}.into()`;
 	return name;
 }
+/**
+* Detect a non-default per-operation security requirement (e.g. SSO's
+* `get_profile` requires an OAuth access token rather than the WorkOS API
+* key). Returns the snake_case parameter name to use for the override.
+*/
+function bearerOverrideToken(op) {
+	const override = op.security?.find((s) => s.schemeName !== "bearerAuth");
+	if (!override) return null;
+	return fieldName(override.schemeName);
+}
 function renderMethod(op, resolved, paramsType, method, emptyParams) {
 	planOperation(op);
 	const segments = parsePathTemplate(op.path);
@@ -23941,13 +24196,15 @@ function renderMethod(op, resolved, paramsType, method, emptyParams) {
 	const pathArgNames = op.pathParams.map((p) => methodName(p.name));
 	const returnType = renderResponseType(op);
 	const bodyRequired = isBodyRequired(op);
+	const tokenParam = bearerOverrideToken(op);
 	const sig = [];
 	for (const line of methodDocLines(op)) sig.push(`    ${line}`);
 	if (op.deprecated) sig.push("    #[deprecated]");
 	const argsConvenience = [
 		"&self",
 		...pathArgList,
-		...emptyParams ? [] : [`params: ${paramsType}`]
+		...emptyParams ? [] : [`params: ${paramsType}`],
+		...tokenParam ? [`${tokenParam}: impl Into<String>`] : []
 	];
 	const convenienceSig = `    pub async fn ${method}(${argsConvenience.join(", ")}) -> Result<${returnType}, Error> {`;
 	if (convenienceSig.length <= 100) sig.push(convenienceSig);
@@ -23959,6 +24216,7 @@ function renderMethod(op, resolved, paramsType, method, emptyParams) {
 	const delegateArgs = [
 		...pathArgNames,
 		...emptyParams ? [] : ["params"],
+		...tokenParam ? [tokenParam] : [],
 		"None"
 	].join(", ");
 	sig.push(`        self.${method}_with_options(${delegateArgs}).await`);
@@ -23970,6 +24228,7 @@ function renderMethod(op, resolved, paramsType, method, emptyParams) {
 		"&self",
 		...pathArgList,
 		...emptyParams ? [] : [`params: ${paramsType}`],
+		...tokenParam ? [`${tokenParam}: impl Into<String>`] : [],
 		"options: Option<&crate::RequestOptions>"
 	];
 	const optsSig = `    pub async fn ${method}_with_options(${argsOpts.join(", ")}) -> Result<${returnType}, Error> {`;
@@ -23988,6 +24247,14 @@ function renderMethod(op, resolved, paramsType, method, emptyParams) {
 		sig.push(`        let path = format!(${JSON.stringify(pathFormat)});`);
 	} else sig.push(`        let path = ${JSON.stringify(pathFormat)}.to_string();`);
 	sig.push(`        let method = http::Method::${op.httpMethod.toUpperCase()};`);
+	if (tokenParam) {
+		sig.push(`        let ${tokenParam}: String = ${tokenParam}.into();`);
+		sig.push(`        let auth = http::HeaderValue::from_str(&format!("Bearer {${tokenParam}}"))`);
+		sig.push(`            .map_err(|e| Error::Builder(format!("invalid bearer token: {e}")))?;`);
+		sig.push("        let mut merged = options.cloned().unwrap_or_default();");
+		sig.push("        merged.extra_headers.push((http::header::AUTHORIZATION, auth));");
+		sig.push("        let options = Some(&merged);");
+	}
 	const queryRef = emptyParams ? "&()" : "&params";
 	const emptyResp = isEmptyResponse(op);
 	const bodyMethod = emptyResp ? "request_with_body_opts_empty" : "request_with_body_opts";
@@ -24006,28 +24273,95 @@ function renderMethod(op, resolved, paramsType, method, emptyParams) {
 	return sig.join("\n");
 }
 /**
-* Generate a `<method>_auto_paging` helper for paginated list endpoints.
-* Returns null when the operation isn't a recognised list endpoint (response
-* model lacks both `data: Vec<T>` and `list_metadata`, or the params struct
-* has no `after` cursor).
+* Render a URL-builder method. URL-builder ops (e.g. `GET /sso/authorize`,
+* `GET /sso/logout`) issue no HTTP request — they format a redirect URL the
+* application sends the user to. Generated methods return `Result<String,
+* Error>` because percent-encoding the query string can still fail.
+*/
+function renderUrlBuilderMethod(op, resolved, paramsType, method, emptyParams) {
+	const segments = parsePathTemplate(op.path);
+	const pathArgList = op.pathParams.map((p) => `${methodName(p.name)}: &str`);
+	op.pathParams.map((p) => methodName(p.name));
+	const sig = [];
+	for (const line of methodDocLines(op)) sig.push(`    ${line}`);
+	if (op.deprecated) sig.push("    #[deprecated]");
+	const args = [
+		"&self",
+		...pathArgList,
+		...emptyParams ? [] : [`params: ${paramsType}`]
+	];
+	const headSig = `    pub fn ${method}(${args.join(", ")}) -> Result<String, Error> {`;
+	if (headSig.length <= 100) sig.push(headSig);
+	else {
+		sig.push(`    pub fn ${method}(`);
+		for (const arg of args) sig.push(`        ${arg},`);
+		sig.push("    ) -> Result<String, Error> {");
+	}
+	const pathFormat = segments.map((s) => s.kind === "literal" ? s.value : `{${methodName(s.name)}}`).join("");
+	if (segments.some((s) => s.kind === "param")) {
+		for (const p of op.pathParams) {
+			const n = methodName(p.name);
+			sig.push(`        let ${n} = crate::client::path_segment(${n});`);
+		}
+		sig.push(`        let path = format!(${JSON.stringify(pathFormat)});`);
+	} else sig.push(`        let path = ${JSON.stringify(pathFormat)}.to_string();`);
+	const defaults = resolved.defaults ?? {};
+	const inferred = resolved.inferFromClient ?? [];
+	if (Object.keys(defaults).length > 0 || inferred.length > 0) {
+		sig.push("        let mut overlay = serde_json::Map::new();");
+		for (const [k, v] of Object.entries(defaults)) sig.push(`        overlay.insert(${JSON.stringify(k)}.to_string(), serde_json::json!(${JSON.stringify(v)}));`);
+		for (const k of inferred) sig.push(`        overlay.insert(${JSON.stringify(k)}.to_string(), serde_json::Value::String(${clientFieldExpression(k)}.to_string()));`);
+		if (!emptyParams) {
+			sig.push("        let params_value = serde_json::to_value(&params)");
+			sig.push("            .map_err(|e| Error::Builder(format!(\"query encode failed: {e}\")))?;");
+			sig.push("        if let serde_json::Value::Object(map) = params_value {");
+			sig.push("            for (k, v) in map { overlay.insert(k, v); }");
+			sig.push("        }");
+		}
+		sig.push("        let merged = serde_json::Value::Object(overlay);");
+		sig.push("        let qs = crate::query::encode_query(&merged)?;");
+	} else if (!emptyParams) sig.push("        let qs = crate::query::encode_query(&params)?;");
+	else sig.push("        let qs = String::new();");
+	sig.push("        let url = if qs.is_empty() {");
+	sig.push("            format!(\"{}{}\", self.client.base_url(), path)");
+	sig.push("        } else {");
+	sig.push("            format!(\"{}{}?{}\", self.client.base_url(), path, qs)");
+	sig.push("        };");
+	sig.push("        Ok(url)");
+	sig.push("    }");
+	return sig.join("\n");
+}
+/**
+* Generate a `<method>_auto_paging` helper from `op.pagination`. Returns null
+* when the operation isn't paginated, when the strategy isn't `cursor`, or
+* when the response model lacks the expected `data` / pagination-cursor
+* fields (defensive — the IR shouldn't produce that combination today).
 */
-function renderAutoPagingMethod(op, _resolved, paramsType, method, ctx) {
-	if (!op.response || op.response.kind !== "model") return null;
-	const responseRef = op.response;
-	const responseModel = ctx.spec.models.find((m) => m.name === responseRef.name);
+function renderAutoPagingMethod(op, resolved, paramsType, method, ctx) {
+	if (!op.pagination) return null;
+	if (op.pagination.strategy !== "cursor") return null;
+	if (resolved.urlBuilder) return null;
+	if (op.response.kind !== "model") return null;
+	const responseModel = ctx.spec.models.find((m) => m.name === op.response.name);
 	if (!responseModel) return null;
-	const dataField = responseModel.fields.find((f) => f.name === "data");
-	const hasListMetadata = responseModel.fields.some((f) => f.name === "list_metadata");
-	if (!dataField || !hasListMetadata) return null;
-	if (dataField.type.kind !== "array") return null;
+	const cursorParam = op.pagination.param;
+	const dataPath = op.pagination.dataPath ?? "data";
+	const dataField = responseModel.fields.find((f) => f.name === dataPath);
+	if (!dataField || dataField.type.kind !== "array") return null;
+	const listMetadataField = responseModel.fields.find((f) => f.name === "list_metadata");
+	if (!listMetadataField || listMetadataField.type.kind !== "model") return null;
+	const metadataModel = ctx.spec.models.find((m) => m.name === listMetadataField.type.name);
+	if (!metadataModel) return null;
+	if (!metadataModel.fields.some((f) => f.name === cursorParam)) return null;
 	const itemType = mapTypeRef$1(dataField.type.items);
-	if (!op.queryParams.some((p) => p.name === "after")) return null;
+	const cursorField = fieldName(cursorParam);
+	const dataAccessor = fieldName(dataPath);
 	const pathArgList = op.pathParams.map((p) => `${methodName(p.name)}: impl Into<String>`);
 	const pathArgNames = op.pathParams.map((p) => methodName(p.name));
 	const sig = [];
 	sig.push("");
 	sig.push(`    /// Returns an async [\`futures_util::Stream\`] that yields every \`${itemType}\``);
-	sig.push(`    /// across all pages, advancing the \`after\` cursor under the hood.`);
+	sig.push(`    /// across all pages, advancing the \`${cursorParam}\` cursor under the hood.`);
 	sig.push("    ///");
 	sig.push("    /// ```ignore");
 	sig.push("    /// use futures_util::TryStreamExt;");
@@ -24053,17 +24387,17 @@ function renderAutoPagingMethod(op, _resolved, paramsType, method, ctx) {
 	sig.push("        crate::pagination::auto_paginate_pages(move |after| {");
 	for (const n of pathArgNames) sig.push(`            let ${n} = ${n}.clone();`);
 	sig.push("            let mut params = params.clone();");
-	sig.push("            params.after = after;");
+	sig.push(`            params.${cursorField} = after;`);
 	sig.push("            async move {");
 	const callArgs = [...pathArgNames.map((n) => `&${n}`), "params"].join(", ");
 	sig.push(`                let page = self.${method}(${callArgs}).await?;`);
-	sig.push("                Ok((page.data, page.list_metadata.after))");
+	sig.push(`                Ok((page.${dataAccessor}, page.list_metadata.${cursorField}))`);
 	sig.push("            }");
 	sig.push("        })");
 	sig.push("    }");
 	return sig.join("\n");
 }
-function renderWrapperParamsStruct(name, _op, _wrapper, params, registry) {
+function renderWrapperParamsStruct(name, _op, _wrapper, params, registry, ctx) {
 	const fields = [];
 	const fieldLines = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -24081,32 +24415,52 @@ function renderWrapperParamsStruct(name, _op, _wrapper, params, registry) {
 		rust = applySecretRedaction(rust, rp.paramName);
 		const desc = rp.field?.description?.trim();
 		if (desc) for (const c of paramDocComment(desc)) fieldLines.push(`    ${c}`);
+		const fieldDefault = rp.field?.default;
+		if (fieldDefault != null) {
+			if (desc) fieldLines.push("    ///");
+			fieldLines.push(`    /// Defaults to \`${formatDefault(fieldDefault)}\`.`);
+		}
 		const required = !rp.isOptional && !rust.startsWith("Option<");
 		if (required) {
-			if (desc) fieldLines.push("    ///");
+			if (desc || fieldDefault != null) fieldLines.push("    ///");
 			fieldLines.push("    /// Required.");
 		}
 		if (rust.startsWith("Option<")) fieldLines.push("    #[serde(skip_serializing_if = \"Option::is_none\")]");
 		if (fname !== rp.paramName) fieldLines.push(`    #[serde(rename = ${JSON.stringify(rp.paramName)})]`);
 		fieldLines.push(`    pub ${fname}: ${rust},`);
+		const defaultExpr = fieldDefault != null && rp.field ? rustDefaultExpr(fieldDefault, rp.field.type, rust.startsWith("Option<"), ctx) : null;
 		fields.push({
 			fname,
 			rust,
-			required
+			required,
+			defaultExpr
 		});
 	}
 	const requiredFields = fields.filter((f) => f.required);
-	const derives = fields.length === 0 || requiredFields.length === 0 ? "Debug, Clone, Default, Serialize" : "Debug, Clone, Serialize";
+	const allOptional = fields.length === 0 || requiredFields.length === 0;
+	const hasSpecDefault = fields.some((f) => f.defaultExpr !== null);
+	const derives = allOptional && !hasSpecDefault ? "Debug, Clone, Default, Serialize" : "Debug, Clone, Serialize";
 	const out = [];
 	if (fieldLines.length === 0) out.push(`#[derive(${derives})]`, `pub struct ${name} {}`);
 	else out.push(`#[derive(${derives})]`, `pub struct ${name} {`, ...fieldLines, "}");
+	if (allOptional && hasSpecDefault) {
+		const defaultInitLines = fields.map((f) => `            ${f.fname}: ${f.defaultExpr ?? "Default::default()"},`);
+		out.push("");
+		out.push(`impl Default for ${name} {`);
+		out.push("    fn default() -> Self {");
+		out.push("        Self {");
+		out.push(...defaultInitLines);
+		out.push("        }");
+		out.push("    }");
+		out.push("}");
+	}
 	if (requiredFields.length > 0) {
 		const ctorArgs = requiredFields.map((f) => `${f.fname}: ${ctorParamType(f.rust)}`).join(", ");
 		const initLines = [];
 		for (const f of fields) if (f.required) {
 			const value = ctorParamConvert(f.rust, f.fname);
 			initLines.push(value === f.fname ? `            ${f.fname},` : `            ${f.fname}: ${value},`);
-		} else initLines.push(`            ${f.fname}: Default::default(),`);
+		} else initLines.push(`            ${f.fname}: ${f.defaultExpr ?? "Default::default()"},`);
 		out.push("");
 		out.push(`impl ${name} {`);
 		out.push(`    /// Construct a new \`${name}\` with the required fields set.`);
@@ -24207,6 +24561,47 @@ function clientFieldExpression(field) {
 function paramDocComment(text) {
 	return text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).map((l) => `/// ${l}`);
 }
+/**
+* Render a spec-level default value for inclusion in a doc comment. Strings
+* render bare (e.g. `desc`) so they nest naturally inside the surrounding
+* backticks; numbers/booleans use JSON encoding.
+*/
+function formatDefault(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+/**
+* Render a spec-level default value as a Rust expression suitable for an
+* `impl Default` body or a `new(…)` initialiser. When `isOptional` is true the
+* result is wrapped in `Some(…)` so it matches an `Option<T>` field.
+*
+* Returns `null` for types/values the emitter doesn't know how to materialise
+* — caller falls back to `Default::default()`.
+*/
+function rustDefaultExpr(value, ref, isOptional, ctx) {
+	if (ref.kind === "nullable") return rustDefaultExpr(value, ref.inner, isOptional, ctx);
+	let expr = null;
+	switch (ref.kind) {
+		case "primitive":
+			if (ref.type === "integer" && typeof value === "number" && Number.isFinite(value)) expr = String(Math.trunc(value));
+			else if (ref.type === "number" && typeof value === "number" && Number.isFinite(value)) expr = Number.isInteger(value) ? `${value}.0` : String(value);
+			else if (ref.type === "boolean" && typeof value === "boolean") expr = String(value);
+			else if (ref.type === "string" && typeof value === "string") expr = `${JSON.stringify(value)}.to_string()`;
+			break;
+		case "enum": {
+			if (typeof value !== "string" && typeof value !== "number") break;
+			const enumDef = ctx.spec.enums.find((e) => e.name === ref.name);
+			if (!enumDef) break;
+			const ev = enumDef.values.find((v) => v.value === value);
+			if (!ev) break;
+			expr = `${typeName(ref.name)}::${variantName(ev.value)}`;
+			break;
+		}
+		default: break;
+	}
+	if (expr === null) return null;
+	return isOptional ? `Some(${expr})` : expr;
+}
 function methodDocLines(op) {
 	const lines = [];
 	if (op.description && op.description.trim().length > 0) for (const raw of op.description.split("\n")) {
@@ -24240,16 +24635,19 @@ function isBodyRequired(op) {
 }
 /**
 * `true` when the resolved operation contributes nothing to a params struct:
-* no request body, and every exposed query/header parameter is inferred from
-* the client or supplied as a default. Such methods take no `params:` arg in
-* the public API and skip the empty struct entirely.
+* no request body, and every exposed query/header/cookie parameter is
+* inferred from the client or supplied as a default. Such methods take no
+* `params:` arg in the public API and skip the empty struct entirely.
 */
 function isEmptyParams(op, resolved) {
 	if (op.requestBody) return false;
 	const hidden = new Set([...Object.keys(resolved.defaults ?? {}), ...resolved.inferFromClient ?? []]);
-	const visibleQuery = op.queryParams.filter((p) => !hidden.has(p.name));
+	const grouped = /* @__PURE__ */ new Set();
+	for (const g of op.parameterGroups ?? []) for (const v of g.variants) for (const p of v.parameters) grouped.add(p.name);
+	const visibleQuery = op.queryParams.filter((p) => !hidden.has(p.name) && !grouped.has(p.name));
 	const visibleHeader = op.headerParams.filter((p) => !hidden.has(p.name));
-	return visibleQuery.length === 0 && visibleHeader.length === 0;
+	const visibleCookie = (op.cookieParams ?? []).filter((p) => !hidden.has(p.name));
+	return visibleQuery.length === 0 && visibleHeader.length === 0 && visibleCookie.length === 0 && (op.parameterGroups?.length ?? 0) === 0;
 }
 function renderResourcesBarrel(exports) {
 	const seen = /* @__PURE__ */ new Set();
@@ -24356,7 +24754,8 @@ function generateModelFixture(model, modelMap, enumMap, visiting) {
 	visiting.add(model.name);
 	for (const field of model.fields) {
 		if (!field.required) continue;
-		result[field.name] = exampleFor(field.type, modelMap, enumMap, visiting, field.name);
+		const fromExample = exampleFromSpec(field.example, field.type, enumMap);
+		result[field.name] = fromExample !== void 0 ? fromExample : exampleFor(field.type, modelMap, enumMap, visiting, field.name);
 	}
 	visiting.delete(model.name);
 	return result;
@@ -24398,13 +24797,80 @@ function exampleFor(type, modelMap, enumMap, visiting, fieldName) {
 		}
 	}
 }
+/**
+* Resolve a spec-provided `example` against a TypeRef and return the value to
+* embed in the fixture, or `undefined` when the example cannot be used safely.
+*
+* "Safely" means the value would round-trip through serde to the generated
+* Rust type. We deliberately only accept primitives, enum string/number
+* values, and homogenous arrays of those; nested object examples (which the
+* spec sometimes supplies as illustrative metadata blobs) are skipped because
+* they rarely match the strict struct shape Rust expects.
+*/
+function exampleFromSpec(example, type, enumMap) {
+	if (example === void 0) return void 0;
+	if (example === null) return void 0;
+	return matchExampleToType(example, type, enumMap);
+}
+function matchExampleToType(value, type, enumMap) {
+	switch (type.kind) {
+		case "primitive": return matchPrimitive(value, type.type);
+		case "literal": return value === type.value ? value : void 0;
+		case "enum": {
+			const e = enumMap.get(type.name);
+			if (!e) return void 0;
+			return e.values.some((v) => v.value === value) ? value : void 0;
+		}
+		case "array": {
+			if (!Array.isArray(value)) return void 0;
+			const out = [];
+			for (const item of value) {
+				const matched = matchExampleToType(item, type.items, enumMap);
+				if (matched === void 0) return void 0;
+				out.push(matched);
+			}
+			if (out.length === 0) return void 0;
+			return out;
+		}
+		case "nullable": return matchExampleToType(value, type.inner, enumMap);
+		case "map":
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+			return value;
+		case "union":
+			for (const variant of type.variants) {
+				const matched = matchExampleToType(value, variant, enumMap);
+				if (matched !== void 0) return matched;
+			}
+			return;
+		case "model": return;
+	}
+}
+function matchPrimitive(value, primitive) {
+	switch (primitive) {
+		case "string": return typeof value === "string" ? value : void 0;
+		case "integer": return typeof value === "number" && Number.isInteger(value) ? value : void 0;
+		case "number": return typeof value === "number" ? value : void 0;
+		case "boolean": return typeof value === "boolean" ? value : void 0;
+		case "unknown": return value;
+	}
+}
 //#endregion
 //#region src/rust/tests.ts
 /**
 * Generate integration tests under `tests/`. Each mount group gets one
-* `tests/{mount}_test.rs` file. Generated tests construct params, mock the
-* expected request, then call the SDK method and assert the request was sent
-* (`Mock::expect(1)`). JSON fixtures are emitted alongside.
+* `tests/{mount}_test.rs` file. Per operation the generator emits:
+*
+*   - `_round_trip`: happy-path 200 mock + call.
+*   - `_unauthorized`, `_not_found`, `_rate_limited`, `_server_error`: error
+*     paths for every HTTP-calling op.
+*   - `_bad_request`, `_unprocessable`: additional 4xx error paths for write
+*     ops (POST/PUT/PATCH/DELETE).
+*   - `_empty_page`: empty `data: []` response for paginated ops.
+*   - `_encodes_query_params`: outbound query-string assertion for ops with
+*     array query params (`explode: true` repeated keys, `explode: false`
+*     comma-joined).
+*
+* URL-builder ops (no HTTP call) only get the round-trip test.
 */
 function generateTests(spec, ctx) {
 	const files = [];
@@ -24456,6 +24922,7 @@ function renderMountTest(mountName, resolvedOps, ctx, modelMap, enumMap) {
 	lines.push("");
 	lines.push("use wiremock::matchers::{method, path as path_matcher};");
 	lines.push("use wiremock::{Mock, MockServer, ResponseTemplate};");
+	lines.push(`use ${crate}::Error;`);
 	lines.push("");
 	const seen = /* @__PURE__ */ new Set();
 	for (const r of resolvedOps) {
@@ -24485,43 +24952,316 @@ function renderRegularTest(op, resolved, accessor, crate, modelMap, enumMap) {
 	const literalPath = op.path.replace(/\{[^}]+\}/g, "test_id");
 	const httpMethod = op.httpMethod.toUpperCase();
 	const responseExpr = responseBodyExpr(op.response, modelMap, enumMap);
+	const isUrlBuilder = resolved.urlBuilder === true;
+	const callArgs = buildCallArgs(op, resolved, crate, accessor, modelMap, enumMap).join(", ");
+	const shape = {
+		methodIdent: m,
+		literalPath,
+		httpMethod,
+		callArgs,
+		isUrlBuilder,
+		isWrite: isWriteMethod(op.httpMethod),
+		isPaginated: !!op.pagination,
+		hasBodyGroup: !!op.requestBody && hasBodyParameterGroup(op)
+	};
+	const lines = [];
+	lines.push("#[tokio::test]");
+	lines.push(`async fn ${accessor}_${m}_round_trip() {`);
+	if (isUrlBuilder) {
+		lines.push("    let server = MockServer::start().await;");
+		lines.push("    let client = common::test_client(&server).await;");
+		lines.push(`    let _ = client.${accessor}().${m}(${callArgs});`);
+	} else {
+		lines.push("    let server = MockServer::start().await;");
+		lines.push(`    Mock::given(method(${JSON.stringify(httpMethod)}))`);
+		lines.push(`        .and(path_matcher(${JSON.stringify(literalPath)}))`);
+		lines.push(`        .respond_with(ResponseTemplate::new(200).set_body_string(${responseExpr}))`);
+		lines.push("        .expect(1)");
+		lines.push("        .mount(&server)");
+		lines.push("        .await;");
+		lines.push("    let client = common::test_client(&server).await;");
+		lines.push(`    let _ = client.${accessor}().${m}(${callArgs}).await;`);
+	}
+	lines.push("}");
+	if (isUrlBuilder) return lines;
+	for (const errTest of standardErrorTests(shape, accessor)) {
+		lines.push("");
+		lines.push(...errTest);
+	}
+	if (shape.isWrite) for (const errTest of writeErrorTests(shape, accessor)) {
+		lines.push("");
+		lines.push(...errTest);
+	}
+	if (shape.isPaginated) {
+		const emptyTest = emptyPageTest(op, shape, accessor);
+		if (emptyTest) {
+			lines.push("");
+			lines.push(...emptyTest);
+		}
+	}
+	const encodingTest = encodesQueryParamsTest(op, resolved, accessor, crate, modelMap, enumMap);
+	if (encodingTest) {
+		lines.push("");
+		lines.push(...encodingTest);
+	}
+	return lines;
+}
+/**
+* Build the positional args for the resource method call: path-param literals,
+* then a single params struct (when the op has any), then a token-string for
+* non-bearer security overrides. This factors the constructor logic out of
+* the round-trip renderer so the error/encoding tests can reuse it verbatim
+* — every test category sends the same request, only the mocked response and
+* assertion differ.
+*/
+function buildCallArgs(op, resolved, crate, accessor, modelMap, enumMap) {
 	const hidden = new Set([...Object.keys(resolved.defaults ?? {}), ...resolved.inferFromClient ?? []]);
-	const visibleQuery = op.queryParams.filter((p) => !hidden.has(p.name));
+	const groupedNames = /* @__PURE__ */ new Set();
+	for (const g of op.parameterGroups ?? []) for (const v of g.variants) for (const p of v.parameters) groupedNames.add(p.name);
+	const visibleQuery = op.queryParams.filter((p) => !hidden.has(p.name) && !groupedNames.has(p.name));
 	const visibleHeader = op.headerParams.filter((p) => !hidden.has(p.name));
 	const visibleParams = [...visibleQuery, ...visibleHeader];
 	const requiredParams = visibleParams.filter((p) => p.required);
 	const hasBody = op.requestBody !== void 0;
 	const bodyRequired = hasBody && op.requestBody.kind !== "nullable";
-	const emptyParams = !hasBody && visibleParams.length === 0;
+	const queryNames = new Set(op.queryParams.map((p) => p.name));
+	const requiredQueryGroups = (op.parameterGroups ?? []).filter((g) => !g.optional).filter((g) => g.variants.every((v) => v.parameters.every((p) => queryNames.has(p.name))));
+	const emptyParams = !hasBody && visibleParams.length === 0 && (op.parameterGroups?.length ?? 0) === 0;
 	const callArgs = [];
 	for (const _ of op.pathParams) callArgs.push("\"test_id\"");
 	if (!emptyParams) {
 		const paramsType = `${crate}::${accessor}::${typeName(resolved.methodName)}Params`;
-		if (requiredParams.length === 0 && !bodyRequired) callArgs.push(`${paramsType}::default()`);
+		if (requiredParams.length === 0 && !bodyRequired && requiredQueryGroups.length === 0) callArgs.push(`${paramsType}::default()`);
 		else {
 			const ctorArgs = [];
 			for (const p of requiredParams) ctorArgs.push(stubExpr(p.type, p.name, modelMap, enumMap));
-			if (hasBody) {
-				if (bodyRequired) ctorArgs.push(stubExpr(op.requestBody, "body", modelMap, enumMap));
-			}
+			for (const g of requiredQueryGroups) ctorArgs.push(parameterGroupStubExpr(g, crate, accessor));
+			if (hasBody && bodyRequired) if (hasBodyParameterGroup(op)) ctorArgs.push(syntheticBodyStubExpr(op, resolved, crate, accessor, modelMap));
+			else ctorArgs.push(stubExpr(op.requestBody, "body", modelMap, enumMap));
 			callArgs.push(`${paramsType}::new(${ctorArgs.join(", ")})`);
 		}
 	}
+	const tokenName = bearerOverrideTokenName(op);
+	if (tokenName) callArgs.push(`"stub_${tokenName}".to_string()`);
+	return callArgs;
+}
+/**
+* Build the four common-error test bodies (401/404/429/500). Each one mocks a
+* single response with the given status, calls the SDK method (which should
+* fail), and asserts on the unwrapped `Error::Api` payload.
+*/
+function standardErrorTests(shape, accessor) {
+	const tests = [];
+	tests.push(errorTestBody(shape, accessor, "unauthorized", 401, "{\"message\":\"Unauthorized\"}", void 0));
+	tests.push(errorTestBody(shape, accessor, "not_found", 404, "{\"message\":\"Not found\"}", void 0));
+	tests.push(errorTestBody(shape, accessor, "rate_limited", 429, "{\"message\":\"Slow down\"}", {
+		retryAfterSeconds: 1,
+		assertRetryAfter: true
+	}));
+	tests.push(errorTestBody(shape, accessor, "server_error", 500, "{\"message\":\"Internal error\"}", void 0));
+	return tests;
+}
+/** Build the two write-op-only error tests (400/422). */
+function writeErrorTests(shape, accessor) {
+	return [errorTestBody(shape, accessor, "bad_request", 400, "{\"code\":\"validation_error\",\"message\":\"Bad request\"}", { assertCode: "validation_error" }), errorTestBody(shape, accessor, "unprocessable", 422, "{\"message\":\"Unprocessable\"}", void 0)];
+}
+function errorTestBody(shape, accessor, category, status, body, opts) {
 	const lines = [];
 	lines.push("#[tokio::test]");
-	lines.push(`async fn ${accessor}_${m}_round_trip() {`);
+	lines.push(`async fn ${accessor}_${shape.methodIdent}_${category}() {`);
 	lines.push("    let server = MockServer::start().await;");
-	lines.push(`    Mock::given(method(${JSON.stringify(httpMethod)}))`);
-	lines.push(`        .and(path_matcher(${JSON.stringify(literalPath)}))`);
-	lines.push(`        .respond_with(ResponseTemplate::new(200).set_body_string(${responseExpr}))`);
+	lines.push(`    let template = ResponseTemplate::new(${status})`);
+	if (opts?.retryAfterSeconds !== void 0) lines.push(`        .insert_header("retry-after", ${JSON.stringify(String(opts.retryAfterSeconds))})`);
+	lines.push(`        .set_body_string(${JSON.stringify(body)});`);
+	lines.push(`    Mock::given(method(${JSON.stringify(shape.httpMethod)}))`);
+	lines.push(`        .and(path_matcher(${JSON.stringify(shape.literalPath)}))`);
+	lines.push("        .respond_with(template)");
 	lines.push("        .expect(1)");
 	lines.push("        .mount(&server)");
 	lines.push("        .await;");
 	lines.push("    let client = common::test_client(&server).await;");
-	lines.push(`    let _ = client.${accessor}().${m}(${callArgs.join(", ")}).await;`);
+	lines.push(`    let err = client.${accessor}().${shape.methodIdent}(${shape.callArgs}).await.expect_err("expected error");`);
+	lines.push("    let api = match &err {");
+	lines.push("        Error::Api(api) => api.as_ref(),");
+	lines.push("        other => panic!(\"expected Error::Api, got {other:?}\"),");
+	lines.push("    };");
+	lines.push(`    assert_eq!(api.status, ${status});`);
+	if (opts?.assertRetryAfter) lines.push(`    assert_eq!(api.retry_after, Some(std::time::Duration::from_secs(${opts.retryAfterSeconds ?? 0})));`);
+	if (opts?.assertCode) lines.push(`    assert_eq!(api.code.as_deref(), Some(${JSON.stringify(opts.assertCode)}));`);
 	lines.push("}");
 	return lines;
 }
+/**
+* Return an `_empty_page` test for a paginated list op. Two shapes are
+* supported:
+*
+*  - Wrapper model: `{"data": [], "list_metadata": {...}}`, accessed via
+*    `resp.data` on the returned struct.
+*  - Bare array: `[]`, accessed via `resp.is_empty()` directly (the SDK
+*    returns `Vec<T>` for paginated ops without a wrapper model).
+*
+* Returns null when the response shape isn't recognised (e.g. a primitive
+* or unknown shape we can't safely assert against).
+*/
+function emptyPageTest(op, shape, accessor) {
+	const responseKind = op.response.kind;
+	let body;
+	let dataAccessor;
+	if (responseKind === "array") {
+		body = "[]";
+		dataAccessor = "resp";
+	} else if (responseKind === "model") {
+		body = "{\"object\":\"list\",\"data\":[],\"list_metadata\":{\"before\":null,\"after\":null}}";
+		dataAccessor = "resp.data";
+	} else return null;
+	const lines = [];
+	lines.push("#[tokio::test]");
+	lines.push(`async fn ${accessor}_${shape.methodIdent}_empty_page() {`);
+	lines.push("    let server = MockServer::start().await;");
+	lines.push(`    Mock::given(method(${JSON.stringify(shape.httpMethod)}))`);
+	lines.push(`        .and(path_matcher(${JSON.stringify(shape.literalPath)}))`);
+	lines.push(`        .respond_with(ResponseTemplate::new(200).set_body_string(${JSON.stringify(body)}))`);
+	lines.push("        .expect(1)");
+	lines.push("        .mount(&server)");
+	lines.push("        .await;");
+	lines.push("    let client = common::test_client(&server).await;");
+	lines.push(`    let resp = client.${accessor}().${shape.methodIdent}(${shape.callArgs}).await.expect("expected success");`);
+	lines.push(`    assert!(${dataAccessor}.is_empty(), "expected empty data array");`);
+	lines.push("}");
+	return lines;
+}
+/**
+* Build an `_encodes_query_params` test when the op declares at least one
+* array query param. Constructs a params struct with a known Vec value on
+* each array field and asserts the actual outbound query string contains
+* either repeated keys (`events=foo&events=bar`, default for `explode: true`)
+* or a comma-joined value (`events=foo%2Cbar`, when `explode: false`).
+*
+* Returns null when no array query params apply — those ops have nothing
+* interesting to encode.
+*/
+function encodesQueryParamsTest(op, resolved, accessor, crate, modelMap, enumMap) {
+	const hidden = new Set([...Object.keys(resolved.defaults ?? {}), ...resolved.inferFromClient ?? []]);
+	const groupedNames = /* @__PURE__ */ new Set();
+	for (const g of op.parameterGroups ?? []) for (const v of g.variants) for (const p of v.parameters) groupedNames.add(p.name);
+	const arrayParams = op.queryParams.filter((p) => !hidden.has(p.name) && !groupedNames.has(p.name) && isStringArrayParam(p));
+	if (arrayParams.length === 0) return null;
+	const target = arrayParams[0];
+	const expectedFragment = target.explode !== false ? `${target.name}=foo&${target.name}=bar` : `${target.name}=foo%2Cbar`;
+	const callArgs = buildCallArgs(op, resolved, crate, accessor, modelMap, enumMap);
+	const pathArgCount = op.pathParams.length;
+	const tokenName = bearerOverrideTokenName(op);
+	if (!(callArgs.length > pathArgCount && (tokenName ? callArgs.length > pathArgCount + 1 : true))) return null;
+	const tokenArg = tokenName ? callArgs[callArgs.length - 1] : null;
+	const paramsExpr = callArgs[pathArgCount];
+	const lines = [];
+	const respExpr = encodingResponseExpr(op, modelMap, enumMap);
+	lines.push("#[tokio::test]");
+	lines.push(`async fn ${accessor}_${methodName(resolved.methodName)}_encodes_query_params() {`);
+	lines.push("    let server = MockServer::start().await;");
+	lines.push(`    Mock::given(method(${JSON.stringify("GET".replace("GET", op.httpMethod.toUpperCase()))}))`);
+	lines.push(`        .and(path_matcher(${JSON.stringify(op.path.replace(/\{[^}]+\}/g, "test_id"))}))`);
+	lines.push(`        .respond_with(ResponseTemplate::new(200).set_body_string(${respExpr}))`);
+	lines.push("        .mount(&server)");
+	lines.push("        .await;");
+	lines.push("    let client = common::test_client(&server).await;");
+	if (paramsExpr.endsWith("::default()")) {
+		const ty = paramsExpr.slice(0, -11);
+		lines.push(`    let params = ${ty} {`);
+		lines.push(`        ${fieldIdent(target.name)}: Some(vec!["foo".to_string(), "bar".to_string()]),`);
+		lines.push("        ..Default::default()");
+		lines.push("    };");
+	} else {
+		lines.push(`    let mut params = ${paramsExpr};`);
+		lines.push(`    params.${fieldIdent(target.name)} = Some(vec!["foo".to_string(), "bar".to_string()]);`);
+	}
+	const passArgs = [];
+	for (let i = 0; i < pathArgCount; i++) passArgs.push(callArgs[i]);
+	passArgs.push("params");
+	if (tokenArg) passArgs.push(tokenArg);
+	lines.push(`    let _ = client.${accessor}().${methodName(resolved.methodName)}(${passArgs.join(", ")}).await;`);
+	lines.push("    let received = server.received_requests().await.expect(\"recorded requests\");");
+	lines.push("    let request = received.first().expect(\"at least one request\");");
+	lines.push("    let query = request.url.query().unwrap_or(\"\");");
+	lines.push(`    assert!(query.contains(${JSON.stringify(expectedFragment)}), "expected query to contain {:?}, got {:?}", ${JSON.stringify(expectedFragment)}, query);`);
+	lines.push("}");
+	return lines;
+}
+/** Body expression for the encoding-test response (success, ignored). */
+function encodingResponseExpr(op, modelMap, enumMap) {
+	if (op.pagination) {
+		if (op.response.kind === "array") return JSON.stringify("[]");
+		return JSON.stringify("{\"object\":\"list\",\"data\":[],\"list_metadata\":{\"before\":null,\"after\":null}}");
+	}
+	return responseBodyExpr(op.response, modelMap, enumMap);
+}
+/**
+* True if `param.type` is `Vec<String>` (or `Option<Vec<String>>`). Restricts
+* the encoding test to string arrays because non-string arrays would need
+* per-type constructors we can't synthesise reliably.
+*/
+function isStringArrayParam(p) {
+	let t = p.type;
+	while (t.kind === "nullable") t = t.inner;
+	if (t.kind !== "array") return false;
+	let inner = t.items;
+	while (inner.kind === "nullable") inner = inner.inner;
+	return inner.kind === "primitive" && inner.type === "string";
+}
+/** Snake-case field accessor matching the resources emitter's naming. */
+function fieldIdent(name) {
+	return methodName(name);
+}
+/** True for HTTP methods that mutate state and should retry-defensively. */
+function isWriteMethod(method) {
+	return method !== "get" && method !== "head";
+}
+/** True when the op has at least one body-side parameter group. */
+function hasBodyParameterGroup(op) {
+	const queryNames = new Set(op.queryParams.map((p) => p.name));
+	return (op.parameterGroups ?? []).some((g) => g.variants.every((v) => v.parameters.every((p) => !queryNames.has(p.name))));
+}
+/** Pick the snake_case token-arg name for an op with a non-bearer security override. */
+function bearerOverrideTokenName(op) {
+	const override = op.security?.find((s) => s.schemeName !== "bearerAuth");
+	if (!override) return null;
+	return override.schemeName.replace(/[A-Z]/g, (m) => `_${m.toLowerCase()}`).replace(/^_/, "");
+}
+/**
+* Construct a synthetic body type via its `new(...)` constructor. The
+* resources emitter passes required flat fields and required flatten enums
+* positionally; mirror that ordering here so the stub compiles against the
+* generated `impl <Type> { fn new(...) }`.
+*/
+function syntheticBodyStubExpr(op, resolved, crate, accessor, modelMap) {
+	const bodyRef = op.requestBody;
+	const fqn = `${crate}::${accessor}::${`${typeName(resolved.methodName)}ParamsBody`}`;
+	const model = bodyRef.kind === "model" ? modelMap.get(bodyRef.name) ?? null : null;
+	const queryNames = new Set(op.queryParams.map((p) => p.name));
+	const bodyGroupNames = /* @__PURE__ */ new Set();
+	for (const g of op.parameterGroups ?? []) if (g.variants.every((v) => v.parameters.every((p) => !queryNames.has(p.name)))) for (const v of g.variants) for (const p of v.parameters) bodyGroupNames.add(p.name);
+	const args = [];
+	if (model) for (const f of model.fields) {
+		if (bodyGroupNames.has(f.name)) continue;
+		if (!(!!f.required && f.type.kind !== "nullable")) continue;
+		args.push(`${JSON.stringify(`stub_${f.name}`)}.to_string()`);
+	}
+	for (const g of op.parameterGroups ?? []) {
+		if (!g.variants.every((v) => v.parameters.every((p) => !queryNames.has(p.name)))) continue;
+		if (g.optional) continue;
+		args.push(parameterGroupStubExpr(g, crate, accessor));
+	}
+	return `${fqn}::new(${args.join(", ")})`;
+}
+/** First-variant stub for a parameter-group enum, fully crate-qualified. */
+function parameterGroupStubExpr(group, crate, accessor) {
+	const enumName = group.name.split("_").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+	const firstVariant = group.variants[0];
+	const variantName = firstVariant.name.split("_").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+	const fqn = `${crate}::${accessor}::${enumName}`;
+	if (firstVariant.parameters.length === 0) return `${fqn}::${variantName}`;
+	return `${fqn}::${variantName} { ${firstVariant.parameters.map((p) => `${p.name}: ${JSON.stringify(`stub_${p.name}`)}.to_string()`).join(", ")} }`;
+}
 /** Test for a wrapper-method operation. */
 function renderWrapperTest(op, wrapper, ctx, accessor, crate, modelMap, enumMap) {
 	const m = methodName(wrapper.name);
@@ -24544,6 +25284,7 @@ function renderWrapperTest(op, wrapper, ctx, accessor, crate, modelMap, enumMap)
 		});
 		callArgs.push(`${paramsType}::new(${ctorArgs.join(", ")})`);
 	}
+	const callArgsStr = callArgs.join(", ");
 	const lines = [];
 	lines.push("#[tokio::test]");
 	lines.push(`async fn ${accessor}_${m}_round_trip() {`);
@@ -24555,8 +25296,26 @@ function renderWrapperTest(op, wrapper, ctx, accessor, crate, modelMap, enumMap)
 	lines.push("        .mount(&server)");
 	lines.push("        .await;");
 	lines.push("    let client = common::test_client(&server).await;");
-	lines.push(`    let _ = client.${accessor}().${m}(${callArgs.join(", ")}).await;`);
+	lines.push(`    let _ = client.${accessor}().${m}(${callArgsStr}).await;`);
 	lines.push("}");
+	const shape = {
+		methodIdent: m,
+		literalPath,
+		httpMethod,
+		callArgs: callArgsStr,
+		isUrlBuilder: false,
+		isWrite: isWriteMethod(op.httpMethod),
+		isPaginated: !!op.pagination,
+		hasBodyGroup: false
+	};
+	for (const errTest of standardErrorTests(shape, accessor)) {
+		lines.push("");
+		lines.push(...errTest);
+	}
+	if (shape.isWrite) for (const errTest of writeErrorTests(shape, accessor)) {
+		lines.push("");
+		lines.push(...errTest);
+	}
 	return lines;
 }
 /** Rust string-expression for the mock response body. */
@@ -24727,4 +25486,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { pythonEmitter as _, rustExtractor as a, pythonExtractor as c, rustEmitter as d, rubyEmitter as f, phpEmitter as g, goEmitter as h, kotlinExtractor as i, rubyExtractor as l, dotnetEmitter as m, elixirExtractor as n, goExtractor as o, kotlinEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u, nodeEmitter as v };
 
-//# sourceMappingURL=plugin-C408Wh-o.mjs.map
+//# sourceMappingURL=plugin-CmfzawTp.mjs.map