New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@umbraco-cms/backoffice

Package Overview
Dependencies
Maintainers
6
Versions
562
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@umbraco-cms/backoffice - npm Package Compare versions

Comparing version

1.0.0-next.71583c15
to
1.0.0-next.7b47547e

router.d.ts

82

context-api.d.ts

@@ -1,2 +0,4 @@

import { UmbControllerHostInterface, UmbControllerInterface } from './controller';
import { UmbControllerHostElement, UmbControllerInterface } from './controller';
import { UmbWorkspaceContextInterface } from './workspace';
import { BaseEntity } from './models';

@@ -93,5 +95,5 @@ declare class UmbContextToken<T = unknown> {

declare class UmbContextConsumerController<T = unknown> extends UmbContextConsumer<UmbControllerHostInterface, T> implements UmbControllerInterface {
declare class UmbContextConsumerController<T = unknown> extends UmbContextConsumer<UmbControllerHostElement, T> implements UmbControllerInterface {
get unique(): undefined;
constructor(host: UmbControllerHostInterface, contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
constructor(host: UmbControllerHostElement, contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
destroy(): void;

@@ -140,5 +142,5 @@ }

declare class UmbContextProviderController<T = unknown> extends UmbContextProvider<UmbControllerHostInterface> implements UmbControllerInterface {
declare class UmbContextProviderController<T = unknown> extends UmbContextProvider<UmbControllerHostElement> implements UmbControllerInterface {
get unique(): string;
constructor(host: UmbControllerHostInterface, contextAlias: string | UmbContextToken<T>, instance: T);
constructor(host: UmbControllerHostElement, contextAlias: string | UmbContextToken<T>, instance: T);
destroy(): void;

@@ -167,2 +169,70 @@ }

export { UmbContextCallback, UmbContextConsumer, UmbContextConsumerController, UmbContextDebugRequest, UmbContextProvideEvent, UmbContextProvideEventImplementation, UmbContextProvider, UmbContextProviderController, UmbContextRequestEvent, UmbContextRequestEventImplementation, UmbContextToken, isUmbContextProvideEventType, isUmbContextRequestEvent, umbContextProvideEventType, umbContextRequestEventType, umbDebugContextEventType };
interface UmbEntityWorkspaceContextInterface<EntityType = unknown> extends UmbWorkspaceContextInterface<EntityType> {
getEntityKey(): string | undefined;
getEntityType(): string;
save(): Promise<void>;
}
declare const UMB_ENTITY_WORKSPACE_CONTEXT: UmbContextToken<UmbEntityWorkspaceContextInterface<BaseEntity>>;
/**
* Change the collection of Contexts into a simplified array of data
*
* @param contexts This is a map of the collected contexts from umb-debug
* @returns An array of simplified context data
*/
declare function contextData(contexts: Map<any, any>): Array<DebugContextData>;
interface DebugContextData {
/**
* The alias of the context
*
* @type {string}
* @memberof DebugContextData
*/
alias: string;
/**
* The type of the context such as object or string
*
* @type {("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function")}
* @memberof DebugContextData
*/
type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
/**
* Data about the context that includes method and property names
*
* @type {DebugContextItemData}
* @memberof DebugContextData
*/
data: DebugContextItemData;
}
interface DebugContextItemData {
type: string;
methods?: Array<unknown>;
properties?: Array<DebugContextItemPropertyData>;
value?: unknown;
}
interface DebugContextItemPropertyData {
/**
* The name of the property
*
* @type {string}
* @memberof DebugContextItemPropertyData
*/
key: string;
/**
* The type of the property's value such as string or number
*
* @type {("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function")}
* @memberof DebugContextItemPropertyData
*/
type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
/**
* Simple types such as string or number can have their value displayed stored inside the property
*
* @type {("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function")}
* @memberof DebugContextItemPropertyData
*/
value?: unknown;
}
export { DebugContextData, DebugContextItemData, DebugContextItemPropertyData, UMB_ENTITY_WORKSPACE_CONTEXT, UmbContextCallback, UmbContextConsumer, UmbContextConsumerController, UmbContextDebugRequest, UmbContextProvideEvent, UmbContextProvideEventImplementation, UmbContextProvider, UmbContextProviderController, UmbContextRequestEvent, UmbContextRequestEventImplementation, UmbContextToken, contextData, isUmbContextProvideEventType, isUmbContextRequestEvent, umbContextProvideEventType, umbContextRequestEventType, umbDebugContextEventType };

10

controller.d.ts

@@ -10,3 +10,3 @@ import { HTMLElementConstructor } from './models';

declare class UmbControllerHostInterface extends HTMLElement {
declare class UmbControllerHostElement extends HTMLElement {
hasController(controller: UmbControllerInterface): boolean;

@@ -24,3 +24,3 @@ getControllers(filterMethod: (ctrl: UmbControllerInterface) => boolean): UmbControllerInterface[];

*/
declare const UmbControllerHostMixin: <T extends HTMLElementConstructor<HTMLElement>>(superClass: T) => HTMLElementConstructor<UmbControllerHostInterface> & T;
declare const UmbControllerHostMixin: <T extends HTMLElementConstructor<HTMLElement>>(superClass: T) => HTMLElementConstructor<UmbControllerHostElement> & T;
declare global {

@@ -34,6 +34,6 @@ interface HTMLElement {

declare abstract class UmbController implements UmbControllerInterface {
protected host?: UmbControllerHostInterface;
protected host?: UmbControllerHostElement;
private _alias?;
get unique(): string | undefined;
constructor(host: UmbControllerHostInterface, alias?: string);
constructor(host: UmbControllerHostElement, alias?: string);
abstract hostConnected(): void;

@@ -44,2 +44,2 @@ abstract hostDisconnected(): void;

export { UmbController, UmbControllerHostInterface, UmbControllerHostMixin, UmbControllerInterface };
export { UmbController, UmbControllerHostElement, UmbControllerHostMixin, UmbControllerInterface };

4

element.d.ts
import { Observable } from 'rxjs';
import { HTMLElementConstructor } from './models';
import { UmbControllerHostInterface } from './controller';
import { UmbControllerHostElement } from './controller';
import { UmbContextToken, UmbContextProviderController, UmbContextCallback, UmbContextConsumerController } from './context-api';

@@ -10,3 +10,3 @@ import { UmbObserverController } from './observable-api';

}
declare class UmbElementMixinInterface extends UmbControllerHostInterface {
declare class UmbElementMixinInterface extends UmbControllerHostElement {
observe<T>(source: Observable<T>, callback: (_value: T) => void, unique?: string): UmbObserverController<T>;

@@ -13,0 +13,0 @@ provideContext<R = unknown>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;

43

entity-action.d.ts

@@ -1,6 +0,7 @@

import { UmbControllerHostInterface } from './controller';
import { UmbControllerHostElement } from './controller';
import { UmbEntityActionBase as UmbEntityActionBase$1 } from './entity-action';
import { UmbFolderRepository } from './repository';
interface UmbAction<RepositoryType = unknown> {
host: UmbControllerHostInterface;
host: UmbControllerHostElement;
repository: RepositoryType;

@@ -10,5 +11,5 @@ execute(): Promise<void>;

declare class UmbActionBase<RepositoryType> {
host: UmbControllerHostInterface;
host: UmbControllerHostElement;
repository?: RepositoryType;
constructor(host: UmbControllerHostInterface, repositoryAlias: string);
constructor(host: UmbControllerHostElement, repositoryAlias: string);
}

@@ -21,3 +22,4 @@

unique: string;
constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
repositoryAlias: string;
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
}

@@ -31,3 +33,3 @@

selection: Array<string>;
constructor(host: UmbControllerHostInterface, repositoryAlias: string, selection: Array<string>);
constructor(host: UmbControllerHostElement, repositoryAlias: string, selection: Array<string>);
setSelection(selection: Array<string>): void;

@@ -39,3 +41,3 @@ }

}> extends UmbEntityActionBase$1<T> {
constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;

@@ -46,13 +48,28 @@ }

delete(unique: string): Promise<void>;
requestItems(uniques: Array<string>): any;
requestTreeItems(uniques: Array<string>): any;
}> extends UmbEntityActionBase$1<T> {
#private;
constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;
}
declare class UmbDeleteFolderEntityAction<T extends {
deleteFolder(unique: string): Promise<void>;
requestTreeItems(uniques: Array<string>): any;
}> extends UmbEntityActionBase$1<T> {
#private;
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;
}
declare class UmbFolderUpdateEntityAction<T extends UmbFolderRepository = UmbFolderRepository> extends UmbEntityActionBase$1<T> {
#private;
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;
}
declare class UmbMoveEntityAction<T extends {
move(): Promise<void>;
}> extends UmbEntityActionBase$1<T> {
constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;

@@ -64,3 +81,3 @@ }

}> extends UmbEntityActionBase$1<T> {
constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;

@@ -74,6 +91,6 @@ }

#private;
constructor(host: UmbControllerHostInterface, repositoryAlias: string, unique: string);
constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
execute(): Promise<void>;
}
export { UmbAction, UmbActionBase, UmbCopyEntityAction, UmbDeleteEntityAction, UmbEntityAction, UmbEntityActionBase, UmbEntityBulkAction, UmbEntityBulkActionBase, UmbMoveEntityAction, UmbSortChildrenOfEntityAction, UmbTrashEntityAction };
export { UmbAction, UmbActionBase, UmbCopyEntityAction, UmbDeleteEntityAction, UmbDeleteFolderEntityAction, UmbEntityAction, UmbEntityActionBase, UmbEntityBulkAction, UmbEntityBulkActionBase, UmbFolderUpdateEntityAction, UmbMoveEntityAction, UmbSortChildrenOfEntityAction, UmbTrashEntityAction };

4

extensions-api.d.ts
import { Observable } from 'rxjs';
import { ManifestTypes, ManifestKind, ManifestTypeMap, ManifestBase, SpecificManifestTypeOrManifestBase, ManifestElement, ManifestElementWithElementName, ManifestClass } from './extensions-registry';
import { UmbContextToken } from './context-api';
import { UmbControllerHostInterface } from './controller';
import { UmbControllerHostElement } from './controller';

@@ -31,3 +31,3 @@ declare class UmbExtensionRegistry {

type UmbEntrypointOnInit = (host: UmbControllerHostInterface, extensionRegistry: UmbExtensionRegistry) => void;
type UmbEntrypointOnInit = (host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry) => void;
/**

@@ -34,0 +34,0 @@ * Interface containing supported life-cycle functions for ESModule entrypoints

33

extensions-registry.d.ts

@@ -1,7 +0,7 @@

import { ClassConstructor } from './models';
import { InterfaceLook, InterfaceColor } from '@umbraco-ui/uui-base/lib/types/index';
import { UmbWorkspaceAction } from './workspace';
import { UmbStoreBase, UmbTreeStoreBase } from './store';
import { ClassConstructor } from './models';
import { UmbStoreBase, UmbTreeStore } from './store';
import { UmbExtensionRegistry } from './extensions-api';
import { UmbControllerHostInterface } from './controller';
import { UmbControllerHostElement } from './controller';

@@ -245,11 +245,18 @@ interface ManifestCollectionView extends ManifestElement, ManifestWithConditions<ConditionsCollectionView> {

interface MetaTree {
storeAlias?: string;
repository?: ClassConstructor<unknown>;
repositoryAlias: string;
}
interface ManifestUserDashboard extends ManifestElement {
type: 'userDashboard';
meta: MetaUserDashboard;
interface ManifestTreeItem extends ManifestElement {
type: 'treeItem';
conditions: ConditionsTreeItem;
}
interface MetaUserDashboard {
interface ConditionsTreeItem {
entityType: string;
}
interface ManifestUserProfileApp extends ManifestElement {
type: 'userProfileApp';
meta: MetaUserProfileApp;
}
interface MetaUserProfileApp {
label: string;

@@ -323,7 +330,7 @@ pathname: string;

}
interface ManifestTreeStore extends ManifestClass<UmbTreeStoreBase> {
interface ManifestTreeStore extends ManifestClass<UmbTreeStore> {
type: 'treeStore';
}
type ManifestTypes = ManifestCollectionView | ManifestDashboard | ManifestDashboardCollection | ManifestEntityAction | ManifestEntityBulkAction | ManifestEntrypoint | ManifestExternalLoginProvider | ManifestHeaderApp | ManifestHeaderAppButtonKind | ManifestHealthCheck | ManifestPackageView | ManifestPropertyAction | ManifestPropertyEditorModel | ManifestPropertyEditorUI | ManifestRepository | ManifestSection | ManifestSectionSidebarApp | ManifestSectionSidebarAppMenuKind | ManifestSectionView | ManifestMenu | ManifestMenuItem | ManifestMenuItemTreeKind | ManifestTheme | ManifestTree | ManifestUserDashboard | ManifestWorkspace | ManifestWorkspaceAction | ManifestWorkspaceView | ManifestWorkspaceViewCollection | ManifestModal | ManifestStore | ManifestTreeStore | ManifestBase;
type ManifestTypes = ManifestCollectionView | ManifestDashboard | ManifestDashboardCollection | ManifestEntityAction | ManifestEntityBulkAction | ManifestEntrypoint | ManifestExternalLoginProvider | ManifestHeaderApp | ManifestHeaderAppButtonKind | ManifestHealthCheck | ManifestPackageView | ManifestPropertyAction | ManifestPropertyEditorModel | ManifestPropertyEditorUI | ManifestRepository | ManifestSection | ManifestSectionSidebarApp | ManifestSectionSidebarAppMenuKind | ManifestSectionView | ManifestMenu | ManifestMenuItem | ManifestMenuItemTreeKind | ManifestTheme | ManifestTree | ManifestTreeItem | ManifestUserProfileApp | ManifestWorkspace | ManifestWorkspaceAction | ManifestWorkspaceView | ManifestWorkspaceViewCollection | ManifestModal | ManifestStore | ManifestTreeStore | ManifestBase;
type ManifestStandardTypes = ManifestTypes['type'];

@@ -388,6 +395,6 @@ type ManifestTypeMap = {

#private;
constructor(rootHost: UmbControllerHostInterface, extensionRegistry: UmbExtensionRegistry);
constructor(rootHost: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry);
instantiateEntryPoint(manifest: ManifestEntrypoint): void;
}
export { ConditionsCollectionView, ConditionsDashboard, ConditionsDashboardCollection, ConditionsEditorViewCollection, ConditionsEntityAction, ConditionsEntityBulkAction, ConditionsMenuItem, ConditionsPropertyAction, ConditionsSectionSidebarApp, ConditionsSectionView, ConditionsWorkspaceAction, ConditionsWorkspaceView, HealthCheck, ManifestBase, ManifestClass, ManifestClassWithClassConstructor, ManifestCollectionView, ManifestDashboard, ManifestDashboardCollection, ManifestElement, ManifestElementWithElementName, ManifestEntityAction, ManifestEntityBulkAction, ManifestEntrypoint, ManifestExternalLoginProvider, ManifestHeaderApp, ManifestHeaderAppButtonKind, ManifestHealthCheck, ManifestKind, ManifestMenu, ManifestMenuItem, ManifestMenuItemTreeKind, ManifestModal, ManifestPackageView, ManifestPropertyAction, ManifestPropertyEditorModel, ManifestPropertyEditorUI, ManifestRepository, ManifestSection, ManifestSectionSidebarApp, ManifestSectionSidebarAppMenuKind, ManifestSectionView, ManifestStandardTypes, ManifestStore, ManifestTheme, ManifestTree, ManifestTreeStore, ManifestTypeMap, ManifestTypes, ManifestUserDashboard, ManifestWithConditions, ManifestWithLoader, ManifestWithMeta, ManifestWithView, ManifestWorkspace, ManifestWorkspaceAction, ManifestWorkspaceView, ManifestWorkspaceViewCollection, MetaCollectionView, MetaDashboard, MetaDashboardCollection, MetaEditor, MetaEditorViewCollection, MetaEntityAction, MetaEntityBulkAction, MetaExternalLoginProvider, MetaHeaderApp, MetaHeaderAppButtonKind, MetaHealthCheck, MetaManifestWithView, MetaMenuItem, MetaMenuItemTreeKind, MetaPackageView, MetaPropertyEditorModel, MetaPropertyEditorUI, MetaSection, MetaSectionSidebarAppMenuKind, MetaSectionView, MetaTree, MetaUserDashboard, MetaWorkspaceAction, MetaWorkspaceView, PropertyEditorConfig, PropertyEditorConfigDefaultData, PropertyEditorConfigProperty, SpecificManifestTypeOrManifestBase, UmbEntryPointExtensionInitializer };
export { ConditionsCollectionView, ConditionsDashboard, ConditionsDashboardCollection, ConditionsEditorViewCollection, ConditionsEntityAction, ConditionsEntityBulkAction, ConditionsMenuItem, ConditionsPropertyAction, ConditionsSectionSidebarApp, ConditionsSectionView, ConditionsTreeItem, ConditionsWorkspaceAction, ConditionsWorkspaceView, HealthCheck, ManifestBase, ManifestClass, ManifestClassWithClassConstructor, ManifestCollectionView, ManifestDashboard, ManifestDashboardCollection, ManifestElement, ManifestElementWithElementName, ManifestEntityAction, ManifestEntityBulkAction, ManifestEntrypoint, ManifestExternalLoginProvider, ManifestHeaderApp, ManifestHeaderAppButtonKind, ManifestHealthCheck, ManifestKind, ManifestMenu, ManifestMenuItem, ManifestMenuItemTreeKind, ManifestModal, ManifestPackageView, ManifestPropertyAction, ManifestPropertyEditorModel, ManifestPropertyEditorUI, ManifestRepository, ManifestSection, ManifestSectionSidebarApp, ManifestSectionSidebarAppMenuKind, ManifestSectionView, ManifestStandardTypes, ManifestStore, ManifestTheme, ManifestTree, ManifestTreeItem, ManifestTreeStore, ManifestTypeMap, ManifestTypes, ManifestUserProfileApp, ManifestWithConditions, ManifestWithLoader, ManifestWithMeta, ManifestWithView, ManifestWorkspace, ManifestWorkspaceAction, ManifestWorkspaceView, ManifestWorkspaceViewCollection, MetaCollectionView, MetaDashboard, MetaDashboardCollection, MetaEditor, MetaEditorViewCollection, MetaEntityAction, MetaEntityBulkAction, MetaExternalLoginProvider, MetaHeaderApp, MetaHeaderAppButtonKind, MetaHealthCheck, MetaManifestWithView, MetaMenuItem, MetaMenuItemTreeKind, MetaPackageView, MetaPropertyEditorModel, MetaPropertyEditorUI, MetaSection, MetaSectionSidebarAppMenuKind, MetaSectionView, MetaTree, MetaUserProfileApp, MetaWorkspaceAction, MetaWorkspaceView, PropertyEditorConfig, PropertyEditorConfigDefaultData, PropertyEditorConfigProperty, SpecificManifestTypeOrManifestBase, UmbEntryPointExtensionInitializer };

609

modal.d.ts
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import * as lit_html from 'lit-html';
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 { LitElement, TemplateResult } from 'lit';
import { UUIModalDialogElement, UUIModalSidebarElement, UUIModalSidebarSize } from '@umbraco-ui/uui';
import { UmbControllerHostElement, UmbControllerInterface } from './controller';
import { UmbContextToken } from './context-api';
import { UmbModalToken as UmbModalToken$1, UmbModalConfig as UmbModalConfig$1, UmbPickerModalData as UmbPickerModalData$1 } from './modal';
import { LanguageResponseModel, FolderReponseModel } from './backend-api';
import { UserDetails } from './models';

@@ -26,3 +29,3 @@ declare class UmbSearchModalElement extends LitElement {

declare class UmbModalToken<Data = unknown, Result = unknown> {
declare class UmbModalToken<Data extends object = object, Result = unknown> {
protected alias: string;

@@ -72,3 +75,3 @@ protected defaultConfig?: UmbModalConfig | undefined;

*/
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 ? {

@@ -81,3 +84,3 @@ submit: () => void;

};
declare class UmbModalHandlerClass<ModalData, ModalResult> {
declare class UmbModalHandlerClass<ModalData extends object = object, ModalResult = unknown> {
#private;

@@ -88,7 +91,7 @@ private _submitPromise;

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);
constructor(host: UmbControllerHostElement, modalAlias: string | UmbModalToken<ModalData, ModalResult>, data?: ModalData, config?: UmbModalConfig);
private submit;

@@ -107,5 +110,5 @@ reject(): void;

#private;
host: UmbControllerHostInterface;
readonly modals: rxjs.Observable<UmbModalHandler<any, any>[]>;
constructor(host: UmbControllerHostInterface);
host: UmbControllerHostElement;
readonly modals: rxjs.Observable<UmbModalHandler<object, any>[]>;
constructor(host: UmbControllerHostElement);
search(): UmbModalHandler<any, any>;

@@ -120,3 +123,3 @@ /**

*/
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): UmbModalHandler<ModalData, ModalResult>;
/**

@@ -132,2 +135,580 @@ * Closes a modal or sidebar modal

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;
type ModuleResolver = Promise<{
default: any;
}>;
type Class<T extends PageComponent = PageComponent> = {
new (...args: any[]): T;
};
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: Class | ModuleResolver | PageComponent | (() => Class) | (() => PageComponent) | (() => ModuleResolver);
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;
}
}
/**
* Slot for a node in the router tree.
* @slot - Default content.
* @event changestate - Dispatched when the router slot state changes.
*/
declare class RouterSlot<D = any, P = any> extends HTMLElement implements IRouterSlot<D, P> {
/**
* Listeners on the router.
*/
private listeners;
/**
* The available routes.
*/
private _routes;
get routes(): IRoute<D>[];
set routes(routes: IRoute<D>[]);
/**
* The parent router.
* Is REQUIRED if this router is a child.
* When set, the relevant listeners are added or teared down because they depend on the parent.
*/
_parent: IRouterSlot<P> | null | undefined;
get parent(): IRouterSlot<P> | null | undefined;
set parent(router: IRouterSlot<P> | null | undefined);
/**
* Whether the router is a root router.
*/
get isRoot(): boolean;
/**
* The current route match.
*/
private _routeMatch;
get match(): IRouteMatch<D> | null;
/**
* The current route of the match.
*/
get route(): IRoute<D> | null;
/**
* The current path fragment of the match
*/
get fragments(): IPathFragments | null;
/**
* The current params of the match.
*/
get params(): Params | null;
/**
* Hooks up the element.
*/
constructor();
/**
* Query the parent router slot when the router slot is connected.
*/
connectedCallback(): void;
/**
* Tears down the element.
*/
disconnectedCallback(): void;
/**
* Queries the parent router.
*/
queryParentRouterSlot(): IRouterSlot<P> | null;
/**
* Returns an absolute path relative to the router slot.
* @param path
*/
constructAbsolutePath(path: PathFragment): string;
/**
* Adds routes to the router.
* Navigates automatically if the router slot is the root and is connected.
* @param routes
* @param navigate
*/
add(routes: IRoute<D>[], navigate?: boolean): void;
/**
* Removes all routes.
*/
clear(): void;
/**
* Each time the path changes, load the new path.
*/
render(): Promise<void>;
/**
* Attaches listeners, either globally or on the parent router.
*/
protected attachListeners(): void;
/**
* Clears the children in the DOM.
*/
protected clearChildren(): void;
/**
* Detaches the listeners.
*/
protected detachListeners(): void;
/**
* Notify the listeners.
*/
notifyChildRouters(info: any): void;
/**
* Loads a new path based on the routes.
* Returns true if a navigation was made to a new page.
*/
protected renderPath(path: string | PathFragment): Promise<boolean>;
}
declare global {
interface HTMLElementTagNameMap {
"router-slot": RouterSlot;
}
}
/**
* Router link.
* @slot - Default content.
*/
declare class RouterLink extends HTMLElement {
private listeners;
private _context;
static get observedAttributes(): string[];
/**
* The path of the navigation.
* @attr
*/
set path(value: string | PathFragment);
get path(): string | PathFragment;
/**
* Whether the element is disabled or not.
* @attr
*/
get disabled(): boolean;
set disabled(value: boolean);
/**
* Whether the element is active or not.
* @attr
*/
get active(): boolean;
set active(value: boolean);
/**
* Whether the focus should be delegated.
* @attr
*/
get delegateFocus(): boolean;
set delegateFocus(value: boolean);
/**
* Whether the query should be preserved or not.
* @attr
*/
get preserveQuery(): boolean;
set preserveQuery(value: boolean);
/**
* The current router slot context.
*/
get context(): IRouterSlot | null;
set context(value: IRouterSlot | null);
/**
* Returns the absolute path.
*/
get absolutePath(): string;
constructor();
/**
* Hooks up the element.
*/
connectedCallback(): void;
/**
* Tear down listeners.
*/
disconnectedCallback(): void;
/**
* Reacts to attribute changed callback.
* @param name
* @param oldValue
* @param newValue
*/
attributeChangedCallback(name: string, oldValue: unknown, newValue: unknown): void;
private updateTabIndex;
/**
* Returns the absolute path constructed relative to the context.
* If no router parent was found the path property is the absolute one.
*/
constructAbsolutePath(path: string): string;
/**
* Updates whether the route is active or not.
*/
protected updateActive(): void;
/**
* Navigates to the specified path.
*/
navigate(path: string, e?: Event): void;
}
declare global {
interface HTMLElementTagNameMap {
"router-link": RouterLink;
}
}
declare global {
interface History {
"native": {
"back": ((distance?: any) => void);
"forward": ((distance?: any) => void);
"go": ((delta?: any) => void);
"pushState": ((data: any, title?: string, url?: string | null) => void);
"replaceState": ((data: any, title?: string, url?: string | null) => void);
};
}
}
type UmbModalRouteBuilder = (params: {
[key: string]: string | number;
}) => string;
declare class UmbModalRouteRegistration<UmbModalTokenData extends object = object, UmbModalTokenResult = any> {
#private;
constructor(modalAlias: UmbModalToken<UmbModalTokenData, UmbModalTokenResult> | string, path: string, modalConfig?: UmbModalConfig);
get key(): string;
get alias(): string | UmbModalToken<UmbModalTokenData, UmbModalTokenResult>;
get path(): string;
protected _setPath(path: string): 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) => UmbModalTokenData | false): this;
onSubmit(callback: (data: UmbModalTokenResult) => void): this;
onReject(callback: () => void): this;
routeSetup(modalContext: UmbModalContext, params: Params): UmbModalHandler<UmbModalTokenData, UmbModalTokenResult> | null;
}
declare class UmbModalRouteRegistrationController<D extends object = object, R = any> extends UmbModalRouteRegistration<D, R> implements UmbControllerInterface {
#private;
get unique(): undefined;
constructor(host: UmbControllerHostElement, alias: UmbModalToken$1<D, R> | string, path: string, uniqueParts?: Map<string, string | undefined> | null, modalConfig?: UmbModalConfig$1);
setUniqueIdentifier(identifier: string, value: string | undefined): void;
private _registererModal;
hostConnected(): void;
hostDisconnected(): void;
destroy(): void;
}
interface UmbAllowedDocumentTypesModalData {
key: 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>;
interface UmbDocumentPickerModalData {
multiple?: boolean;
selection?: Array<string>;
}
interface UmbDocumentPickerModalResult {
selection: Array<string>;
}
declare const UMB_DOCUMENT_PICKER_MODAL: UmbModalToken$1<UmbDocumentPickerModalData, UmbDocumentPickerModalResult>;
interface UmbDocumentTypePickerModalData {
multiple?: boolean;
selection?: Array<string>;
}
interface UmbDocumentTypePickerModalResult {
selection: Array<string>;
}
declare const UMB_DOCUMENT_TYPE_PICKER_MODAL: UmbModalToken$1<UmbDocumentTypePickerModalData, UmbDocumentTypePickerModalResult>;
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 {
multiple: boolean;
selection: string[];
}
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 {
fileName?: string;
parentKey?: 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>;
filter?: (language: LanguageResponseModel) => boolean;
}
interface UmbLanguagePickerModalResult {
selection: Array<string>;
}
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>;
interface UmbMediaPickerModalData {
multiple?: boolean;
selection: Array<string>;
}
interface UmbMediaPickerModalResult {
selection: Array<string>;
}
declare const UMB_MEDIA_PICKER_MODAL: UmbModalToken$1<UmbMediaPickerModalData, UmbMediaPickerModalResult>;
interface UmbPropertyEditorUIPickerModalData {
selection?: Array<string>;
submitLabel?: string;
}
type UmbPropertyEditorUIPickerModalResult = {
selection: Array<string>;
};
declare const UMB_PROPERTY_EDITOR_UI_PICKER_MODAL: UmbModalToken$1<UmbPropertyEditorUIPickerModalData, UmbPropertyEditorUIPickerModalResult>;
interface UmbPropertySettingsModalResult {
label: string;
alias: string;
description: string;
propertyEditorUI?: string;
labelOnTop: boolean;
validation: {
mandatory: boolean;
mandatoryMessage: string;
pattern: string;
patternMessage: string;
};
}
declare const UMB_PROPERTY_SETTINGS_MODAL: UmbModalToken$1<object, UmbPropertySettingsModalResult>;
declare const UMB_SEARCH_MODAL: UmbModalToken$1<object, unknown>;
interface UmbSectionPickerModalData {
multiple: boolean;
selection: string[];
}
declare const UMB_SECTION_PICKER_MODAL: UmbModalToken$1<UmbSectionPickerModalData, unknown>;
interface UmbTemplateModalData {
key: string;
language?: 'razor' | 'typescript' | 'javascript' | 'css' | 'markdown' | 'json' | 'html';
}
interface UmbTemplateModalResult {
key: string;
}
declare const UMB_TEMPLATE_MODAL: UmbModalToken$1<UmbTemplateModalData, UmbTemplateModalResult>;
interface UmbTemplatePickerModalData {
multiple: boolean;
selection: string[];
}
interface UmbTemplatePickerModalResult {
selection: string[] | undefined;
}
declare const UMB_TEMPLATE_PICKER_MODAL: UmbModalToken$1<UmbTemplatePickerModalData, UmbTemplatePickerModalResult>;
declare const UMB_USER_GROUP_PICKER_MODAL: UmbModalToken$1<UmbPickerModalData$1<UserDetails>, unknown>;
declare const UMB_USER_PICKER_MODAL: UmbModalToken$1<UmbPickerModalData$1<UserDetails>, unknown>;
interface UmbFolderModalData {
repositoryAlias: string;
unique?: string;
}
interface UmbFolderModalResult {
folder: FolderReponseModel;
}
declare const UMB_FOLDER_MODAL: UmbModalToken$1<UmbFolderModalData, UmbFolderModalResult>;
interface UmbPickerModalData<T> {

@@ -142,2 +723,2 @@ multiple: boolean;

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_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_PICKER_MODAL, UMB_MODAL_CONTEXT_TOKEN, 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, UmbDocumentPickerModalData, UmbDocumentPickerModalResult, UmbDocumentTypePickerModalData, UmbDocumentTypePickerModalResult, UmbEmbeddedMediaModalData, UmbEmbeddedMediaModalResult, UmbExamineFieldsSettingsModalData, UmbExportDictionaryModalData, UmbExportDictionaryModalResult, UmbFolderModalData, UmbFolderModalResult, UmbIconPickerModalData, UmbIconPickerModalResult, UmbImportDictionaryModalData, UmbImportDictionaryModalResult, UmbLanguagePickerModalData, UmbLanguagePickerModalResult, UmbLinkPickerConfig, UmbLinkPickerLink, UmbLinkPickerModalData, UmbLinkPickerModalResult, UmbMediaPickerModalData, UmbMediaPickerModalResult, UmbModalConfig, UmbModalContext, UmbModalHandler, UmbModalHandlerClass, UmbModalRouteBuilder, UmbModalRouteRegistration, UmbModalRouteRegistrationController, UmbModalToken, UmbModalType, UmbPickerModalData, UmbPickerModalResult, UmbPropertyEditorUIPickerModalData, UmbPropertyEditorUIPickerModalResult, UmbPropertySettingsModalResult, UmbSectionPickerModalData, UmbTemplateModalData, UmbTemplateModalResult, UmbTemplatePickerModalData, UmbTemplatePickerModalResult };

7

models.d.ts

@@ -13,2 +13,7 @@ import { EntityTreeItemResponseModel, FolderTreeItemResponseModel, PackageManifestResponseModel } from './backend-api';

}
/** Tried to find a common base of our entities — used by Entity Workspace Context */
type BaseEntity = {
key?: string;
name?: string;
};
interface UserEntity extends Entity {

@@ -76,2 +81,2 @@ type: 'user';

export { ClassConstructor, DocumentBlueprintDetails, Entity, HTMLElementConstructor, MediaTypeDetails, MemberDetails, MemberGroupDetails, MemberTypeDetails, PackageManifestResponse, SwatchDetails, UmbPackage, UmbPackageWithMigrationStatus, UserDetails, UserEntity, UserGroupDetails, UserGroupEntity, UserStatus };
export { BaseEntity, ClassConstructor, DocumentBlueprintDetails, Entity, HTMLElementConstructor, MediaTypeDetails, MemberDetails, MemberGroupDetails, MemberTypeDetails, PackageManifestResponse, SwatchDetails, UmbPackage, UmbPackageWithMigrationStatus, UserDetails, UserEntity, UserGroupDetails, UserGroupEntity, UserStatus };

23

observable-api.d.ts
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject } from 'rxjs';
import { UmbControllerInterface, UmbControllerHostInterface } from './controller';
import { UmbControllerInterface, UmbControllerHostElement } from './controller';

@@ -16,3 +16,3 @@ declare class UmbObserver<T> {

get unique(): string | undefined;
constructor(host: UmbControllerHostInterface, source: Observable<T>, callback: (_value: T) => void, alias?: string);
constructor(host: UmbControllerHostElement, source: Observable<T>, callback: (_value: T) => void, alias?: string);
}

@@ -103,3 +103,3 @@

private _getUnique?;
constructor(initialData: T[], _getUnique?: ((entry: T) => unknown) | undefined);
constructor(initialData: T[], getUniqueMethod?: (entry: T) => unknown);
/**

@@ -186,2 +186,17 @@ * @method remove

append(entries: T[]): this;
/**
* @method updateOne
* @param {unknown} unique - Unique value to find entry to update.
* @param {Partial<T>} entry - new data to be added in this Subject.
* @return {ArrayState<T>} Reference to it self.
* @description - Update a item with some new data, requires the ArrayState to be constructed with a getUnique method.
* @example <caption>Example append some data.</caption>
* const data = [
* { key: 1, value: 'foo'},
* { key: 2, value: 'bar'}
* ];
* const myState = new ArrayState(data, (x) => x.key);
* myState.updateOne(2, {value: 'updated-bar'});
*/
updateOne(unique: unknown, entry: Partial<T>): this;
}

@@ -252,2 +267,2 @@

export { ArrayState, BooleanState, ClassState, DeepState, NumberState, ObjectState, StringState, UmbObserver, UmbObserverController, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };
export { ArrayState, BasicState, BooleanState, ClassState, DeepState, MappingFunction, NumberState, ObjectState, StringState, UmbObserver, UmbObserverController, appendToFrozenArray, createObservablePart, partialUpdateFrozenArray };

2

package.json
{
"name": "@umbraco-cms/backoffice",
"version": "1.0.0-next.71583c15",
"version": "1.0.0-next.7b47547e",
"license": "MIT",

@@ -5,0 +5,0 @@ "keywords": [

88

repository.d.ts

@@ -1,4 +0,4 @@

import { ProblemDetailsModel, PagedEntityTreeItemResponseModel, EntityTreeItemResponseModel } from './backend-api';
import { ProblemDetailsModel, FolderReponseModel, CreateFolderRequestModel, UpdateFolderReponseModel, FolderModelBaseModel } from './backend-api';
import { DataSourceResponse as DataSourceResponse$1 } from './repository';
import { Observable } from 'rxjs';
import { DataSourceResponse as DataSourceResponse$1 } from './repository';

@@ -10,2 +10,24 @@ interface DataSourceResponse<T = undefined> {

interface UmbDataSource<CreateRequestType, UpdateRequestType, ResponseType> {
createScaffold(parentKey: string | null): Promise<DataSourceResponse$1<ResponseType>>;
get(unique: string): Promise<DataSourceResponse$1<ResponseType>>;
insert(data: CreateRequestType): Promise<any>;
update(unique: string, data: UpdateRequestType): Promise<DataSourceResponse$1<ResponseType>>;
delete(unique: string): Promise<DataSourceResponse$1>;
}
interface UmbFolderDataSource {
createScaffold(parentKey: string | null): Promise<DataSourceResponse<FolderReponseModel>>;
get(unique: string): Promise<DataSourceResponse<FolderReponseModel>>;
insert(data: CreateFolderRequestModel): Promise<DataSourceResponse<string>>;
update(unique: string, data: CreateFolderRequestModel): Promise<DataSourceResponse<UpdateFolderReponseModel>>;
delete(unique: string): Promise<DataSourceResponse>;
}
interface UmbTreeDataSource<PagedItemsType = any, ItemsType = any> {
getRootItems(): Promise<DataSourceResponse$1<PagedItemsType>>;
getChildrenOf(parentUnique: string): Promise<DataSourceResponse$1<PagedItemsType>>;
getItems(unique: Array<string>): Promise<DataSourceResponse$1<Array<ItemsType>>>;
}
interface UmbDetailRepository<DetailType> {

@@ -31,37 +53,49 @@ createScaffold(parentKey: string | null): Promise<{

interface UmbTreeRepository {
interface UmbPagedData<T> {
total: number;
items: Array<T>;
}
interface UmbTreeRepository<ItemType = any, PagedItemType = UmbPagedData<ItemType>> {
requestRootTreeItems: () => Promise<{
data: PagedEntityTreeItemResponseModel | undefined;
data: PagedItemType | undefined;
error: ProblemDetailsModel | undefined;
asObservable?: () => Observable<EntityTreeItemResponseModel[]>;
asObservable?: () => Observable<ItemType[]>;
}>;
requestTreeItemsOf: (parentKey: string | null) => Promise<{
data: PagedEntityTreeItemResponseModel | undefined;
requestTreeItemsOf: (parentUnique: string | null) => Promise<{
data: PagedItemType | undefined;
error: ProblemDetailsModel | undefined;
asObservable?: () => Observable<EntityTreeItemResponseModel[]>;
asObservable?: () => Observable<ItemType[]>;
}>;
requestTreeItems: (keys: string[]) => Promise<{
data: Array<EntityTreeItemResponseModel> | undefined;
requestTreeItems: (uniques: string[]) => Promise<{
data: Array<ItemType> | undefined;
error: ProblemDetailsModel | undefined;
asObservable?: () => Observable<EntityTreeItemResponseModel[]>;
asObservable?: () => Observable<ItemType[]>;
}>;
rootTreeItems: () => Promise<Observable<EntityTreeItemResponseModel[]>>;
treeItemsOf: (parentKey: string | null) => Promise<Observable<EntityTreeItemResponseModel[]>>;
treeItems: (keys: string[]) => Promise<Observable<EntityTreeItemResponseModel[]>>;
rootTreeItems: () => Promise<Observable<ItemType[]>>;
treeItemsOf: (parentUnique: string | null) => Promise<Observable<ItemType[]>>;
treeItems: (uniques: string[]) => Promise<Observable<ItemType[]>>;
}
interface RepositoryTreeDataSource {
getRootItems(): Promise<DataSourceResponse$1<PagedEntityTreeItemResponseModel>>;
getChildrenOf(parentKey: string): Promise<DataSourceResponse$1<PagedEntityTreeItemResponseModel>>;
getItems(key: Array<string>): Promise<DataSourceResponse$1<EntityTreeItemResponseModel[]>>;
interface UmbFolderRepository {
createFolderScaffold(parentKey: string | null): Promise<{
data?: FolderReponseModel;
error?: ProblemDetailsModel;
}>;
createFolder(folderRequest: CreateFolderRequestModel): Promise<{
data?: string;
error?: ProblemDetailsModel;
}>;
requestFolder(unique: string): Promise<{
data?: FolderReponseModel;
error?: ProblemDetailsModel;
}>;
updateFolder(unique: string, folder: FolderModelBaseModel): Promise<{
data?: UpdateFolderReponseModel;
error?: ProblemDetailsModel;
}>;
deleteFolder(key: string): Promise<{
error?: ProblemDetailsModel;
}>;
}
interface RepositoryDetailDataSource<DetailType> {
createScaffold(parentKey: string | null): Promise<DataSourceResponse$1<DetailType>>;
get(key: string): Promise<DataSourceResponse$1<DetailType>>;
insert(data: DetailType): Promise<DataSourceResponse$1<DetailType>>;
update(data: DetailType): Promise<DataSourceResponse$1<DetailType>>;
delete(key: string): Promise<DataSourceResponse$1<DetailType>>;
}
export { DataSourceResponse, RepositoryDetailDataSource, RepositoryTreeDataSource, UmbDetailRepository, UmbTreeRepository };
export { DataSourceResponse, UmbDataSource, UmbDetailRepository, UmbFolderDataSource, UmbFolderRepository, UmbPagedData, UmbTreeDataSource, UmbTreeRepository };

6

resources.d.ts
import { UmbNotificationOptions } from './notification';
import { ProblemDetailsModel } from './backend-api';
import { UmbController, UmbControllerHostInterface } from './controller';
import { UmbController, UmbControllerHostElement } from './controller';
import { DataSourceResponse as DataSourceResponse$1 } from './repository';

@@ -8,3 +8,3 @@

#private;
constructor(host: UmbControllerHostInterface, promise: Promise<any>, alias?: string);
constructor(host: UmbControllerHostElement, promise: Promise<any>, alias?: string);
hostConnected(): void;

@@ -49,4 +49,4 @@ hostDisconnected(): void;

declare function tryExecuteAndNotify<T>(host: UmbControllerHostInterface, resource: Promise<T>, options?: UmbNotificationOptions<any>): Promise<DataSourceResponse<T>>;
declare function tryExecuteAndNotify<T>(host: UmbControllerHostElement, resource: Promise<T>, options?: UmbNotificationOptions<any>): Promise<DataSourceResponse<T>>;
export { UmbResourceController, tryExecute, tryExecuteAndNotify };

114

store.d.ts
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import { UmbControllerHostInterface } from './controller';
import { EntityTreeItemResponseModel } from './backend-api';
import { UmbStoreBase as UmbStoreBase$1 } from './store';
import { UmbControllerHostElement } from './controller';
import { EntityTreeItemResponseModel, FileSystemTreeItemPresentationModel } from './backend-api';
import { UmbStoreBase as UmbStoreBase$1, UmbTreeStore as UmbTreeStore$1 } from './store';

@@ -14,20 +14,2 @@ interface UmbDataStoreIdentifiers {

}
interface UmbTreeStore<T> extends UmbDataStore {
getTreeRoot(): Observable<Array<T>>;
getTreeItemChildren(key: string): Observable<Array<T>>;
/**
* @description - Trash data.
* @param {string[]} keys
* @return {*} {(Promise<void>)}
* @memberof UmbTreeStore
*/
trash(keys: string[]): Promise<void>;
/**
* @description - Move data.
* @param {string[]} keys
* @return {*} {(Promise<void>)}
* @memberof UmbTreeStore
*/
move(keys: string[], destination: string): Promise<void>;
}
interface UmbEntityDetailStore<T> extends UmbDataStore {

@@ -61,5 +43,5 @@ /**

declare class UmbStoreBase {
protected _host: UmbControllerHostInterface;
protected _host: UmbControllerHostElement;
readonly storeAlias: string;
constructor(_host: UmbControllerHostInterface, storeAlias: string);
constructor(_host: UmbControllerHostElement, storeAlias: string);
}

@@ -69,12 +51,12 @@

* @export
* @class UmbTreeStoreBase
* @class UmbEntityTreeStore
* @extends {UmbStoreBase}
* @description - General Tree Data Store
*/
declare class UmbTreeStoreBase extends UmbStoreBase$1 {
declare class UmbEntityTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<EntityTreeItemResponseModel> {
#private;
/**
* Appends items to the store
* @param {Array<EntityTreeItemModel>} items
* @memberof UmbTreeStoreBase
* @param {Array<EntityTreeItemResponseModel>} items
* @memberof UmbEntityTreeStore
*/

@@ -85,4 +67,4 @@ appendItems(items: Array<EntityTreeItemResponseModel>): void;

* @param {string} key
* @param {Partial<EntityTreeItemModel>} data
* @memberof UmbTreeStoreBase
* @param {Partial<EntityTreeItemResponseModel>} data
* @memberof UmbEntityTreeStore
*/

@@ -93,3 +75,3 @@ updateItem(key: string, data: Partial<EntityTreeItemResponseModel>): void;

* @param {string} key
* @memberof UmbTreeStoreBase
* @memberof UmbEntityTreeStore
*/

@@ -99,3 +81,3 @@ removeItem(key: string): void;

* An observable to observe the root items
* @memberof UmbTreeStoreBase
* @memberof UmbEntityTreeStore
*/

@@ -107,3 +89,3 @@ rootItems: rxjs.Observable<EntityTreeItemResponseModel[]>;

* @return {*}
* @memberof UmbTreeStoreBase
* @memberof UmbEntityTreeStore
*/

@@ -115,3 +97,3 @@ childrenOf(parentKey: string | null): rxjs.Observable<EntityTreeItemResponseModel[]>;

* @return {*}
* @memberof UmbTreeStoreBase
* @memberof UmbEntityTreeStore
*/

@@ -121,2 +103,66 @@ items(keys: Array<string>): rxjs.Observable<EntityTreeItemResponseModel[]>;

export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbStoreBase, UmbTreeStore, UmbTreeStoreBase };
/**
* @export
* @class UmbFileSystemTreeStore
* @extends {UmbStoreBase}
* @description - General Tree Data Store
*/
declare class UmbFileSystemTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
#private;
/**
* Appends items to the store
* @param {Array<FileSystemTreeItemPresentationModel>} items
* @memberof UmbFileSystemTreeStore
*/
appendItems(items: Array<FileSystemTreeItemPresentationModel>): void;
/**
* Updates an item in the store
* @param {string} path
* @param {Partial<FileSystemTreeItemPresentationModel>} data
* @memberof UmbFileSystemTreeStore
*/
updateItem(path: string, data: Partial<FileSystemTreeItemPresentationModel>): void;
/**
* Removes an item from the store
* @param {string} path
* @memberof UmbFileSystemTreeStore
*/
removeItem(path: string): void;
/**
* An observable to observe the root items
* @memberof UmbFileSystemTreeStore
*/
rootItems: rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
/**
* Returns an observable to observe the children of a given parent
* @param {(string | null)} parentPath
* @return {*}
* @memberof UmbFileSystemTreeStore
*/
childrenOf(parentPath: string | null): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
/**
* Returns an observable to observe the items with the given keys
* @param {Array<string>} paths
* @return {*}
* @memberof UmbFileSystemTreeStore
*/
items(paths: Array<string>): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
}
type TreeItemPresentationModel = {
name?: string;
type?: string;
icon?: string;
hasChildren?: boolean;
};
interface UmbTreeStore<T extends TreeItemPresentationModel = any> {
appendItems: (items: Array<T>) => void;
updateItem: (unique: string, item: Partial<T>) => void;
removeItem: (unique: string) => void;
rootItems: Observable<Array<T>>;
childrenOf: (parentUnique: string | null) => Observable<Array<T>>;
items: (uniques: Array<string>) => Observable<Array<T>>;
}
export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbEntityTreeStore, UmbFileSystemTreeStore, UmbStoreBase, UmbTreeStore };

25

workspace.d.ts

@@ -1,6 +0,7 @@

import { UmbControllerHostInterface } from './controller';
import { UmbControllerHostElement } from './controller';
import { Observable } from 'rxjs';
import { UmbWorkspaceContextInterface as UmbWorkspaceContextInterface$1 } from './workspace';
interface UmbWorkspaceAction<T = unknown> {
host: UmbControllerHostInterface;
host: UmbControllerHostElement;
workspaceContext?: T;

@@ -10,9 +11,9 @@ execute(): Promise<void>;

declare class UmbWorkspaceActionBase<WorkspaceType> {
host: UmbControllerHostInterface;
host: UmbControllerHostElement;
workspaceContext?: WorkspaceType;
constructor(host: UmbControllerHostInterface);
constructor(host: UmbControllerHostElement);
}
interface UmbWorkspaceContextInterface<T = unknown> {
host: UmbControllerHostInterface;
interface UmbWorkspaceContextInterface<DataType = unknown> {
host: UmbControllerHostElement;
repository: any;

@@ -23,3 +24,3 @@ isNew: Observable<boolean>;

getEntityType(): string;
getData(): T;
getData(): DataType | undefined;
destroy(): void;

@@ -31,6 +32,12 @@ setValidationErrors?(errorMap: any): void;

#private;
constructor(host: UmbControllerHostInterface);
constructor(host: UmbControllerHostElement);
execute(): Promise<void>;
}
export { UmbSaveWorkspaceAction, UmbWorkspaceAction, UmbWorkspaceActionBase };
interface UmbEntityWorkspaceContextInterface<EntityType = unknown> extends UmbWorkspaceContextInterface$1<EntityType> {
getEntityKey(): string | undefined;
getEntityType(): string;
save(): Promise<void>;
}
export { UmbEntityWorkspaceContextInterface, UmbSaveWorkspaceAction, UmbWorkspaceAction, UmbWorkspaceActionBase, UmbWorkspaceContextInterface };
custom-elements.json

Sorry, the diff of this file is too big to display

vscode-html-custom-data.json

Sorry, the diff of this file is too big to display