@umbraco-cms/backoffice 1.0.0-next.37dcc47c → 1.0.0-next.386e13e7

package/modal.d.ts

@@ -1,20 +1,129 @@
 import * as rxjs from 'rxjs';
-import * as lit_html from 'lit-html';
+import { Observable } from 'rxjs';
 import * as lit from 'lit';
-import { LitElement } from 'lit';
-import { UUIModalSidebarElement, UUIModalSidebarSize } from '@umbraco-ui/uui-modal-sidebar';
-import { UUIModalDialogElement } from '@umbraco-ui/uui-modal-dialog';
-import { UmbControllerHostInterface } from './controller';
-import { UmbContextToken } from './context-api';
+import { LitElement, TemplateResult } from 'lit';
+import * as lit_html from 'lit-html';
+import { UUIModalDialogElement, UUIModalSidebarElement, UUIModalSidebarSize } from '@umbraco-ui/uui';
+import { UmbController, UmbControllerHostElement, UmbControllerInterface } from '@umbraco-cms/backoffice/controller-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { Params as Params$1 } from '@umbraco-cms/backoffice/router';
+import { UmbModalToken as UmbModalToken$1, UmbModalConfig as UmbModalConfig$1, UmbTreePickerModalData as UmbTreePickerModalData$1, UmbPickerModalResult as UmbPickerModalResult$1, UmbPickerModalData as UmbPickerModalData$1 } from '@umbraco-cms/backoffice/modal';
+import { DocumentTreeItemResponseModel, EntityTreeItemResponseModel, LanguageResponseModel, ContentTreeItemResponseModel, PropertyTypeResponseModelBaseModel, UserResponseModel, FolderReponseModel, FolderTreeItemResponseModel } from '@umbraco-cms/backoffice/backend-api';
+
+interface IRouterSlot<D = any, P = any> extends HTMLElement {
+    readonly route: IRoute<D> | null;
+    readonly isRoot: boolean;
+    readonly fragments: IPathFragments | null;
+    readonly params: Params | null;
+    readonly match: IRouteMatch<D> | null;
+    routes: IRoute<D>[];
+    add: ((routes: IRoute<D>[], navigate?: boolean) => void);
+    clear: (() => void);
+    render: (() => Promise<void>);
+    constructAbsolutePath: ((path: PathFragment) => string);
+    parent: IRouterSlot<P> | null | undefined;
+    queryParentRouterSlot: (() => IRouterSlot<P> | null);
+}
+type IRoutingInfo<D = any, P = any> = {
+    slot: IRouterSlot<D, P>;
+    match: IRouteMatch<D>;
+};
+type CustomResolver<D = any, P = any> = ((info: IRoutingInfo<D>) => boolean | void | Promise<boolean> | Promise<void>);
+type Guard<D = any, P = any> = ((info: IRoutingInfo<D, P>) => boolean | Promise<boolean>);
+type PageComponent = HTMLElement | undefined;
+type ModuleResolver = Promise<{
+    default: any;
+}>;
+type Class<T extends PageComponent = PageComponent> = {
+    new (...args: any[]): T;
+};
+type Component = Class | ModuleResolver | PageComponent | (() => Class) | (() => PromiseLike<Class>) | (() => PageComponent) | (() => PromiseLike<PageComponent>) | (() => ModuleResolver) | (() => PromiseLike<ModuleResolver>);
+type Setup<D = any> = ((component: PageComponent, info: IRoutingInfo<D>) => void);
+type PathMatch = "prefix" | "suffix" | "full" | "fuzzy";
+/**
+ * The base route interface.
+ * D = the data type of the data
+ */
+interface IRouteBase<D = any> {
+    path: PathFragment;
+    data?: D;
+    guards?: Guard[];
+    pathMatch?: PathMatch;
+}
+/**
+ * Route type used for redirection.
+ */
+interface IRedirectRoute<D = any> extends IRouteBase<D> {
+    redirectTo: string;
+    preserveQuery?: boolean;
+}
+/**
+ * Route type used to resolve and stamp components.
+ */
+interface IComponentRoute<D = any> extends IRouteBase<D> {
+    component: Component | PromiseLike<Component>;
+    setup?: Setup;
+}
+/**
+ * Route type used to take control of how the route should resolve.
+ */
+interface IResolverRoute<D = any> extends IRouteBase<D> {
+    resolve: CustomResolver;
+}
+type IRoute<D = any> = IRedirectRoute<D> | IComponentRoute<D> | IResolverRoute<D>;
+type PathFragment = string;
+type IPathFragments = {
+    consumed: PathFragment;
+    rest: PathFragment;
+};
+interface IRouteMatch<D = any> {
+    route: IRoute<D>;
+    params: Params;
+    fragments: IPathFragments;
+    match: RegExpMatchArray;
+}
+type PushStateEvent = CustomEvent<null>;
+type ReplaceStateEvent = CustomEvent<null>;
+type ChangeStateEvent = CustomEvent<null>;
+type WillChangeStateEvent = CustomEvent<{
+    url?: string | null;
+    eventName: GlobalRouterEvent;
+}>;
+type NavigationStartEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationSuccessEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationCancelEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationErrorEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type NavigationEndEvent<D = any> = CustomEvent<IRoutingInfo<D>>;
+type Params = {
+    [key: string]: string;
+};
+/**
+ * History related events.
+ */
+type GlobalRouterEvent = "pushstate" | "replacestate" | "popstate" | "changestate" | "willchangestate" | "navigationstart" | "navigationcancel" | "navigationerror" | "navigationsuccess" | "navigationend";
+declare global {
+    interface GlobalEventHandlersEventMap {
+        "pushstate": PushStateEvent;
+        "replacestate": ReplaceStateEvent;
+        "popstate": PopStateEvent;
+        "changestate": ChangeStateEvent;
+        "navigationstart": NavigationStartEvent;
+        "navigationend": NavigationEndEvent;
+        "navigationsuccess": NavigationSuccessEvent;
+        "navigationcancel": NavigationCancelEvent;
+        "navigationerror": NavigationErrorEvent;
+        "willchangestate": WillChangeStateEvent;
+    }
+}
 
 declare class UmbSearchModalElement extends LitElement {
     #private;
-    static styles: lit.CSSResult[];
     private _input;
     private _search;
     private _groups;
     connectedCallback(): void;
     render(): lit_html.TemplateResult<1>;
+    static styles: lit.CSSResult[];
 }
 
 declare global {
@@ -23,38 +132,36 @@ declare global {
     }
 }
 
