@manifest-editor/shell 1.0.0 → 1.0.4

package/dist/index.d.ts

@@ -0,0 +1,817 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode, SetStateAction, Dispatch, HTMLAttributes } from 'react';
+import { Vault } from '@iiif/helpers/vault';
+import { TransitionStatus } from 'react-transition-group';
+import * as _iiif_presentation_3 from '@iiif/presentation-3';
+import { Reference, SpecificResource, Collection } from '@iiif/presentation-3';
+import { CreatorDefinition as CreatorDefinition$1, Creator } from '@manifest-editor/creator-api';
+import { Vault as Vault$1 } from '@iiif/helpers';
+import { EditorInstance } from '@manifest-editor/editor-api';
+import * as styled_components from 'styled-components';
+import * as styled_components_dist_types from 'styled-components/dist/types';
+import { Emitter } from 'mitt';
+import { ManifestNormalized } from '@iiif/presentation-3-normalized';
+import * as zustand from 'zustand';
+
+interface EditableResource {
+    parent?: Reference;
+    property?: string;
+    index?: number;
+    resource: SpecificResource;
+    onlyReference?: boolean;
+}
+interface CreatableResource {
+    type: string;
+    parent?: Reference;
+    property?: string;
+    index?: number;
+    onlyReference?: boolean;
+    target?: Reference;
+    initialData?: any;
+    isPainting?: boolean;
+}
+interface EditingStackState {
+    current: EditableResource | null;
+    stack: Array<EditableResource>;
+    create: {
+        resource: CreatableResource;
+        options: any;
+    } | null;
+}
+interface EditingStackActions {
+    edit(resource: EditableResource | null, reset?: boolean): void;
+    updateCurrent(resource: Partial<EditableResource>): void;
+    close(): void;
+    back(): void;
+    create(resource: CreatableResource, options?: any): () => void;
+}
+type EditingStackActionCreators = {
+    type: "edit";
+    payload: {
+        resource: EditableResource | null;
+        reset?: boolean;
+    };
+} | {
+    type: "updateCurrent";
+    payload: {
+        resource: EditableResource;
+    };
+} | {
+    type: "syncRemoval";
+    payload: {
+        resource: EditableResource;
+    };
+} | {
+    type: "back";
+} | {
+    type: "create";
+    payload: {
+        resource: CreatableResource | null;
+        options?: any;
+    };
+} | {
+    type: "close";
+};
+
+interface Preview {
+    id: string;
+    type: string;
+    data: any;
+}
+type PreviewContext = PreviewState & {
+    handlers: Array<PreviewHandler>;
+    actions: PreviewActions;
+    configs: Array<PreviewConfiguration>;
+};
+interface PreviewState {
+    selected: string | null;
+    active: string[];
+}
+interface PreviewActions {
+    activatePreview(id: string): void;
+    updatePreviews(): void;
+    selectPreview(id: string): void;
+    deletePreview(id: string): void;
+    focusPreview(id: string): void;
+    getPreviewLink(): Promise<string | null>;
+}
+type PreviewActionsType = {
+    [T in keyof PreviewActions]: {
+        type: T;
+        payload: Parameters<PreviewActions[T]>[0];
+    };
+}[keyof PreviewActions];
+interface PreviewConfiguration<Config = any> {
+    id: string;
+    type: string;
+    label: string;
+    config: Config;
+}
+interface PreviewHandler {
+    id: string;
+    label: string;
+    type: string;
+    focusable: boolean;
+    getRequires(): string[];
+    getProvides(): string[];
+    isPreviewValid(instanceId: string, instance: Preview): boolean | Promise<boolean>;
+    createPreview(instanceId: string, resource: {
+        id: string;
+        type: string;
+    }, vault: Vault, ctx: any): Promise<Preview>;
+    focus(instanceId: string): Promise<void>;
+    updatePreview(instanceId: string, resource: {
+        id: string;
+        type: string;
+    }, vault: Vault, ctx: any): Promise<Preview | null>;
+    deletePreview(id: string): Promise<void>;
+}
+
+interface Config {
+    previews: PreviewConfiguration[];
+    behaviorPresets: string[];
+    newTemplates: Collection | null;
+    defaultPreview: string | null;
+    editorConfig: {
+        All?: EditorConfig;
+        Manifest?: EditorConfig;
+        Canvas?: EditorConfig;
+        Annotation?: EditorConfig;
+        AnnotationPage?: EditorConfig;
+        AnnotationCollection?: EditorConfig;
+        Range?: EditorConfig;
+        Collection?: EditorConfig;
+        ContentResource?: EditorConfig;
+    };
+    editorFeatureFlags: {
+        enableMultiImageCanvases?: boolean;
+        enableMultiMediaCanvases?: boolean;
+    };
+    i18n: {
+        defaultLanguage: string;
+        availableLanguages: string[];
+        advancedLanguageMode: boolean;
+    };
+    export: {
+        baseIdentifier: string | null;
+        version: 3 | 2;
+    };
+    uploadBackends: Array<UploadBackendConfig>;
+}
+interface EditorConfig {
+    singleTab?: string;
+    fields?: string[];
+    hideTabs?: string[];
+    onlyTabs?: string[];
+}
+interface UploadBackendConfig {
+    id: string;
+    label: string;
+    resourceTypes: string[];
+    canUpload?: () => Promise<boolean>;
+    upload: (resource: File) => Promise<{
+        id: string;
+        type: string;
+    }> | null;
+}
+declare function useConfig(): Config;
+declare function useSaveConfig(): (config: Partial<Config>) => void;
+declare function ConfigProvider({ children, config, saveConfig, }: {
+    children: ReactNode;
+    config?: Partial<Config>;
+    saveConfig?: (config: Partial<Config>) => void;
+}): react_jsx_runtime.JSX.Element;
+
+type CreatorDefinition = any;
+interface LayoutProviderProps {
+    loading?: true;
+    leftPanels: Array<LayoutPanel>;
+    rightPanels: Array<LayoutPanel>;
+    centerPanels: Array<LayoutPanel>;
+    modals?: Array<LayoutPanel>;
+}
+interface LayoutContext extends LayoutProviderProps {
+    state: LayoutState;
+    actions: LayoutActions;
+}
+interface LayoutState {
+    leftPanel: PanelState;
+    centerPanel: PanelState;
+    rightPanel: PanelState;
+    pinnedRightPanel: PinnablePanelState;
+    modal: PanelState;
+}
+interface LayoutActions {
+    stack(id: string, state?: any): void;
+    stack(args: {
+        id: string;
+        state?: any;
+    }): void;
+    open(id: string, state?: any): void;
+    open(args: {
+        id: string;
+        state?: any;
+        stacked?: boolean;
+        unique?: boolean;
+    }): void;
+    change(id: string, state?: any): void;
+    change(args: {
+        id: string;
+        state?: any;
+        stacked?: boolean;
+        unique?: boolean;
+    }): void;
+    close(id: string, state?: any): void;
+    close(args: {
+        id: string;
+        state?: any;
+    }): void;
+    toggle(id: string, state?: any): void;
+    toggle(args: {
+        id: string;
+        state?: any;
+    }): void;
+    edit(resource: Reference | SpecificResource, context?: Omit<EditableResource, "resource">, options?: {
+        reset?: boolean;
+        property?: string;
+        stacked?: boolean | undefined;
+        selectedTab?: string;
+    }): void;
+    create(resource: CreatableResource): void;
+    leftPanel: PanelActions;
+    centerPanel: PanelActions;
+    rightPanel: PanelActions;
+    pinnedRightPanel: PinnablePanelActions;
+    modal: PanelActions;
+}
+interface PanelState {
+    current: string | null;
+    state: any;
+    open: boolean;
+    minimised: boolean;
+    customWidth?: number;
+    stack: Array<{
+        id: string;
+        state: any;
+    }>;
+}
+interface PanelActions {
+    change(args: {
+        id: string;
+        state?: any;
+        stacked?: boolean;
+        unique?: boolean;
+    }): void;
+    open(args?: {
+        id: string;
+        state?: any;
+        stacked?: boolean;
+        unique?: boolean;
+    }): void;
+    close(): void;
+    toggle(): void;
+    minimise(): void;
+    maximise(args?: {
+        id: string;
+        state?: any;
+    }): void;
+    setCustomWidth(size: number): void;
+    resetSize(): void;
+    popStack(): void;
+}
+type PanelActionType = {
+    [T in keyof PinnablePanelActions]: {
+        type: T;
+        panel: keyof LayoutState;
+        payload: Parameters<PinnablePanelActions[T]>[0];
+    };
+}[keyof PinnablePanelActions];
+interface PinnablePanelState extends PanelState {
+    pinnable: true;
+    pinned: boolean;
+}
+interface PinnablePanelActions extends PanelActions {
+    pin(args: {
+        id: string;
+        state?: any;
+    }): void;
+    unpin(): void;
+}
+type LayoutPanelContext = {
+    global: {
+        currentCanvasId: string | null;
+    };
+    current: {
+        actions: PanelActions;
+        state: any;
+    };
+    actions: LayoutActions;
+    state: LayoutState;
+};
+type LayoutFunction = (state: any, ctx: {
+    current: PanelActions;
+    vault?: Vault;
+    transition?: TransitionStatus;
+} & LayoutContext, app: AppState) => ReactNode;
+interface LayoutPanel {
+    id: string;
+    label: string;
+    divide?: boolean;
+    icon?: null | string | ReactNode;
+    render: LayoutFunction;
+    onMount?: (state: any, ctx: {
+        current: PanelActions;
+        vault?: Vault;
+    } & LayoutContext, app: AppState) => (() => void) | void;
+    defaultState?: any;
+    requiresState?: boolean;
+    backAction?: (state: any, ctx: {
+        current: PanelActions;
+    } & LayoutContext, app: AppState) => void;
+    renderBackAction?: (options: {
+        backAction: (e?: React.MouseEvent) => void;
+        fallback: any;
+    }) => ReactNode | null;
+    renderCloseAction?: (options: {
+        closeAction: () => void;
+        fallback: any;
+    }) => ReactNode | null;
+    options?: {
+        minWidth?: number;
+        maxWidth?: number;
+        hideHeader?: boolean;
+        pinnable?: boolean;
+        openPinned?: boolean;
+        tabs?: boolean;
+    };
+}
+type MenuPositions = "left" | "right" | "bottom" | "top";
+interface PinnedLayoutPanel<T = any> extends LayoutPanel {
+    pinned: true;
+    state: T;
+}
+interface EditorDefinition {
+    id: string;
+    label: string;
+    tabs?: {
+        showTitle?: boolean;
+        hide?: boolean;
+    };
+    supports: {
+        properties: string[];
+        readOnlyProperties?: string[];
+        resourceTypes: string[];
+        sortKey?: string;
+        sortFallback?: boolean;
+        read?: boolean;
+        edit?: boolean;
+        customLocking?: boolean;
+        target?: boolean;
+        multi?: boolean;
+        custom?: (resource: EditableResource, vault: Vault) => boolean;
+    };
+    component: (config: EditorConfig) => ReactNode;
+}
+interface ResourceDefinition {
+    id: string;
+    label: string;
+    resourceType: string;
+    auto: boolean;
+    editors: EditorDefinition[];
+}
+interface LayoutProps$1 {
+    isLoading?: boolean;
+    className?: string;
+    hideHeader?: boolean;
+    isProject?: boolean;
+    provider?: React.FC;
+    leftPanels: Array<LayoutPanel>;
+    rightPanels: Array<LayoutPanel>;
+    centerPanels: Array<LayoutPanel>;
+    modals?: Array<LayoutPanel>;
+    footer?: ReactNode;
+    menu?: ReactNode;
+    header?: ReactNode;
+    onClickLogo?: (e: React.MouseEvent) => void;
+    leftPanelMenu?: ReactNode;
+    centerPanelMenu?: ReactNode;
+    rightPanelMenu?: ReactNode;
+    leftPanelMenuPosition?: MenuPositions;
+    centerPanelMenuPosition?: MenuPositions;
+    rightPanelMenuPosition?: MenuPositions;
+    editors?: EditorDefinition[];
+    resources?: (string | ResourceDefinition)[];
+    creators?: CreatorDefinition[];
+}
+
+type AppContext = {
+    instanceId: string;
+    appId: string;
+    args?: any;
+};
+type LoadedApp = Partial<LayoutProps$1> & {
+    default: {
+        id: string;
+        title: string;
+        type?: "manifest" | "launcher";
+        project?: boolean;
+        projectType?: "Manifest" | "Collection";
+        dev?: boolean;
+        desktop?: boolean;
+        web?: boolean;
+        drafts?: boolean;
+    };
+};
+type MappedApp$1 = {
+    metadata: LoadedApp["default"];
+    layout: LayoutProps$1;
+};
+type AppState = {
+    state: null | any;
+    setState: SetStateAction<any>;
+};
+declare const PrimeAppReactContext: react.Context<MappedApp$1 | null>;
+declare function useAppInstance(): AppContext;
+declare function useApp(): MappedApp$1;
+declare function useAppState<S = any>(): {
+    state: any;
+    setState: any;
+};
+declare function AppProvider({ instanceId, appId, args, definition, children, initialState, }: {
+    initialState?: any;
+    instanceId: string;
+    appId: string;
+    args?: any;
+    definition: MappedApp$1;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type MappedApp = any;
+type MultiAppContext = {
+    apps: Record<string, MappedApp>;
+    currentApp: {
+        id: string;
+        args?: any;
+    };
+    initialApp: {
+        id: string;
+        args?: any;
+    };
+    changeApp: (app: {
+        id: string;
+        args?: any;
+    }) => void;
+    changeProjectType: (type: "Manifest" | "Collection") => void;
+};
+declare function useApps(): MultiAppContext;
+declare function MultiAppProvider({ apps, initialApp, saveCurrentApp, instanceId, children, config, }: {
+    apps: Record<string, MappedApp>;
+    initialApp?: MultiAppContext["currentApp"];
+    saveCurrentApp?: boolean;
+    instanceId: string;
+    children: ReactNode;
+    config?: {
+        defaultApp?: string;
+        manifestApp?: string;
+        collectionApp?: string;
+    };
+}): react_jsx_runtime.JSX.Element | null;
+
+interface AppHeaderProps {
+    onClickLogo?: () => void;
+}
+declare const AppHeader: react.NamedExoticComponent<AppHeaderProps>;
+
+type MenuItem = {
+    label: string;
+    onClick?: () => void;
+    active?: boolean;
+};
+interface AppMenuContext {
+    file: {
+        new: MenuItem;
+        edit: MenuItem;
+        open: MenuItem;
+        newOptions: MenuItem[];
+        openOptions: MenuItem[];
+    };
+}
+declare function useAppMenu(): AppMenuContext | null;
+declare function useAppMenuItem<Key extends keyof AppMenuContext, Name extends keyof AppMenuContext[Key], Return extends AppMenuContext[Key][Name]>(menu: Key, name: Name): Return | null;
+declare function AppMenuProvider({ children, menu }: {
+    children: React.ReactNode;
+    menu: AppMenuContext;
+}): react_jsx_runtime.JSX.Element;
+
+interface Resource {
+    id: string;
+    type: string;
+}
+declare function useAppResourceInstance(): string;
+declare function useAppResource(): Resource;
+declare function AppResourceInstanceProvider({ id, children }: {
+    id?: string;
+    children: React.ReactNode;
+}): string | number | boolean | Iterable<react.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+declare function AppResourceProvider({ resource, children }: {
+    resource?: Resource;
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare const baseCreator: LayoutPanel;
+
+declare function matchBasedOnResource(resource: CreatableResource, list: CreatorDefinition$1[], options: {
+    vault: Vault;
+}): CreatorDefinition$1[];
+declare function useCreator(parent: any, property: string, type: string, target?: Reference, options?: {
+    isPainting?: boolean;
+    onlyReference?: boolean;
+}): readonly [any, {
+    readonly create: (index?: number, initialData?: any) => void;
+    readonly edit: (resource: any, index?: number) => void;
+    readonly buttonProps: {
+        "data-action-id": string;
+    };
+}];
+declare function useInlineCreator(): Creator;
+
+declare const baseEditor: LayoutPanel;
+
+declare function BaseEditorBackButton({ fallback, backAction }: any): any;
+declare function BaseEditorCloseButton({ closeAction, fallback }: any): any;
+declare function editBasedOnResource(resource: EditableResource, list: ResourceDefinition[], options: {
+    edit?: boolean;
+    vault: Vault$1;
+}, config: EditorConfig): ResourceDefinition | null;
+declare function BaseEditor({ currentTab }: {
+    currentTab?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+declare function ConfigEditor(): react_jsx_runtime.JSX.Element;
+
+declare function useEditingStack(): EditingStackActions;
+declare function useEditingResource(): EditableResource | null;
+declare function useEditingResourceStack(): EditableResource[];
+declare function useCreatingResource(): {
+    resource: CreatableResource;
+    options: any;
+} | null;
+declare function useManifestEditor(): EditorInstance<Partial<_iiif_presentation_3.DescriptiveProperties> & Partial<_iiif_presentation_3.TechnicalProperties> & Partial<_iiif_presentation_3.LinkingProperties> & Partial<_iiif_presentation_3.StructuralProperties<unknown>> & Partial<_iiif_presentation_3.NavPlaceExtension & _iiif_presentation_3.TextGranularityExtension>>;
+declare function useCollectionEditor(): EditorInstance<Partial<_iiif_presentation_3.DescriptiveProperties> & Partial<_iiif_presentation_3.TechnicalProperties> & Partial<_iiif_presentation_3.LinkingProperties> & Partial<_iiif_presentation_3.StructuralProperties<unknown>> & Partial<_iiif_presentation_3.NavPlaceExtension & _iiif_presentation_3.TextGranularityExtension>>;
+declare function useGenericEditor(ref: Reference<any> | SpecificResource | undefined, ctx?: {
+    parent?: Reference;
+    parentProperty?: string;
+    index?: number;
+}): EditorInstance<Partial<_iiif_presentation_3.DescriptiveProperties> & Partial<_iiif_presentation_3.TechnicalProperties> & Partial<_iiif_presentation_3.LinkingProperties> & Partial<_iiif_presentation_3.StructuralProperties<unknown>> & Partial<_iiif_presentation_3.NavPlaceExtension & _iiif_presentation_3.TextGranularityExtension>>;
+declare function useAnnotationPageEditor(): EditorInstance<Partial<_iiif_presentation_3.DescriptiveProperties> & Partial<_iiif_presentation_3.TechnicalProperties> & Partial<_iiif_presentation_3.LinkingProperties> & Partial<_iiif_presentation_3.StructuralProperties<unknown>> & Partial<_iiif_presentation_3.NavPlaceExtension & _iiif_presentation_3.TextGranularityExtension>>;
+declare function useEditor(): EditorInstance<Partial<_iiif_presentation_3.DescriptiveProperties> & Partial<_iiif_presentation_3.TechnicalProperties> & Partial<_iiif_presentation_3.LinkingProperties> & Partial<_iiif_presentation_3.StructuralProperties<unknown>> & Partial<_iiif_presentation_3.NavPlaceExtension & _iiif_presentation_3.TextGranularityExtension>>;
+declare function EditingStack(props: {
+    children?: any;
+    editing?: {
+        id: string;
+        type: string;
+    };
+}): react_jsx_runtime.JSX.Element;
+
+interface ExportPanelProps {
+    initialVersion?: 2 | 3;
+    versions?: Array<2 | 3>;
+}
+declare function ExportPanel(props: ExportPanelProps): react_jsx_runtime.JSX.Element;
+
+interface LayoutProps {
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    menu?: React.ReactNode;
+    leftPanelMenu?: React.ReactNode;
+    rightPanelMenu?: React.ReactNode;
+    centerPanelMenu?: React.ReactNode;
+    leftPanelMenuPosition?: "top" | "bottom";
+    rightPanelMenuPosition?: "top" | "bottom";
+    hideHeader?: boolean;
+    isLoading?: boolean;
+    className?: string;
+    centerPanelMenuPosition?: "top" | "bottom";
+}
+declare const Layout: react.NamedExoticComponent<LayoutProps>;
+
+declare const LayoutActionsReactContext: react.Context<LayoutActions>;
+declare const LayoutStateReactContext: react.Context<LayoutState>;
+declare function useLayoutState(): LayoutState;
+declare function useLayoutActions(): LayoutActions;
+declare function useAvailableLayouts(): LayoutProps$1;
+declare function useLayoutProvider(): LayoutProviderProps & {
+    loading?: true;
+    actions: LayoutActions;
+    state: LayoutState;
+};
+
+declare function isPinnableState(t: unknown): t is PinnablePanelState;
+declare function panelSizing({ initial, fallback, options, }: {
+    initial?: number;
+    fallback: number;
+    options?: {
+        minWidth?: number;
+        maxWidth?: number;
+    };
+}): number;
+declare function renderHelper(htmlOrReact: string | ReactNode): ReactNode;
+
+declare function usePanelActions(panel: keyof LayoutState, dispatch: Dispatch<PanelActionType>): PanelActions | PinnablePanelActions;
+
+declare const layoutReducer: (state: LayoutState, args_0: PanelActionType) => LayoutState;
+declare function getDefaultPanelState(): PanelState;
+declare function getDefaultLayoutState(): LayoutState;
+
+declare const HandleContainer: styled_components.IStyledComponent<"web", styled_components_dist_types.FastOmit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>;
+declare const HandleControls: react.ForwardRefExoticComponent<{
+    dir: "left" | "right";
+    open: boolean;
+    actions: PanelActions;
+    transition?: TransitionStatus | undefined;
+    reset?: (() => void) | undefined;
+} & react.RefAttributes<HTMLDivElement>>;
+
+interface ModularPanelProps {
+    panel?: LayoutPanel;
+    isLeft?: boolean;
+    state: PinnablePanelState | PanelState;
+    actions: PanelActions;
+    pinActions?: PinnablePanelActions;
+    transition?: TransitionStatus;
+    noHeader?: boolean;
+    close?: () => void;
+    available?: LayoutPanel[];
+    style?: any;
+}
+declare function useSetCustomTitle(): (title: string) => void;
+declare const ModularPanelHeader: styled_components.IStyledComponent<"web", styled_components_dist_types.Substitute<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $tabs?: boolean | undefined;
+    $error?: boolean | undefined;
+}>>;
+declare const ModulePanelButton: styled_components.IStyledComponent<"web", styled_components_dist_types.FastOmit<react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>>;
+declare function ModularPanel({ panel, state, actions, isLeft, pinActions, transition, close, available, style, noHeader, }: ModularPanelProps): react_jsx_runtime.JSX.Element | null;
+
+declare function PanelError(props: {
+    error: Error;
+    resetErrorBoundary: () => void;
+}): react_jsx_runtime.JSX.Element;
+
+declare function PreviewButton({ downloadEnabled, fileName }: {
+    downloadEnabled?: boolean;
+    fileName?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare const PreviewProvider: react.NamedExoticComponent<{
+    previews: Preview[];
+    children: ReactNode;
+    configs: PreviewConfiguration[];
+}>;
+declare function usePreviews(): Preview[];
+declare function usePreviewContext(): PreviewContext;
+
+declare function usePreviewVault(): Vault;
+declare const HOMEPAGE_COLLECTION = "manifest-editor://homepage-collection.json";
+declare function usePreviewHistory(): {
+    addHistory: (id: string, type: string) => void;
+    clearHistory: () => void;
+};
+declare function PreviewVaultContext(props: {
+    children: any;
+}): react_jsx_runtime.JSX.Element;
+declare function PreviewVaultBoundary({ children }: {
+    children: any;
+}): react_jsx_runtime.JSX.Element;
+
+declare function createPreviewVault(homepageCollectionId?: string): {
+    readonly vault: Vault;
+    readonly unsubscribe: () => void;
+    readonly addHistory: (id: string, type: string) => void;
+    readonly clearHistory: () => void;
+};
+
+interface ResourceEditingContext {
+    resource: Reference<any> | null;
+}
+declare function useEditingContext(): ResourceEditingContext;
+/**
+ * useResource
+ *
+ * Only use this if you KNOW that there is a resource (e.g. in a panel)
+ */
+declare function useResource<T = Record<string, never>>(): T & Reference<any>;
+/**
+ * useOptionalResource
+ *
+ * Use in components where you don't know if something is editing. (e.g. canvas listing)
+ */
+declare function useOptionalResource(): {
+    type: any;
+    id: string;
+} | null;
+declare function ResourceEditingProvider({ resource, children, }: {
+    resource: {
+        id: string;
+        type: string;
+    } | null | undefined;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function ShellProvider({ config, saveConfig, children, theme, previews, resource, editing, }: {
+    resource: Resource;
+    config?: Partial<Config>;
+    saveConfig?: (config: Partial<Config>) => void;
+    children: ReactNode;
+    theme?: any;
+    previews?: Preview[];
+    editing?: {
+        id: string;
+        type: string;
+    };
+}): react_jsx_runtime.JSX.Element;
+
+interface Task<Req = any, Res = any> {
+    name: string;
+    status: "idle" | "running" | "complete" | "error";
+    emitter: Emitter<any>;
+    promise: Promise<any>;
+    abort: AbortController;
+    resolve: (value?: any) => void;
+    reject: (reason?: any) => void;
+    error?: string;
+    request?: Req;
+    response?: Res;
+}
+declare function useTask(name: string): Task<any, any>;
+declare function useTaskEvent<Req = any, Res = any>(task: Task<Req, Res>, name: string, _cb: (task: Task<Req, Res>) => any): void;
+declare function useTaskDispatch<Req = any, Res = any>(name: string, onComplete?: (task: Task<Req, Res>) => void | Promise<void>): readonly [(request?: any) => void, Task<any, any>];
+declare function useTaskRunner<Req = any, Res = any>(name: string, onRun: (task: Task<Req, Res>) => void | Promise<void>): readonly [(response?: any) => void, Task<any, any>, (reason?: any, error?: any) => void];
+declare function TaskBridge({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface UniversalCopyPasteProps<T> {
+    as?: keyof JSX.IntrinsicElements | react.ComponentType<T>;
+    children?: ReactNode;
+    reference?: Reference;
+    onReference?: (reference: Reference) => void;
+    onPasteReference?: (reference: Reference) => void;
+    onDropReference?: (reference: Reference, e: DragEvent) => void;
+    onLink?: (link: string) => void;
+    onPasteLink?: (link: string) => void;
+    onDropLink?: (link: string) => void;
+    onAnalysis?: (analysisResults: any) => void;
+    onPasteAnalysis?: (analysisResults: any) => void;
+    onDropAnalysis?: (analysisResults: any) => void;
+    onLoading?: () => void;
+    onComplete?: () => void;
+}
+
+declare function UniversalCopyTarget<T>({ as, reference: _ref, onReference, onLink, onAnalysis, onDropReference: _onDropReference, onDropLink: _onDropLink, onDropAnalysis: _onDropAnalysis, onPasteReference: _onPasteReference, onPasteLink: _onPasteLink, onPasteAnalysis: _onPasteAnalysis, ...props }: Partial<HTMLAttributes<HTMLElement>> & UniversalCopyPasteProps<T> & T): react_jsx_runtime.JSX.Element;
+
+declare function detectMedia(): Promise<void>;
+declare function analyse(url: string, ...expectedTypes: string[]): Promise<any>;
+declare function analyseJson(data: any, url: string): Promise<any>;
+declare function getFormat(url: string, capturedContentType?: string): Promise<string>;
+declare function getImageDimensions(url: string): Promise<{
+    width: number;
+    height: number;
+} | null>;
+
+declare function getManifestNomalized(id: string): Promise<ManifestNormalized | undefined>;
+declare function createActionIdentity(type: string, property: string, parent: any): string;
+declare function createDownload(data: any, fileName: string, fileType?: string): void;
+declare function copyToClipboard(json: string | any): Promise<void>;
+declare function randomId(): string;
+declare function mapApp(input: any, map?: (app: MappedApp$1) => MappedApp$1): MappedApp$1;
+
+type Projection = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+interface HighlightedImageResources {
+    regions: Record<string, Projection | null>;
+    resources: string[];
+    setRegion: (id: string, region?: Projection | null) => void;
+    setHighlight: (id: string | string[]) => void;
+    highlight: (id: string) => void;
+    clearHighlight: (id: string) => void;
+}
+declare const useHighlightedImageResource: zustand.UseBoundStore<zustand.StoreApi<HighlightedImageResources>>;
+declare function useTemporaryHighlight(newValue?: Projection | null): void;
+declare function useHoverHighlightImageResource(id?: string): {
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+};
+
+declare function useSaveVault(vault: Vault$1, saveChanges: () => void, saveInterval: number, enabled?: boolean): void;
+
+declare function useDecayState(time: number): readonly [boolean, {
+    readonly set: () => void;
+    readonly clear: (existing?: boolean) => void;
+}];
+
+export { type AppContext, AppHeader, AppMenuProvider, AppProvider, AppResourceInstanceProvider, AppResourceProvider, type AppState, BaseEditor, BaseEditorBackButton, BaseEditorCloseButton, type Config, ConfigEditor, ConfigProvider, type CreatableResource, type EditableResource, EditingStack, type EditingStackActionCreators, type EditingStackActions, type EditingStackState, type EditorConfig, type EditorDefinition, ExportPanel, type ExportPanelProps, HOMEPAGE_COLLECTION, HandleContainer, HandleControls, Layout, type LayoutActions, LayoutActionsReactContext, type LayoutContext, type LayoutFunction, type LayoutPanel, type LayoutPanelContext, type LayoutProps$1 as LayoutProps, type LayoutProviderProps, type LayoutState, LayoutStateReactContext, type LoadedApp, type MappedApp$1 as MappedApp, type MenuPositions, ModularPanel, ModularPanelHeader, ModulePanelButton, type MultiAppContext, MultiAppProvider, type PanelActionType, type PanelActions, PanelError, type PanelState, type PinnablePanelActions, type PinnablePanelState, type PinnedLayoutPanel, type Preview, type PreviewActions, type PreviewActionsType, PreviewButton, type PreviewConfiguration, type PreviewContext, type PreviewHandler, PreviewProvider, type PreviewState, PreviewVaultBoundary, PreviewVaultContext, PrimeAppReactContext, type Resource, type ResourceDefinition, ResourceEditingProvider, ShellProvider, TaskBridge, type UniversalCopyPasteProps, UniversalCopyTarget, type UploadBackendConfig, analyse, analyseJson, baseCreator, baseEditor, copyToClipboard, createActionIdentity, createDownload, createPreviewVault, detectMedia, editBasedOnResource, getDefaultLayoutState, getDefaultPanelState, getFormat, getImageDimensions, getManifestNomalized, isPinnableState, layoutReducer, mapApp, matchBasedOnResource, panelSizing, randomId, renderHelper, useAnnotationPageEditor, useApp, useAppInstance, useAppMenu, useAppMenuItem, useAppResource, useAppResourceInstance, useAppState, useApps, useAvailableLayouts, useCollectionEditor, useConfig, useCreatingResource, useCreator, useDecayState, useEditingContext, useEditingResource, useEditingResourceStack, useEditingStack, useEditor, useGenericEditor, useHighlightedImageResource, useHoverHighlightImageResource, useInlineCreator, useLayoutActions, useLayoutProvider, useLayoutState, useManifestEditor, useOptionalResource, usePanelActions, usePreviewContext, usePreviewHistory, usePreviewVault, usePreviews, useResource, useSaveConfig, useSaveVault, useSetCustomTitle, useTask, useTaskDispatch, useTaskEvent, useTaskRunner, useTemporaryHighlight };