minimal-piral 0.15.0-beta.4411

package/app/index.d.ts

@@ -0,0 +1,1465 @@
+import * as React from 'react';
+import * as ReactRouter from 'react-router';
+
+declare module "minimal-piral" {
+  /**
+   * Defines the API accessible from pilets.
+   */
+  export interface PiletApi extends EventEmitter, PiletCustomApi, PiletCoreApi {
+    /**
+     * Gets the metadata of the current pilet.
+     */
+    meta: PiletMetadata;
+  }
+
+  /**
+   * The emitter for Piral app shell events.
+   */
+  export interface EventEmitter {
+    /**
+     * Attaches a new event listener.
+     * @param type The type of the event to listen for.
+     * @param callback The callback to trigger.
+     */
+    on<K extends keyof PiralEventMap>(type: K, callback: Listener<PiralEventMap[K]>): EventEmitter;
+    /**
+     * Detaches an existing event listener.
+     * @param type The type of the event to listen for.
+     * @param callback The callback to trigger.
+     */
+    off<K extends keyof PiralEventMap>(type: K, callback: Listener<PiralEventMap[K]>): EventEmitter;
+    /**
+     * Emits a new event with the given type.
+     * @param type The type of the event to emit.
+     * @param arg The payload of the event.
+     */
+    emit<K extends keyof PiralEventMap>(type: K, arg: PiralEventMap[K]): EventEmitter;
+  }
+
+  /**
+   * Custom Pilet API parts defined outside of piral-core.
+   */
+  export interface PiletCustomApi {}
+
+  /**
+   * Defines the Pilet API from piral-core.
+   * This interface will be consumed by pilet developers so that their pilet can interact with the piral instance.
+   */
+  export interface PiletCoreApi {
+    /**
+     * Gets a shared data value.
+     * @param name The name of the data to retrieve.
+     */
+    getData<TKey extends string>(name: TKey): SharedData[TKey];
+    /**
+     * Sets the data using a given name. The name needs to be used exclusively by the current pilet.
+     * Using the name occupied by another pilet will result in no change.
+     * @param name The name of the data to store.
+     * @param value The value of the data to store.
+     * @param options The optional configuration for storing this piece of data.
+     * @returns True if the data could be set, otherwise false.
+     */
+    setData<TKey extends string>(name: TKey, value: SharedData[TKey], options?: DataStoreOptions): boolean;
+    /**
+     * Registers a route for predefined page component.
+     * The route needs to be unique and can contain params.
+     * Params are following the path-to-regexp notation, e.g., :id for an id parameter.
+     * @param route The route to register.
+     * @param Component The component to render the page.
+     * @param meta The optional metadata to use.
+     */
+    registerPage(route: string, Component: AnyComponent<PageComponentProps>, meta?: PiralPageMeta): RegistrationDisposer;
+    /**
+     * Unregisters the page identified by the given route.
+     * @param route The route that was previously registered.
+     */
+    unregisterPage(route: string): void;
+    /**
+     * Registers an extension component with a predefined extension component.
+     * The name must refer to the extension slot.
+     * @param name The global name of the extension slot.
+     * @param Component The component to be rendered.
+     * @param defaults Optionally, sets the default values for the expected data.
+     */
+    registerExtension<TName>(name: TName extends string ? TName : string, Component: AnyExtensionComponent<TName>, defaults?: Partial<ExtensionParams<TName>>): RegistrationDisposer;
+    /**
+     * Unregisters a global extension component.
+     * Only previously registered extension components can be unregistered.
+     * @param name The name of the extension slot to unregister from.
+     * @param Component The registered extension component to unregister.
+     */
+    unregisterExtension<TName>(name: TName extends string ? TName : string, Component: AnyExtensionComponent<TName>): void;
+    /**
+     * React component for displaying extensions for a given name.
+     * @param props The extension's rendering props.
+     * @return The created React element.
+     */
+    Extension<TName>(props: ExtensionSlotProps<TName>): React.ReactElement | null;
+    /**
+     * Renders an extension in a plain DOM component.
+     * @param element The DOM element or shadow root as a container for rendering the extension.
+     * @param props The extension's rendering props.
+     * @return The disposer to clear the extension.
+     */
+    renderHtmlExtension<TName>(element: HTMLElement | ShadowRoot, props: ExtensionSlotProps<TName>): Disposable;
+  }
+
+  /**
+   * Describes the metadata of a pilet available in its API.
+   */
+  export interface PiletMetadata {
+    /**
+     * The name of the pilet, i.e., the package id.
+     */
+    name: string;
+    /**
+     * The version of the pilet. Should be semantically versioned.
+     */
+    version: string;
+    /**
+     * Provides the version of the specification for this pilet.
+     */
+    spec: string;
+    /**
+     * Provides some custom metadata for the pilet.
+     */
+    custom?: any;
+    /**
+     * Optionally indicates the global require reference, if any.
+     */
+    requireRef?: string;
+    /**
+     * Additional shared dependencies from the pilet.
+     */
+    dependencies: Record<string, string>;
+    /**
+     * Provides some configuration to be used in the pilet.
+     */
+    config: Record<string, any>;
+    /**
+     * The URL of the main script of the pilet.
+     */
+    link: string;
+    /**
+     * The base path to the pilet. Can be used to make resource requests
+     * and override the public path.
+     */
+    basePath: string;
+  }
+
+  /**
+   * Listener for Piral app shell events.
+   */
+  export interface Listener<T> {
+    (arg: T): void;
+  }
+
+  /**
+   * The map of known Piral app shell events.
+   */
+  export interface PiralEventMap extends PiralCustomEventMap {
+    "unload-pilet": PiralUnloadPiletEvent;
+    [custom: string]: any;
+    "store-data": PiralStoreDataEvent;
+  }
+
+  /**
+   * Defines the shape of the data store for storing shared data.
+   */
+  export interface SharedData<TValue = any> {
+    [key: string]: TValue;
+  }
+
+  /**
+   * Defines the options to be used for storing data.
+   */
+  export type DataStoreOptions = DataStoreTarget | CustomDataStoreOptions;
+
+  /**
+   * Possible shapes for a component.
+   */
+  export type AnyComponent<T> = React.ComponentType<T> | FirstParametersOf<ComponentConverters<T>>;
+
+  /**
+   * The props used by a page component.
+   */
+  export interface PageComponentProps<T = any, S = any> extends RouteBaseProps<T, S> {
+    /**
+     * The meta data registered with the page.
+     */
+    meta: PiralPageMeta;
+  }
+
+  /**
+   * The meta data registered for a page.
+   */
+  export interface PiralPageMeta extends PiralCustomPageMeta, PiralCustomPageMeta {}
+
+  /**
+   * The shape of an implicit unregister function.
+   */
+  export interface RegistrationDisposer {
+    (): void;
+  }
+
+  /**
+   * Shorthand for the definition of an extension component.
+   */
+  export type AnyExtensionComponent<TName> = TName extends keyof PiralExtensionSlotMap ? AnyComponent<ExtensionComponentProps<TName>> : TName extends string ? AnyComponent<ExtensionComponentProps<any>> : AnyComponent<ExtensionComponentProps<TName>>;
+
+  /**
+   * Gives the extension params shape for the given extension slot name.
+   */
+  export type ExtensionParams<TName> = TName extends keyof PiralExtensionSlotMap ? PiralExtensionSlotMap[TName] : TName extends string ? any : TName;
+
+  /**
+   * The props for defining an extension slot.
+   */
+  export type ExtensionSlotProps<TName = string> = BaseExtensionSlotProps<TName extends string ? TName : string, ExtensionParams<TName>>;
+
+  /**
+   * Can be implemented by functions to be used for disposal purposes.
+   */
+  export interface Disposable {
+    (): void;
+  }
+
+  /**
+   * Custom events defined outside of piral-core.
+   */
+  export interface PiralCustomEventMap {}
+
+  /**
+   * Gets fired when a pilet gets unloaded.
+   */
+  export interface PiralUnloadPiletEvent {
+    /**
+     * The name of the pilet to be unloaded.
+     */
+    name: string;
+  }
+
+  /**
+   * Gets fired when a data item gets stored in piral.
+   */
+  export interface PiralStoreDataEvent<TValue = any> {
+    /**
+     * The name of the item that was stored.
+     */
+    name: string;
+    /**
+     * The storage target of the item.
+     */
+    target: string;
+    /**
+     * The value that was stored.
+     */
+    value: TValue;
+    /**
+     * The owner of the item.
+     */
+    owner: string;
+    /**
+     * The expiration of the item.
+     */
+    expires: number;
+  }
+
+  /**
+   * Defines the potential targets when storing data.
+   */
+  export type DataStoreTarget = "memory" | "local" | "remote";
+
+  /**
+   * Defines the custom options for storing data.
+   */
+  export interface CustomDataStoreOptions {
+    /**
+     * The target data store. By default the data is only stored in memory.
+     */
+    target?: DataStoreTarget;
+    /**
+     * Optionally determines when the data expires.
+     */
+    expires?: "never" | Date | number;
+  }
+
+  export type FirstParametersOf<T> = {
+    [K in keyof T]: T[K] extends (arg: any) => any ? FirstParameter<T[K]> : never;
+  }[keyof T];
+
+  /**
+   * Mapping of available component converters.
+   */
+  export interface ComponentConverters<TProps> extends PiralCustomComponentConverters<TProps> {
+    /**
+     * Converts the HTML component to a framework-independent component.
+     * @param component The vanilla JavaScript component to be converted.
+     */
+    html(component: HtmlComponent<TProps>): ForeignComponent<TProps>;
+  }
+
+  /**
+   * The props that every registered page component obtains.
+   */
+  export interface RouteBaseProps<UrlParams = any, UrlState = any> extends ReactRouter.RouteComponentProps<UrlParams, {}, UrlState>, BaseComponentProps {}
+
+  /**
+   * Custom meta data to include for pages.
+   */
+  export interface PiralCustomPageMeta {}
+
+  /**
+   * The props of an extension component.
+   */
+  export interface ExtensionComponentProps<T> extends BaseComponentProps {
+    /**
+     * The provided parameters for showing the extension.
+     */
+    params: T extends keyof PiralExtensionSlotMap ? PiralExtensionSlotMap[T] : T extends string ? any : T;
+    /**
+     * The optional children to receive, if any.
+     */
+    children?: React.ReactNode;
+  }
+
+  /**
+   * The mapping of the existing (known) extension slots.
+   */
+  export interface PiralExtensionSlotMap extends PiralCustomExtensionSlotMap {}
+
+  /**
+   * The basic props for defining an extension slot.
+   */
+  export interface BaseExtensionSlotProps<TName, TParams> {
+    /**
+     * The children to transport, if any.
+     */
+    children?: React.ReactNode;
+    /**
+     * Defines what should be rendered when no components are available
+     * for the specified extension.
+     */
+    empty?(): React.ReactNode;
+    /**
+     * Determines if the `render` function should be called in case no
+     * components are available for the specified extension.
+     * 
+     * If true, `empty` will be called and returned from the slot.
+     * If false, `render` will be called with the result of calling `empty`.
+     * The result of calling `render` will then be returned from the slot.
+     */
+    emptySkipsRender?: boolean;
+    /**
+     * Defines the order of the components to render.
+     * May be more convient than using `render` w.r.t. ordering extensions
+     * by their supplied metadata.
+     * @param extensions The registered extensions.
+     * @returns The ordered extensions.
+     */
+    order?(extensions: Array<ExtensionRegistration>): Array<ExtensionRegistration>;
+    /**
+     * Defines how the provided nodes should be rendered.
+     * @param nodes The rendered extension nodes.
+     * @returns The rendered nodes, i.e., an ReactElement.
+     */
+    render?(nodes: Array<React.ReactNode>): React.ReactElement<any, any> | null;
+    /**
+     * The custom parameters for the given extension.
+     */
+    params?: TParams;
+    /**
+     * The name of the extension to render.
+     */
+    name: TName;
+  }
+
+  export type FirstParameter<T extends (arg: any) => any> = T extends (arg: infer P) => any ? P : never;
+
+  /**
+   * Custom component converters defined outside of piral-core.
+   */
+  export interface PiralCustomComponentConverters<TProps> {}
+
+  /**
+   * Definition of a vanilla JavaScript component.
+   */
+  export interface HtmlComponent<TProps> {
+    /**
+     * Renders a component into the provided element using the given props and context.
+     */
+    component: ForeignComponent<TProps>;
+    /**
+     * The type of the HTML component.
+     */
+    type: "html";
+  }
+
+  /**
+   * Generic definition of a framework-independent component.
+   */
+  export interface ForeignComponent<TProps> {
+    /**
+     * Called when the component is mounted.
+     * @param element The container hosting the element.
+     * @param props The props to transport.
+     * @param ctx The associated context.
+     * @param locals The local state of this component instance.
+     */
+    mount(element: HTMLElement, props: TProps, ctx: ComponentContext, locals: Record<string, any>): void;
+    /**
+     * Called when the component should be updated.
+     * @param element The container hosting the element.
+     * @param props The props to transport.
+     * @param ctx The associated context.
+     * @param locals The local state of this component instance.
+     */
+    update?(element: HTMLElement, props: TProps, ctx: ComponentContext, locals: Record<string, any>): void;
+    /**
+     * Called when a component is unmounted.
+     * @param element The container that was hosting the element.
+     * @param locals The local state of this component instance.
+     */
+    unmount?(element: HTMLElement, locals: Record<string, any>): void;
+  }
+
+  /**
+   * The props that every registered component obtains.
+   */
+  export interface BaseComponentProps {
+    /**
+     * The currently used pilet API.
+     */
+    piral: PiletApi;
+  }
+
+  /**
+   * Custom extension slots outside of piral-core.
+   */
+  export interface PiralCustomExtensionSlotMap {}
+
+  /**
+   * The interface modeling the registration of a pilet extension component.
+   */
+  export interface ExtensionRegistration extends BaseRegistration {
+    /**
+     * The wrapped registered extension component.
+     */
+    component: WrappedComponent<ExtensionComponentProps<string>>;
+    /**
+     * The original extension component that has been registered.
+     */
+    reference: any;
+    /**
+     * The default params (i.e., meta) of the extension.
+     */
+    defaults: any;
+  }
+
+  /**
+   * The context to be transported into the generic components.
+   */
+  export interface ComponentContext {
+    router: ReactRouter.RouteComponentProps;
+    readState: PiralActions["readState"];
+  }
+
+  /**
+   * The base type for pilet component registration in the global state context.
+   */
+  export interface BaseRegistration {
+    /**
+     * The pilet registering the component.
+     */
+    pilet: string;
+  }
+
+  export type WrappedComponent<TProps> = React.ComponentType<React.PropsWithChildren<Without<TProps, keyof BaseComponentProps>>>;
+
+  /**
+   * The globally defined actions.
+   */
+  export interface PiralActions extends PiralCustomActions {
+    /**
+     * Initializes the application shell.
+     * @param loading The current loading state.
+     * @param error The application error, if any.
+     * @param modules The loaded pilets.
+     */
+    initialize(loading: boolean, error: Error | undefined, modules: Array<Pilet>): void;
+    /**
+     * Injects an evaluated pilet at runtime - removes the pilet from registry first if available.
+     * @param pilet The pilet to be injected.
+     * @returns The injected pilet.
+     */
+    injectPilet(pilet: Pilet): Pilet;
+    /**
+     * Adds a pilet at runtime by loading it, evaluating it, and then injecting it.
+     * @param pilet The pilet to be added.
+     * @returns The promise indicating when the pilet was fully added.
+     */
+    addPilet(pilet: PiletEntry): Promise<void>;
+    /**
+     * Removes a pilet by unloading it and deleting all component registrations.
+     * @param name The name of the pilet to remove.
+     */
+    removePilet(name: string): Promise<void>;
+    /**
+     * Defines a single action for Piral.
+     * @param actionName The name of the action to define.
+     * @param action The action to include.
+     */
+    defineAction<T extends keyof PiralActions>(actionName: T, action: PiralAction<PiralActions[T]>): void;
+    /**
+     * Defines a set of actions for Piral.
+     * @param actions The actions to define.
+     */
+    defineActions(actions: PiralDefineActions): void;
+    /**
+     * Reads the value of a shared data item.
+     * @param name The name of the shared item.
+     */
+    readDataValue(name: string): any;
+    /**
+     * Tries to write a shared data item. The write access is only
+     * possible if the name belongs to the provided owner or has not
+     * been taken yet.
+     * Setting the value to null will release it.
+     * @param name The name of the shared data item.
+     * @param value The value of the shared data item.
+     * @param owner The owner of the shared data item.
+     * @param target The target storage locatation.
+     * @param expiration The time for when to dispose the shared item.
+     */
+    tryWriteDataItem(name: string, value: any, owner: string, target: DataStoreTarget, expiration: number): boolean;
+    /**
+     * Registers a new route to be resolved.
+     * @param route The route to register.
+     * @param value The page to be rendered on the route.
+     */
+    registerPage(route: string, value: PageRegistration): void;
+    /**
+     * Unregisters an existing route.
+     * @param route The route to be removed.
+     */
+    unregisterPage(route: string): void;
+    /**
+     * Registers a new extension.
+     * @param name The name of the extension category.
+     * @param value The extension registration.
+     */
+    registerExtension(name: string, value: ExtensionRegistration): void;
+    /**
+     * Unregisters an existing extension.
+     * @param name The name of the extension category.
+     * @param value The extension that will be removed.
+     */
+    unregisterExtension(name: string, reference: any): void;
+    /**
+     * Sets the common component to render.
+     * @param name The name of the component.
+     * @param component The component to use for rendering.
+     */
+    setComponent<TKey extends keyof ComponentsState>(name: TKey, component: ComponentsState[TKey]): void;
+    /**
+     * Sets the error component to render.
+     * @param type The type of the error.
+     * @param component The component to use for rendering.
+     */
+    setErrorComponent<TKey extends keyof ErrorComponentsState>(type: TKey, component: ErrorComponentsState[TKey]): void;
+    /**
+     * Sets the common routes to render.
+     * @param path The name of the component.
+     * @param component The component to use for rendering.
+     */
+    setRoute<T = {}>(path: string, component: React.ComponentType<ReactRouter.RouteComponentProps<T>>): void;
+    /**
+     * Includes a new provider as a sub-provider to the current provider.
+     * @param provider The provider to include.
+     */
+    includeProvider(provider: JSX.Element): void;
+    /**
+     * Destroys (i.e., resets) the given portal instance.
+     * @param id The id of the portal to destroy.
+     */
+    destroyPortal(id: string): void;
+    /**
+     * Includes the provided portal in the rendering pipeline.
+     * @param id The id of the portal to use.
+     * @param entry The child to render.
+     */
+    showPortal(id: string, entry: React.ReactPortal): void;
+    /**
+     * Hides the provided portal in the rendering pipeline.
+     * @param id The id of the portal to use.
+     * @param entry The child to remove.
+     */
+    hidePortal(id: string, entry: React.ReactPortal): void;
+    /**
+     * Updates the provided portal in the rendering pipeline.
+     * @param id The id of the portal to use.
+     * @param current The currently displayed child.
+     * @param next The updated child that should be displayed.
+     */
+    updatePortal(id: string, current: React.ReactPortal, next: React.ReactPortal): void;
+    /**
+     * Dispatches a state change.
+     * @param update The update function creating a new state.
+     */
+    dispatch(update: (state: GlobalState) => GlobalState): void;
+    /**
+     * Reads the selected part of the global state.
+     * @param select The selector for getting the desired part.
+     * @returns The desired part.
+     */
+    readState<S>(select: (state: GlobalState) => S): S;
+    /**
+     * Performs a navigation.
+     * @param path The path to navigate to.
+     * @param state The optional state for the navigation.
+     */
+    navigate(path: string, state?: any): void;
+  }
+
+  export type Without<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+  /**
+   * Custom actions defined outside of piral-core.
+   */
+  export interface PiralCustomActions {}
+
+  /**
+   * An evaluated pilet, i.e., a full pilet: functionality and metadata.
+   */
+  export type Pilet = SinglePilet | MultiPilet;
+
+  /**
+   * Pilet entry representing part of a response from the feed service.
+   */
+  export type PiletEntry = MultiPiletEntry | SinglePiletEntry;
+
+  /**
+   * The shape of an app action in Piral.
+   */
+  export interface PiralAction<T extends (...args: any) => any> {
+    (ctx: GlobalStateContext, ...args: Parameters<T>): ReturnType<T>;
+  }
+
+  /**
+   * A subset of the available app actions in Piral.
+   */
+  export type PiralDefineActions = Partial<{
+    [P in keyof PiralActions]: PiralAction<PiralActions[P]>;
+  }>;
+
+  /**
+   * The interface modeling the registration of a pilet page component.
+   */
+  export interface PageRegistration extends BaseRegistration {
+    /**
+     * The registered page component.
+     */
+    component: WrappedComponent<PageComponentProps>;
+    /**
+     * The page's associated metadata.
+     */
+    meta: PiralPageMeta;
+  }
+
+  /**
+   * The Piral global app sub-state container for shared components.
+   */
+  export interface ComponentsState extends PiralCustomComponentsState {
+    /**
+     * The loading indicator renderer.
+     */
+    LoadingIndicator: React.ComponentType<LoadingIndicatorProps>;
+    /**
+     * The error renderer.
+     */
+    ErrorInfo: React.ComponentType<ErrorInfoProps>;
+    /**
+     * The router context.
+     */
+    Router: React.ComponentType<RouterProps>;
+    /**
+     * The layout used for pages.
+     */
+    Layout: React.ComponentType<LayoutProps>;
+    /**
+     * The route switch used for determining the route registration.
+     */
+    RouteSwitch: React.ComponentType<RouteSwitchProps>;
+    /**
+     * A component that can be used for debugging purposes.
+     */
+    Debug?: React.ComponentType;
+  }
+
+  export type ErrorComponentsState = {
+    [P in keyof Errors]?: React.ComponentType<Errors[P]>;
+  };
+
+  /**
+   * The Piral global app state container.
+   */
+  export interface GlobalState extends PiralCustomState {
+    /**
+     * The relevant state for the app itself.
+     */
+    app: AppState;
+    /**
+     * The relevant state for rendering errors of the app.
+     */
+    errorComponents: ErrorComponentsState;
+    /**
+     * The relevant state for rendering parts of the app.
+     */
+    components: ComponentsState;
+    /**
+     * The relevant state for the registered components.
+     */
+    registry: RegistryState;
+    /**
+     * Gets the loaded modules.
+     */
+    modules: Array<Pilet>;
+    /**
+     * The foreign component portals to render.
+     */
+    portals: Record<string, Array<React.ReactPortal>>;
+    /**
+     * The application's shared data.
+     */
+    data: Dict<SharedDataItem>;
+    /**
+     * The used (exact) application routes.
+     */
+    routes: Dict<React.ComponentType<ReactRouter.RouteComponentProps<any>>>;
+    /**
+     * The current provider.
+     */
+    provider?: React.ComponentType;
+  }
+
+  /**
+   * An evaluated single pilet.
+   */
+  export type SinglePilet = SinglePiletApp & PiletMetadata;
+
+  /**
+   * An evaluated multi pilet.
+   */
+  export type MultiPilet = MultiPiletApp & PiletMetadata;
+
+  /**
+   * The metadata response for a multi pilet.
+   */
+  export type MultiPiletEntry = PiletBundleEntry;
+
+  /**
+   * The metadata response for a single pilet.
+   */
+  export type SinglePiletEntry = PiletV0Entry | PiletV1Entry | PiletV2Entry | PiletVxEntry;
+
+  /**
+   * The Piral app instance context.
+   */
+  export interface GlobalStateContext extends PiralActions, EventEmitter {
+    /**
+     * The global state context atom.
+     * Changes to the state should always be dispatched via the `dispatch` action.
+     */
+    state: UseBoundStore<GlobalState>;
+    /**
+     * The API objects created for the loaded pilets.
+     */
+    apis: PiletsBag;
+    /**
+     * The available component converters.
+     */
+    converters: ComponentConverters<any>;
+    /**
+     * The initial options.
+     */
+    options: LoadPiletsOptions;
+  }
+
+  /**
+   * Custom parts of the global custom component state defined outside of piral-core.
+   */
+  export interface PiralCustomComponentsState {}
+
+  /**
+   * The props of a Loading indicator component.
+   */
+  export interface LoadingIndicatorProps {}
+
+  /**
+   * The props for the ErrorInfo component.
+   */
+  export type ErrorInfoProps = UnionOf<Errors>;
+
+  /**
+   * The props of a Router component.
+   */
+  export interface RouterProps {
+    /**
+     * The content to be rendered inside the router.
+     */
+    children?: React.ReactNode;
+  }
+
+  /**
+   * The props of a Layout component.
+   */
+  export interface LayoutProps {
+    /**
+     * The currently selected layout type.
+     */
+    currentLayout: LayoutType;
+    /**
+     * The page's content.
+     */
+    children: React.ReactNode;
+  }
+
+  /**
+   * The props of the RouteSwitch component.
+   */
+  export interface RouteSwitchProps extends ReactRouter.SwitchProps {
+    /**
+     * The component that should be used in case nothing was found.
+     */
+    NotFound: React.ComponentType<ReactRouter.RouteComponentProps>;
+    /**
+     * The component to register for the different paths.
+     */
+    paths: Array<AppPath>;
+  }
+
+  /**
+   * Map of all error types to their respective props.
+   */
+  export interface Errors extends PiralCustomErrors {
+    /**
+     * The props type for an extension error.
+     */
+    extension: ExtensionErrorInfoProps;
+    /**
+     * The props type for a loading error.
+     */
+    loading: LoadingErrorInfoProps;
+    /**
+     * The props type for a page error.
+     */
+    page: PageErrorInfoProps;
+    /**
+     * The props type for a not found error.
+     */
+    not_found: NotFoundErrorInfoProps;
+    /**
+     * The props type for an unknown error.
+     */
+    unknown: UnknownErrorInfoProps;
+  }
+
+  /**
+   * Custom state extensions defined outside of piral-core.
+   */
+  export interface PiralCustomState {}
+
+  /**
+   * The Piral global app sub-state container for app information.
+   */
+  export interface AppState {
+    /**
+     * Gets if the application is currently performing a background loading
+     * activity, e.g., for loading modules asynchronously or fetching
+     * translations.
+     */
+    loading: boolean;
+    /**
+     * Gets an unrecoverable application error, if any.
+     */
+    error: Error | undefined;
+    /**
+     * Gets the public path of the application.
+     */
+    publicPath: string;
+  }
+
+  /**
+   * The Piral global app sub-state container for component registrations.
+   */
+  export interface RegistryState extends PiralCustomRegistryState {
+    /**
+     * The registered page components for the router.
+     */
+    pages: Dict<PageRegistration>;
+    /**
+     * The registered extension components for extension slots.
+     */
+    extensions: Dict<Array<ExtensionRegistration>>;
+    /**
+     * The registered wrappers for any component.
+     */
+    wrappers: Dict<React.ComponentType<any>>;
+  }
+
+  export type Dict<T> = Record<string, T>;
+
+  /**
+   * Defines the shape of a shared data item.
+   */
+  export interface SharedDataItem<TValue = any> {
+    /**
+     * Gets the associated value.
+     */
+    value: TValue;
+    /**
+     * Gets the owner of the item.
+     */
+    owner: string;
+    /**
+     * Gets the storage location.
+     */
+    target: DataStoreTarget;
+    /**
+     * Gets the expiration of the item.
+     */
+    expires: number;
+  }
+
+  /**
+   * The pilet app, i.e., the functional exports.
+   */
+  export interface SinglePiletApp {
+    /**
+     * Integrates the evaluated pilet into the application.
+     * @param api The API to access the application.
+     */
+    setup(api: PiletApi): void | Promise<void>;
+    /**
+     * Optional function for cleanup.
+     * @param api The API to access the application.
+     */
+    teardown?(api: PiletApi): void;
+  }
+
+  /**
+   * The pilet app, i.e., the functional exports.
+   */
+  export interface MultiPiletApp {
+    /**
+     * Integrates the evaluated pilet into the application.
+     * @param api The API to access the application.
+     */
+    setup(apiFactory: PiletApiCreator): void | Promise<void>;
+  }
+
+  /**
+   * Metadata for pilets using the bundle schema.
+   */
+  export interface PiletBundleEntry {
+    /**
+     * The name of the bundle pilet, i.e., the package id.
+     */
+    name?: string;
+    /**
+     * Optionally provides the version of the specification for this pilet.
+     */
+    spec?: "v1";
+    /**
+     * The link for retrieving the bundle content of the pilet.
+     */
+    link: string;
+    /**
+     * The reference name for the global bundle-shared require.
+     */
+    bundle: string;
+    /**
+     * The computed integrity of the pilet. Will be used to set the
+     * integrity value of the script.
+     */
+    integrity?: string;
+    /**
+     * Optionally provides some custom metadata for the pilet.
+     */
+    custom?: any;
+    /**
+     * Additional shared dependency script files.
+     */
+    dependencies?: Record<string, string>;
+  }
+
+  /**
+   * Metadata for pilets using the v0 schema.
+   */
+  export type PiletV0Entry = PiletV0ContentEntry | PiletV0LinkEntry;
+
+  /**
+   * Metadata for pilets using the v1 schema.
+   */
+  export interface PiletV1Entry {
+    /**
+     * The name of the pilet, i.e., the package id.
+     */
+    name: string;
+    /**
+     * The version of the pilet. Should be semantically versioned.
+     */
+    version: string;
+    /**
+     * Optionally provides the version of the specification for this pilet.
+     */
+    spec?: "v1";
+    /**
+     * The link for retrieving the content of the pilet.
+     */
+    link: string;
+    /**
+     * The reference name for the global require.
+     */
+    requireRef: string;
+    /**
+     * The computed integrity of the pilet. Will be used to set the
+     * integrity value of the script.
+     */
+    integrity?: string;
+    /**
+     * Optionally provides some custom metadata for the pilet.
+     */
+    custom?: any;
+    /**
+     * Optionally provides some configuration to be used in the pilet.
+     */
+    config?: Record<string, any>;
+    /**
+     * Additional shared dependency script files.
+     */
+    dependencies?: Record<string, string>;
+  }
+
+  /**
+   * Metadata for pilets using the v2 schema.
+   */
+  export interface PiletV2Entry {
+    /**
+     * The name of the pilet, i.e., the package id.
+     */
+    name: string;
+    /**
+     * The version of the pilet. Should be semantically versioned.
+     */
+    version: string;
+    /**
+     * Provides the version of the specification for this pilet.
+     */
+    spec: "v2";
+    /**
+     * The reference name for the global require.
+     */
+    requireRef: string;
+    /**
+     * The computed integrity of the pilet.
+     */
+    integrity?: string;
+    /**
+     * The link for retrieving the content of the pilet.
+     */
+    link: string;
+    /**
+     * Optionally provides some custom metadata for the pilet.
+     */
+    custom?: any;
+    /**
+     * Optionally provides some configuration to be used in the pilet.
+     */
+    config?: Record<string, any>;
+    /**
+     * Additional shared dependency script files.
+     */
+    dependencies?: Record<string, string>;
+  }
+
+  export interface PiletVxEntry {
+    /**
+     * The name of the pilet, i.e., the package id.
+     */
+    name: string;
+    /**
+     * The version of the pilet. Should be semantically versioned.
+     */
+    version: string;
+    /**
+     * Provides an identifier for the custom specification.
+     */
+    spec: string;
+    /**
+     * Optionally provides some custom metadata for the pilet.
+     */
+    custom?: any;
+    /**
+     * Optionally provides some configuration to be used in the pilet.
+     */
+    config?: Record<string, any>;
+    /**
+     * Additional shared dependency script files.
+     */
+    dependencies?: Record<string, string>;
+  }
+
+  export type UseBoundStore<T extends State, CustomStoreApi extends StoreApi<T> = StoreApi<T>> = {
+    (): T;
+    <U>(selector: StateSelector<T, U>, equalityFn?: EqualityChecker<U>): U;
+  } & CustomStoreApi;
+
+  /**
+   * Represents the dictionary of the loaded pilets and their APIs.
+   */
+  export interface PiletsBag {
+    [name: string]: PiletApi;
+  }
+
+  /**
+   * The options for loading pilets.
+   */
+  export interface LoadPiletsOptions {
+    /**
+     * The callback function for creating an API object.
+     * The API object is passed on to a specific pilet.
+     */
+    createApi: PiletApiCreator;
+    /**
+     * The callback for fetching the dynamic pilets.
+     */
+    fetchPilets: PiletRequester;
+    /**
+     * Optionally, some already existing evaluated pilets, e.g.,
+     * helpful when debugging or in SSR scenarios.
+     */
+    pilets?: Array<Pilet>;
+    /**
+     * Optionally, configures the default loader.
+     */
+    config?: DefaultLoaderConfig;
+    /**
+     * Optionally, defines the default way how to load a pilet.
+     */
+    loadPilet?: PiletLoader;
+    /**
+     * Optionally, defines loaders for custom specifications.
+     */
+    loaders?: CustomSpecLoaders;
+    /**
+     * Optionally, defines a set of loading hooks to be used.
+     */
+    hooks?: PiletLifecycleHooks;
+    /**
+     * Gets the map of globally available dependencies with their names
+     * as keys and their evaluated pilet content as value.
+     */
+    dependencies?: AvailableDependencies;
+    /**
+     * Optionally, defines the loading strategy to use.
+     */
+    strategy?: PiletLoadingStrategy;
+  }
+
+  export type UnionOf<T> = {
+    [K in keyof T]: T[K];
+  }[keyof T];
+
+  /**
+   * The different known layout types.
+   */
+  export type LayoutType = "mobile" | "tablet" | "desktop";
+
+  /**
+   * Represents a path in the app registration.
+   */
+  export interface AppPath {
+    /**
+     * The exact path to use.
+     */
+    path: string;
+    /**
+     * The component to register for this path.
+     */
+    Component: React.ComponentType<ReactRouter.RouteComponentProps>;
+  }
+
+  /**
+   * Custom errors defined outside of piral-core.
+   */
+  export interface PiralCustomErrors {}
+
+  /**
+   * The error used when a registered extension component crashed.
+   */
+  export interface ExtensionErrorInfoProps {
+    /**
+     * The type of the error.
+     */
+    type: "extension";
+    /**
+     * The provided error details.
+     */
+    error: any;
+    /**
+     * The name of the pilet emitting the error.
+     */
+    pilet?: string;
+  }
+
+  /**
+   * The error used when the app could not be loaded.
+   */
+  export interface LoadingErrorInfoProps {
+    /**
+     * The type of the error.
+     */
+    type: "loading";
+    /**
+     * The provided error details.
+     */
+    error: any;
+  }
+
+  /**
+   * The error used when a registered page component crashes.
+   */
+  export interface PageErrorInfoProps extends ReactRouter.RouteComponentProps {
+    /**
+     * The type of the error.
+     */
+    type: "page";
+    /**
+     * The provided error details.
+     */
+    error: any;
+    /**
+     * The name of the pilet emitting the error.
+     */
+    pilet?: string;
+  }
+
+  /**
+   * The error used when a route cannot be resolved.
+   */
+  export interface NotFoundErrorInfoProps extends ReactRouter.RouteComponentProps {
+    /**
+     * The type of the error.
+     */
+    type: "not_found";
+  }
+
+  /**
+   * The error used when the exact type is unknown.
+   */
+  export interface UnknownErrorInfoProps {
+    /**
+     * The type of the error.
+     */
+    type: "unknown";
+    /**
+     * The provided error details.
+     */
+    error: any;
+    /**
+     * The name of the pilet emitting the error.
+     */
+    pilet?: string;
+  }
+
+  /**
+   * Custom parts of the global registry state defined outside of piral-core.
+   */
+  export interface PiralCustomRegistryState {}
+
+  /**
+   * The creator function for the pilet API.
+   */
+  export interface PiletApiCreator {
+    (target: PiletMetadata): PiletApi;
+  }
+
+  /**
+   * Metadata for pilets using the v0 schema with a content.
+   */
+  export interface PiletV0ContentEntry extends PiletV0BaseEntry {
+    /**
+     * The content of the pilet. If the content is not available
+     * the link will be used (unless caching has been activated).
+     */
+    content: string;
+    /**
+     * If available indicates that the pilet should not be cached.
+     * In case of a string this is interpreted as the expiration time
+     * of the cache. In case of an accurate hash this should not be
+     * required or set.
+     */
+    noCache?: boolean | string;
+  }
+
+  /**
+   * Metadata for pilets using the v0 schema with a link.
+   */
+  export interface PiletV0LinkEntry extends PiletV0BaseEntry {
+    /**
+     * The link for retrieving the content of the pilet.
+     */
+    link: string;
+  }
+
+  export type StateSelector<T extends State, U> = (state: T) => U;
+
+  export type EqualityChecker<T> = (state: T, newState: T) => boolean;
+
+  export type State = object;
+
+  export type StoreApi<T extends State> = {
+    setState: SetState<T>;
+    getState: GetState<T>;
+    subscribe: Subscribe<T>;
+    destroy: Destroy;
+  };
+
+  /**
+   * The interface describing a function capable of fetching pilets.
+   */
+  export interface PiletRequester {
+    (): Promise<PiletEntries>;
+  }
+
+  /**
+   * Additional configuration options for the default loader.
+   */
+  export interface DefaultLoaderConfig {
+    /**
+     * Sets the cross-origin attribute of potential script tags.
+     * For pilets v1 this may be useful. Otherwise, only pilets that
+     * have an integrity defined will be set to "anonymous".
+     */
+    crossOrigin?: string;
+  }
+
+  /**
+   * The callback to be used to load a single pilet.
+   */
+  export interface PiletLoader {
+    (entry: PiletEntry): Promise<Pilet>;
+  }
+
+  /**
+   * Defines the spec identifiers for custom loading.
+   */
+  export type CustomSpecLoaders = Record<string, PiletLoader>;
+
+  /**
+   * A set of pipeline hooks used by the Piral loading orchestrator.
+   */
+  export interface PiletLifecycleHooks {
+    /**
+     * Hook fired before a pilet is loaded.
+     */
+    loadPilet?(pilet: PiletMetadata): void;
+    /**
+     * Hook fired before a pilet is being set up.
+     */
+    setupPilet?(pilet: Pilet): void;
+    /**
+     * Hook fired before a pilet is being cleaned up.
+     */
+    cleanupPilet?(pilet: Pilet): void;
+  }
+
+  /**
+   * The record containing all available dependencies.
+   */
+  export interface AvailableDependencies {
+    [name: string]: any;
+  }
+
+  /**
+   * The strategy for how pilets are loaded at runtime.
+   */
+  export interface PiletLoadingStrategy {
+    (options: LoadPiletsOptions, pilets: PiletsLoaded): PromiseLike<void>;
+  }
+
+  /**
+   * Basic metadata for pilets using the v0 schema.
+   */
+  export interface PiletV0BaseEntry {
+    /**
+     * The name of the pilet, i.e., the package id.
+     */
+    name: string;
+    /**
+     * The version of the pilet. Should be semantically versioned.
+     */
+    version: string;
+    /**
+     * Optionally provides the version of the specification for this pilet.
+     */
+    spec?: "v0";
+    /**
+     * The computed hash value of the pilet's content. Should be
+     * accurate to allow caching.
+     */
+    hash: string;
+    /**
+     * Optionally provides some custom metadata for the pilet.
+     */
+    custom?: any;
+    /**
+     * Optionally provides some configuration to be used in the pilet.
+     */
+    config?: Record<string, any>;
+    /**
+     * Additional shared dependency script files.
+     */
+    dependencies?: Record<string, string>;
+  }
+
+  export type SetState<T extends State> = {
+    <K1 extends keyof T, K2 extends keyof T = K1, K3 extends keyof T = K2, K4 extends keyof T = K3>(partial: PartialState<T, K1, K2, K3, K4>, replace?: boolean): void;
+  };
+
+  export type GetState<T extends State> = () => T;
+
+  export type Subscribe<T extends State> = {
+    (listener: StateListener<T>): () => void;
+    <StateSlice>(listener: StateSliceListener<StateSlice>, selector?: StateSelector<T, StateSlice>, equalityFn?: EqualityChecker<StateSlice>): () => void;
+  };
+
+  export type Destroy = () => void;
+
+  /**
+   * The entries representing pilets from a feed service response.
+   */
+  export type PiletEntries = Array<PiletEntry>;
+
+  /**
+   * The callback to be used when pilets have been loaded.
+   */
+  export interface PiletsLoaded {
+    (error: Error | undefined, pilets: Array<Pilet>): void;
+  }
+
+  /**
+   * @deprecated Use the builtin `Partial<T>` instead of `PartialState<T>`.
+   * Additionally turn on `--exactOptionalPropertyTypes` tsc flag.
+   * `PartialState` will be removed in next major
+   */
+  export type PartialState<T extends State, K1 extends keyof T = keyof T, K2 extends keyof T = K1, K3 extends keyof T = K2, K4 extends keyof T = K3> = (Pick<T, K1> | Pick<T, K2> | Pick<T, K3> | Pick<T, K4> | T) | ((state: T) => Pick<T, K1> | Pick<T, K2> | Pick<T, K3> | Pick<T, K4> | T);
+
+  export type StateListener<T> = (state: T, previousState: T) => void;
+
+  /**
+   * @deprecated Use `StateListener<T>` instead of `StateSliceListener<T>`.
+   */
+  export type StateSliceListener<T> = (slice: T, previousSlice: T) => void;
+}