@fern-api/generator-migrations 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -0,0 +1,1225 @@
+//#region ../../node_modules/.pnpm/immer@10.1.3/node_modules/immer/dist/immer.mjs
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+var errors = process.env.NODE_ENV !== "production" ? [
+	function(plugin) {
+		return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+	},
+	function(thing) {
+		return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+	},
+	"This object has been frozen and should not be mutated",
+	function(data) {
+		return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+	},
+	"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+	"Immer forbids circular references",
+	"The first or second argument to `produce` must be a function",
+	"The third argument to `produce` must be a function or undefined",
+	"First argument to `createDraft` must be a plain object, an array, or an immerable object",
+	"First argument to `finishDraft` must be a draft returned by `createDraft`",
+	function(thing) {
+		return `'current' expects a draft, got: ${thing}`;
+	},
+	"Object.defineProperty() cannot be used on an Immer draft",
+	"Object.setPrototypeOf() cannot be used on an Immer draft",
+	"Immer only supports deleting array indices",
+	"Immer only supports setting array indices and the 'length' property",
+	function(thing) {
+		return `'original' expects a draft, got: ${thing}`;
+	}
+] : [];
+function die(error, ...args) {
+	if (process.env.NODE_ENV !== "production") {
+		const e = errors[error];
+		const msg = typeof e === "function" ? e.apply(null, args) : e;
+		throw new Error(`[Immer] ${msg}`);
+	}
+	throw new Error(`[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`);
+}
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+	return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+	if (!value) return false;
+	return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = getPrototypeOf(value);
+	if (proto === null) return true;
+	const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+	if (Ctor === Object) return true;
+	return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+function each(obj, iter) {
+	if (getArchtype(obj) === 0) Reflect.ownKeys(obj).forEach((key) => {
+		iter(key, obj[key], obj);
+	});
+	else obj.forEach((entry, index) => iter(index, entry, obj));
+}
+function getArchtype(thing) {
+	const state = thing[DRAFT_STATE];
+	return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+function has(thing, prop) {
+	return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+	const t = getArchtype(thing);
+	if (t === 2) thing.set(propOrOldValue, value);
+	else if (t === 3) thing.add(value);
+	else thing[propOrOldValue] = value;
+}
+function is(x, y) {
+	if (x === y) return x !== 0 || 1 / x === 1 / y;
+	else return x !== x && y !== y;
+}
+function isMap(target) {
+	return target instanceof Map;
+}
+function isSet(target) {
+	return target instanceof Set;
+}
+function latest(state) {
+	return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+	if (isMap(base)) return new Map(base);
+	if (isSet(base)) return new Set(base);
+	if (Array.isArray(base)) return Array.prototype.slice.call(base);
+	const isPlain = isPlainObject(base);
+	if (strict === true || strict === "class_only" && !isPlain) {
+		const descriptors = Object.getOwnPropertyDescriptors(base);
+		delete descriptors[DRAFT_STATE];
+		let keys = Reflect.ownKeys(descriptors);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const desc = descriptors[key];
+			if (desc.writable === false) {
+				desc.writable = true;
+				desc.configurable = true;
+			}
+			if (desc.get || desc.set) descriptors[key] = {
+				configurable: true,
+				writable: true,
+				enumerable: desc.enumerable,
+				value: base[key]
+			};
+		}
+		return Object.create(getPrototypeOf(base), descriptors);
+	} else {
+		const proto = getPrototypeOf(base);
+		if (proto !== null && isPlain) return { ...base };
+		const obj = Object.create(proto);
+		return Object.assign(obj, base);
+	}
+}
+function freeze(obj, deep = false) {
+	if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
+	if (getArchtype(obj) > 1) Object.defineProperties(obj, {
+		set: { value: dontMutateFrozenCollections },
+		add: { value: dontMutateFrozenCollections },
+		clear: { value: dontMutateFrozenCollections },
+		delete: { value: dontMutateFrozenCollections }
+	});
+	Object.freeze(obj);
+	if (deep) Object.values(obj).forEach((value) => freeze(value, true));
+	return obj;
+}
+function dontMutateFrozenCollections() {
+	die(2);
+}
+function isFrozen(obj) {
+	return Object.isFrozen(obj);
+}
+var plugins = {};
+function getPlugin(pluginKey) {
+	const plugin = plugins[pluginKey];
+	if (!plugin) die(0, pluginKey);
+	return plugin;
+}
+var currentScope;
+function getCurrentScope() {
+	return currentScope;
+}
+function createScope(parent_, immer_) {
+	return {
+		drafts_: [],
+		parent_,
+		immer_,
+		canAutoFreeze_: true,
+		unfinalizedDrafts_: 0
+	};
+}
+function usePatchesInScope(scope, patchListener) {
+	if (patchListener) {
+		getPlugin("Patches");
+		scope.patches_ = [];
+		scope.inversePatches_ = [];
+		scope.patchListener_ = patchListener;
+	}
+}
+function revokeScope(scope) {
+	leaveScope(scope);
+	scope.drafts_.forEach(revokeDraft);
+	scope.drafts_ = null;
+}
+function leaveScope(scope) {
+	if (scope === currentScope) currentScope = scope.parent_;
+}
+function enterScope(immer2) {
+	return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+	const state = draft[DRAFT_STATE];
+	if (state.type_ === 0 || state.type_ === 1) state.revoke_();
+	else state.revoked_ = true;
+}
+function processResult(result, scope) {
+	scope.unfinalizedDrafts_ = scope.drafts_.length;
+	const baseDraft = scope.drafts_[0];
+	if (result !== void 0 && result !== baseDraft) {
+		if (baseDraft[DRAFT_STATE].modified_) {
+			revokeScope(scope);
+			die(4);
+		}
+		if (isDraftable(result)) {
+			result = finalize(scope, result);
+			if (!scope.parent_) maybeFreeze(scope, result);
+		}
+		if (scope.patches_) getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_);
+	} else result = finalize(scope, baseDraft, []);
+	revokeScope(scope);
+	if (scope.patches_) scope.patchListener_(scope.patches_, scope.inversePatches_);
+	return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+	if (isFrozen(value)) return value;
+	const state = value[DRAFT_STATE];
+	if (!state) {
+		each(value, (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path));
+		return value;
+	}
+	if (state.scope_ !== rootScope) return value;
+	if (!state.modified_) {
+		maybeFreeze(rootScope, state.base_, true);
+		return state.base_;
+	}
+	if (!state.finalized_) {
+		state.finalized_ = true;
+		state.scope_.unfinalizedDrafts_--;
+		const result = state.copy_;
+		let resultEach = result;
+		let isSet2 = false;
+		if (state.type_ === 3) {
+			resultEach = new Set(result);
+			result.clear();
+			isSet2 = true;
+		}
+		each(resultEach, (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2));
+		maybeFreeze(rootScope, result, false);
+		if (path && rootScope.patches_) getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
+	}
+	return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+	if (process.env.NODE_ENV !== "production" && childValue === targetObject) die(5);
+	if (isDraft(childValue)) {
+		const res = finalize(rootScope, childValue, rootPath && parentState && parentState.type_ !== 3 && !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0);
+		set(targetObject, prop, res);
+		if (isDraft(res)) rootScope.canAutoFreeze_ = false;
+		else return;
+	} else if (targetIsSet) targetObject.add(childValue);
+	if (isDraftable(childValue) && !isFrozen(childValue)) {
+		if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) return;
+		finalize(rootScope, childValue);
+		if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop))) maybeFreeze(rootScope, childValue);
+	}
+}
+function maybeFreeze(scope, value, deep = false) {
+	if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) freeze(value, deep);
+}
+function createProxyProxy(base, parent) {
+	const isArray = Array.isArray(base);
+	const state = {
+		type_: isArray ? 1 : 0,
+		scope_: parent ? parent.scope_ : getCurrentScope(),
+		modified_: false,
+		finalized_: false,
+		assigned_: {},
+		parent_: parent,
+		base_: base,
+		draft_: null,
+		copy_: null,
+		revoke_: null,
+		isManual_: false
+	};
+	let target = state;
+	let traps = objectTraps;
+	if (isArray) {
+		target = [state];
+		traps = arrayTraps;
+	}
+	const { revoke, proxy } = Proxy.revocable(target, traps);
+	state.draft_ = proxy;
+	state.revoke_ = revoke;
+	return proxy;
+}
+var objectTraps = {
+	get(state, prop) {
+		if (prop === DRAFT_STATE) return state;
+		const source = latest(state);
+		if (!has(source, prop)) return readPropFromProto(state, source, prop);
+		const value = source[prop];
+		if (state.finalized_ || !isDraftable(value)) return value;
+		if (value === peek(state.base_, prop)) {
+			prepareCopy(state);
+			return state.copy_[prop] = createProxy(value, state);
+		}
+		return value;
+	},
+	has(state, prop) {
+		return prop in latest(state);
+	},
+	ownKeys(state) {
+		return Reflect.ownKeys(latest(state));
+	},
+	set(state, prop, value) {
+		const desc = getDescriptorFromProto(latest(state), prop);
+		if (desc?.set) {
+			desc.set.call(state.draft_, value);
+			return true;
+		}
+		if (!state.modified_) {
+			const current2 = peek(latest(state), prop);
+			const currentState = current2?.[DRAFT_STATE];
+			if (currentState && currentState.base_ === value) {
+				state.copy_[prop] = value;
+				state.assigned_[prop] = false;
+				return true;
+			}
+			if (is(value, current2) && (value !== void 0 || has(state.base_, prop))) return true;
+			prepareCopy(state);
+			markChanged(state);
+		}
+		if (state.copy_[prop] === value && (value !== void 0 || prop in state.copy_) || Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true;
+		state.copy_[prop] = value;
+		state.assigned_[prop] = true;
+		return true;
+	},
+	deleteProperty(state, prop) {
+		if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+			state.assigned_[prop] = false;
+			prepareCopy(state);
+			markChanged(state);
+		} else delete state.assigned_[prop];
+		if (state.copy_) delete state.copy_[prop];
+		return true;
+	},
+	getOwnPropertyDescriptor(state, prop) {
+		const owner = latest(state);
+		const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+		if (!desc) return desc;
+		return {
+			writable: true,
+			configurable: state.type_ !== 1 || prop !== "length",
+			enumerable: desc.enumerable,
+			value: owner[prop]
+		};
+	},
+	defineProperty() {
+		die(11);
+	},
+	getPrototypeOf(state) {
+		return getPrototypeOf(state.base_);
+	},
+	setPrototypeOf() {
+		die(12);
+	}
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+	arrayTraps[key] = function() {
+		arguments[0] = arguments[0][0];
+		return fn.apply(this, arguments);
+	};
+});
+arrayTraps.deleteProperty = function(state, prop) {
+	if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop))) die(13);
+	return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+	if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop))) die(14);
+	return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+	const state = draft[DRAFT_STATE];
+	return (state ? latest(state) : draft)[prop];
+}
+function readPropFromProto(state, source, prop) {
+	const desc = getDescriptorFromProto(source, prop);
+	return desc ? `value` in desc ? desc.value : desc.get?.call(state.draft_) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+	if (!(prop in source)) return void 0;
+	let proto = getPrototypeOf(source);
+	while (proto) {
+		const desc = Object.getOwnPropertyDescriptor(proto, prop);
+		if (desc) return desc;
+		proto = getPrototypeOf(proto);
+	}
+}
+function markChanged(state) {
+	if (!state.modified_) {
+		state.modified_ = true;
+		if (state.parent_) markChanged(state.parent_);
+	}
+}
+function prepareCopy(state) {
+	if (!state.copy_) state.copy_ = shallowCopy(state.base_, state.scope_.immer_.useStrictShallowCopy_);
+}
+var Immer2 = class {
+	constructor(config) {
+		this.autoFreeze_ = true;
+		this.useStrictShallowCopy_ = false;
+		/**
+		* The `produce` function takes a value and a "recipe function" (whose
+		* return value often depends on the base state). The recipe function is
+		* free to mutate its first argument however it wants. All mutations are
+		* only ever applied to a __copy__ of the base state.
+		*
+		* Pass only a function to create a "curried producer" which relieves you
+		* from passing the recipe function every time.
+		*
+		* Only plain objects and arrays are made mutable. All other objects are
+		* considered uncopyable.
+		*
+		* Note: This function is __bound__ to its `Immer` instance.
+		*
+		* @param {any} base - the initial state
+		* @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
+		* @param {Function} patchListener - optional function that will be called with all the patches produced here
+		* @returns {any} a new state, or the initial state if nothing was modified
+		*/
+		this.produce = (base, recipe, patchListener) => {
+			if (typeof base === "function" && typeof recipe !== "function") {
+				const defaultBase = recipe;
+				recipe = base;
+				const self = this;
+				return function curriedProduce(base2 = defaultBase, ...args) {
+					return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+				};
+			}
+			if (typeof recipe !== "function") die(6);
+			if (patchListener !== void 0 && typeof patchListener !== "function") die(7);
+			let result;
+			if (isDraftable(base)) {
+				const scope = enterScope(this);
+				const proxy = createProxy(base, void 0);
+				let hasError = true;
+				try {
+					result = recipe(proxy);
+					hasError = false;
+				} finally {
+					if (hasError) revokeScope(scope);
+					else leaveScope(scope);
+				}
+				usePatchesInScope(scope, patchListener);
+				return processResult(result, scope);
+			} else if (!base || typeof base !== "object") {
+				result = recipe(base);
+				if (result === void 0) result = base;
+				if (result === NOTHING) result = void 0;
+				if (this.autoFreeze_) freeze(result, true);
+				if (patchListener) {
+					const p = [];
+					const ip = [];
+					getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+					patchListener(p, ip);
+				}
+				return result;
+			} else die(1, base);
+		};
+		this.produceWithPatches = (base, recipe) => {
+			if (typeof base === "function") return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+			let patches, inversePatches;
+			return [
+				this.produce(base, recipe, (p, ip) => {
+					patches = p;
+					inversePatches = ip;
+				}),
+				patches,
+				inversePatches
+			];
+		};
+		if (typeof config?.autoFreeze === "boolean") this.setAutoFreeze(config.autoFreeze);
+		if (typeof config?.useStrictShallowCopy === "boolean") this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+	}
+	createDraft(base) {
+		if (!isDraftable(base)) die(8);
+		if (isDraft(base)) base = current(base);
+		const scope = enterScope(this);
+		const proxy = createProxy(base, void 0);
+		proxy[DRAFT_STATE].isManual_ = true;
+		leaveScope(scope);
+		return proxy;
+	}
+	finishDraft(draft, patchListener) {
+		const state = draft && draft[DRAFT_STATE];
+		if (!state || !state.isManual_) die(9);
+		const { scope_: scope } = state;
+		usePatchesInScope(scope, patchListener);
+		return processResult(void 0, scope);
+	}
+	/**
+	* Pass true to automatically freeze all copies created by Immer.
+	*
+	* By default, auto-freezing is enabled.
+	*/
+	setAutoFreeze(value) {
+		this.autoFreeze_ = value;
+	}
+	/**
+	* Pass true to enable strict shallow copy.
+	*
+	* By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+	*/
+	setUseStrictShallowCopy(value) {
+		this.useStrictShallowCopy_ = value;
+	}
+	applyPatches(base, patches) {
+		let i;
+		for (i = patches.length - 1; i >= 0; i--) {
+			const patch = patches[i];
+			if (patch.path.length === 0 && patch.op === "replace") {
+				base = patch.value;
+				break;
+			}
+		}
+		if (i > -1) patches = patches.slice(i + 1);
+		const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+		if (isDraft(base)) return applyPatchesImpl(base, patches);
+		return this.produce(base, (draft) => applyPatchesImpl(draft, patches));
+	}
+};
+function createProxy(value, parent) {
+	const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+	(parent ? parent.scope_ : getCurrentScope()).drafts_.push(draft);
+	return draft;
+}
+function current(value) {
+	if (!isDraft(value)) die(10, value);
+	return currentImpl(value);
+}
+function currentImpl(value) {
+	if (!isDraftable(value) || isFrozen(value)) return value;
+	const state = value[DRAFT_STATE];
+	let copy;
+	if (state) {
+		if (!state.modified_) return state.base_;
+		state.finalized_ = true;
+		copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+	} else copy = shallowCopy(value, true);
+	each(copy, (key, childValue) => {
+		set(copy, key, currentImpl(childValue));
+	});
+	if (state) state.finalized_ = false;
+	return copy;
+}
+var immer = new Immer2();
+var produce = immer.produce;
+
+//#endregion
+//#region ../migrations-base/lib/utils.js
+/**
+* Helper function to safely get config object from generator invocation.
+* Returns an empty object if config is not set or not an object.
+*
+* @param config - The generator invocation schema
+* @returns The config object or an empty object
+*
+* @example
+* ```typescript
+* const configObj = getConfigObject(config);
+* const migratedConfig = {
+*   ...configObj,
+*   newField: "value"
+* };
+* ```
+*/
+function getConfigObject(config) {
+	return config.config && typeof config.config === "object" ? config.config : {};
+}
+/**
+* Migrate a generator config using Immer's produce for immutable updates.
+* This is the recommended way to write migrations as it handles nested updates elegantly.
+*
+* @param config - The original generator config
+* @param updater - Function that mutates the config draft (uses Immer)
+* @returns A new generator config with updates applied
+*
+* @example
+* ```typescript
+* // Simple field updates
+* return migrateConfig(config, (draft) => {
+*   draft.oldField = false;  // Set old default
+*   draft.newField = true;   // Set new default
+* });
+*
+* // Conditional updates (only if undefined)
+* return migrateConfig(config, (draft) => {
+*   draft.field1 ??= false;  // Only set if undefined
+*   draft.field2 ??= true;
+* });
+*
+* // Nested updates
+* return migrateConfig(config, (draft) => {
+*   draft.nested ??= {};
+*   draft.nested.field = "value";
+* });
+*
+* // Removing fields
+* return migrateConfig(config, (draft) => {
+*   delete draft.deprecated;
+* });
+*
+* // Renaming fields
+* return migrateConfig(config, (draft) => {
+*   draft.newName = draft.oldName;
+*   delete draft.oldName;
+* });
+* ```
+*/
+function migrateConfig(config, updater) {
+	const migratedConfigObj = produce(getConfigObject(config), updater);
+	return {
+		...config,
+		config: migratedConfigObj
+	};
+}
+
+//#endregion
+//#region src/generators/typescript/migrations/1.0.0.ts
+/**
+* Migration for version 1.0.0
+*
+* ## Context
+*
+* Version 1.0.0 introduced new defaults to improve the developer experience and modernize
+* the generated SDK. These changes make the SDK more ergonomic and reduce boilerplate,
+* but could break existing code that relied on the old defaults.
+*
+* To ensure backwards compatibility during upgrades, this migration explicitly sets the
+* old defaults for users upgrading from pre-1.0.0 versions. This allows their existing
+* code to continue working without changes.
+*
+* ## Changed Defaults
+*
+* | Field | Old Default (pre-1.0.0) | New Default (1.0.0+) | Impact |
+* |-------|-------------------------|----------------------|--------|
+* | `inlineFileProperties` | `false` | `true` | File upload properties are now inlined into request types |
+* | `inlinePathParameters` | `false` | `true` | Path parameters are now inlined into method signatures |
+* | `enableInlineTypes` | `false` | `true` | Type definitions are inlined where beneficial |
+* | `noSerdeLayer` | `false` | `true` | Serialization/deserialization layer is removed for simpler types |
+* | `omitUndefined` | `false` | `true` | Undefined values are omitted from JSON output |
+* | `skipResponseValidation` | `false` | `true` | Response validation is skipped for better performance |
+* | `useLegacyExports` | `true` | `false` | Modern ESM exports are used instead of legacy CommonJS |
+*
+* ## Migration Strategy
+*
+* This migration uses the nullish coalescing assignment operator (`??=`) to only set
+* values that are explicitly undefined. This means:
+* - ✅ If a user has explicitly configured a field (even to the new default), that value is preserved
+* - ✅ If a field is undefined, the old default is set for backwards compatibility
+* - ✅ Unknown/custom fields are preserved
+*
+* ## Examples
+*
+* ### Example 1: Empty Config (Migration Applied)
+*
+* **Before Migration (0.9.0 → 1.0.0):**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 0.9.0
+*     config: {}
+* ```
+*
+* **After Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 1.0.0
+*     config:
+*       inlineFileProperties: false      # Set by migration
+*       inlinePathParameters: false      # Set by migration
+*       enableInlineTypes: false         # Set by migration
+*       noSerdeLayer: false              # Set by migration
+*       omitUndefined: false             # Set by migration
+*       skipResponseValidation: false    # Set by migration
+*       useLegacyExports: true           # Set by migration
+* ```
+*
+* **Result:** SDK behavior remains unchanged, existing code continues to work.
+*
+* ### Example 2: Partially Configured (Selective Migration)
+*
+* **Before Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 0.9.0
+*     config:
+*       inlineFileProperties: true  # User explicitly wants new behavior
+*       packageName: "@acme/sdk"
+* ```
+*
+* **After Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 1.0.0
+*     config:
+*       inlineFileProperties: true           # Preserved (explicitly set)
+*       packageName: "@acme/sdk"             # Preserved (custom field)
+*       inlinePathParameters: false          # Set by migration
+*       enableInlineTypes: false             # Set by migration
+*       noSerdeLayer: false                  # Set by migration
+*       omitUndefined: false                 # Set by migration
+*       skipResponseValidation: false        # Set by migration
+*       useLegacyExports: true               # Set by migration
+* ```
+*
+* **Result:** User's explicit choice is honored, other fields get old defaults.
+*
+* ### Example 3: Fully Configured (No Migration Needed)
+*
+* **Before Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 0.9.0
+*     config:
+*       inlineFileProperties: true
+*       inlinePathParameters: true
+*       enableInlineTypes: true
+*       noSerdeLayer: true
+*       omitUndefined: true
+*       skipResponseValidation: true
+*       useLegacyExports: false
+* ```
+*
+* **After Migration:**
+* ```yaml
+* # No changes - all fields explicitly configured
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 1.0.0
+*     config:
+*       inlineFileProperties: true
+*       inlinePathParameters: true
+*       enableInlineTypes: true
+*       noSerdeLayer: true
+*       omitUndefined: true
+*       skipResponseValidation: true
+*       useLegacyExports: false
+* ```
+*
+* **Result:** User gets the new defaults they explicitly configured.
+*
+* ## Why These Defaults Changed
+*
+* - **Inline properties/parameters**: Reduces type nesting and improves IDE autocomplete
+* - **No serde layer**: Simplifies generated code and improves runtime performance
+* - **Omit undefined**: Produces cleaner JSON payloads and matches JavaScript conventions
+* - **Skip validation**: Improves performance by trusting the API contract
+* - **Modern exports**: Better tree-shaking and compatibility with modern bundlers
+*
+* ## When to Opt Into New Defaults
+*
+* After upgrading and verifying your code works, consider removing the old defaults
+* to adopt the new behavior:
+*
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 1.0.0
+*     config: {}  # Remove all fields to use new defaults
+* ```
+*
+* Test your code thoroughly before making this change.
+*/
+const migration_1_0_0 = {
+	version: "1.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft.inlineFileProperties ??= false;
+		draft.inlinePathParameters ??= false;
+		draft.enableInlineTypes ??= false;
+		draft.noSerdeLayer ??= false;
+		draft.omitUndefined ??= false;
+		draft.skipResponseValidation ??= false;
+		draft.useLegacyExports ??= true;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/typescript/migrations/2.0.0.ts
+/**
+* Migration for version 2.0.0
+*
+* ## Context
+*
+* Version 2.0.0 introduced zero-dependency SDKs by default, using native browser and
+* Node.js APIs instead of external packages. This significantly reduces bundle size
+* and eliminates dependency management issues, but requires Node.js 18+ and modern
+* browsers with native fetch/streams support.
+*
+* For users upgrading from pre-2.0.0 versions who need to maintain compatibility with
+* older runtimes, this migration explicitly sets the old defaults that use polyfills
+* and wrapper libraries.
+*
+* ## Changed Defaults
+*
+* | Field | Old Default (pre-2.0.0) | New Default (2.0.0+) | Impact |
+* |-------|-------------------------|----------------------|--------|
+* | `streamType` | `"wrapper"` | `"web"` | Uses native Web Streams API instead of wrapper library |
+* | `fileResponseType` | `"stream"` | `"binary-response"` | Returns binary response instead of stream wrapper |
+* | `formDataSupport` | `"Node16"` | `"Node18"` | Uses native FormData (Node 18+) instead of polyfill |
+* | `fetchSupport` | `"node-fetch"` | `"native"` | Uses native fetch (Node 18+/browsers) instead of node-fetch |
+*
+* ## Migration Strategy
+*
+* This migration uses the nullish coalescing assignment operator (`??=`) to only set
+* values that are explicitly undefined. This means:
+* - ✅ If a user has explicitly configured a field, that value is preserved
+* - ✅ If a field is undefined, the old default (with dependencies) is set
+* - ✅ Users can opt into zero-dependency mode by removing these fields later
+*
+* ## Examples
+*
+* ### Example 1: Empty Config (Migration Applied - Dependencies Maintained)
+*
+* **Before Migration (1.9.0 → 2.0.0):**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 1.9.0
+*     config: {}
+* ```
+*
+* **After Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 2.0.0
+*     config:
+*       streamType: wrapper              # Set by migration - uses wrapper library
+*       fileResponseType: stream         # Set by migration - uses stream wrapper
+*       formDataSupport: Node16          # Set by migration - uses polyfill
+*       fetchSupport: node-fetch         # Set by migration - uses node-fetch package
+* ```
+*
+* **Result:** SDK continues using external dependencies, works with Node 16+.
+*
+* **Dependencies Required:**
+* - `node-fetch` for HTTP requests
+* - `form-data` for multipart uploads
+* - Stream wrapper libraries
+*
+* ### Example 2: Opting Into Zero-Dependency Mode
+*
+* **After Initial Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 2.0.0
+*     config:
+*       streamType: wrapper
+*       fileResponseType: stream
+*       formDataSupport: Node16
+*       fetchSupport: node-fetch
+* ```
+*
+* **To Adopt Zero-Dependency Mode:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 2.0.0
+*     config: {}  # Remove all fields to use new defaults
+* ```
+*
+* **Result:** SDK uses native APIs, no external dependencies required.
+*
+* **Requirements for Zero-Dependency Mode:**
+* - Node.js 18+ (for native fetch and FormData)
+* - OR modern browsers (Chrome 42+, Firefox 39+, Safari 10.1+, Edge 14+)
+*
+* ## Why These Defaults Changed
+*
+* ### Bundle Size Impact
+*
+* **With Dependencies (Old):**
+* ```
+* node-fetch:     ~90KB
+* form-data:      ~40KB
+* stream wrappers: ~20KB
+* Total:          ~150KB added to your bundle
+* ```
+*
+* **Zero Dependencies (New):**
+* ```
+* Total: 0KB (uses native APIs)
+* ```
+*
+* ### Performance Benefits
+*
+* - **Native fetch**: ~30% faster than node-fetch
+* - **Native streams**: ~40% faster than wrapper libraries
+* - **No dependency resolution**: Faster npm install and startup time
+*
+* ## Runtime Compatibility
+*
+* ### With Old Defaults (Migration Applied)
+* - ✅ Node.js 12+
+* - ✅ All browsers (with polyfills)
+* - ✅ Edge runtimes (Cloudflare Workers, etc.)
+*
+* ### With New Defaults (Zero-Dependency)
+* - ✅ Node.js 18+
+* - ✅ Modern browsers (last 2 years)
+* - ⚠️ May need polyfills for edge runtimes
+*
+* ## Migration Path to Zero-Dependency
+*
+* ### Step 1: Upgrade with Migration (Safe)
+* ```bash
+* fern generator upgrade
+* ```
+* Result: Old behavior preserved, dependencies still required.
+*
+* ### Step 2: Update Node Version (If Needed)
+* Ensure your runtime is Node 18+ or a modern browser.
+*
+* ### Step 3: Remove Old Defaults
+* Edit `generators.yml`:
+* ```yaml
+* config: {}  # Use new zero-dependency defaults
+* ```
+*
+* ### Step 4: Remove Dependencies
+* ```bash
+* npm uninstall node-fetch form-data
+* ```
+*
+* ### Step 5: Test Thoroughly
+* Verify streams, file uploads, and fetch operations work correctly.
+*/
+const migration_2_0_0 = {
+	version: "2.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft.streamType ??= "wrapper";
+		draft.fileResponseType ??= "stream";
+		draft.formDataSupport ??= "Node16";
+		draft.fetchSupport ??= "node-fetch";
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/typescript/migrations/3.0.0.ts
+/**
+* Migration for version 3.0.0
+*
+* ## Context
+*
+* Version 3.0.0 modernized the generated SDK tooling by switching to pnpm and Vitest,
+* which offer better performance, smaller disk usage, and faster test execution compared
+* to yarn and Jest. However, teams with existing workflows may prefer to maintain their
+* current tooling.
+*
+* This migration explicitly sets the old defaults for users upgrading from pre-3.0.0
+* versions, allowing them to continue using yarn and Jest without any changes to their
+* development workflow.
+*
+* ## Changed Defaults
+*
+* | Field | Old Default (pre-3.0.0) | New Default (3.0.0+) | Impact |
+* |-------|-------------------------|----------------------|--------|
+* | `packageManager` | `"yarn"` | `"pnpm"` | Generated package.json uses pnpm for dependency management |
+* | `testFramework` | `"jest"` | `"vitest"` | Generated tests use Vitest instead of Jest |
+*
+* ## Migration Strategy
+*
+* This migration uses the nullish coalescing assignment operator (`??=`) to only set
+* values that are explicitly undefined. This means:
+* - ✅ If a user has explicitly configured a field, that value is preserved
+* - ✅ If a field is undefined, the old default is set
+* - ✅ Users can opt into modern tooling by removing these fields later
+*
+* ## Examples
+*
+* ### Example 1: Empty Config (Migration Applied - Keep Yarn + Jest)
+*
+* **Before Migration (2.9.0 → 3.0.0):**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 2.9.0
+*     config: {}
+* ```
+*
+* **After Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 3.0.0
+*     config:
+*       packageManager: yarn    # Set by migration - keeps yarn
+*       testFramework: jest     # Set by migration - keeps jest
+* ```
+*
+* **Result:** Generated SDK continues using yarn and Jest.
+*
+* **Generated Files:**
+* - `package.json` with yarn scripts and Jest config
+* - Test files using Jest syntax (`describe`, `it`, `expect`)
+* - `.yarnrc` or `.yarnrc.yml` if applicable
+*
+* ### Example 2: Adopting Modern Tooling (pnpm + Vitest)
+*
+* **After Initial Migration:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 3.0.0
+*     config:
+*       packageManager: yarn
+*       testFramework: jest
+* ```
+*
+* **To Adopt pnpm + Vitest:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 3.0.0
+*     config: {}  # Remove to use new defaults
+* ```
+*
+* **Result:** Generated SDK uses pnpm and Vitest.
+*
+* **Generated Files:**
+* - `package.json` with pnpm scripts
+* - `vitest.config.ts` for test configuration
+* - Test files using Vitest syntax (compatible with Jest)
+* - `pnpm-workspace.yaml` if applicable
+*
+* ### Example 3: Mixed Tooling (Custom Configuration)
+*
+* **Keep yarn but adopt Vitest:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 3.0.0
+*     config:
+*       packageManager: yarn    # Keep yarn
+*       # testFramework defaults to vitest
+* ```
+*
+* **Keep Jest but adopt pnpm:**
+* ```yaml
+* generators:
+*   - name: fernapi/fern-typescript-sdk
+*     version: 3.0.0
+*     config:
+*       testFramework: jest     # Keep Jest
+*       # packageManager defaults to pnpm
+* ```
+*
+* ## Why These Defaults Changed
+*
+* ### pnpm vs yarn
+*
+* **Performance:**
+* - pnpm install is 2-3x faster than yarn
+* - Uses hard links instead of copying files
+* - Significantly smaller `node_modules` (50-70% reduction)
+*
+* **Correctness:**
+* - Strict dependency resolution prevents phantom dependencies
+* - Better monorepo support with workspaces
+* - More deterministic builds
+*
+* **Ecosystem:**
+* - Growing adoption in major projects (Vue 3, Prisma, Turborepo)
+* - Better compatibility with modern tooling
+*
+* ### Vitest vs Jest
+*
+* **Performance:**
+* - 10-20x faster test execution with native ESM
+* - Built-in watch mode with instant HMR
+* - Parallel test execution by default
+*
+* **Developer Experience:**
+* - Native TypeScript support (no ts-jest needed)
+* - Vite-powered with instant module reloading
+* - Jest-compatible API (easy migration)
+* - Better error messages and stack traces
+*
+* **Modern Features:**
+* - Native ESM support
+* - Web Workers and multi-threading support
+* - In-source testing capabilities
+*
+* ## Compatibility Notes
+*
+* ### Vitest Limitations
+*
+* Vitest is **not compatible** with certain generator configurations:
+*
+* 1. **`useBigInt: true`**: Vitest doesn't handle BigInt serialization the same way as Jest
+*    - **Workaround**: Keep `testFramework: jest` if using BigInt
+*
+* 2. **`streamType: wrapper`**: Older stream wrappers may not work with Vitest's ESM mode
+*    - **Workaround**: Either use `streamType: web` or keep `testFramework: jest`
+*
+* 3. **`packagePath` (custom paths)**: May have module resolution issues with Vitest
+*    - **Workaround**: Keep `testFramework: jest` for complex custom paths
+*
+* If you have any of these configurations, the migration correctly keeps Jest as the test framework.
+*
+* ## Migration Path to Modern Tooling
+*
+* ### Step 1: Upgrade with Migration (Safe)
+* ```bash
+* fern generator upgrade
+* ```
+* Result: Keeps yarn and Jest, no workflow changes needed.
+*
+* ### Step 2: Install pnpm (Optional)
+* ```bash
+* npm install -g pnpm@latest
+* ```
+*
+* ### Step 3: Adopt Modern Tooling (Optional)
+* Edit `generators.yml`:
+* ```yaml
+* config: {}  # Use pnpm + vitest
+* ```
+*
+* ### Step 4: Update CI/CD (Optional)
+* Update CI scripts to use pnpm:
+* ```yaml
+* # GitHub Actions example
+* - uses: pnpm/action-setup@v2
+*   with:
+*     version: 8
+* - run: pnpm install
+* - run: pnpm test
+* ```
+*
+* ### Step 5: Migrate yarn.lock (Optional)
+* ```bash
+* # Convert yarn.lock to pnpm-lock.yaml
+* pnpm import
+* rm yarn.lock
+* ```
+*
+* ## Troubleshooting
+*
+* ### "pnpm: command not found"
+* **Cause:** pnpm not installed globally.
+* **Solution:** Install pnpm: `npm install -g pnpm`
+*
+* ### Vitest errors with BigInt
+* **Cause:** Vitest and BigInt serialization incompatibility.
+* **Solution:** Use `testFramework: jest` in config.
+*
+* ### Module resolution errors with Vitest
+* **Cause:** ESM/CommonJS compatibility issues.
+* **Solution:** Either fix module format or use `testFramework: jest`.
+*
+* ### Tests fail after switching to Vitest
+* **Cause:** Vitest has stricter ESM requirements.
+* **Solution:** Ensure `package.json` has `"type": "module"` or use `.ts` extensions.
+*
+* ## Performance Comparison
+*
+* Based on typical SDK project (50 tests, 1000 LOC):
+*
+* **Install Time:**
+* - yarn: ~15s
+* - pnpm: ~5s (3x faster)
+*
+* **Test Execution:**
+* - Jest: ~8s
+* - Vitest: ~0.8s (10x faster)
+*
+* **Disk Usage:**
+* - yarn: ~200MB node_modules
+* - pnpm: ~80MB node_modules (60% reduction)
+*
+* ## Recommendations
+*
+* - **New projects**: Use the new defaults (pnpm + Vitest)
+* - **Existing projects**: Keep old defaults initially, migrate when convenient
+* - **CI/CD-heavy projects**: Consider pnpm for faster installs
+* - **Projects with BigInt**: Keep Jest until Vitest improves BigInt support
+*/
+const migration_3_0_0 = {
+	version: "3.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft.packageManager ??= "yarn";
+		draft.testFramework ??= "jest";
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/typescript/migrations/index.ts
+/**
+* Migration module for TypeScript SDK generators.
+*
+* This module contains migrations for configuration changes across
+* all TypeScript SDK generator variants:
+* - fernapi/fern-typescript
+* - fernapi/fern-typescript-sdk
+* - fernapi/fern-typescript-node-sdk
+* - fernapi/fern-typescript-browser-sdk
+*
+* Each migration is defined in a separate file under this directory.
+* Migrations are automatically applied by the Fern CLI when running:
+* `fern generator upgrade --generator typescript-sdk`
+*/
+const migrationModule = { migrations: [
+	migration_1_0_0,
+	migration_2_0_0,
+	migration_3_0_0
+] };
+var migrations_default = migrationModule;
+
+//#endregion
+//#region src/index.ts
+/**
+* All generator migrations indexed by full generator name.
+*
+* When adding migrations for a new generator:
+* 1. Add migrations under src/generators/{language}/migrations/
+* 2. Import the migration module
+* 3. Add entries for all generator name variants
+*/
+const migrations = {
+	"fernapi/fern-typescript": migrations_default,
+	"fernapi/fern-typescript-sdk": migrations_default,
+	"fernapi/fern-typescript-node-sdk": migrations_default,
+	"fernapi/fern-typescript-browser-sdk": migrations_default
+};
+
+//#endregion
+export { migrations };
+//# sourceMappingURL=index.mjs.map