@module-federation/enhanced 2.0.1 → 2.2.0

package/dist/src/schemas/container/ModuleFederationPlugin.d.ts

@@ -1,887 +1,892 @@
+//#region src/schemas/container/ModuleFederationPlugin.d.ts
 declare const _default: {
-    readonly definitions: {
-        readonly AmdContainer: {
-            readonly description: "Add a container for define/require functions in the AMD module.";
+  readonly definitions: {
+    readonly AmdContainer: {
+      readonly description: "Add a container for define/require functions in the AMD module.";
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly AuxiliaryComment: {
+      readonly description: "Add a comment in the UMD wrapper.";
+      readonly anyOf: readonly [{
+        readonly description: "Append the same comment above each import style.";
+        readonly type: "string";
+      }, {
+        readonly $ref: "#/definitions/LibraryCustomUmdCommentObject";
+      }];
+    };
+    readonly EntryRuntime: {
+      readonly description: "The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.";
+      readonly anyOf: readonly [{
+        readonly enum: readonly [false];
+      }, {
+        readonly type: "string";
+        readonly minLength: 1;
+      }];
+    };
+    readonly Exposes: {
+      readonly description: "Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.";
+      readonly anyOf: readonly [{
+        readonly type: "array";
+        readonly items: {
+          readonly description: "Modules that should be exposed by this container.";
+          readonly anyOf: readonly [{
+            readonly $ref: "#/definitions/ExposesItem";
+          }, {
+            readonly $ref: "#/definitions/ExposesObject";
+          }];
+        };
+      }, {
+        readonly $ref: "#/definitions/ExposesObject";
+      }];
+    };
+    readonly ExposesConfig: {
+      readonly description: "Advanced configuration for modules that should be exposed by this container.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly import: {
+          readonly description: "Request to a module that should be exposed by this container.";
+          readonly anyOf: readonly [{
+            readonly $ref: "#/definitions/ExposesItem";
+          }, {
+            readonly $ref: "#/definitions/ExposesItems";
+          }];
+        };
+        readonly name: {
+          readonly description: "Custom chunk name for the exposed module.";
+          readonly type: "string";
+        };
+      };
+      readonly required: readonly ["import"];
+    };
+    readonly ExposesItem: {
+      readonly description: "Module that should be exposed by this container.";
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly ExposesItems: {
+      readonly description: "Modules that should be exposed by this container.";
+      readonly type: "array";
+      readonly items: {
+        readonly $ref: "#/definitions/ExposesItem";
+      };
+    };
+    readonly ExposesObject: {
+      readonly description: "Modules that should be exposed by this container. Property names are used as public paths.";
+      readonly type: "object";
+      readonly additionalProperties: {
+        readonly description: "Modules that should be exposed by this container.";
+        readonly anyOf: readonly [{
+          readonly $ref: "#/definitions/ExposesConfig";
+        }, {
+          readonly $ref: "#/definitions/ExposesItem";
+        }, {
+          readonly $ref: "#/definitions/ExposesItems";
+        }];
+      };
+    };
+    readonly ExternalsType: {
+      readonly description: "Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).";
+      readonly enum: readonly ["var", "module", "assign", "this", "window", "self", "global", "commonjs", "commonjs2", "commonjs-module", "commonjs-static", "amd", "amd-require", "umd", "umd2", "jsonp", "system", "promise", "import", "module-import", "script", "node-commonjs"];
+    };
+    readonly LibraryCustomUmdCommentObject: {
+      readonly description: "Set explicit comments for `commonjs`, `commonjs2`, `amd`, and `root`.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly amd: {
+          readonly description: "Set comment for `amd` section in UMD.";
+          readonly type: "string";
+        };
+        readonly commonjs: {
+          readonly description: "Set comment for `commonjs` (exports) section in UMD.";
+          readonly type: "string";
+        };
+        readonly commonjs2: {
+          readonly description: "Set comment for `commonjs2` (module.exports) section in UMD.";
+          readonly type: "string";
+        };
+        readonly root: {
+          readonly description: "Set comment for `root` (global variable) section in UMD.";
+          readonly type: "string";
+        };
+      };
+    };
+    readonly LibraryCustomUmdObject: {
+      readonly description: "Description object for all UMD variants of the library name.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly amd: {
+          readonly description: "Name of the exposed AMD library in the UMD.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly commonjs: {
+          readonly description: "Name of the exposed commonjs export in the UMD.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly root: {
+          readonly description: "Name of the property exposed globally by a UMD library.";
+          readonly anyOf: readonly [{
+            readonly type: "array";
+            readonly items: {
+              readonly description: "Part of the name of the property exposed globally by a UMD library.";
+              readonly type: "string";
+              readonly minLength: 1;
+            };
+          }, {
             readonly type: "string";
             readonly minLength: 1;
+          }];
         };
-        readonly AuxiliaryComment: {
-            readonly description: "Add a comment in the UMD wrapper.";
-            readonly anyOf: readonly [{
-                readonly description: "Append the same comment above each import style.";
-                readonly type: "string";
-            }, {
-                readonly $ref: "#/definitions/LibraryCustomUmdCommentObject";
-            }];
+      };
+    };
+    readonly LibraryExport: {
+      readonly description: "Specify which export should be exposed as library.";
+      readonly anyOf: readonly [{
+        readonly type: "array";
+        readonly items: {
+          readonly description: "Part of the export that should be exposed as library.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+      }, {
+        readonly type: "string";
+        readonly minLength: 1;
+      }];
+    };
+    readonly LibraryName: {
+      readonly description: "The name of the library (some types allow unnamed libraries too).";
+      readonly anyOf: readonly [{
+        readonly type: "array";
+        readonly items: {
+          readonly description: "A part of the library name.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly minItems: 1;
+      }, {
+        readonly type: "string";
+        readonly minLength: 1;
+      }, {
+        readonly $ref: "#/definitions/LibraryCustomUmdObject";
+      }];
+    };
+    readonly LibraryOptions: {
+      readonly description: "Options for library.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly amdContainer: {
+          readonly $ref: "#/definitions/AmdContainer";
         };
-        readonly EntryRuntime: {
-            readonly description: "The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.";
-            readonly anyOf: readonly [{
-                readonly enum: readonly [false];
-            }, {
-                readonly type: "string";
-                readonly minLength: 1;
-            }];
+        readonly auxiliaryComment: {
+          readonly $ref: "#/definitions/AuxiliaryComment";
         };
-        readonly Exposes: {
-            readonly description: "Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.";
-            readonly anyOf: readonly [{
-                readonly type: "array";
-                readonly items: {
-                    readonly description: "Modules that should be exposed by this container.";
-                    readonly anyOf: readonly [{
-                        readonly $ref: "#/definitions/ExposesItem";
-                    }, {
-                        readonly $ref: "#/definitions/ExposesObject";
-                    }];
-                };
-            }, {
-                readonly $ref: "#/definitions/ExposesObject";
-            }];
+        readonly export: {
+          readonly $ref: "#/definitions/LibraryExport";
         };
-        readonly ExposesConfig: {
-            readonly description: "Advanced configuration for modules that should be exposed by this container.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly import: {
-                    readonly description: "Request to a module that should be exposed by this container.";
-                    readonly anyOf: readonly [{
-                        readonly $ref: "#/definitions/ExposesItem";
-                    }, {
-                        readonly $ref: "#/definitions/ExposesItems";
-                    }];
-                };
-                readonly name: {
-                    readonly description: "Custom chunk name for the exposed module.";
-                    readonly type: "string";
-                };
-            };
-            readonly required: readonly ["import"];
+        readonly name: {
+          readonly $ref: "#/definitions/LibraryName";
+        };
+        readonly type: {
+          readonly $ref: "#/definitions/LibraryType";
+        };
+        readonly umdNamedDefine: {
+          readonly $ref: "#/definitions/UmdNamedDefine";
+        };
+      };
+      readonly required: readonly ["type"];
+    };
+    readonly LibraryType: {
+      readonly description: "Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).";
+      readonly anyOf: readonly [{
+        readonly enum: readonly ["var", "module", "assign", "assign-properties", "this", "window", "self", "global", "commonjs", "commonjs2", "commonjs-module", "commonjs-static", "amd", "amd-require", "umd", "umd2", "jsonp", "system"];
+      }, {
+        readonly type: "string";
+      }];
+    };
+    readonly Remotes: {
+      readonly description: "Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.";
+      readonly anyOf: readonly [{
+        readonly type: "array";
+        readonly items: {
+          readonly description: "Container locations and request scopes from which modules should be resolved and loaded at runtime.";
+          readonly anyOf: readonly [{
+            readonly $ref: "#/definitions/RemotesItem";
+          }, {
+            readonly $ref: "#/definitions/RemotesObject";
+          }];
+        };
+      }, {
+        readonly $ref: "#/definitions/RemotesObject";
+      }];
+    };
+    readonly RemotesConfig: {
+      readonly description: "Advanced configuration for container locations from which modules should be resolved and loaded at runtime.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly external: {
+          readonly description: "Container locations from which modules should be resolved and loaded at runtime.";
+          readonly anyOf: readonly [{
+            readonly $ref: "#/definitions/RemotesItem";
+          }, {
+            readonly $ref: "#/definitions/RemotesItems";
+          }];
         };
-        readonly ExposesItem: {
-            readonly description: "Module that should be exposed by this container.";
+        readonly shareScope: {
+          readonly description: "The name of the share scope shared with this remote.";
+          readonly anyOf: readonly [{
             readonly type: "string";
             readonly minLength: 1;
-        };
-        readonly ExposesItems: {
-            readonly description: "Modules that should be exposed by this container.";
+          }, {
             readonly type: "array";
             readonly items: {
-                readonly $ref: "#/definitions/ExposesItem";
-            };
-        };
-        readonly ExposesObject: {
-            readonly description: "Modules that should be exposed by this container. Property names are used as public paths.";
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly description: "Modules that should be exposed by this container.";
-                readonly anyOf: readonly [{
-                    readonly $ref: "#/definitions/ExposesConfig";
-                }, {
-                    readonly $ref: "#/definitions/ExposesItem";
-                }, {
-                    readonly $ref: "#/definitions/ExposesItems";
-                }];
-            };
-        };
-        readonly ExternalsType: {
-            readonly description: "Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).";
-            readonly enum: readonly ["var", "module", "assign", "this", "window", "self", "global", "commonjs", "commonjs2", "commonjs-module", "commonjs-static", "amd", "amd-require", "umd", "umd2", "jsonp", "system", "promise", "import", "module-import", "script", "node-commonjs"];
-        };
-        readonly LibraryCustomUmdCommentObject: {
-            readonly description: "Set explicit comments for `commonjs`, `commonjs2`, `amd`, and `root`.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly amd: {
-                    readonly description: "Set comment for `amd` section in UMD.";
-                    readonly type: "string";
-                };
-                readonly commonjs: {
-                    readonly description: "Set comment for `commonjs` (exports) section in UMD.";
-                    readonly type: "string";
-                };
-                readonly commonjs2: {
-                    readonly description: "Set comment for `commonjs2` (module.exports) section in UMD.";
-                    readonly type: "string";
-                };
-                readonly root: {
-                    readonly description: "Set comment for `root` (global variable) section in UMD.";
-                    readonly type: "string";
-                };
-            };
-        };
-        readonly LibraryCustomUmdObject: {
-            readonly description: "Description object for all UMD variants of the library name.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly amd: {
-                    readonly description: "Name of the exposed AMD library in the UMD.";
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly commonjs: {
-                    readonly description: "Name of the exposed commonjs export in the UMD.";
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly root: {
-                    readonly description: "Name of the property exposed globally by a UMD library.";
-                    readonly anyOf: readonly [{
-                        readonly type: "array";
-                        readonly items: {
-                            readonly description: "Part of the name of the property exposed globally by a UMD library.";
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                    }, {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    }];
-                };
+              readonly type: "string";
+              readonly minLength: 1;
             };
+          }];
         };
-        readonly LibraryExport: {
-            readonly description: "Specify which export should be exposed as library.";
-            readonly anyOf: readonly [{
-                readonly type: "array";
-                readonly items: {
-                    readonly description: "Part of the export that should be exposed as library.";
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-            }, {
-                readonly type: "string";
-                readonly minLength: 1;
-            }];
+      };
+      readonly required: readonly ["external"];
+    };
+    readonly RemotesItem: {
+      readonly description: "Container location from which modules should be resolved and loaded at runtime.";
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly RemotesItems: {
+      readonly description: "Container locations from which modules should be resolved and loaded at runtime.";
+      readonly type: "array";
+      readonly items: {
+        readonly $ref: "#/definitions/RemotesItem";
+      };
+    };
+    readonly RemotesObject: {
+      readonly description: "Container locations from which modules should be resolved and loaded at runtime. Property names are used as request scopes.";
+      readonly type: "object";
+      readonly additionalProperties: {
+        readonly description: "Container locations from which modules should be resolved and loaded at runtime.";
+        readonly anyOf: readonly [{
+          readonly $ref: "#/definitions/RemotesConfig";
+        }, {
+          readonly $ref: "#/definitions/RemotesItem";
+        }, {
+          readonly $ref: "#/definitions/RemotesItems";
+        }];
+      };
+    };
+    readonly Shared: {
+      readonly description: "Modules that should be shared in the share scope. When provided, property names are used to match requested modules in this compilation.";
+      readonly anyOf: readonly [{
+        readonly type: "array";
+        readonly items: {
+          readonly description: "Modules that should be shared in the share scope.";
+          readonly anyOf: readonly [{
+            readonly $ref: "#/definitions/SharedItem";
+          }, {
+            readonly $ref: "#/definitions/SharedObject";
+          }];
+        };
+      }, {
+        readonly $ref: "#/definitions/SharedObject";
+      }];
+    };
+    readonly SharedConfig: {
+      readonly description: "Advanced configuration for modules that should be shared in the share scope.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly eager: {
+          readonly description: "Include the provided and fallback module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.";
+          readonly type: "boolean";
+        };
+        readonly exclude: {
+          readonly description: "Options for excluding specific versions or request paths of the shared module. When specified, matching modules will not be shared. Cannot be used with 'include'.";
+          readonly $ref: "#/definitions/IncludeExcludeOptions";
+        };
+        readonly include: {
+          readonly description: "Options for including only specific versions or request paths of the shared module. When specified, only matching modules will be shared. Cannot be used with 'exclude'.";
+          readonly $ref: "#/definitions/IncludeExcludeOptions";
+        };
+        readonly import: {
+          readonly description: "Provided module that should be provided to share scope. Also acts as fallback module if no shared module is found in share scope or version isn't valid. Defaults to the property name.";
+          readonly anyOf: readonly [{
+            readonly description: "No provided or fallback module.";
+            readonly enum: readonly [false];
+          }, {
+            readonly $ref: "#/definitions/SharedItem";
+          }];
+        };
+        readonly request: {
+          readonly description: "Import request to match on";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly layer: {
+          readonly description: "Layer in which the shared module should be placed.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly issuerLayer: {
+          readonly description: "Layer of the issuer.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly packageName: {
+          readonly description: "Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.";
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+        readonly requiredVersion: {
+          readonly description: "Version requirement from module in share scope.";
+          readonly anyOf: readonly [{
+            readonly description: "No version requirement check.";
+            readonly enum: readonly [false];
+          }, {
+            readonly description: "Version as string. Can be prefixed with '^' or '~' for minimum matches. Each part of the version should be separated by a dot '.'.";
+            readonly type: "string";
+          }];
         };
-        readonly LibraryName: {
-            readonly description: "The name of the library (some types allow unnamed libraries too).";
-            readonly anyOf: readonly [{
-                readonly type: "array";
-                readonly items: {
-                    readonly description: "A part of the library name.";
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-                readonly minItems: 1;
-            }, {
-                readonly type: "string";
-                readonly minLength: 1;
-            }, {
-                readonly $ref: "#/definitions/LibraryCustomUmdObject";
-            }];
+        readonly shareKey: {
+          readonly description: "Module is looked up under this key from the share scope.";
+          readonly type: "string";
+          readonly minLength: 1;
         };
-        readonly LibraryOptions: {
-            readonly description: "Options for library.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly amdContainer: {
-                    readonly $ref: "#/definitions/AmdContainer";
-                };
-                readonly auxiliaryComment: {
-                    readonly $ref: "#/definitions/AuxiliaryComment";
-                };
-                readonly export: {
-                    readonly $ref: "#/definitions/LibraryExport";
-                };
-                readonly name: {
-                    readonly $ref: "#/definitions/LibraryName";
-                };
-                readonly type: {
-                    readonly $ref: "#/definitions/LibraryType";
-                };
-                readonly umdNamedDefine: {
-                    readonly $ref: "#/definitions/UmdNamedDefine";
-                };
+        readonly shareScope: {
+          readonly description: "Share scope name.";
+          readonly anyOf: readonly [{
+            readonly type: "string";
+            readonly minLength: 1;
+          }, {
+            readonly type: "array";
+            readonly items: {
+              readonly type: "string";
+              readonly minLength: 1;
             };
-            readonly required: readonly ["type"];
+          }];
         };
-        readonly LibraryType: {
-            readonly description: "Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).";
-            readonly anyOf: readonly [{
-                readonly enum: readonly ["var", "module", "assign", "assign-properties", "this", "window", "self", "global", "commonjs", "commonjs2", "commonjs-module", "commonjs-static", "amd", "amd-require", "umd", "umd2", "jsonp", "system"];
-            }, {
-                readonly type: "string";
-            }];
+        readonly shareStrategy: {
+          readonly description: "[Deprecated]: load shared strategy(defaults to 'version-first').";
+          readonly enum: readonly ["version-first", "loaded-first"];
+          readonly type: "string";
+        };
+        readonly singleton: {
+          readonly description: "Allow only a single version of the shared module in share scope (disabled by default).";
+          readonly type: "boolean";
+        };
+        readonly strictVersion: {
+          readonly description: "Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).";
+          readonly type: "boolean";
+        };
+        readonly version: {
+          readonly description: "Version of the provided module. Will replace lower matching versions, but not higher.";
+          readonly anyOf: readonly [{
+            readonly description: "Don't provide a version.";
+            readonly enum: readonly [false];
+          }, {
+            readonly description: "Version as string. Each part of the version should be separated by a dot '.'.";
+            readonly type: "string";
+          }];
         };
-        readonly Remotes: {
-            readonly description: "Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.";
-            readonly anyOf: readonly [{
-                readonly type: "array";
-                readonly items: {
-                    readonly description: "Container locations and request scopes from which modules should be resolved and loaded at runtime.";
-                    readonly anyOf: readonly [{
-                        readonly $ref: "#/definitions/RemotesItem";
-                    }, {
-                        readonly $ref: "#/definitions/RemotesObject";
-                    }];
-                };
-            }, {
-                readonly $ref: "#/definitions/RemotesObject";
-            }];
+        readonly allowNodeModulesSuffixMatch: {
+          readonly description: "Enable reconstructed lookup for node_modules paths for this share item";
+          readonly type: "boolean";
         };
-        readonly RemotesConfig: {
-            readonly description: "Advanced configuration for container locations from which modules should be resolved and loaded at runtime.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly external: {
-                    readonly description: "Container locations from which modules should be resolved and loaded at runtime.";
-                    readonly anyOf: readonly [{
-                        readonly $ref: "#/definitions/RemotesItem";
-                    }, {
-                        readonly $ref: "#/definitions/RemotesItems";
-                    }];
-                };
-                readonly shareScope: {
-                    readonly description: "The name of the share scope shared with this remote.";
-                    readonly anyOf: readonly [{
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    }, {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                    }];
-                };
-            };
-            readonly required: readonly ["external"];
+        readonly treeShaking: {
+          readonly description: "Enable tree-shaking for the shared module or configure it.";
+          readonly anyOf: readonly [{
+            readonly type: "boolean";
+          }, {
+            readonly $ref: "#/definitions/TreeShakingConfig";
+          }];
         };
-        readonly RemotesItem: {
-            readonly description: "Container location from which modules should be resolved and loaded at runtime.";
+      };
+    };
+    readonly SharedItem: {
+      readonly description: "A module that should be shared in the share scope.";
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly SharedObject: {
+      readonly description: "Modules that should be shared in the share scope. Property names are used to match requested modules in this compilation. Relative requests are resolved, module requests are matched unresolved, absolute paths will match resolved requests. A trailing slash will match all requests with this prefix. In this case shareKey must also have a trailing slash.";
+      readonly type: "object";
+      readonly additionalProperties: {
+        readonly description: "Modules that should be shared in the share scope.";
+        readonly anyOf: readonly [{
+          readonly $ref: "#/definitions/SharedConfig";
+        }, {
+          readonly $ref: "#/definitions/SharedItem";
+        }];
+      };
+    };
+    readonly UmdNamedDefine: {
+      readonly description: "If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.";
+      readonly type: "boolean";
+    };
+    readonly IncludeExcludeOptions: {
+      readonly type: "object";
+      readonly properties: {
+        readonly request: {
+          readonly type: readonly ["string", "object"];
+          readonly description: "A string (which can be a regex pattern) or a RegExp object to match the request path.";
+        };
+        readonly version: {
+          readonly type: "string";
+          readonly description: "Semantic versioning range to match against the module's version.";
+        };
+        readonly fallbackVersion: {
+          readonly type: "string";
+          readonly description: "Semantic versioning range to match against the fallback module's version for exclusion/inclusion context where applicable.";
+        };
+      };
+      readonly additionalProperties: false;
+      readonly anyOf: readonly [{
+        readonly required: readonly ["request"];
+      }, {
+        readonly required: readonly ["version"];
+      }, {
+        readonly required: readonly ["fallbackVersion"];
+      }];
+    };
+    readonly Exclude: {
+      readonly description: "Advanced filtering options.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly request: {
+          readonly description: "Regular expression pattern to filter module requests";
+          readonly instanceof: "RegExp";
+        };
+        readonly version: {
+          readonly description: "Specific version string or range to filter by (exclude matches).";
+          readonly type: "string";
+        };
+        readonly fallbackVersion: {
+          readonly description: "Optional specific version string to check against the filter.version range instead of reading package.json.";
+          readonly type: "string";
+        };
+      };
+    };
+    readonly TreeShakingConfig: {
+      readonly description: "Tree-shake configuration for shared module.";
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly usedExports: {
+          readonly description: "List of export names used from the shared module.";
+          readonly type: "array";
+          readonly items: {
             readonly type: "string";
             readonly minLength: 1;
+          };
         };
-        readonly RemotesItems: {
-            readonly description: "Container locations from which modules should be resolved and loaded at runtime.";
-            readonly type: "array";
-            readonly items: {
-                readonly $ref: "#/definitions/RemotesItem";
-            };
+        readonly mode: {
+          readonly description: "Tree-shake analysis mode.";
+          readonly type: "string";
+          readonly enum: readonly ["server-calc", "runtime-infer"];
         };
-        readonly RemotesObject: {
-            readonly description: "Container locations from which modules should be resolved and loaded at runtime. Property names are used as request scopes.";
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly description: "Container locations from which modules should be resolved and loaded at runtime.";
-                readonly anyOf: readonly [{
-                    readonly $ref: "#/definitions/RemotesConfig";
-                }, {
-                    readonly $ref: "#/definitions/RemotesItem";
-                }, {
-                    readonly $ref: "#/definitions/RemotesItems";
-                }];
-            };
+        readonly filename: {
+          readonly description: "Filename for generated treeShaking metadata.";
+          readonly type: "string";
         };
-        readonly Shared: {
-            readonly description: "Modules that should be shared in the share scope. When provided, property names are used to match requested modules in this compilation.";
+      };
+    };
+  };
+  readonly title: "ModuleFederationPluginOptions";
+  readonly type: "object";
+  readonly additionalProperties: false;
+  readonly properties: {
+    readonly async: {
+      readonly description: "Enable/disable asynchronous loading of runtime modules or provide async boundary options.";
+      readonly anyOf: readonly [{
+        readonly type: "boolean";
+      }, {
+        readonly type: "object";
+        readonly properties: {
+          readonly eager: {
+            readonly description: "Eagerly load a module, matched via RegExp or predicate function";
             readonly anyOf: readonly [{
-                readonly type: "array";
-                readonly items: {
-                    readonly description: "Modules that should be shared in the share scope.";
-                    readonly anyOf: readonly [{
-                        readonly $ref: "#/definitions/SharedItem";
-                    }, {
-                        readonly $ref: "#/definitions/SharedObject";
-                    }];
-                };
+              readonly instanceof: "RegExp";
             }, {
-                readonly $ref: "#/definitions/SharedObject";
+              readonly instanceof: "Function";
             }];
-        };
-        readonly SharedConfig: {
-            readonly description: "Advanced configuration for modules that should be shared in the share scope.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly eager: {
-                    readonly description: "Include the provided and fallback module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.";
-                    readonly type: "boolean";
-                };
-                readonly exclude: {
-                    readonly description: "Options for excluding specific versions or request paths of the shared module. When specified, matching modules will not be shared. Cannot be used with 'include'.";
-                    readonly $ref: "#/definitions/IncludeExcludeOptions";
-                };
-                readonly include: {
-                    readonly description: "Options for including only specific versions or request paths of the shared module. When specified, only matching modules will be shared. Cannot be used with 'exclude'.";
-                    readonly $ref: "#/definitions/IncludeExcludeOptions";
+          };
+          readonly excludeChunk: {
+            readonly description: "Predicate to exclude chunk from async boundary";
+            readonly instanceof: "Function";
+          };
+        };
+        readonly additionalProperties: false;
+      }];
+    };
+    readonly exposes: {
+      readonly $ref: "#/definitions/Exposes";
+    };
+    readonly filename: {
+      readonly description: "The filename for this container relative path inside the `output.path` directory.";
+      readonly type: "string";
+      readonly absolutePath: false;
+      readonly minLength: 1;
+    };
+    readonly treeShakingSharedExcludePlugins: {
+      readonly description: "Plugin names to exclude from independent shared compilation (will be filtered out by name).";
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+        readonly minLength: 1;
+      };
+    };
+    readonly treeShakingSharedPlugins: {
+      readonly description: "List of plugin module paths to apply when building independent shared fallbacks.";
+      readonly type: "array";
+      readonly items: {
+        readonly type: "string";
+        readonly minLength: 1;
+      };
+    };
+    readonly treeShakingDir: {
+      readonly description: "The directory where tree-shaking assets will be generated.";
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly injectTreeShakingUsedExports: {
+      readonly description: "Inject tree-shaking used exports to the shared module.";
+      readonly type: "boolean";
+    };
+    readonly library: {
+      readonly $ref: "#/definitions/LibraryOptions";
+    };
+    readonly name: {
+      readonly description: "The name for this container.";
+      readonly type: "string";
+      readonly minLength: 1;
+    };
+    readonly remoteType: {
+      readonly description: "The external type of the remote containers.";
+      readonly oneOf: readonly [{
+        readonly $ref: "#/definitions/ExternalsType";
+      }];
+    };
+    readonly remotes: {
+      readonly $ref: "#/definitions/Remotes";
+    };
+    readonly runtime: {
+      readonly $ref: "#/definitions/EntryRuntime";
+    };
+    readonly shareScope: {
+      readonly description: "The name of the share scope which is shared with the host (defaults to 'default').";
+      readonly anyOf: readonly [{
+        readonly type: "string";
+        readonly minLength: 1;
+      }, {
+        readonly type: "array";
+        readonly items: {
+          readonly type: "string";
+          readonly minLength: 1;
+        };
+      }];
+    };
+    readonly shareStrategy: {
+      readonly description: "Strategy for resolving shared modules (defaults to 'version-first').";
+      readonly enum: readonly ["version-first", "loaded-first"];
+      readonly type: "string";
+    };
+    readonly shared: {
+      readonly $ref: "#/definitions/Shared";
+    };
+    readonly dts: {
+      readonly description: "TypeScript declaration file generation options";
+      readonly anyOf: readonly [{
+        readonly type: "boolean";
+      }, {
+        readonly type: "object";
+        readonly properties: {
+          readonly generateTypes: {
+            readonly anyOf: readonly [{
+              readonly type: "boolean";
+            }, {
+              readonly type: "object";
+              readonly properties: {
+                readonly tsConfigPath: {
+                  readonly type: "string";
                 };
-                readonly import: {
-                    readonly description: "Provided module that should be provided to share scope. Also acts as fallback module if no shared module is found in share scope or version isn't valid. Defaults to the property name.";
-                    readonly anyOf: readonly [{
-                        readonly description: "No provided or fallback module.";
-                        readonly enum: readonly [false];
-                    }, {
-                        readonly $ref: "#/definitions/SharedItem";
-                    }];
+                readonly typesFolder: {
+                  readonly type: "string";
                 };
-                readonly request: {
-                    readonly description: "Import request to match on";
-                    readonly type: "string";
-                    readonly minLength: 1;
+                readonly compiledTypesFolder: {
+                  readonly type: "string";
                 };
-                readonly layer: {
-                    readonly description: "Layer in which the shared module should be placed.";
-                    readonly type: "string";
-                    readonly minLength: 1;
+                readonly deleteTypesFolder: {
+                  readonly type: "boolean";
                 };
-                readonly issuerLayer: {
-                    readonly description: "Layer of the issuer.";
+                readonly additionalFilesToCompile: {
+                  readonly type: "array";
+                  readonly items: {
                     readonly type: "string";
-                    readonly minLength: 1;
+                  };
                 };
-                readonly packageName: {
-                    readonly description: "Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.";
-                    readonly type: "string";
-                    readonly minLength: 1;
+                readonly compileInChildProcess: {
+                  readonly type: "boolean";
                 };
-                readonly requiredVersion: {
-                    readonly description: "Version requirement from module in share scope.";
-                    readonly anyOf: readonly [{
-                        readonly description: "No version requirement check.";
-                        readonly enum: readonly [false];
-                    }, {
-                        readonly description: "Version as string. Can be prefixed with '^' or '~' for minimum matches. Each part of the version should be separated by a dot '.'.";
-                        readonly type: "string";
-                    }];
+                readonly compilerInstance: {
+                  readonly type: "string";
                 };
-                readonly shareKey: {
-                    readonly description: "Module is looked up under this key from the share scope.";
-                    readonly type: "string";
-                    readonly minLength: 1;
+                readonly generateAPITypes: {
+                  readonly type: "boolean";
                 };
-                readonly shareScope: {
-                    readonly description: "Share scope name.";
-                    readonly anyOf: readonly [{
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    }, {
+                readonly extractThirdParty: {
+                  readonly anyOf: readonly [{
+                    readonly type: "boolean";
+                  }, {
+                    readonly type: "object";
+                    readonly properties: {
+                      readonly exclude: {
                         readonly type: "array";
                         readonly items: {
+                          readonly anyOf: readonly [{
                             readonly type: "string";
-                            readonly minLength: 1;
+                          }, {
+                            readonly instanceof: "RegExp";
+                          }];
                         };
-                    }];
-                };
-                readonly shareStrategy: {
-                    readonly description: "[Deprecated]: load shared strategy(defaults to 'version-first').";
-                    readonly enum: readonly ["version-first", "loaded-first"];
-                    readonly type: "string";
-                };
-                readonly singleton: {
-                    readonly description: "Allow only a single version of the shared module in share scope (disabled by default).";
-                    readonly type: "boolean";
-                };
-                readonly strictVersion: {
-                    readonly description: "Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).";
-                    readonly type: "boolean";
+                      };
+                    };
+                    readonly additionalProperties: false;
+                  }];
                 };
-                readonly version: {
-                    readonly description: "Version of the provided module. Will replace lower matching versions, but not higher.";
-                    readonly anyOf: readonly [{
-                        readonly description: "Don't provide a version.";
-                        readonly enum: readonly [false];
-                    }, {
-                        readonly description: "Version as string. Each part of the version should be separated by a dot '.'.";
-                        readonly type: "string";
-                    }];
+                readonly extractRemoteTypes: {
+                  readonly type: "boolean";
                 };
-                readonly allowNodeModulesSuffixMatch: {
-                    readonly description: "Enable reconstructed lookup for node_modules paths for this share item";
-                    readonly type: "boolean";
+                readonly abortOnError: {
+                  readonly type: "boolean";
                 };
-                readonly treeShaking: {
-                    readonly description: "Enable tree-shaking for the shared module or configure it.";
-                    readonly anyOf: readonly [{
-                        readonly type: "boolean";
-                    }, {
-                        readonly $ref: "#/definitions/TreeShakingConfig";
-                    }];
+              };
+            }];
+          };
+          readonly consumeTypes: {
+            readonly anyOf: readonly [{
+              readonly type: "boolean";
+            }, {
+              readonly type: "object";
+              readonly properties: {
+                readonly typesFolder: {
+                  readonly type: "string";
                 };
-            };
-        };
-        readonly SharedItem: {
-            readonly description: "A module that should be shared in the share scope.";
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly SharedObject: {
-            readonly description: "Modules that should be shared in the share scope. Property names are used to match requested modules in this compilation. Relative requests are resolved, module requests are matched unresolved, absolute paths will match resolved requests. A trailing slash will match all requests with this prefix. In this case shareKey must also have a trailing slash.";
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly description: "Modules that should be shared in the share scope.";
-                readonly anyOf: readonly [{
-                    readonly $ref: "#/definitions/SharedConfig";
-                }, {
-                    readonly $ref: "#/definitions/SharedItem";
-                }];
-            };
-        };
-        readonly UmdNamedDefine: {
-            readonly description: "If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.";
-            readonly type: "boolean";
-        };
-        readonly IncludeExcludeOptions: {
-            readonly type: "object";
-            readonly properties: {
-                readonly request: {
-                    readonly type: readonly ["string", "object"];
-                    readonly description: "A string (which can be a regex pattern) or a RegExp object to match the request path.";
+                readonly abortOnError: {
+                  readonly type: "boolean";
                 };
-                readonly version: {
-                    readonly type: "string";
-                    readonly description: "Semantic versioning range to match against the module's version.";
+                readonly remoteTypesFolder: {
+                  readonly type: "string";
                 };
-                readonly fallbackVersion: {
-                    readonly type: "string";
-                    readonly description: "Semantic versioning range to match against the fallback module's version for exclusion/inclusion context where applicable.";
+                readonly deleteTypesFolder: {
+                  readonly type: "boolean";
                 };
-            };
-            readonly additionalProperties: false;
-            readonly anyOf: readonly [{
-                readonly required: readonly ["request"];
-            }, {
-                readonly required: readonly ["version"];
-            }, {
-                readonly required: readonly ["fallbackVersion"];
-            }];
-        };
-        readonly Exclude: {
-            readonly description: "Advanced filtering options.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly request: {
-                    readonly description: "Regular expression pattern to filter module requests";
-                    readonly instanceof: "RegExp";
+                readonly maxRetries: {
+                  readonly type: "number";
                 };
-                readonly version: {
-                    readonly description: "Specific version string or range to filter by (exclude matches).";
-                    readonly type: "string";
+                readonly consumeAPITypes: {
+                  readonly type: "boolean";
                 };
-                readonly fallbackVersion: {
-                    readonly description: "Optional specific version string to check against the filter.version range instead of reading package.json.";
+                readonly runtimePkgs: {
+                  readonly type: "array";
+                  readonly items: {
                     readonly type: "string";
+                  };
                 };
-            };
-        };
-        readonly TreeShakingConfig: {
-            readonly description: "Tree-shake configuration for shared module.";
-            readonly type: "object";
-            readonly additionalProperties: false;
-            readonly properties: {
-                readonly usedExports: {
-                    readonly description: "List of export names used from the shared module.";
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                        readonly minLength: 1;
+                readonly remoteTypeUrls: {
+                  readonly description: "Remote type URLs provider or map";
+                  readonly anyOf: readonly [{
+                    readonly instanceof: "Function";
+                  }, {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                      readonly type: "object";
+                      readonly properties: {
+                        readonly alias: {
+                          readonly type: "string";
+                        };
+                        readonly api: {
+                          readonly type: "string";
+                        };
+                        readonly zip: {
+                          readonly type: "string";
+                        };
+                      };
+                      readonly required: readonly ["api", "zip"];
+                      readonly additionalProperties: false;
                     };
+                  }];
                 };
-                readonly mode: {
-                    readonly description: "Tree-shake analysis mode.";
-                    readonly type: "string";
-                    readonly enum: readonly ["server-calc", "runtime-infer"];
+                readonly timeout: {
+                  readonly type: "number";
                 };
-                readonly filename: {
-                    readonly description: "Filename for generated treeShaking metadata.";
-                    readonly type: "string";
+                readonly family: {
+                  readonly enum: readonly [4, 6];
                 };
-            };
-        };
-    };
-    readonly title: "ModuleFederationPluginOptions";
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly properties: {
-        readonly async: {
-            readonly description: "Enable/disable asynchronous loading of runtime modules or provide async boundary options.";
-            readonly anyOf: readonly [{
-                readonly type: "boolean";
-            }, {
-                readonly type: "object";
-                readonly properties: {
-                    readonly eager: {
-                        readonly description: "Eagerly load a module, matched via RegExp or predicate function";
-                        readonly anyOf: readonly [{
-                            readonly instanceof: "RegExp";
-                        }, {
-                            readonly instanceof: "Function";
-                        }];
-                    };
-                    readonly excludeChunk: {
-                        readonly description: "Predicate to exclude chunk from async boundary";
-                        readonly instanceof: "Function";
-                    };
+                readonly typesOnBuild: {
+                  readonly type: "boolean";
                 };
-                readonly additionalProperties: false;
+              };
             }];
-        };
-        readonly exposes: {
-            readonly $ref: "#/definitions/Exposes";
-        };
-        readonly filename: {
-            readonly description: "The filename for this container relative path inside the `output.path` directory.";
+          };
+          readonly tsConfigPath: {
             readonly type: "string";
-            readonly absolutePath: false;
-            readonly minLength: 1;
-        };
-        readonly treeShakingSharedExcludePlugins: {
-            readonly description: "List of plugins to exclude from tree-shake analysis.";
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-        };
-        readonly treeShakingSharedPlugins: {
-            readonly description: "List of plugins to exclude from tree-shake analysis.";
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-        };
-        readonly treeShakingDir: {
-            readonly description: "The directory where tree-shaking assets will be generated.";
+          };
+          readonly extraOptions: {
+            readonly type: "object";
+          };
+          readonly implementation: {
             readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly injectTreeShakingUsedExports: {
-            readonly description: "Inject tree-shaking used exports to the shared module.";
-            readonly type: "boolean";
-        };
-        readonly library: {
-            readonly $ref: "#/definitions/LibraryOptions";
-        };
-        readonly name: {
-            readonly description: "The name for this container.";
+          };
+          readonly cwd: {
             readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly remoteType: {
-            readonly description: "The external type of the remote containers.";
-            readonly oneOf: readonly [{
-                readonly $ref: "#/definitions/ExternalsType";
-            }];
-        };
-        readonly remotes: {
-            readonly $ref: "#/definitions/Remotes";
-        };
-        readonly runtime: {
-            readonly $ref: "#/definitions/EntryRuntime";
-        };
-        readonly shareScope: {
-            readonly description: "The name of the share scope which is shared with the host (defaults to 'default').";
-            readonly anyOf: readonly [{
-                readonly type: "string";
-                readonly minLength: 1;
-            }, {
-                readonly type: "array";
-                readonly items: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
-            }];
-        };
-        readonly shareStrategy: {
-            readonly description: "Strategy for resolving shared modules";
-            readonly enum: readonly ["version-first", "loaded-first"];
-            readonly type: "string";
-        };
-        readonly shared: {
-            readonly $ref: "#/definitions/Shared";
-        };
-        readonly dts: {
-            readonly description: "TypeScript declaration file generation options";
-            readonly anyOf: readonly [{
-                readonly type: "boolean";
-            }, {
-                readonly type: "object";
-                readonly properties: {
-                    readonly generateTypes: {
-                        readonly anyOf: readonly [{
-                            readonly type: "boolean";
-                        }, {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly tsConfigPath: {
-                                    readonly type: "string";
-                                };
-                                readonly typesFolder: {
-                                    readonly type: "string";
-                                };
-                                readonly compiledTypesFolder: {
-                                    readonly type: "string";
-                                };
-                                readonly deleteTypesFolder: {
-                                    readonly type: "boolean";
-                                };
-                                readonly additionalFilesToCompile: {
-                                    readonly type: "array";
-                                    readonly items: {
-                                        readonly type: "string";
-                                    };
-                                };
-                                readonly compileInChildProcess: {
-                                    readonly type: "boolean";
-                                };
-                                readonly compilerInstance: {
-                                    readonly type: "string";
-                                };
-                                readonly generateAPITypes: {
-                                    readonly type: "boolean";
-                                };
-                                readonly extractThirdParty: {
-                                    readonly anyOf: readonly [{
-                                        readonly type: "boolean";
-                                    }, {
-                                        readonly type: "object";
-                                        readonly properties: {
-                                            readonly exclude: {
-                                                readonly type: "array";
-                                                readonly items: {
-                                                    readonly anyOf: readonly [{
-                                                        readonly type: "string";
-                                                    }, {
-                                                        readonly instanceof: "RegExp";
-                                                    }];
-                                                };
-                                            };
-                                        };
-                                        readonly additionalProperties: false;
-                                    }];
-                                };
-                                readonly extractRemoteTypes: {
-                                    readonly type: "boolean";
-                                };
-                                readonly abortOnError: {
-                                    readonly type: "boolean";
-                                };
-                            };
-                        }];
-                    };
-                    readonly consumeTypes: {
-                        readonly anyOf: readonly [{
-                            readonly type: "boolean";
-                        }, {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly typesFolder: {
-                                    readonly type: "string";
-                                };
-                                readonly abortOnError: {
-                                    readonly type: "boolean";
-                                };
-                                readonly remoteTypesFolder: {
-                                    readonly type: "string";
-                                };
-                                readonly deleteTypesFolder: {
-                                    readonly type: "boolean";
-                                };
-                                readonly maxRetries: {
-                                    readonly type: "number";
-                                };
-                                readonly consumeAPITypes: {
-                                    readonly type: "boolean";
-                                };
-                                readonly runtimePkgs: {
-                                    readonly type: "array";
-                                    readonly items: {
-                                        readonly type: "string";
-                                    };
-                                };
-                                readonly remoteTypeUrls: {
-                                    readonly description: "Remote type URLs provider or map";
-                                    readonly anyOf: readonly [{
-                                        readonly instanceof: "Function";
-                                    }, {
-                                        readonly type: "object";
-                                        readonly additionalProperties: {
-                                            readonly type: "object";
-                                            readonly properties: {
-                                                readonly alias: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly api: {
-                                                    readonly type: "string";
-                                                };
-                                                readonly zip: {
-                                                    readonly type: "string";
-                                                };
-                                            };
-                                            readonly required: readonly ["api", "zip"];
-                                            readonly additionalProperties: false;
-                                        };
-                                    }];
-                                };
-                                readonly timeout: {
-                                    readonly type: "number";
-                                };
-                                readonly family: {
-                                    readonly enum: readonly [4, 6];
-                                };
-                                readonly typesOnBuild: {
-                                    readonly type: "boolean";
-                                };
-                            };
-                        }];
-                    };
-                    readonly tsConfigPath: {
-                        readonly type: "string";
-                    };
-                    readonly extraOptions: {
-                        readonly type: "object";
-                    };
-                    readonly implementation: {
-                        readonly type: "string";
-                    };
-                    readonly cwd: {
-                        readonly type: "string";
-                    };
-                    readonly displayErrorInTerminal: {
-                        readonly type: "boolean";
-                    };
-                };
-            }];
+          };
+          readonly displayErrorInTerminal: {
+            readonly type: "boolean";
+          };
         };
-        readonly experiments: {
-            readonly type: "object";
-            readonly properties: {
-                readonly asyncStartup: {
-                    readonly description: "Enable async startup for the container";
-                    readonly type: "boolean";
-                };
-                readonly externalRuntime: {
-                    readonly type: "boolean";
-                };
-                readonly provideExternalRuntime: {
-                    readonly type: "boolean";
-                };
-                readonly optimization: {
-                    readonly description: "Options related to build optimizations.";
-                    readonly type: "object";
-                    readonly properties: {
-                        readonly disableSnapshot: {
-                            readonly description: "Enable optimization to skip snapshot plugin";
-                            readonly type: "boolean";
-                        };
-                        readonly target: {
-                            readonly description: "Target environment for the build";
-                            readonly enum: readonly ["web", "node"];
-                        };
-                    };
-                    readonly additionalProperties: false;
-                };
+      }];
+    };
+    readonly experiments: {
+      readonly type: "object";
+      readonly properties: {
+        readonly asyncStartup: {
+          readonly description: "Enable async startup for the container";
+          readonly type: "boolean";
+        };
+        readonly externalRuntime: {
+          readonly description: "Externalize '@module-federation/runtime-core' and expect global '_FEDERATION_RUNTIME_CORE' at runtime.";
+          readonly type: "boolean";
+        };
+        readonly provideExternalRuntime: {
+          readonly description: "Provide external runtime injection for pure consumer builds (no `exposes`). When enabled, automatically adds '@module-federation/inject-external-runtime-core-plugin'. Throws error if used together with exposes.";
+          readonly type: "boolean";
+        };
+        readonly optimization: {
+          readonly description: "Options related to build optimizations.";
+          readonly type: "object";
+          readonly properties: {
+            readonly disableSnapshot: {
+              readonly description: "Enable optimization to skip snapshot plugin";
+              readonly type: "boolean";
             };
-        };
-        readonly bridge: {
-            readonly description: "Bridge configuration options";
-            readonly type: "object";
-            readonly properties: {
-                readonly enableBridgeRouter: {
-                    readonly description: "Enables bridge router functionality for React applications. When enabled, automatically handles routing context and basename injection for micro-frontend applications using react-router-dom.";
-                    readonly type: "boolean";
-                    readonly default: false;
-                };
-                readonly disableAlias: {
-                    readonly description: "[Deprecated] Use `enableBridgeRouter: false` instead. Disables the default alias setting in the bridge. When true, users must manually handle basename through root component props.";
-                    readonly type: "boolean";
-                    readonly default: false;
-                };
+            readonly target: {
+              readonly description: "Target environment for the build";
+              readonly enum: readonly ["web", "node"];
             };
-            readonly additionalProperties: false;
+          };
+          readonly additionalProperties: false;
         };
-        readonly virtualRuntimeEntry: {
-            readonly description: "Uses a virtual module instead of a file for federation runtime entry";
+      };
+    };
+    readonly bridge: {
+      readonly description: "Bridge configuration options";
+      readonly type: "object";
+      readonly properties: {
+        readonly enableBridgeRouter: {
+          readonly description: "Enables bridge router functionality for React applications. When enabled, automatically handles routing context and basename injection for micro-frontend applications using react-router-dom.";
+          readonly type: "boolean";
+          readonly default: false;
+        };
+        readonly disableAlias: {
+          readonly description: "[Deprecated] Use `enableBridgeRouter: false` instead. Disables the default alias setting in the bridge. When true, users must manually handle basename through root component props.";
+          readonly type: "boolean";
+          readonly default: false;
+        };
+      };
+      readonly additionalProperties: false;
+    };
+    readonly virtualRuntimeEntry: {
+      readonly description: "Uses a virtual module instead of a file for federation runtime entry";
+      readonly type: "boolean";
+    };
+    readonly dev: {
+      readonly description: "Development mode configuration options";
+      readonly anyOf: readonly [{
+        readonly type: "boolean";
+      }, {
+        readonly type: "object";
+        readonly properties: {
+          readonly disableLiveReload: {
+            readonly description: "Disable live reload for development mode";
             readonly type: "boolean";
+          };
+          readonly disableHotTypesReload: {
+            readonly description: "Disable hot types reload for development mode";
+            readonly type: "boolean";
+          };
+          readonly disableDynamicRemoteTypeHints: {
+            readonly description: "Disable dynamic remote type hints for development mode";
+            readonly type: "boolean";
+          };
         };
-        readonly dev: {
-            readonly description: "Development mode configuration options";
-            readonly anyOf: readonly [{
-                readonly type: "boolean";
-            }, {
-                readonly type: "object";
-                readonly properties: {
-                    readonly disableLiveReload: {
-                        readonly description: "Disable live reload for development mode";
-                        readonly type: "boolean";
-                    };
-                    readonly disableHotTypesReload: {
-                        readonly description: "Disable hot types reload for development mode";
-                        readonly type: "boolean";
-                    };
-                    readonly disableDynamicRemoteTypeHints: {
-                        readonly description: "Disable dynamic remote type hints for development mode";
-                        readonly type: "boolean";
-                    };
-                };
-                readonly additionalProperties: false;
-            }];
-        };
-        readonly manifest: {
-            readonly description: "Manifest generation configuration options. IMPORTANT: When using this option, you must set a string value for `output.publicPath` in your webpack configuration.";
-            readonly anyOf: readonly [{
-                readonly type: "boolean";
-            }, {
-                readonly type: "object";
-                readonly properties: {
-                    readonly filePath: {
-                        readonly description: "Path where the manifest file will be generated";
-                        readonly type: "string";
-                    };
-                    readonly disableAssetsAnalyze: {
-                        readonly description: "Disable assets analyze for manifest generation";
-                        readonly type: "boolean";
-                    };
-                    readonly fileName: {
-                        readonly description: "Name of the manifest file";
-                        readonly type: "string";
-                    };
-                    readonly additionalData: {
-                        readonly description: "Function that provides additional data to the manifest";
-                        readonly instanceof: "Function";
-                    };
-                };
-                readonly additionalProperties: false;
-            }];
-        };
-        readonly runtimePlugins: {
-            readonly description: "Runtime plugin file paths or package names to be included in federation runtime";
-            readonly type: "array";
-            readonly items: {
-                readonly anyOf: readonly [{
-                    readonly type: "string";
-                }, {
-                    readonly type: "array";
-                    readonly items: readonly [{
-                        readonly type: "string";
-                    }, {
-                        readonly type: "object";
-                    }];
-                    readonly minItems: 2;
-                    readonly maxItems: 2;
-                }];
-            };
-        };
-        readonly getPublicPath: {
-            readonly description: "Custom public path function for remote entry";
+        readonly additionalProperties: false;
+      }];
+    };
+    readonly manifest: {
+      readonly description: "Manifest generation configuration options. IMPORTANT: When using this option, you must set a string value for `output.publicPath` in your webpack configuration.";
+      readonly anyOf: readonly [{
+        readonly type: "boolean";
+      }, {
+        readonly type: "object";
+        readonly properties: {
+          readonly filePath: {
+            readonly description: "Path where the manifest file will be generated";
             readonly type: "string";
-        };
-        readonly dataPrefetch: {
-            readonly description: "Whether enable data prefetch";
+          };
+          readonly disableAssetsAnalyze: {
+            readonly description: "Disable assets analyze for manifest generation";
             readonly type: "boolean";
-        };
-        readonly implementation: {
-            readonly description: "Bundler runtime path";
+          };
+          readonly fileName: {
+            readonly description: "Name of the manifest file";
             readonly type: "string";
-        };
+          };
+          readonly additionalData: {
+            readonly description: "Function that provides additional data to the manifest";
+            readonly instanceof: "Function";
+          };
+        };
+        readonly additionalProperties: false;
+      }];
+    };
+    readonly runtimePlugins: {
+      readonly description: "Runtime plugin file paths or package names to be included in federation runtime";
+      readonly type: "array";
+      readonly items: {
+        readonly anyOf: readonly [{
+          readonly type: "string";
+        }, {
+          readonly type: "array";
+          readonly items: readonly [{
+            readonly type: "string";
+          }, {
+            readonly type: "object";
+          }];
+          readonly minItems: 2;
+          readonly maxItems: 2;
+        }];
+      };
+    };
+    readonly getPublicPath: {
+      readonly description: "Stringified function or return expression to compute dynamic publicPath. Effective only when 'exposes' is set. Example: `function(){ return window.cdn_prefix }` or `return 'https://cdn.example.com/app/'`.";
+      readonly type: "string";
+    };
+    readonly dataPrefetch: {
+      readonly description: "Whether enable data prefetch";
+      readonly type: "boolean";
+    };
+    readonly implementation: {
+      readonly description: "Bundler runtime path";
+      readonly type: "string";
     };
+  };
 };
-export default _default;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=ModuleFederationPlugin.d.ts.map