@dtwo/schema 3.1.2 → 3.2.1

package/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2022 - Dtwo Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2022 - Dtwo Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -7,7 +7,7 @@ import { Ignore } from 'ignore';
 import { TSConfig, readPackageJSON } from 'pkg-types';
 import { Server } from 'node:http';
 import { Server as Server$1 } from 'node:https';
-import { InlineConfig, WiteDevServer, UserConfig, ServerOptions } from 'wite';
+import { InlineConfig, LahmDevServer, UserConfig, ServerOptions } from 'lahm';
 import { Manifest } from 'kdu-bundle-renderer';
 import { EventHandler } from 'h3';
 import { Configuration, Compiler, Stats, WebpackError } from 'webpack';
@@ -23,10 +23,11 @@ import { BasePluginOptions as BasePluginOptions$1, DefinedDefaultMinimizerAndOpt
 import { Options } from 'webpack-dev-middleware';
 import { IncomingMessage, ServerResponse } from 'http';
 import { MiddlewareOptions, ClientOptions } from 'webpack-hot-middleware';
-import { Options as Options$1 } from '@witejs/plugin-kdu';
+import { Options as Options$1 } from '@lahmjs/plugin-kdu';
+import { Options as Options$2 } from '@lahmjs/plugin-kdu-jsx';
 import { MergeHead, Head } from '@kdhead/schema';
 
-interface WiteHot {
+interface LahmHot {
     readonly data: any;
     accept(): void;
     accept(cb: (mod: any) => void): void;
@@ -38,18 +39,18 @@ interface WiteHot {
     on(event: any, cb: (payload: any) => void): void;
     send(event: any, data?: any): void;
 }
-interface WiteGlobOptions {
+interface LahmGlobOptions {
     as?: string;
     eager?: boolean;
     import?: string;
     query?: string | Record<string, string | number | boolean>;
     exhaustive?: boolean;
 }
-interface WiteImportMeta {
-    /** Wite client HMR API - see https://witejs.web.app/guide/api-hmr.html */
-    readonly hot?: WiteHot;
-    /** wite glob import utility - https://witejs.web.app/guide/features.html#glob-import */
-    glob(glob: string | string[], options?: WiteGlobOptions): Record<string, () => Promise<Record<string, any>>>;
+interface LahmImportMeta {
+    /** Lahm client HMR API - see https://lahmjs.web.app/guide/api-hmr.html */
+    readonly hot?: LahmHot;
+    /** lahm glob import utility - https://lahmjs.web.app/guide/features.html#glob-import */
+    glob(glob: string | string[], options?: LahmGlobOptions): Record<string, () => Promise<Record<string, any>>>;
 }
 
 /**
@@ -257,7 +258,7 @@ interface WebpackImportMeta {
     webpack?: number;
 }
 
-type BundlerImportMeta = WiteImportMeta & WebpackImportMeta;
+type BundlerImportMeta = LahmImportMeta & WebpackImportMeta;
 declare global {
     interface ImportMeta extends BundlerImportMeta {
         /** the `file:` url of the current file (similar to `__filename` but as file url) */
@@ -460,71 +461,286 @@ interface ImportPresetWithDeprecation extends InlinePreset {
 interface GenerateAppOptions {
     filter?: (template: ResolvedDtwoTemplate<any>) => boolean;
 }
+/**
+ * The listeners to Dtwo build time events
+ */
 interface DtwoHooks {
+    /**
+     * Allows extending compatibility checks.
+     * @param compatibility Compatibility object
+     * @param issues Issues to be mapped
+     * @returns Promise
+     */
     'kit:compatibility': (compatibility: DtwoCompatibility, issues: DtwoCompatibilityIssues) => HookResult;
+    /**
+     * Called after Dtwo initialization, when the Dtwo instance is ready to work.
+     * @param dtwo The configured Dtwo object
+     * @returns Promise
+     */
     'ready': (dtwo: Dtwo) => HookResult;
+    /**
+     * Called when Dtwo instance is gracefully closing.
+     * @param dtwo The configured Dtwo object
+     * @returns Promise
+     */
     'close': (dtwo: Dtwo) => HookResult;
+    /**
+     * Called during Dtwo initialization, before installing user modules.
+     * @returns Promise
+     */
     'modules:before': () => HookResult;
+    /**
+     * Called during Dtwo initialization, after installing user modules.
+     * @returns Promise
+     */
     'modules:done': () => HookResult;
+    /**
+     * Called after resolving the `app` instance.
+     * @param app The resolved `DtwoApp` object
+     * @returns Promise
+     */
     'app:resolve': (app: DtwoApp) => HookResult;
+    /**
+     * Called during `DtwoApp` generation, to allow customizing, modifying or adding new files to the build directory (either virtually or to written to `.dtwo`).
+     * @param app The configured `DtwoApp` object
+     * @returns Promise
+     */
     'app:templates': (app: DtwoApp) => HookResult;
+    /**
+     * Called after templates are compiled into the [virtual file system](https://dtwojs.web.app/docs/guide/directory-structure/dtwo#virtual-file-system) (vfs).
+     * @param app The configured `DtwoApp` object
+     * @returns Promise
+     */
     'app:templatesGenerated': (app: DtwoApp) => HookResult;
+    /**
+     * Called before Dtwo bundle builder.
+     * @returns Promise
+     */
     'build:before': () => HookResult;
+    /**
+     * Called after Dtwo bundle builder is complete.
+     * @returns Promise
+     */
     'build:done': () => HookResult;
+    /**
+     * Called during the manifest build by Lahm and Webpack. This allows customizing the manifest that Hole will use to render `<script>` and `<link>` tags in the final HTML.
+     * @param manifest The manifest object to build
+     * @returns Promise
+     */
     'build:manifest': (manifest: Manifest) => HookResult;
+    /**
+     * Called before generating the app.
+     * @param options GenerateAppOptions object
+     * @returns Promise
+     */
     'builder:generateApp': (options?: GenerateAppOptions) => HookResult;
+    /**
+     * Called at build time in development when the watcher spots a change to a file or directory in the project.
+     * @param event "add" | "addDir" | "change" | "unlink" | "unlinkDir"
+     * @param path the path to the watched file
+     * @returns Promise
+     */
     'builder:watch': (event: WatchEvent, path: string) => HookResult;
+    /**
+     * Called after pages routes are resolved.
+     * @param pages Array containing resolved pages
+     * @returns Promise
+     */
     'pages:extend': (pages: DtwoPage[]) => HookResult;
+    /**
+     * Called when the dev middleware is being registered on the Hole dev server.
+     * @param handler the Lahm or Webpack event handler
+     * @returns Promise
+     */
     'server:devHandler': (handler: EventHandler) => HookResult;
+    /**
+     * Called at setup allowing modules to extend sources.
+     * @param presets Array containing presets objects
+     * @returns Promise
+     */
     'imports:sources': (presets: ImportPresetWithDeprecation[]) => HookResult;
+    /**
+     * Called at setup allowing modules to extend imports.
+     * @param imports Array containing the imports to extend
+     * @returns Promise
+     */
     'imports:extend': (imports: Import[]) => HookResult;
+    /**
+     * Called when the `kdimport` context is created.
+     * @param context The Kdimport context
+     * @returns Promise
+     */
     'imports:context': (context: Kdimport) => HookResult;
+    /**
+     * Allows extending import directories.
+     * @param dirs Array containing directories as string
+     * @returns Promise
+     */
     'imports:dirs': (dirs: string[]) => HookResult;
+    /**
+     * Called within `app:resolve` allowing to extend the directories that are scanned for auto-importable components.
+     * @param dirs The `dirs` option to push new items
+     * @returns Promise
+     */
     'components:dirs': (dirs: ComponentsOptions['dirs']) => HookResult;
+    /**
+     * Allows extending new components.
+     * @param components The `components` array to push new items
+     * @returns Promise
+     */
     'components:extend': (components: Component[]) => HookResult;
+    /**
+     * Called before initializing Hole, allowing customization of Hole's configuration.
+     * @param holeConfig The hole config to be extended
+     * @returns Promise
+     */
     'hole:config': (holeConfig: HoleConfig) => HookResult;
+    /**
+     * Called after Hole is initialized, which allows registering Hole hooks and interacting directly with Hole.
+     * @param hole The created hole object
+     * @returns Promise
+     */
     'hole:init': (hole: Hole) => HookResult;
+    /**
+     * Called before building the Hole instance.
+     * @param hole The created hole object
+     * @returns Promise
+     */
     'hole:build:before': (hole: Hole) => HookResult;
+    /**
+     * Allows extending the routes to be pre-rendered.
+     * @param ctx Dtwo context
+     * @returns Promise
+     */
     'prerender:routes': (ctx: {
         routes: Set<string>;
     }) => HookResult;
+    /**
+     * Called when an error occurs at build time.
+     * @param error Error object
+     * @returns Promise
+     */
     'build:error': (error: Error) => HookResult;
+    /**
+     * Called before Dtwc writes `.dtwo/tsconfig.json` and `.dtwo/dtwo.d.ts`, allowing addition of custom references and declarations in `dtwo.d.ts`, or directly modifying the options in `tsconfig.json`
+     * @param options Objects containing `references`, `declarations`, `tsConfig`
+     * @returns Promise
+     */
     'prepare:types': (options: {
         references: TSReference[];
         declarations: string[];
         tsConfig: TSConfig;
     }) => HookResult;
+    /**
+     * Called when the dev server is loading.
+     * @param listenerServer The HTTP/HTTPS server object
+     * @param listener The server's listener object
+     * @returns Promise
+     */
     'listen': (listenerServer: Server | Server$1, listener: any) => HookResult;
+    /**
+     * Allows extending default schemas.
+     * @param schemas Schemas to be extend
+     * @returns void
+     */
     'schema:extend': (schemas: SchemaDefinition[]) => void;
+    /**
+     * Allows extending resolved schema.
+     * @param schema Schema object
+     * @returns void
+     */
     'schema:resolved': (schema: Schema) => void;
+    /**
+     * Called before writing the given schema.
+     * @param schema Schema object
+     * @returns void
+     */
     'schema:beforeWrite': (schema: Schema) => void;
+    /**
+     * Called after the schema is written.
+     * @returns void
+     */
     'schema:written': () => void;
-    'wite:extend': (witeBuildContext: {
+    /**
+     * Allows to extend Lahm default context.
+     * @param lahmBuildContext The lahm build context object
+     * @returns Promise
+     */
+    'lahm:extend': (lahmBuildContext: {
         dtwo: Dtwo;
         config: InlineConfig;
     }) => HookResult;
-    'wite:extendConfig': (witeInlineConfig: InlineConfig, env: {
+    /**
+     * Allows to extend Lahm default config.
+     * @param lahmInlineConfig The lahm inline config object
+     * @param env Server or client
+     * @returns Promise
+     */
+    'lahm:extendConfig': (lahmInlineConfig: InlineConfig, env: {
         isClient: boolean;
         isServer: boolean;
     }) => HookResult;
-    'wite:serverCreated': (witeServer: WiteDevServer, env: {
+    /**
+     * Called when the Lahm server is created.
+     * @param lahmServer Lahm development server
+     * @param env Server or client
+     * @returns Promise
+     */
+    'lahm:serverCreated': (lahmServer: LahmDevServer, env: {
         isClient: boolean;
         isServer: boolean;
     }) => HookResult;
-    'wite:compiled': () => HookResult;
+    /**
+     * Called after Lahm server is compiled.
+     * @returns Promise
+     */
+    'lahm:compiled': () => HookResult;
+    /**
+     * Called before configuring the webpack compiler.
+     * @param webpackConfigs Configs objects to be pushed to the compiler
+     * @returns Promise
+     */
     'webpack:config': (webpackConfigs: Configuration[]) => HookResult;
+    /**
+     * Called right before compilation.
+     * @param options The options to be added
+     * @returns Promise
+     */
     'webpack:compile': (options: {
         name: string;
         compiler: Compiler;
     }) => HookResult;
+    /**
+     * Called after resources are loaded.
+     * @param options The compiler options
+     * @returns Promise
+     */
     'webpack:compiled': (options: {
         name: string;
         compiler: Compiler;
         stats: Stats;
     }) => HookResult;
+    /**
+     * Called on `change` on WebpackBar.
+     * @param shortPath the short path
+     * @returns void
+     */
     'webpack:change': (shortPath: string) => void;
+    /**
+     * Called on `done` if has errors on WebpackBar.
+     * @returns void
+     */
     'webpack:error': () => void;
+    /**
+     * Called on `allDone` on WebpackBar.
+     * @returns void
+     */
     'webpack:done': () => void;
+    /**
+     * Called on `progress` on WebpackBar.
+     * @param statesArray The array containing the states on progress
+     * @returns void
+     */
     'webpack:progress': (statesArray: any[]) => void;
 }
 type DtwoHookName = keyof DtwoHooks;
@@ -836,9 +1052,9 @@ interface ConfigSchema {
  /**
   * The builder to use for bundling the Kdu part of your application.
   * 
-  * @default "@dtwo/wite-builder"
+  * @default "@dtwo/lahm-builder"
  */
- builder: 'wite' | 'webpack' | { bundle: (dtwo: Dtwo) => Promise<void> },
+ builder: 'lahm' | 'webpack' | { bundle: (dtwo: Dtwo) => Promise<void> },
 
  /**
   * Whether to generate sourcemaps.
@@ -889,7 +1105,7 @@ interface ConfigSchema {
   /**
    * Dtwo uses `webpack-bundle-analyzer` to visualize your bundles and how to optimize them.
    * 
-   * Set to `true` to enable bundle analysis, or pass an object with options: [for webpack](https://github.com/webpack-contrib/webpack-bundle-analyzer#options-for-plugin) or [for wite](https://github.com/btd/rollup-plugin-visualizer#options).
+   * Set to `true` to enable bundle analysis, or pass an object with options: [for webpack](https://github.com/webpack-contrib/webpack-bundle-analyzer#options-for-plugin) or [for lahm](https://github.com/btd/rollup-plugin-visualizer#options).
    * 
    * @default false
    * 
@@ -1043,7 +1259,7 @@ interface ConfigSchema {
  debug: boolean,
 
  /**
-  * Whether to enable rendering of HTML - either dynamically (in server mode) or at generate time. If set to `false` and combined with `static` target, generated pages will simply display a loading screen with no content.
+  * Whether to enable rendering of HTML - either dynamically (in server mode) or at generate time. If set to `false` generated pages will have no content.
   * 
   * @default true
  */
@@ -1335,12 +1551,14 @@ interface ConfigSchema {
   /**
    * Dev server listening host
    * 
-   * @default "localhost"
+   * @default ""
   */
   host: string,
 
   /**
-   * Listening dev server url
+   * Listening dev server URL.
+   * 
+   * This should not be set directly as it will always be overridden by the dev server with the full URL (for module and internal use).
    * 
    * @default "http://localhost:3000"
   */
@@ -1379,23 +1597,32 @@ interface ConfigSchema {
   treeshakeClientOnly: boolean,
 
   /**
-   * Use wite-node for on-demand server chunk loading
+   * Emit `app:chunkError` hook when there is an error loading lahm/webpack chunks.
+   * 
+   * You can set this to `reload` to perform a hard reload of the new route when a chunk fails to load when navigating to a new route.
+   * 
+   * @default false
+  */
+  emitRouteChunkError: boolean | 'reload',
+
+  /**
+   * Use lahm-node for on-demand server chunk loading
    * 
    * @default true
    * 
-   * @deprecated use `wite.devBundler: 'wite-node'`
+   * @deprecated use `lahm.devBundler: 'lahm-node'`
   */
-  witeNode: boolean,
+  lahmNode: boolean,
 
   /**
    * Split server bundle into multiple chunks and dynamically import them.
    * 
    * @default true
   */
-  witeServerDynamicImports: boolean,
+  lahmServerDynamicImports: boolean,
 
   /**
-   * Inline styles when rendering HTML (currently wite only).
+   * Inline styles when rendering HTML (currently lahm only).
    * 
    * You can also pass a function that receives the path of a Kdu component and returns a boolean indicating whether to inline the styles for that component.
    * 
@@ -1671,18 +1898,18 @@ interface ConfigSchema {
  },
 
  /**
-  * Configuration that will be passed directly to Wite.
+  * Configuration that will be passed directly to Lahm.
   * 
-  * See https://witejs.web.app/config for more information. Please note that not all wite options are supported in Dtwo.
+  * See https://lahmjs.web.app/config for more information. Please note that not all lahm options are supported in Dtwo.
   * 
  */
- wite: WiteConfig,
+ lahm: LahmConfig,
 
  webpack: {
   /**
    * Dtwo uses `webpack-bundle-analyzer` to visualize your bundles and how to optimize them.
    * 
-   * Set to `true` to enable bundle analysis, or pass an object with options: [for webpack](https://github.com/webpack-contrib/webpack-bundle-analyzer#options-for-plugin) or [for wite](https://github.com/btd/rollup-plugin-visualizer#options).
+   * Set to `true` to enable bundle analysis, or pass an object with options: [for webpack](https://github.com/webpack-contrib/webpack-bundle-analyzer#options-for-plugin) or [for lahm](https://github.com/btd/rollup-plugin-visualizer#options).
    * 
    * @default false
    * 
@@ -2035,9 +2262,20 @@ type AppHeadMetaObject = MetaObjectRaw & {
 type DeepPartial<T> = T extends Function ? T : T extends Record<string, any> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
+type ExtractUpperChunk<T extends string> = T extends `${infer A}${infer B}` ? A extends Uppercase<A> ? B extends `${Uppercase<string>}${infer Rest}` ? B extends `${infer C}${Rest}` ? `${A}${C}${ExtractUpperChunk<Rest>}` : never : A : '' : never;
+type SliceLast<T extends string> = T extends `${infer A}${infer B}` ? B extends `${infer C}${infer D}` ? D extends '' ? A : `${A}${C}${SliceLast<D>}` : '' : never;
+type UpperSnakeCase<T extends string, State extends 'start' | 'lower' | 'upper' = 'start'> = T extends `${infer A}${infer B}` ? A extends Uppercase<A> ? A extends `${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0}` ? `${A}${UpperSnakeCase<B, 'lower'>}` : State extends 'lower' | 'upper' ? B extends `${SliceLast<ExtractUpperChunk<B>>}${infer Rest}` ? SliceLast<ExtractUpperChunk<B>> extends '' ? `_${A}_${UpperSnakeCase<B, 'start'>}` : `_${A}${SliceLast<ExtractUpperChunk<B>>}_${UpperSnakeCase<Rest, 'start'>}` : B extends Uppercase<B> ? `_${A}${B}` : `_${A}${UpperSnakeCase<B, 'lower'>}` : State extends 'start' ? `${A}${UpperSnakeCase<B, 'lower'>}` : never : State extends 'start' | 'lower' ? `${Uppercase<A>}${UpperSnakeCase<B, 'lower'>}` : `_${Uppercase<A>}${UpperSnakeCase<B, 'lower'>}` : Uppercase<T>;
+declare const message: unique symbol;
+type RuntimeValue<T, B extends string> = T & {
+    [message]?: B;
+};
+type Overrideable<T extends Record<string, any>, Path extends string = ''> = {
+    [K in keyof T]?: K extends string ? T[K] extends Record<string, any> ? RuntimeValue<Overrideable<T[K], `${Path}_${UpperSnakeCase<K>}`>, `You can override this value at runtime with DTWO${Path}_${UpperSnakeCase<K>}`> : RuntimeValue<T[K], `You can override this value at runtime with DTWO${Path}_${UpperSnakeCase<K>}`> : K extends number ? T[K] : never;
+};
 /** User configuration in `dtwo.config` file */
-interface DtwoConfig extends DeepPartial<Omit<ConfigSchema, 'wite'>> {
-    wite?: ConfigSchema['wite'];
+interface DtwoConfig extends DeepPartial<Omit<ConfigSchema, 'lahm' | 'runtimeConfig'>> {
+    lahm?: ConfigSchema['lahm'];
+    runtimeConfig?: Overrideable<RuntimeConfig>;
     /**
      * Experimental custom config schema
     */
@@ -2055,24 +2293,28 @@ type DtwoConfigLayer = ConfigLayer<DtwoConfig & {
 /** Normalized Dtwo options available as `dtwo.options.*` */
 interface DtwoOptions extends Omit<ConfigSchema, 'builder'> {
     sourcemap: Required<Exclude<ConfigSchema['sourcemap'], boolean>>;
-    builder: '@dtwo/wite-builder' | '@dtwo/webpack-builder' | {
+    builder: '@dtwo/lahm-builder' | '@dtwo/webpack-builder' | {
         bundle: (dtwo: Dtwo) => Promise<void>;
     };
     _layers: DtwoConfigLayer[];
     $schema: SchemaDefinition;
 }
-interface WiteConfig extends UserConfig {
+interface LahmConfig extends UserConfig {
     /**
-     * Options passed to @witejs/plugin-kdu
+     * Options passed to @lahmjs/plugin-kdu
      */
     kdu?: Options$1;
+    /**
+     * Options passed to @lahmjs/plugin-kdu-jsx
+     */
+    kduJsx?: Options$2;
     /**
      * Bundler for dev time server-side rendering.
-     * @default 'wite-node'
+     * @default 'lahm-node'
      */
-    devBundler?: 'wite-node' | 'legacy';
+    devBundler?: 'lahm-node' | 'legacy';
     /**
-     * Warmup wite entrypoint caches on dev startup.
+     * Warmup lahm entrypoint caches on dev startup.
      */
     warmupEntry?: boolean;
     /**
@@ -2109,4 +2351,4 @@ declare const _default: {
     [x: string]: untyped.SchemaDefinition | untyped.JSValue | untyped.InputObject;
 };
 
-export { AppConfig, AppConfigInput, AppHeadMetaObject, Component, ComponentsDir, ComponentsOptions, Dtwo, DtwoApp, DtwoAppConfig, DtwoCompatibility, DtwoCompatibilityIssue, DtwoCompatibilityIssues, DtwoConfig, DtwoConfigLayer, _default as DtwoConfigSchema, DtwoHookName, DtwoHooks, DtwoLayout, DtwoMiddleware, DtwoModule, DtwoOptions, DtwoPage, DtwoPlugin, DtwoPluginTemplate, DtwoTemplate, GenerateAppOptions, HeadAugmentations, HookResult, ImportPresetWithDeprecation, ImportsOptions, MetaObject, MetaObjectRaw, ModuleDefinition, ModuleMeta, ModuleOptions, PublicRuntimeConfig, ResolvedDtwoTemplate, RouterConfig, RouterConfigSerializable, RouterOptions, RuntimeConfig, ScanDir, TSReference, WatchEvent, WiteConfig };
+export { AppConfig, AppConfigInput, AppHeadMetaObject, Component, ComponentsDir, ComponentsOptions, Dtwo, DtwoApp, DtwoAppConfig, DtwoCompatibility, DtwoCompatibilityIssue, DtwoCompatibilityIssues, DtwoConfig, DtwoConfigLayer, _default as DtwoConfigSchema, DtwoHookName, DtwoHooks, DtwoLayout, DtwoMiddleware, DtwoModule, DtwoOptions, DtwoPage, DtwoPlugin, DtwoPluginTemplate, DtwoTemplate, GenerateAppOptions, HeadAugmentations, HookResult, ImportPresetWithDeprecation, ImportsOptions, LahmConfig, MetaObject, MetaObjectRaw, ModuleDefinition, ModuleMeta, ModuleOptions, PublicRuntimeConfig, ResolvedDtwoTemplate, RouterConfig, RouterConfigSerializable, RouterOptions, RuntimeConfig, RuntimeValue, ScanDir, TSReference, WatchEvent };