-declare class UmbModalToken<Data = unknown, Result = unknown> {
+declare class UmbModalToken<ModalDataType extends object = object, ModalResultType = unknown> {
     protected alias: string;
     protected defaultConfig?: UmbModalConfig | undefined;
-    protected _desc?: string | undefined;
+    protected defaultData?: ModalDataType | undefined;
     /**
      * Get the data type of the token's data.
      *
      * @public
-     * @type      {Data}
+     * @type      {ModalDataType}
      * @memberOf  UmbModalToken
      * @example   `typeof MyModal.TYPE`
      * @returns   undefined
      */
-    readonly DATA: Data;
+    readonly DATA: ModalDataType;
     /**
      * Get the result type of the token
      *
      * @public
-     * @type      {Result}
+     * @type      {ModalResultType}
      * @memberOf  UmbModalToken
      * @example   `typeof MyModal.RESULT`
      * @returns   undefined
      */
-    readonly RESULT: Result;
+    readonly RESULT: ModalResultType;
     /**
      * @param alias   Unique identifier for the token,
      * @param defaultConfig  Default configuration for the modal,
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
+     * @param defaultData  Default data for the modal,
      */
-    constructor(alias: string, defaultConfig?: UmbModalConfig | undefined, _desc?: string | undefined);
+    constructor(alias: string, defaultConfig?: UmbModalConfig | undefined, defaultData?: ModalDataType | undefined);
     /**
      * This method must always return the unique alias of the token since that
      * will be used to look up the token in the injector.
@@ -63,12 +170,13 @@ declare class UmbModalToken<Data = unknown, Result = unknown> {
      */
     toString(): string;
     getDefaultConfig(): UmbModalConfig | undefined;
+    getDefaultData(): ModalDataType | undefined;
 }
 
 /**
  * Type which omits the real submit method, and replaces it with a submit method which accepts an optional argument depending on the generic type.
  */
-type UmbModalHandler<ModalData = unknown, ModalResult = unknown> = Omit<UmbModalHandlerClass<ModalData, ModalResult>, 'submit'> & OptionalSubmitArgumentIfUndefined<ModalResult>;
+type UmbModalHandler<ModalData extends object = object, ModalResult = any> = Omit<UmbModalHandlerClass<ModalData, ModalResult>, 'submit'> & OptionalSubmitArgumentIfUndefined<ModalResult>;
 type OptionalSubmitArgumentIfUndefined<T> = T extends undefined ? {
     submit: () => void;
 } : T extends unknown ? {
@@ -76,20 +184,24 @@ type OptionalSubmitArgumentIfUndefined<T> = T extends undefined ? {
 } : {
     submit: (arg: T) => void;
 };
-declare class UmbModalHandlerClass<ModalData, ModalResult> {
+declare class UmbModalHandlerClass<ModalData extends object = object, ModalResult = unknown> extends UmbController {
     #private;
     private _submitPromise;
     private _submitResolver?;
     private _submitRejecter?;
     modalElement: UUIModalDialogElement | UUIModalSidebarElement;
-    readonly innerElement: rxjs.Observable<any>;
+    readonly innerElement: rxjs.Observable<HTMLElement | undefined>;
     key: string;
     type: UmbModalType;
     size: UUIModalSidebarSize;
-    constructor(host: UmbControllerHostInterface, modalAlias: string | UmbModalToken<ModalData, ModalResult>, data?: ModalData, config?: UmbModalConfig);
+    private modalAlias;
+    constructor(host: UmbControllerHostElement, router: IRouterSlot | null, modalAlias: string | UmbModalToken<ModalData, ModalResult>, data?: ModalData, config?: UmbModalConfig);
+    hostConnected(): void;
+    hostDisconnected(): void;
     private submit;
     reject(): void;
     onSubmit(): Promise<ModalResult>;
+    destroy(): void;
 }
 
 type UmbModalType = 'dialog' | 'sidebar';
@@ -100,9 +212,9 @@ interface UmbModalConfig {
 }
 declare class UmbModalContext {
     #private;
-    host: UmbControllerHostInterface;
-    readonly modals: rxjs.Observable<UmbModalHandler<any, any>[]>;
-    constructor(host: UmbControllerHostInterface);
+    host: UmbControllerHostElement;
+    readonly modals: rxjs.Observable<UmbModalHandler[]>;
+    constructor(host: UmbControllerHostElement);
     search(): UmbModalHandler<any, any>;
     /**
      * Opens a modal or sidebar modal
@@ -112,7 +224,7 @@ declare class UmbModalContext {
      * @return {*}  {UmbModalHandler}
      * @memberof UmbModalContext
      */
-    open<ModalData = unknown, ModalResult = unknown>(modalAlias: string | UmbModalToken<ModalData, ModalResult>, data?: ModalData, config?: UmbModalConfig): UmbModalHandler<ModalData, ModalResult>;
+    open<ModalData extends object = object, ModalResult = unknown>(modalAlias: string | UmbModalToken<ModalData, ModalResult>, data?: ModalData, config?: UmbModalConfig, router?: IRouterSlot | null): UmbModalHandler<ModalData, ModalResult>;
     /**
      * Closes a modal or sidebar modal
      * @private
@@ -123,13 +235,352 @@ declare class UmbModalContext {
 }
 declare const UMB_MODAL_CONTEXT_TOKEN: UmbContextToken<UmbModalContext>;
 
-interface UmbPickerModalData<T> {
-    multiple: boolean;
+type UmbModalRouteBuilder = (params: {
+    [key: string]: string | number;
+} | null) => string;
+declare class UmbModalRouteRegistration<UmbModalTokenData extends object = object, UmbModalTokenResult = any> {
+    #private;
+    constructor(modalAlias: UmbModalToken<UmbModalTokenData, UmbModalTokenResult> | string, path?: string | null, modalConfig?: UmbModalConfig);
+    get key(): string;
+    get alias(): string | UmbModalToken<UmbModalTokenData, UmbModalTokenResult>;
+    generateModalPath(): string;
+    get path(): string | null;
+    protected _setPath(path: string | null): void;
+    get modalConfig(): UmbModalConfig | undefined;
+    /**
+     * Returns true if the modal is currently active.
+     */
+    get active(): boolean;
+    open(params: {
+        [key: string]: string | number;
+    }): void;
+    /**
+     * Returns the modal handler if the modal is currently active. Otherwise its undefined.
+     */
+    get modalHandler(): UmbModalHandler<UmbModalTokenData, UmbModalTokenResult> | undefined;
+    observeRouteBuilder(callback: (urlBuilder: UmbModalRouteBuilder) => void): this;
+    _internal_setRouteBuilder(urlBuilder: UmbModalRouteBuilder): void;
+    onSetup(callback: (routingInfo: Params$1) => UmbModalTokenData | false): this;
+    onSubmit(callback: (data: UmbModalTokenResult) => void): this;
+    onReject(callback: () => void): this;
+    routeSetup(router: IRouterSlot, modalContext: UmbModalContext, params: Params$1): UmbModalHandler<UmbModalTokenData, UmbModalTokenResult> | null | undefined;
+}
+
+declare class UmbModalRouteRegistrationController<D extends object = object, R = any> extends UmbModalRouteRegistration<D, R> implements UmbControllerInterface {
+    #private;
+    get unique(): undefined;
+    /**
+     * Creates an instance of UmbModalRouteRegistrationController.
+     * @param {EventTarget} host - The host element of the modal, this is used to identify the modal.
+     * @param {UmbModalToken} alias - The alias of the modal, this is used to identify the modal.
+     * @param {UmbModalConfig} modalConfig - The configuration of the modal.
+     * @memberof UmbModalRouteRegistrationController
+     */
+    constructor(host: UmbControllerHostElement, alias: UmbModalToken$1<D, R> | string, modalConfig?: UmbModalConfig$1);
+    /**
+     * Appends an additional path to the modal route.
+     *
+     * This can help specify the URL for this modal, or used to add a parameter to the URL like this: "/modal/my-modal/:index/"
+     * A folder name starting with a colon ":" will be interpreted as a parameter. Then this modal can open with any value in that location.
+     * When modal is being setup the value of the parameter can be read from the route params. See the example:
+     * @param additionalPath
+     * @returns UmbModalRouteRegistrationController
+     * @memberof UmbContextConsumer
+     * @example <caption>Example of adding an additional path to the modal route</caption>
+     * const modalRegistration = new UmbModalRouteRegistrationController(this, MY_MODAL_TOKEN)
+     * modalRegistration.addAdditionalPath(':index')
+     *
+     * modalRegistration.onSetup((params) => {
+     * 	const index = params.index;
+     *  // When entering the url of: "/modal/my-modal/hello-world/"
+     *  // Then index will be "hello-world"
+     * }
+     */
+    addAdditionalPath(additionalPath: string): this;
+    /**
+     * Registerer one or more additional paths to the modal route, similar to addAdditionalPath. But without defining the actual path name. This enables this to be asynchronously defined and even changed later.
+     * This can be useful if your modal has to be unique for this registration, avoiding collision with other registrations.
+     * If you made a modal for editing one of multiple property, then you can add a unique path holding the property id.
+     * Making the URL unique to this modal registration: /modal/my-modal/my-unique-value/
+     *
+     * Notice the modal will only be available when all unique paths have a value.
+     * @param {Array<string>} uniquePathNames
+     * @returns UmbModalRouteRegistrationController
+     * @memberof UmbContextConsumer
+     * @example <caption>Example of adding an additional unique path to the modal route</caption>
+     * const modalRegistration = new UmbModalRouteRegistrationController(this, MY_MODAL_TOKEN)
+     * modalRegistration.addUniquePaths(['myAliasForIdentifyingThisPartOfThePath'])
+     *
+     * // Later:
+     * modalRegistration.setUniquePathValue('myAliasForIdentifyingThisPartOfThePath', 'myValue');
+     */
+    addUniquePaths(uniquePathNames: Array<string>): this;
+    /**
+     * Set or change the value of a unique path part.
+     * @param {string} identifier
+     * @param {value | undefined} value
+     * @returns UmbModalRouteRegistrationController
+     * @memberof UmbContextConsumer
+     * @example <caption>Example of adding an additional unique path to the modal route</caption>
+     * const modalRegistration = new UmbModalRouteRegistrationController(this, MY_MODAL_TOKEN)
+     * modalRegistration.addUniquePaths(['first-one', 'another-one'])
+     *
+     * // Later:
+     * modalRegistration.setUniquePathValue('first-one', 'myValue');
+     */
+    setUniquePathValue(identifier: string, value: string | undefined): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    destroy(): void;
+}
+
+interface UmbAllowedDocumentTypesModalData {
+    id: string | null;
+}
+interface UmbAllowedDocumentTypesModalResult {
+    documentTypeKey: string;
+}
+declare const UMB_ALLOWED_DOCUMENT_TYPES_MODAL: UmbModalToken$1<UmbAllowedDocumentTypesModalData, UmbAllowedDocumentTypesModalResult>;
+
+interface UmbChangePasswordModalData {
+    requireOldPassword: boolean;
+}
+declare const UMB_CHANGE_PASSWORD_MODAL: UmbModalToken$1<UmbChangePasswordModalData, unknown>;
+
+interface UmbConfirmModalData {
+    headline: string;
+    content: TemplateResult | string;
+    color?: 'positive' | 'danger';
+    confirmLabel?: string;
+}
+type UmbConfirmModalResult = undefined;
+declare const UMB_CONFIRM_MODAL: UmbModalToken$1<UmbConfirmModalData, undefined>;
+
+interface UmbCreateDictionaryModalData {
+    unique: string | null;
+    parentName?: Observable<string | undefined>;
+}
+interface UmbCreateDictionaryModalResult {
+    name?: string;
+}
+declare const UMB_CREATE_DICTIONARY_MODAL: UmbModalToken$1<UmbCreateDictionaryModalData, UmbCreateDictionaryModalResult>;
+
+declare const UMB_CREATE_USER_MODAL: UmbModalToken$1<object, unknown>;
+
+declare const UMB_CURRENT_USER_MODAL: UmbModalToken$1<object, unknown>;
+
+interface UmbContextDebuggerModalData {
+    content: TemplateResult | string;
+}
+declare const UMB_CONTEXT_DEBUGGER_MODAL: UmbModalToken$1<UmbContextDebuggerModalData, unknown>;
+
+type UmbDocumentPickerModalData = UmbTreePickerModalData$1<DocumentTreeItemResponseModel>;
+type UmbDocumentPickerModalResult = UmbPickerModalResult$1;
+declare const UMB_DOCUMENT_PICKER_MODAL: UmbModalToken$1<UmbDocumentPickerModalData, UmbPickerModalResult$1>;
+
+type UmbDocumentTypePickerModalData = UmbTreePickerModalData$1<EntityTreeItemResponseModel>;
+type UmbDocumentTypePickerModalResult = UmbPickerModalResult$1;
+declare const UMB_DOCUMENT_TYPE_PICKER_MODAL: UmbModalToken$1<UmbDocumentTypePickerModalData, UmbPickerModalResult$1>;
+
+declare enum OEmbedStatus {
+    NotSupported = 0,
+    Error = 1,
+    Success = 2
+}
+interface UmbEmbeddedMediaDimensions {
+    width?: number;
+    height?: number;
+    constrain?: boolean;
+}
+interface UmbEmbeddedMediaModalData extends UmbEmbeddedMediaDimensions {
+    url?: string;
+}
+interface OEmbedResult extends UmbEmbeddedMediaDimensions {
+    oEmbedStatus: OEmbedStatus;
+    supportsDimensions: boolean;
+    markup?: string;
+}
+type UmbEmbeddedMediaModalResult = {
+    selection: OEmbedResult;
+};
+declare const UMB_EMBEDDED_MEDIA_MODAL: UmbModalToken$1<UmbEmbeddedMediaModalData, UmbEmbeddedMediaModalResult>;
+
+type UmbExamineFieldsSettingsModalData = Array<{
+    name: string;
+    exposed: boolean;
+}>;
+interface UmbCreateDocumentModalResultData {
+    fields?: UmbExamineFieldsSettingsModalData;
+}
+declare const UMB_EXAMINE_FIELDS_SETTINGS_MODAL: UmbModalToken$1<UmbExamineFieldsSettingsModalData, UmbCreateDocumentModalResultData>;
+
+interface UmbExportDictionaryModalData {
+    unique: string | null;
+}
+interface UmbExportDictionaryModalResult {
+    includeChildren?: boolean;
+}
+declare const UMB_EXPORT_DICTIONARY_MODAL: UmbModalToken$1<UmbExportDictionaryModalData, UmbExportDictionaryModalResult>;
+
+interface UmbIconPickerModalData {
+    color: string | undefined;
+    icon: string | undefined;
+}
+interface UmbIconPickerModalResult {
+    color: string | undefined;
+    icon: string | undefined;
+}
+declare const UMB_ICON_PICKER_MODAL: UmbModalToken$1<UmbIconPickerModalData, UmbIconPickerModalResult>;
+
+interface UmbImportDictionaryModalData {
+    unique: string | null;
+}
+interface UmbImportDictionaryModalResult {
+    temporaryFileId?: string;
+    parentId?: string;
+}
+declare const UMB_IMPORT_DICTIONARY_MODAL: UmbModalToken$1<UmbImportDictionaryModalData, UmbImportDictionaryModalResult>;
+
+declare const UMB_INVITE_USER_MODAL: UmbModalToken$1<object, unknown>;
+
+interface UmbLanguagePickerModalData {
+    multiple?: boolean;
+    selection?: Array<string | null>;
+    filter?: (language: LanguageResponseModel) => boolean;
+}
+interface UmbLanguagePickerModalResult {
+    selection: Array<string | null>;
+}
+declare const UMB_LANGUAGE_PICKER_MODAL: UmbModalToken$1<UmbLanguagePickerModalData, UmbLanguagePickerModalResult>;
+
+interface UmbLinkPickerModalData {
+    index: number | null;
+    link: UmbLinkPickerLink;
+    config: UmbLinkPickerConfig;
+}
+type UmbLinkPickerModalResult = {
+    index: number | null;
+    link: UmbLinkPickerLink;
+};
+interface UmbLinkPickerLink {
+    icon?: string | null;
+    name?: string | null;
+    published?: boolean | null;
+    queryString?: string | null;
+    target?: string | null;
+    trashed?: boolean | null;
+    udi?: string | null;
+    url?: string | null;
+}
+interface UmbLinkPickerConfig {
+    hideAnchor?: boolean;
+    ignoreUserStartNodes?: boolean;
+    overlaySize?: UUIModalSidebarSize;
+}
+declare const UMB_LINK_PICKER_MODAL: UmbModalToken$1<UmbLinkPickerModalData, UmbLinkPickerModalResult>;
+
+type UmbMediaTreePickerModalData = UmbTreePickerModalData$1<ContentTreeItemResponseModel>;
+type UmbMediaTreePickerModalResult = UmbPickerModalResult$1;
+declare const UMB_MEDIA_TREE_PICKER_MODAL: UmbModalToken$1<UmbMediaTreePickerModalData, UmbPickerModalResult$1>;
+
+interface UmbPropertyEditorUIPickerModalData {
+    selection?: Array<string>;
+    submitLabel?: string;
+}
+type UmbPropertyEditorUIPickerModalResult = {
     selection: Array<string>;
-    filter?: (language: T) => boolean;
+};
+declare const UMB_PROPERTY_EDITOR_UI_PICKER_MODAL: UmbModalToken$1<UmbPropertyEditorUIPickerModalData, UmbPropertyEditorUIPickerModalResult>;
+
+type UmbPropertySettingsModalData = PropertyTypeResponseModelBaseModel;
+type UmbPropertySettingsModalResult = PropertyTypeResponseModelBaseModel;
+declare const UMB_PROPERTY_SETTINGS_MODAL: UmbModalToken$1<PropertyTypeResponseModelBaseModel, PropertyTypeResponseModelBaseModel>;
+
+declare const UMB_SEARCH_MODAL: UmbModalToken$1<object, unknown>;
+
+interface UmbSectionPickerModalData {
+    multiple: boolean;
+    selection: Array<string | null>;
+}
+interface UmbSectionPickerModalResult {
+    selection: Array<string | null>;
+}
+declare const UMB_SECTION_PICKER_MODAL: UmbModalToken$1<UmbSectionPickerModalData, UmbSectionPickerModalResult>;
+
+interface UmbTemplateModalData {
+    id: string;
+    language?: 'razor' | 'typescript' | 'javascript' | 'css' | 'markdown' | 'json' | 'html';
+}
+interface UmbTemplateModalResult {
+    id: string;
+}
+declare const UMB_TEMPLATE_MODAL: UmbModalToken$1<UmbTemplateModalData, UmbTemplateModalResult>;
+
+type UmbTemplatePickerModalData = UmbTreePickerModalData$1<EntityTreeItemResponseModel>;
+type UmbTemplatePickerModalResult = UmbPickerModalResult$1;
+declare const UMB_TEMPLATE_PICKER_MODAL: UmbModalToken$1<UmbTemplatePickerModalData, UmbPickerModalResult$1>;
+
+declare const UMB_USER_GROUP_PICKER_MODAL: UmbModalToken$1<UmbPickerModalData$1<any>, unknown>;
+
+type UmbUserPickerModalData = UmbPickerModalData$1<UserResponseModel>;
+interface UmbUserPickerModalResult {
+    selection: Array<string | null>;
+}
+declare const UMB_USER_PICKER_MODAL: UmbModalToken$1<UmbUserPickerModalData, UmbUserPickerModalResult>;
+
+interface UmbFolderModalData {
+    repositoryAlias: string;
+    unique?: string;
+}
+interface UmbFolderModalResult {
+    folder: FolderReponseModel;
 }
-interface UmbPickerModalResult<T> {
+declare const UMB_FOLDER_MODAL: UmbModalToken$1<UmbFolderModalData, UmbFolderModalResult>;
+
+interface UmbPartialViewPickerModalData {
+    multiple: boolean;
+    selection: string[];
+}
+interface UmbPartialViewPickerModalResult {
+    selection: Array<string | null> | undefined;
+}
+declare const UMB_PARTIAL_VIEW_PICKER_MODAL_ALIAS = "Umb.Modal.PartialViewPicker";
+declare const UMB_PARTIAL_VIEW_PICKER_MODAL: UmbModalToken$1<UmbPartialViewPickerModalData, UmbPartialViewPickerModalResult>;
+
+interface UmbDictionaryItemPickerModalData {
+    multiple: boolean;
+    selection: string[];
+}
+interface UmbDictionaryItemPickerModalResult {
+    selection: Array<string | null>;
+}
+declare const UMB_DICTIONARY_ITEM_PICKER_MODAL_ALIAS = "Umb.Modal.DictionaryItemPicker";
+declare const UMB_DICTIONARY_ITEM_PICKER_MODAL: UmbModalToken$1<UmbDictionaryItemPickerModalData, UmbDictionaryItemPickerModalResult>;
+
+type UmbDataTypePickerModalData = UmbTreePickerModalData$1<FolderTreeItemResponseModel>;
+type UmbDataTypePickerModalResult = UmbPickerModalResult$1;
+declare const UMB_DATA_TYPE_PICKER_MODAL: UmbModalToken$1<UmbDataTypePickerModalData, UmbPickerModalResult$1>;
+
+interface UmbDataTypePickerFlowModalData {
+    selection?: Array<string>;
+    submitLabel?: string;
+}
+type UmbDataTypePickerFlowModalResult = {
     selection: Array<string>;
+};
+declare const UMB_DATA_TYPE_PICKER_FLOW_MODAL: UmbModalToken$1<UmbDataTypePickerFlowModalData, UmbDataTypePickerFlowModalResult>;
+
+interface UmbPickerModalData<ItemType> {
+    multiple?: boolean;
+    selection?: Array<string | null>;
+    filter?: (item: ItemType) => boolean;
+    pickableFilter?: (item: ItemType) => boolean;
+}
+interface UmbPickerModalResult {
+    selection: Array<string | null>;
+}
+interface UmbTreePickerModalData<TreeItemType> extends UmbPickerModalData<TreeItemType> {
+    treeAlias?: string;
 }
 
-export { UMB_MODAL_CONTEXT_TOKEN, UmbModalConfig, UmbModalContext, UmbModalHandler, UmbModalHandlerClass, UmbModalToken, UmbModalType, UmbPickerModalData, UmbPickerModalResult };
+export { OEmbedResult, OEmbedStatus, UMB_ALLOWED_DOCUMENT_TYPES_MODAL, UMB_CHANGE_PASSWORD_MODAL, UMB_CONFIRM_MODAL, UMB_CONTEXT_DEBUGGER_MODAL, UMB_CREATE_DICTIONARY_MODAL, UMB_CREATE_USER_MODAL, UMB_CURRENT_USER_MODAL, UMB_DATA_TYPE_PICKER_FLOW_MODAL, UMB_DATA_TYPE_PICKER_MODAL, UMB_DICTIONARY_ITEM_PICKER_MODAL, UMB_DICTIONARY_ITEM_PICKER_MODAL_ALIAS, UMB_DOCUMENT_PICKER_MODAL, UMB_DOCUMENT_TYPE_PICKER_MODAL, UMB_EMBEDDED_MEDIA_MODAL, UMB_EXAMINE_FIELDS_SETTINGS_MODAL, UMB_EXPORT_DICTIONARY_MODAL, UMB_FOLDER_MODAL, UMB_ICON_PICKER_MODAL, UMB_IMPORT_DICTIONARY_MODAL, UMB_INVITE_USER_MODAL, UMB_LANGUAGE_PICKER_MODAL, UMB_LINK_PICKER_MODAL, UMB_MEDIA_TREE_PICKER_MODAL, UMB_MODAL_CONTEXT_TOKEN, UMB_PARTIAL_VIEW_PICKER_MODAL, UMB_PARTIAL_VIEW_PICKER_MODAL_ALIAS, UMB_PROPERTY_EDITOR_UI_PICKER_MODAL, UMB_PROPERTY_SETTINGS_MODAL, UMB_SEARCH_MODAL, UMB_SECTION_PICKER_MODAL, UMB_TEMPLATE_MODAL, UMB_TEMPLATE_PICKER_MODAL, UMB_USER_GROUP_PICKER_MODAL, UMB_USER_PICKER_MODAL, UmbAllowedDocumentTypesModalData, UmbAllowedDocumentTypesModalResult, UmbChangePasswordModalData, UmbConfirmModalData, UmbConfirmModalResult, UmbContextDebuggerModalData, UmbCreateDictionaryModalData, UmbCreateDictionaryModalResult, UmbCreateDocumentModalResultData, UmbDataTypePickerFlowModalData, UmbDataTypePickerFlowModalResult, UmbDataTypePickerModalData, UmbDataTypePickerModalResult, UmbDictionaryItemPickerModalData, UmbDictionaryItemPickerModalResult, UmbDocumentPickerModalData, UmbDocumentPickerModalResult, UmbDocumentTypePickerModalData, UmbDocumentTypePickerModalResult, UmbEmbeddedMediaModalData, UmbEmbeddedMediaModalResult, UmbExamineFieldsSettingsModalData, UmbExportDictionaryModalData, UmbExportDictionaryModalResult, UmbFolderModalData, UmbFolderModalResult, UmbIconPickerModalData, UmbIconPickerModalResult, UmbImportDictionaryModalData, UmbImportDictionaryModalResult, UmbLanguagePickerModalData, UmbLanguagePickerModalResult, UmbLinkPickerConfig, UmbLinkPickerLink, UmbLinkPickerModalData, UmbLinkPickerModalResult, UmbMediaTreePickerModalData, UmbMediaTreePickerModalResult, UmbModalConfig, UmbModalContext, UmbModalHandler, UmbModalHandlerClass, UmbModalRouteBuilder, UmbModalRouteRegistration, UmbModalRouteRegistrationController, UmbModalToken, UmbModalType, UmbPartialViewPickerModalData, UmbPartialViewPickerModalResult, UmbPickerModalData, UmbPickerModalResult, UmbPropertyEditorUIPickerModalData, UmbPropertyEditorUIPickerModalResult, UmbPropertySettingsModalData, UmbPropertySettingsModalResult, UmbSectionPickerModalData, UmbSectionPickerModalResult, UmbTemplateModalData, UmbTemplateModalResult, UmbTemplatePickerModalData, UmbTemplatePickerModalResult, UmbTreePickerModalData, UmbUserPickerModalData, UmbUserPickerModalResult };