@fern-api/generator-migrations 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -0,0 +1,842 @@
+//#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/csharp/migrations/1.0.0.ts
+const migration_1_0_0$2 = {
+	version: "1.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft["root-namespace-for-core-classes"] ??= false;
+		draft["pascal-case-environments"] ??= false;
+		draft["simplify-object-dictionaries"] ??= false;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/csharp/migrations/2.0.0.ts
+const migration_2_0_0$2 = {
+	version: "2.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		if ("experimental-additional-properties" in draft) {
+			const value = draft["experimental-additional-properties"];
+			delete draft["experimental-additional-properties"];
+			draft["additional-properties"] = value;
+		}
+		if ("experimental-enable-forward-compatible-enums" in draft) {
+			const value = draft["experimental-enable-forward-compatible-enums"];
+			delete draft["experimental-enable-forward-compatible-enums"];
+			draft["enable-forward-compatible-enums"] = value;
+		}
+		draft["additional-properties"] ??= false;
+		draft["enable-forward-compatible-enums"] ??= false;
+		draft["generate-mock-server-tests"] ??= false;
+		draft["inline-path-parameters"] ??= false;
+		draft["simplify-object-dictionaries"] ??= true;
+		draft["use-discriminated-unions"] ??= false;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/csharp/migrations/index.ts
+/**
+* Migration module for C# SDK generator.
+*
+* This module contains migrations for configuration changes for
+* the C# SDK generator:
+* - fernapi/fern-csharp-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 csharp-sdk`
+*/
+const migrationModule$4 = { migrations: [migration_1_0_0$2, migration_2_0_0$2] };
+var migrations_default$4 = migrationModule$4;
+
+//#endregion
+//#region src/generators/java/migrations/2.0.0.ts
+const migration_2_0_0$1 = {
+	version: "2.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft["disable-required-property-builder-checks"] ??= true;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/java/migrations/3.0.0.ts
+const migration_3_0_0$1 = {
+	version: "3.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft["enable-forward-compatible-enums"] ??= false;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/java/migrations/index.ts
+/**
+* Migration module for Java SDK generator.
+*
+* This module contains migrations for configuration changes for
+* the Java SDK generator:
+* - fernapi/fern-java-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 java-sdk`
+*/
+const migrationModule$3 = { migrations: [migration_2_0_0$1, migration_3_0_0$1] };
+var migrations_default$3 = migrationModule$3;
+
+//#endregion
+//#region src/generators/java-model/migrations/1.0.0.ts
+const migration_1_0_0$1 = {
+	version: "1.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		draft["disable-required-property-builder-checks"] ??= true;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/java-model/migrations/index.ts
+/**
+* Migration module for Java Model generators.
+*
+* This module contains migrations for configuration changes for
+* the Java Model generators:
+* - fernapi/fern-java-model
+* - fernapi/fern-java-spring
+*
+* 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 java-model`
+* `fern generator upgrade --generator java-spring`
+*/
+const migrationModule$2 = { migrations: [migration_1_0_0$1] };
+var migrations_default$2 = migrationModule$2;
+
+//#endregion
+//#region src/generators/python/migrations/4.0.0.ts
+const migration_4_0_0 = {
+	version: "4.0.0",
+	migrateGeneratorConfig: ({ config }) => migrateConfig(config, (draft) => {
+		if (draft.pydantic_config === void 0 || draft.pydantic_config === null) draft.pydantic_config = {};
+		if (typeof draft.pydantic_config === "object" && draft.pydantic_config !== null) draft.pydantic_config.use_pydantic_field_aliases ??= true;
+	}),
+	migrateGeneratorsYml: ({ document }) => document
+};
+
+//#endregion
+//#region src/generators/python/migrations/index.ts
+/**
+* Migration module for Python SDK generator.
+*
+* This module contains migrations for configuration changes for
+* the Python SDK generator:
+* - fernapi/fern-python-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 python-sdk`
+*
+* Note: Versions 1.0.0 and 2.0.0 mentioned "breaking configuration changes"
+* but did not document specific configuration options that changed, so they
+* are not included in this migration module.
+*/
+const migrationModule$1 = { migrations: [migration_4_0_0] };
+var migrations_default$1 = migrationModule$1;
+
+//#endregion
+//#region src/generators/typescript/migrations/1.0.0.ts
+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
+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
+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-csharp-sdk": migrations_default$4,
+	"fernapi/fern-java-model": migrations_default$2,
+	"fernapi/fern-java-spring": migrations_default$2,
+	"fernapi/fern-java-sdk": migrations_default$3,
+	"fernapi/fern-python-sdk": migrations_default$1,
+	"fernapi/fern-fastapi-server": migrations_default$1,
+	"fernapi/fern-pydantic-model": migrations_default$1,
+	"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