@workos/oagen-emitters 0.6.7 → 0.7.0

package/dist/{plugin-Bk0xWTQC.mjs → plugin-Bp46oZIh.mjs}

@@ -3016,7 +3016,7 @@ function buildKnownTypeNames(models, ctx) {
 * the output directory for a given IR service name.
 */
 function createServiceDirResolver(models, services, ctx) {
-	const modelToService = assignModelsToServices(models, services);
+	const modelToService = assignModelsToServices(models, services, ctx.modelHints);
 	const serviceNameMap = buildServiceNameMap(services, ctx);
 	const resolveDir = (irService) => irService ? resolveServiceDir$1(serviceNameMap.get(irService) ?? irService) : "common";
 	return {
@@ -6532,7 +6532,7 @@ function modelNeedsRoundTripTest(model) {
 */
 function generateSerializerTests(spec, ctx) {
 	const files = [];
-	const modelToService = assignModelsToServices$1(spec.models, spec.services);
+	const modelToService = assignModelsToServices$1(spec.models, spec.services, ctx.modelHints);
 	const serviceNameMap = /* @__PURE__ */ new Map();
 	for (const service of spec.services) serviceNameMap.set(service.name, resolveResourceClassName$3(service, ctx));
 	const resolveDir = (irService) => irService ? resolveServiceDir$1(serviceNameMap.get(irService) ?? irService) : "common";
@@ -7100,7 +7100,7 @@ function assignEnumsToServices(enums, services) {
 */
 function generateModels$5(models, ctx) {
 	if (models.length === 0) return [];
-	const modelToService = assignModelsToServices(models, ctx.spec.services);
+	const modelToService = assignModelsToServices(models, ctx.spec.services, ctx.modelHints);
 	const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services);
 	const mountDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? mountDirMap.get(irService) ?? "common" : "common";
@@ -7782,7 +7782,7 @@ const buildHiddenParams = buildHiddenParams$1;
 * PascalCase variant class name for a parameter group variant.
 * E.g., group "parent_resource", variant "by_id" -> "ParentResourceById".
 */
-function groupVariantClassName$2(groupName, variantName) {
+function groupVariantClassName$3(groupName, variantName) {
 	return className$5(`${groupName}_${variantName}`);
 }
 /**
@@ -7796,7 +7796,7 @@ function generateParameterGroupDataclasses(operations, specEnumNames, models) {
 	for (const op of operations) {
 		const bodyFieldTypes = collectBodyFieldTypes(op, models);
 		for (const group of op.parameterGroups ?? []) for (const variant of group.variants) {
-			const variantClass = groupVariantClassName$2(group.name, variant.name);
+			const variantClass = groupVariantClassName$3(group.name, variant.name);
 			if (emitted.has(variantClass)) continue;
 			emitted.add(variantClass);
 			lines.push("");
@@ -7829,7 +7829,7 @@ function collectParameterGroupClassNames(operations) {
 	const names = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const op of operations) for (const group of op.parameterGroups ?? []) for (const variant of group.variants) {
-		const cls = groupVariantClassName$2(group.name, variant.name);
+		const cls = groupVariantClassName$3(group.name, variant.name);
 		if (!seen.has(cls)) {
 			seen.add(cls);
 			names.push(cls);
@@ -7924,7 +7924,7 @@ function emitMethodSignature(lines, op, plan, method, isAsync, specEnumNames, mo
 		}
 	}
 	for (const group of op.parameterGroups ?? []) {
-		const unionType = `Union[${group.variants.map((v) => groupVariantClassName$2(group.name, v.name)).join(", ")}]`;
+		const unionType = `Union[${group.variants.map((v) => groupVariantClassName$3(group.name, v.name)).join(", ")}]`;
 		const paramName = fieldName$4(group.name);
 		if (group.optional) lines.push(`        ${paramName}: Optional[${unionType}] = None,`);
 		else lines.push(`        ${paramName}: ${unionType},`);
@@ -8050,7 +8050,7 @@ function emitMethodDocstring(lines, op, plan, method, meta, specEnumNames, ctx,
 		}
 	}
 	for (const group of op.parameterGroups ?? []) {
-		const variantClasses = group.variants.map((v) => groupVariantClassName$2(group.name, v.name));
+		const variantClasses = group.variants.map((v) => groupVariantClassName$3(group.name, v.name));
 		const desc = `Identifies the ${group.name.replace(/_/g, " ")}. One of: ${variantClasses.join(", ")}.`;
 		allParams.push({
 			name: fieldName$4(group.name),
@@ -8357,7 +8357,7 @@ function emitGroupDispatch(lines, op, target = "params", bodyFieldTypes) {
 		const indent = group.optional ? "    " : "";
 		let first = true;
 		for (const variant of group.variants) {
-			const variantClass = groupVariantClassName$2(group.name, variant.name);
+			const variantClass = groupVariantClassName$3(group.name, variant.name);
 			const keyword = first ? "if" : "elif";
 			first = false;
 			lines.push(`        ${indent}${keyword} isinstance(${groupParam}, ${variantClass}):`);
@@ -8453,7 +8453,7 @@ function generateResources$5(services, ctx) {
 		if (enumImports.size > 0) lines.push(`from ${importPrefix}_types import RequestOptions, enum_value`);
 		else lines.push(`from ${importPrefix}_types import RequestOptions`);
 		const actualModelImports = [...modelImports];
-		const modelToServiceMap = assignModelsToServices(ctx.spec.models, ctx.spec.services);
+		const modelToServiceMap = assignModelsToServices(ctx.spec.models, ctx.spec.services, ctx.modelHints);
 		for (const model of ctx.spec.models) if (model.discriminator) {
 			const svc = modelToServiceMap.get(model.name);
 			if (svc) modelToServiceMap.set(model.name + "Variant", svc);
@@ -9270,7 +9270,7 @@ function generateServiceTest$2(service, spec, ctx, accessPaths, resolvedOps) {
 		if (!model) return true;
 		return !isListWrapperModel(model);
 	});
-	const modelToServiceMap = assignModelsToServices(spec.models, spec.services);
+	const modelToServiceMap = assignModelsToServices(spec.models, spec.services, ctx.modelHints);
 	const mountDirMap = buildMountDirMap$1(ctx);
 	const resolveModelDir = (modelName) => {
 		const svc = modelToServiceMap.get(modelName);
@@ -10120,7 +10120,7 @@ function generateModelRoundTripTests(spec, ctx) {
 	for (const name of responseModelNames) requestOnlyModelNames.delete(name);
 	const models = spec.models.filter((m) => !isListWrapperModel(m) && !isListMetadataModel(m) && !requestOnlyModelNames.has(m.name));
 	if (models.length === 0) return null;
-	const modelToService = assignModelsToServices(spec.models, spec.services);
+	const modelToService = assignModelsToServices(spec.models, spec.services, ctx.modelHints);
 	const roundTripDirMap = buildMountDirMap$1(ctx);
 	const resolveDir = (irService) => irService ? roundTripDirMap.get(irService) ?? "common" : "common";
 	const lines = [];
@@ -10928,7 +10928,7 @@ function isRedirectEndpoint(op, resolvedOp) {
 	return false;
 }
 /** PHP class name for a parameter group variant (e.g. ParentResourceById). */
-function groupVariantClassName$1(groupName, variantName) {
+function groupVariantClassName$2(groupName, variantName) {
 	return `${className$4(groupName)}${className$4(variantName)}`;
 }
 /**
@@ -10948,7 +10948,7 @@ function generateParameterGroupFiles(op, ctx, modelMap) {
 	const files = [];
 	const bodyFieldTypes = collectBodyFieldTypes(op, [...modelMap.values()]);
 	for (const group of op.parameterGroups ?? []) for (const variant of group.variants) {
-		const variantClass = groupVariantClassName$1(group.name, variant.name);
+		const variantClass = groupVariantClassName$2(group.name, variant.name);
 		const lines = [];
 		lines.push(`namespace ${ctx.namespacePascal}\\Service;`);
 		lines.push("");
@@ -10982,7 +10982,7 @@ function generateGroupDispatch(op, indent, target = "$query") {
 		const phpParamName = fieldName$3(group.name);
 		for (let vi = 0; vi < group.variants.length; vi++) {
 			const variant = group.variants[vi];
-			const variantClass = groupVariantClassName$1(group.name, variant.name);
+			const variantClass = groupVariantClassName$2(group.name, variant.name);
 			const keyword = vi === 0 ? "if" : "elseif";
 			lines.push(`${indent}${keyword} ($${phpParamName} instanceof ${variantClass}) {`);
 			for (const param of variant.parameters) {
@@ -11036,7 +11036,7 @@ function generateMethod$2(lines, op, service, ctx, modelMap, resolvedOp) {
 		const phpName = fieldName$3(group.name);
 		if (seenDocParams.has(phpName)) continue;
 		seenDocParams.add(phpName);
-		const unionDocType = group.variants.map((v) => groupVariantClassName$1(group.name, v.name)).join("|");
+		const unionDocType = group.variants.map((v) => groupVariantClassName$2(group.name, v.name)).join("|");
 		const nullPrefix = group.optional ? "null|" : "";
 		docParts.push(`@param ${nullPrefix}${unionDocType} $${phpName}`);
 	}
@@ -11258,7 +11258,7 @@ function buildMethodParams(op, plan, modelMap, ctx, hiddenParams) {
 		const phpName = fieldName$3(group.name);
 		if (usedNames.has(phpName)) continue;
 		usedNames.add(phpName);
-		const unionType = group.variants.map((v) => groupVariantClassName$1(group.name, v.name)).join("|");
+		const unionType = group.variants.map((v) => groupVariantClassName$2(group.name, v.name)).join("|");
 		if (group.optional) optional.push(`null|${unionType} $${phpName} = null`);
 		else required.push(`${unionType} $${phpName}`);
 	}
@@ -15565,7 +15565,7 @@ function groupBaseClassName(mountName, groupName) {
 	return `${className$2(mountName)}${className$2(groupName)}`;
 }
 /** Concrete variant class name (e.g. UserManagementRoleSingle). */
-function groupVariantClassName(mountName, groupName, variantName) {
+function groupVariantClassName$1(mountName, groupName, variantName) {
 	return `${className$2(mountName)}${className$2(groupName)}${className$2(variantName)}`;
 }
 /**
@@ -15583,7 +15583,7 @@ function generateParameterGroupTypes(mountName, op, models, emitted) {
 		lines.push("");
 		lines.push(`    public abstract class ${baseName} { }`);
 		for (const variant of group.variants) {
-			const variantName = groupVariantClassName(mountName, group.name, variant.name);
+			const variantName = groupVariantClassName$1(mountName, group.name, variant.name);
 			lines.push("");
 			lines.push(`    public class ${variantName} : ${baseName}`);
 			lines.push("    {");
@@ -15611,7 +15611,7 @@ function emitGroupSerialization(mountName, op, indent, models, target) {
 		const groupField = fieldName$1(group.name);
 		let first = true;
 		for (const variant of group.variants) {
-			const variantName = groupVariantClassName(mountName, group.name, variant.name);
+			const variantName = groupVariantClassName$1(mountName, group.name, variant.name);
 			const localVar = localName(variant.name);
 			const keyword = first ? "if" : "else if";
 			first = false;
@@ -19677,6 +19677,22 @@ function safeParamName(name) {
 function moduleName(name) {
 	return toSnakeCase(name);
 }
+/**
+* PascalCase class name for a parameter-group variant. Mirrors the Python
+* convention: group "password" + variant "plaintext" → `PasswordPlaintext`.
+* Used as the Ruby constant under the WorkOS module.
+*/
+function groupVariantClassName(groupName, variantName) {
+	return className(`${groupName}_${variantName}`);
+}
+/**
+* Fully-qualified Ruby constant for a parameter-group variant scoped under
+* its owning resource module — e.g. "WorkOS::UserManagement::PasswordPlaintext".
+* Mirrors Python's `workos.user_management.PasswordPlaintext` namespacing.
+*/
+function scopedGroupVariantClassName(mountTarget, groupName, variantName) {
+	return `WorkOS::${className(mountTarget)}::${groupVariantClassName(groupName, variantName)}`;
+}
 /** snake_case property name for service accessors on the client. */
 function servicePropertyName(name) {
 	return toSnakeCase(name);
@@ -19762,7 +19778,7 @@ function generateModels(models, ctx) {
 	if (models.length === 0) return [];
 	const enumNames = new Set(ctx.spec.enums.map((e) => e.name));
 	const modelNames = new Set(models.map((m) => m.name));
-	const modelToService = assignModelsToServices(models, ctx.spec.services);
+	const modelToService = assignModelsToServices(models, ctx.spec.services, ctx.modelHints);
 	const mountDirMap = buildMountDirMap(ctx);
 	const dirFor = (modelName) => {
 		const service = modelToService.get(modelName);
@@ -20233,6 +20249,185 @@ function rubyStringLit$1(s) {
 	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
 //#endregion
+//#region src/ruby/parameter-groups.ts
+/**
+* Sorbet type string for a TypeRef. Mirrors `mapSorbetType` in rbi.ts but
+* lives here so the parameter-groups module is self-contained.
+*/
+function mapSorbetType$1(ref) {
+	switch (ref.kind) {
+		case "primitive":
+			switch (ref.type) {
+				case "string": return "String";
+				case "integer": return "Integer";
+				case "number": return "Float";
+				case "boolean": return "T::Boolean";
+				case "unknown": return "T.untyped";
+			}
+			break;
+		case "array": return `T::Array[${mapSorbetType$1(ref.items)}]`;
+		case "model": return `WorkOS::${className(ref.name)}`;
+		case "enum": return "String";
+		case "nullable": return `T.nilable(${mapSorbetType$1(ref.inner)})`;
+		case "literal":
+			if (typeof ref.value === "string") return "String";
+			if (ref.value === null) return "NilClass";
+			if (typeof ref.value === "number") return Number.isInteger(ref.value) ? "Integer" : "Float";
+			return "T::Boolean";
+		case "union": {
+			const variants = ref.variants.map((v) => mapSorbetType$1(v));
+			const unique = [...new Set(variants)];
+			if (unique.length === 1) return unique[0];
+			return `T.any(${unique.join(", ")})`;
+		}
+		case "map": return `T::Hash[String, ${mapSorbetType$1(ref.valueType)}]`;
+	}
+	return "T.untyped";
+}
+/**
+* Build a stable groupName -> mountTarget map. Each parameter group is owned
+* by exactly one resource module — Ruby variant classes are inlined into
+* `WorkOS::<MountTarget>::<Variant>` (matching Python's per-resource layout),
+* so a dispatcher in another resource that references the same group still
+* resolves to a single canonical class.
+*
+* Mount targets are visited in alphabetical order so first-wins is
+* deterministic across runs. In the current spec no group is shared across
+* mount targets; if one ever is, the alphabetically-first owner gets the
+* class and other dispatchers reference it by full path.
+*/
+function buildGroupOwnerMap(ctx) {
+	const owner = /* @__PURE__ */ new Map();
+	const groups = groupByMount(ctx);
+	const sortedTargets = [...groups.keys()].sort();
+	for (const target of sortedTargets) {
+		const g = groups.get(target);
+		if (!g) continue;
+		for (const op of g.operations) for (const grp of op.parameterGroups ?? []) if (!owner.has(grp.name)) owner.set(grp.name, target);
+	}
+	return owner;
+}
+/**
+* Collect all variant classes a given mount target owns. Variants are
+* inlined into the resource file (and its RBI counterpart) — Zeitwerk's
+* collapse convention means subdirectories under `lib/workos/<service>/`
+* don't add a namespace level, so files there can't define
+* `WorkOS::<Service>::<Variant>`. Inline definitions sidestep that.
+*
+* Variant parameter types are taken from the IR's leaf type. When the IR's
+* leaf is a bare primitive but the request body model has a richer type
+* (array/enum/model/map), we fall back to the body type to recover fidelity
+* the IR drops. Body nullability is stripped — when a parameter group is
+* optional, the body field for the group becomes nullable, but within a
+* variant the leaf is always required (selecting the variant means passing it).
+*/
+function collectVariantsForMountTarget(ctx, models, mountTarget) {
+	const owner = buildGroupOwnerMap(ctx);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	const g = groupByMount(ctx).get(mountTarget);
+	if (!g) return out;
+	for (const op of g.operations) {
+		const bodyFieldTypes = collectBodyFieldTypes(op, models);
+		for (const group of op.parameterGroups ?? []) {
+			if (owner.get(group.name) !== mountTarget) continue;
+			for (const variant of group.variants) {
+				const cls = groupVariantClassName(group.name, variant.name);
+				if (seen.has(cls)) continue;
+				seen.add(cls);
+				out.push({
+					className: cls,
+					groupName: group.name,
+					variantName: variant.name,
+					mountTarget,
+					parameters: variant.parameters.map((p) => ({
+						name: p.name,
+						type: pickVariantParamType(p.type, bodyFieldTypes.get(p.name))
+					}))
+				});
+			}
+		}
+	}
+	return out;
+}
+/**
+* Pick the type for a variant leaf parameter.
+*
+* Prefer the IR's leaf type. Use the body model's type only when the IR is a
+* bare primitive but the body has a structured type — that's the original
+* fidelity-recovery case the body fallback was added for. Strip any outer
+* nullable from the body type, since body nullability reflects the parent
+* group's optionality, not the leaf's required-ness within the variant.
+*
+* Exported so the test emitter can recover the same type the variant class
+* declares — IR primitives for fields like `role_slugs` would otherwise stub
+* as `"stub"` strings instead of the `["stub"]` arrays the class accepts.
+*/
+function pickVariantParamType(irType, bodyType) {
+	if (!bodyType) return irType;
+	const unwrappedBody = bodyType.kind === "nullable" ? bodyType.inner : bodyType;
+	const bodyIsStructured = unwrappedBody.kind === "array" || unwrappedBody.kind === "enum" || unwrappedBody.kind === "model" || unwrappedBody.kind === "map";
+	if (irType.kind === "primitive" && bodyIsStructured) return unwrappedBody;
+	return irType;
+}
+function readableName(name) {
+	return name.replace(/_/g, " ");
+}
+/**
+* Render the inline `Data.define` block for a single variant, indented for
+* inclusion inside a `class <Service>` body. Returns an array of lines with
+* 4-space indent (the resource file's class members are 4-space indented).
+*/
+function emitInlineVariantClass(v) {
+	const lines = [];
+	lines.push(`    # Identifies the ${readableName(v.groupName)} (${readableName(v.variantName)} variant).`);
+	lines.push("    #");
+	for (const p of v.parameters) {
+		const yardType = mapTypeRefForYard(p.type);
+		lines.push(`    # @!attribute [r] ${fieldName(p.name)}`);
+		lines.push(`    #   @return [${yardType}]`);
+	}
+	if (v.parameters.length === 0) lines.push(`    ${v.className} = Data.define`);
+	else {
+		const fields = v.parameters.map((p) => `:${fieldName(p.name)}`).join(", ");
+		lines.push(`    ${v.className} = Data.define(${fields})`);
+	}
+	return lines;
+}
+/**
+* Render the inline RBI `class` block for a single variant, indented for
+* inclusion inside a `class <Service>` body in a service .rbi file. Returns
+* lines with 4-space indent.
+*/
+function emitInlineVariantRbi(v) {
+	const lines = [];
+	const fqcn = `WorkOS::${v.mountTarget}::${v.className}`;
+	lines.push(`    class ${v.className}`);
+	for (const p of v.parameters) {
+		lines.push(`      sig { returns(${mapSorbetType$1(p.type)}) }`);
+		lines.push(`      def ${fieldName(p.name)}; end`);
+		lines.push("");
+	}
+	if (v.parameters.length === 0) {
+		lines.push(`      sig { returns(${fqcn}) }`);
+		lines.push(`      def self.new; end`);
+	} else {
+		lines.push("      sig do");
+		lines.push("        params(");
+		for (let i = 0; i < v.parameters.length; i++) {
+			const p = v.parameters[i];
+			const sep = i === v.parameters.length - 1 ? "" : ",";
+			lines.push(`          ${fieldName(p.name)}: ${mapSorbetType$1(p.type)}${sep}`);
+		}
+		lines.push(`        ).returns(${fqcn})`);
+		lines.push("      end");
+		const kwargs = v.parameters.map((p) => `${fieldName(p.name)}:`).join(", ");
+		lines.push(`      def self.new(${kwargs}); end`);
+	}
+	lines.push("    end");
+	return lines;
+}
+//#endregion
 //#region src/ruby/resources.ts
 /**
 * Generate Ruby resource (service) classes from IR services.
@@ -20249,6 +20444,7 @@ function generateResources(services, ctx) {
 	for (const m of ctx.spec.models) modelByName.set(m.name, m);
 	const listWrapperModels = /* @__PURE__ */ new Map();
 	for (const m of ctx.spec.models) if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
+	const groupOwners = buildGroupOwnerMap(ctx);
 	for (const [mountTarget, group] of groups) {
 		const cls = className(mountTarget);
 		const file = fileName(mountTarget);
@@ -20278,7 +20474,8 @@ function generateResources(services, ctx) {
 				modelNames,
 				modelByName,
 				listWrapperModels,
-				requires
+				requires,
+				groupOwners
 			});
 			methodBodies.push(body);
 			if (resolved?.wrappers && resolved.wrappers.length > 0) {
@@ -20299,6 +20496,11 @@ function generateResources(services, ctx) {
 		}
 		lines.push("module WorkOS");
 		lines.push(`  class ${cls}`);
+		const variants = collectVariantsForMountTarget(ctx, ctx.spec.models, mountTarget);
+		for (const v of variants) {
+			for (const line of emitInlineVariantClass(v)) lines.push(line);
+			lines.push("");
+		}
 		lines.push("    def initialize(client)");
 		lines.push("      @client = client");
 		lines.push("    end");
@@ -20319,13 +20521,19 @@ function generateResources(services, ctx) {
 }
 /** Build a single Ruby method from an Operation. */
 function emitMethod(args) {
-	const { op, method, defaults, inferFromClient, hiddenParams, enumNames, modelNames, modelByName, listWrapperModels, requires } = args;
+	const { op, method, defaults, inferFromClient, hiddenParams, enumNames, modelNames, modelByName, listWrapperModels, requires, groupOwners } = args;
+	/** Fully-qualified Ruby constant for a variant (e.g. WorkOS::UserManagement::PasswordPlaintext). */
+	const variantClassRef = (group, variantName) => {
+		const owner = groupOwners.get(group.name);
+		if (!owner) throw new Error(`No owner mount target found for parameter group '${group.name}'`);
+		return scopedGroupVariantClassName(owner, group.name, variantName);
+	};
 	planOperation(op);
 	const lines = [];
 	const pathParams = op.pathParams ?? [];
 	const groupedParamNames = collectGroupedParamNames(op);
 	const queryParams = (op.queryParams ?? []).filter((q) => !groupedParamNames.has(q.name));
-	const bodyFields = getRequestBodyFields(op, hiddenParams, modelByName);
+	const bodyFields = getRequestBodyFields(op, hiddenParams, modelByName).filter((f) => !groupedParamNames.has(f.name));
 	const pathParamNames = new Set(pathParams.map((p) => safeParamName(p.name)));
 	const bodyFieldRenames = /* @__PURE__ */ new Map();
 	for (const f of bodyFields) {
@@ -20393,7 +20601,7 @@ function emitMethod(args) {
 		sigParts.push(`${n}: nil`);
 	}
 	sigParts.push("request_options: {}");
-	const doc = buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bodyFieldRenames, listWrapperModels);
+	const doc = buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bodyFieldRenames, listWrapperModels, variantClassRef);
 	for (const line of doc) lines.push(`    ${line}`);
 	if (sigParts.length === 0) lines.push(`    def ${method}`);
 	else if (sigParts.length === 1 && sigParts[0].length < 60) lines.push(`    def ${method}(${sigParts[0]})`);
@@ -20419,28 +20627,32 @@ function emitMethod(args) {
 	const groupsGoToQuery = hasGroups && !hasBodyMethod;
 	const hasQuery = qEntries.length > 0 || groupsGoToQuery;
 	if (hasQuery) {
+		const queryCompact = qEntries.some((q) => !q.required) ? ".compact" : "";
 		lines.push("      params = {");
 		for (let i = 0; i < qEntries.length; i++) {
 			const q = qEntries[i];
 			const sep = i === qEntries.length - 1 && !groupsGoToQuery ? "" : ",";
 			lines.push(`        ${rubyStringLit(q.name)} => ${safeParamName(q.name)}${sep}`);
 		}
-		lines.push("      }.compact");
+		lines.push(`      }${queryCompact}`);
 		if (groupsGoToQuery) for (const group of op.parameterGroups ?? []) {
 			const prop = fieldName(group.name);
 			if (group.optional) {
 				lines.push(`      if ${prop}`);
-				lines.push(`        case ${prop}[:type]`);
-			} else lines.push(`      case ${prop}[:type]`);
+				lines.push(`        case ${prop}`);
+			} else lines.push(`      case ${prop}`);
 			for (const variant of group.variants) {
-				lines.push(`      when ${rubyStringLit(variant.name)}`);
-				for (const p of variant.parameters) lines.push(`        params[${rubyStringLit(p.name)}] = ${prop}[:${fieldName(p.name)}]`);
+				const variantClass = variantClassRef(group, variant.name);
+				lines.push(`      when ${variantClass}`);
+				for (const p of variant.parameters) lines.push(`        params[${rubyStringLit(p.name)}] = ${prop}.${fieldName(p.name)}`);
 			}
+			lines.push(`      else`);
+			lines.push(`        raise ArgumentError, ${dispatchErrorLiteral(group, prop, variantClassRef)}`);
 			lines.push("      end");
 			if (group.optional) lines.push("      end");
 		}
 	}
-	const hasBody = bodyFields.length > 0 && !["get", "head"].includes(method_http);
+	const hasBody = bodyFields.length > 0 && !["get", "head"].includes(method_http) || hasGroups && hasBodyMethod;
 	if (hasBody) {
 		const bodyEntries = [];
 		for (const [k, v] of Object.entries(defaults)) {
@@ -20452,26 +20664,32 @@ function emitMethod(args) {
 			const optKey = fc === "client_secret" ? "api_key" : fc;
 			bodyEntries.push(`${rubyStringLit(fc)} => (request_options[:${optKey}] || @client.${clientProp})`);
 		}
+		let bodyHasNilable = false;
 		for (const f of bodyFields) {
 			if (hiddenParams.has(f.name)) continue;
 			bodyEntries.push(`${rubyStringLit(f.name)} => ${bodyKwargName(f.name)}`);
+			if (!f.required) bodyHasNilable = true;
 		}
+		const bodyCompact = bodyHasNilable ? ".compact" : "";
 		lines.push("      body = {");
 		for (let i = 0; i < bodyEntries.length; i++) {
 			const sep = i === bodyEntries.length - 1 ? "" : ",";
 			lines.push(`        ${bodyEntries[i]}${sep}`);
 		}
-		lines.push("      }.compact");
+		lines.push(`      }${bodyCompact}`);
 		if (hasGroups && hasBodyMethod) for (const group of op.parameterGroups ?? []) {
 			const prop = fieldName(group.name);
 			if (group.optional) {
 				lines.push(`      if ${prop}`);
-				lines.push(`        case ${prop}[:type]`);
-			} else lines.push(`      case ${prop}[:type]`);
+				lines.push(`        case ${prop}`);
+			} else lines.push(`      case ${prop}`);
 			for (const variant of group.variants) {
-				lines.push(`      when ${rubyStringLit(variant.name)}`);
-				for (const p of variant.parameters) lines.push(`        body[${rubyStringLit(p.name)}] = ${prop}[:${fieldName(p.name)}]`);
+				const variantClass = variantClassRef(group, variant.name);
+				lines.push(`      when ${variantClass}`);
+				for (const p of variant.parameters) lines.push(`        body[${rubyStringLit(p.name)}] = ${prop}.${fieldName(p.name)}`);
 			}
+			lines.push(`      else`);
+			lines.push(`        raise ArgumentError, ${dispatchErrorLiteral(group, prop, variantClassRef)}`);
 			lines.push("      end");
 			if (group.optional) lines.push("      end");
 		}
@@ -20686,7 +20904,7 @@ function oneLine(desc) {
 	if (!desc) return "";
 	return desc.replace(/\r/g, " ").replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
 }
-function buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bodyFieldRenames, listWrapperModels) {
+function buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bodyFieldRenames, listWrapperModels, variantClassRef) {
 	const lines = [];
 	const firstLine = (op.description ?? `${op.httpMethod.toUpperCase()} ${op.path}`).split("\n")[0] ?? "";
 	lines.push(`# ${firstLine}`);
@@ -20722,6 +20940,14 @@ function buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bod
 		const deprecatedPrefix = q.deprecated ? "(deprecated) " : "";
 		lines.push(`# @param ${n} [${type}${suffix}] ${deprecatedPrefix}${oneLine(q.description)}`.trim());
 	}
+	for (const group of op.parameterGroups ?? []) {
+		const n = fieldName(group.name);
+		if (emittedParamNames.has(n)) continue;
+		emittedParamNames.add(n);
+		const variantTypes = group.variants.map((v) => variantClassRef(group, v.name)).join(", ");
+		const suffix = group.optional ? ", nil" : "";
+		lines.push(`# @param ${n} [${variantTypes}${suffix}] Identifies the ${group.name.replace(/_/g, " ")}.`);
+	}
 	lines.push(`# @param request_options [Hash] (see WorkOS::Types::RequestOptions)`);
 	const ref = op.response;
 	if (ref.kind === "primitive" && ref.type === "unknown") lines.push(`# @return [void]`);
@@ -20744,6 +20970,14 @@ function buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bod
 function rubyStringLit(s) {
 	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
+/**
+* Build a Ruby double-quoted string expression for the `else raise ArgumentError`
+* arm of a parameter-group dispatcher. Lists the expected variant classes and
+* interpolates the actual class of the value the caller passed.
+*/
+function dispatchErrorLiteral(group, prop, variantClassRef) {
+	return `"expected ${prop} to be one of: ${group.variants.map((v) => variantClassRef(group, v.name)).join(", ")}, got #{${prop}.class}"`;
+}
 //#endregion
 //#region src/ruby/client.ts
 /**
@@ -20912,7 +21146,7 @@ function generateMainEntryFile(spec, ctx) {
 * keep the generated namespace flat while the filesystem is grouped.
 */
 function collectModelSubdirs(spec, ctx) {
-	const modelToService = assignModelsToServices(spec.models, spec.services);
+	const modelToService = assignModelsToServices(spec.models, spec.services, ctx.modelHints);
 	const mountDirMap = buildMountDirMap(ctx);
 	const subdirs = /* @__PURE__ */ new Set();
 	for (const model of spec.models) {
@@ -20973,9 +21207,11 @@ function generateClientClass(spec, ctx) {
 function generateTests(spec, ctx) {
 	const files = [];
 	const groups = groupByMount(ctx);
+	const models = spec.models;
 	const modelByName = /* @__PURE__ */ new Map();
-	for (const m of spec.models) modelByName.set(m.name, m);
+	for (const m of models) modelByName.set(m.name, m);
 	const lookup = buildResolvedLookup(ctx);
+	const groupOwners = buildGroupOwnerMap(ctx);
 	for (const [mountTarget, group] of groups) {
 		const cls = className(mountTarget);
 		const prop = servicePropertyName(mountTarget);
@@ -21004,7 +21240,9 @@ function generateTests(spec, ctx) {
 			op.httpMethod.toLowerCase();
 			const httpMethodSym = `:${op.httpMethod.toLowerCase()}`;
 			const resolved = lookupResolved(op, lookup);
-			const callArgs = buildCallArgsStub(op, modelByName, buildHiddenParams$1(resolved));
+			const hiddenParams = buildHiddenParams$1(resolved);
+			const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models);
+			const bodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models);
 			authMethodManifest.push({
 				method,
 				httpMethodSym,
@@ -21013,23 +21251,47 @@ function generateTests(spec, ctx) {
 			});
 			const stubRegex = stubUrlRegex(stubUrl);
 			lines.push(`  def test_${method}_returns_expected_result`);
+			lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
+			if (bodyMatcher) lines.push(`      .with(body: ${bodyMatcher})`);
 			if (isList) {
-				lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
 				lines.push(`      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)`);
 				lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
 				lines.push("    assert_kind_of WorkOS::Types::ListStruct, result");
 			} else if (op.response.kind === "primitive") {
-				lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
 				lines.push(`      .to_return(body: "{}", status: 200)`);
 				lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
 				lines.push("    assert_nil result");
 			} else {
-				lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
 				lines.push(`      .to_return(body: "{}", status: 200)`);
 				lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
 				lines.push("    refute_nil result");
 			}
 			lines.push("  end");
+			for (const group of op.parameterGroups ?? []) for (let vi = 1; vi < group.variants.length; vi++) {
+				const variant = group.variants[vi];
+				const overrides = new Map([[group.name, vi]]);
+				const variantCallArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, overrides);
+				const variantBodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models, overrides);
+				const suffix = `with_${fieldName(group.name)}_${fieldName(variant.name)}`;
+				lines.push("");
+				lines.push(`  def test_${method}_${suffix}_returns_expected_result`);
+				lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
+				if (variantBodyMatcher) lines.push(`      .with(body: ${variantBodyMatcher})`);
+				if (isList) {
+					lines.push(`      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)`);
+					lines.push(`    result = @client.${prop}.${method}(${variantCallArgs})`);
+					lines.push("    assert_kind_of WorkOS::Types::ListStruct, result");
+				} else if (op.response.kind === "primitive") {
+					lines.push(`      .to_return(body: "{}", status: 200)`);
+					lines.push(`    result = @client.${prop}.${method}(${variantCallArgs})`);
+					lines.push("    assert_nil result");
+				} else {
+					lines.push(`      .to_return(body: "{}", status: 200)`);
+					lines.push(`    result = @client.${prop}.${method}(${variantCallArgs})`);
+					lines.push("    refute_nil result");
+				}
+				lines.push("  end");
+			}
 			if (resolved?.wrappers && resolved.wrappers.length > 0) for (const wrapper of resolved.wrappers) emitWrapperTests({
 				lines,
 				wrapper,
@@ -21160,8 +21422,12 @@ function roundTripStub(ref, enumNames) {
 		default: return `nil`;
 	}
 }
-/** Build minimal placeholder arguments for calling the SDK method from a test. */
-function buildCallArgsStub(op, modelByName, hiddenParams) {
+/** Build minimal placeholder arguments for calling the SDK method from a test.
+*  `variantOverrides` selects a non-zero variant index per group; absent groups
+*  default to variant 0. Used to emit per-variant test cases that exercise the
+*  second/third arm of each parameter-group dispatcher.
+*/
+function buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, variantOverrides = /* @__PURE__ */ new Map()) {
 	const parts = [];
 	const seen = /* @__PURE__ */ new Set();
 	const pathParamNames = /* @__PURE__ */ new Set();
@@ -21193,17 +21459,68 @@ function buildCallArgsStub(op, modelByName, hiddenParams) {
 		seen.add(name);
 		parts.push(`${name}: ${stubValueFor(q.type)}`);
 	}
+	const bodyFieldTypes = collectBodyFieldTypes(op, models);
 	for (const group of op.parameterGroups ?? []) {
-		if (group.optional) continue;
 		const name = fieldName(group.name);
 		if (seen.has(name)) continue;
 		seen.add(name);
-		const firstVariant = group.variants[0];
-		if (firstVariant) parts.push(`${name}: { type: "${firstVariant.name}" }`);
-		else parts.push(`${name}: {}`);
+		const idx = variantOverrides.get(group.name) ?? 0;
+		const variant = group.variants[idx];
+		if (variant) {
+			const owner = groupOwners.get(group.name);
+			if (!owner) throw new Error(`No owner mount target found for parameter group '${group.name}'`);
+			const variantClass = scopedGroupVariantClassName(owner, group.name, variant.name);
+			const fieldStubs = variant.parameters.map((p) => `${fieldName(p.name)}: ${stubValueFor(pickVariantParamType(p.type, bodyFieldTypes.get(p.name)))}`).join(", ");
+			parts.push(`${name}: ${variantClass}.new(${fieldStubs})`);
+		}
 	}
 	return parts.join(", ");
 }
+/**
+* Build a Ruby `hash_including(...)` matcher describing the wire body the
+* SDK should send for an operation whose body is constructed (in part) by a
+* parameter-group dispatcher. Returns `null` for operations without body
+* groups — those are still stubbed without a body matcher.
+*
+* The matcher includes every required non-group body field plus the first
+* variant's wire-name leaves for each group dispatched into the body. This
+* catches regressions where the dispatcher silently drops a passed group
+* (the original `update_organization_membership` regression).
+*/
+function buildBodyMatcher(op, modelByName, hiddenParams, models, variantOverrides = /* @__PURE__ */ new Map()) {
+	const httpMethod = op.httpMethod.toLowerCase();
+	const hasBodyMethod = ![
+		"get",
+		"head",
+		"delete"
+	].includes(httpMethod);
+	const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
+	if (!hasBodyMethod || !hasGroups) return null;
+	const groupedParamNames = /* @__PURE__ */ new Set();
+	for (const group of op.parameterGroups ?? []) for (const variant of group.variants) for (const p of variant.parameters) groupedParamNames.add(p.name);
+	const entries = [];
+	if (op.requestBody) {
+		const bodyModel = resolveBodyModel(op.requestBody, modelByName);
+		if (bodyModel) for (const f of bodyModel.fields) {
+			if (!f.required) continue;
+			if (hiddenParams.has(f.name)) continue;
+			if (groupedParamNames.has(f.name)) continue;
+			entries.push(`"${f.name}" => ${stubValueFor(f.type)}`);
+		}
+	}
+	const bodyFieldTypes = collectBodyFieldTypes(op, models);
+	for (const group of op.parameterGroups ?? []) {
+		const idx = variantOverrides.get(group.name) ?? 0;
+		const variant = group.variants[idx];
+		if (!variant) continue;
+		for (const p of variant.parameters) {
+			const recovered = pickVariantParamType(p.type, bodyFieldTypes.get(p.name));
+			entries.push(`"${p.name}" => ${stubValueFor(recovered)}`);
+		}
+	}
+	if (entries.length === 0) return null;
+	return `hash_including(${entries.join(", ")})`;
+}
 function resolveBodyModel(ref, modelByName) {
 	if (ref.kind === "model") return modelByName.get(ref.name) ?? null;
 	if (ref.kind === "nullable") return resolveBodyModel(ref.inner, modelByName);
@@ -21257,7 +21574,7 @@ function stubValueFor(ref) {
 			case "boolean": return `true`;
 			default: return `nil`;
 		}
-		case "array": return `[]`;
+		case "array": return `[${stubValueFor(ref.items)}]`;
 		case "map": return `{}`;
 		case "enum": return `"stub"`;
 		case "literal":
@@ -21392,6 +21709,7 @@ function generateRbiFiles(spec, ctx) {
 	for (const m of spec.models) modelByName.set(m.name, m);
 	const listWrapperModels = /* @__PURE__ */ new Map();
 	for (const m of spec.models) if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
+	const groupOwners = buildGroupOwnerMap(ctx);
 	for (const [mountTarget, group] of groups) {
 		const cls = className(mountTarget);
 		const lines = [];
@@ -21399,6 +21717,11 @@ function generateRbiFiles(spec, ctx) {
 		lines.push("");
 		lines.push("module WorkOS");
 		lines.push(`  class ${cls}`);
+		const variants = collectVariantsForMountTarget(ctx, spec.models, mountTarget);
+		for (const v of variants) {
+			for (const line of emitInlineVariantRbi(v)) lines.push(line);
+			lines.push("");
+		}
 		lines.push("    sig { params(client: WorkOS::BaseClient).void }");
 		lines.push("    def initialize(client); end");
 		lines.push("");
@@ -21415,7 +21738,15 @@ function generateRbiFiles(spec, ctx) {
 			const hiddenParams = buildHiddenParams$1(resolved);
 			const groupedParamNames = collectGroupedParamNames(op);
 			const queryParams = (op.queryParams ?? []).filter((q) => !groupedParamNames.has(q.name));
-			const bodyFields = getRequestBodyFieldsFlat(op, hiddenParams, modelByName);
+			const bodyFields = getRequestBodyFieldsFlat(op, hiddenParams, modelByName).filter((f) => !groupedParamNames.has(f.name));
+			const parameterGroups = op.parameterGroups ?? [];
+			const groupSorbetType = (group) => {
+				const owner = groupOwners.get(group.name);
+				if (!owner) throw new Error(`No owner mount target found for parameter group '${group.name}'`);
+				const variants = group.variants.map((v) => scopedGroupVariantClassName(owner, group.name, v.name));
+				if (variants.length === 1) return variants[0];
+				return `T.any(${variants.join(", ")})`;
+			};
 			const sigParams = [];
 			const seen = /* @__PURE__ */ new Set();
 			for (const p of op.pathParams ?? []) {
@@ -21440,6 +21771,13 @@ function generateRbiFiles(spec, ctx) {
 				seen.add(n);
 				sigParams.push(`${n}: ${mapSorbetType(q.type)}`);
 			}
+			for (const group of parameterGroups) {
+				if (group.optional) continue;
+				const n = fieldName(group.name);
+				if (seen.has(n)) continue;
+				seen.add(n);
+				sigParams.push(`${n}: ${groupSorbetType(group)}`);
+			}
 			for (const f of bodyFields) {
 				if (hiddenParams.has(f.name)) continue;
 				if (f.required) continue;
@@ -21456,6 +21794,13 @@ function generateRbiFiles(spec, ctx) {
 				seen.add(n);
 				sigParams.push(`${n}: T.nilable(${unwrapNilable(mapSorbetType(q.type))})`);
 			}
+			for (const group of parameterGroups) {
+				if (!group.optional) continue;
+				const n = fieldName(group.name);
+				if (seen.has(n)) continue;
+				seen.add(n);
+				sigParams.push(`${n}: T.nilable(${groupSorbetType(group)})`);
+			}
 			sigParams.push("request_options: T::Hash[Symbol, T.untyped]");
 			const retType = mapSorbetReturnType(op.response, listWrapperModels, modelNames);
 			lines.push("    sig do");
@@ -21630,4 +21975,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { nodeEmitter as _, rustExtractor as a, pythonExtractor as c, rubyEmitter as d, kotlinEmitter as f, pythonEmitter as g, phpEmitter as h, kotlinExtractor as i, rubyExtractor as l, goEmitter as m, elixirExtractor as n, goExtractor as o, dotnetEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u };
 
-//# sourceMappingURL=plugin-Bk0xWTQC.mjs.map
+//# sourceMappingURL=plugin-Bp46oZIh.mjs.map