@module-federation/enhanced 0.8.9 → 0.8.10

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

@@ -0,0 +1,622 @@
+declare const _default: {
+    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", "script", "module-import", "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 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 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 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 shareScope: {
+                    readonly description: "The name of the share scope shared with this remote.";
+                    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 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 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 shareKey: {
+                    readonly description: "Module is looked up under this key from the share scope.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly shareScope: {
+                    readonly description: "Share scope name.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly shareStrategy: {
+                    readonly description: "load shared strategy(defaults to 'version-first').";
+                    readonly enum: readonly ["version-first", "loaded-first"];
+                };
+                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 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 title: "ModuleFederationPluginOptions";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly dataPrefetch: {
+            readonly description: "Enable Data Prefetch";
+            readonly type: "boolean";
+        };
+        readonly exposes: {
+            readonly $ref: "#/definitions/Exposes";
+        };
+        readonly filename: {
+            readonly description: "The filename of the container as relative path inside the `output.path` directory.";
+            readonly type: "string";
+            readonly absolutePath: false;
+        };
+        readonly getPublicPath: {
+            readonly description: "Custom public path function";
+            readonly type: "string";
+        };
+        readonly implementation: {
+            readonly description: "Bundler runtime path";
+            readonly type: "string";
+        };
+        readonly library: {
+            readonly $ref: "#/definitions/LibraryOptions";
+        };
+        readonly manifest: {
+            readonly description: "Manifest generation options";
+            readonly anyOf: readonly [{
+                readonly type: "boolean";
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly filePath: {
+                        readonly type: "string";
+                    };
+                    readonly disableAssetsAnalyze: {
+                        readonly type: "boolean";
+                    };
+                    readonly fileName: {
+                        readonly type: "string";
+                    };
+                    readonly additionalData: {
+                        readonly type: "string";
+                        readonly description: "Function string to provide additional data to the manifest";
+                    };
+                };
+            }];
+        };
+        readonly name: {
+            readonly description: "The name of the container.";
+            readonly type: "string";
+        };
+        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 runtimePlugins: {
+            readonly description: "Runtime plugin file paths or package name";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly shareScope: {
+            readonly description: "Share scope name used for all shared modules (defaults to 'default').";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly shareStrategy: {
+            readonly description: "load shared strategy(defaults to 'version-first').";
+            readonly enum: readonly ["version-first", "loaded-first"];
+        };
+        readonly shared: {
+            readonly $ref: "#/definitions/Shared";
+        };
+        readonly virtualRuntimeEntry: {
+            readonly description: "Enable virtual runtime entry";
+            readonly type: "boolean";
+        };
+        readonly dev: {
+            readonly description: "Development options";
+            readonly anyOf: readonly [{
+                readonly type: "boolean";
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly disableLiveReload: {
+                        readonly type: "boolean";
+                    };
+                    readonly disableHotTypesReload: {
+                        readonly type: "boolean";
+                    };
+                    readonly disableDynamicRemoteTypeHints: {
+                        readonly type: "boolean";
+                    };
+                };
+            }];
+        };
+        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 enum: readonly ["tsc", "vue-tsc"];
+                                };
+                                readonly generateAPITypes: {
+                                    readonly type: "boolean";
+                                };
+                                readonly extractThirdParty: {
+                                    readonly type: "boolean";
+                                };
+                                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 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 experiments: {
+            readonly type: "object";
+            readonly properties: {
+                readonly federationRuntime: {
+                    readonly anyOf: readonly [{
+                        readonly type: "boolean";
+                        readonly enum: readonly [false];
+                    }, {
+                        readonly type: "string";
+                        readonly enum: readonly ["hoisted"];
+                    }];
+                };
+                readonly externalRuntime: {
+                    readonly type: "boolean";
+                };
+                readonly provideExternalRuntime: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly bridge: {
+            readonly type: "object";
+            readonly properties: {
+                readonly disableAlias: {
+                    readonly description: "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;
+                };
+            };
+        };
+    };
+};
+export default _default;